Package tech.oxfordsemantic.jrdfox.client

Interface DataStoreConnection

All Superinterfaces:
java.lang.AutoCloseable
public interface DataStoreConnection
extends java.lang.AutoCloseable
Encapsulates a connection to an RDFox data store. All instances of this class are single-threaded — that is, no method should be called simultaneously on several threads. However, please note that there is no thread affinity — that is, methods on one connection can be called from different threads as long as the calls are serialised externally. The interrupt(), duplicate(), and checkPassword(String password) methods are exceptions: they can be invoked in parallel with any other method apart from close(). Calling close() in parallel with any other method will almost certainly crash the JVM. Multiple connections to the same data store should be used to access a data store concurrently. A data store connection uses transactions to coordinate how concurrent accesses interact. A connection must be closed after use to release the resources associated with it.

  • Field Summary

    Fields 
    Modifier and Type Field Description
    static long WAIT_FOREVER
    Specifies that the system should wait forever when it needs to acquire a lock on a data store (see setLockTimeout(long)).

  • Method Summary

    Modifier and Type Method Description
    long addRule​(Rule rule)
    Adds a rule to the data store.
    long addRules​(java.util.Collection<Rule> datalogProgram)
    Adds a collection of rules to the data store.
    void begin​(TransactionType transactionType)
    Deprecated. 
    void beginTransaction​(TransactionType transactionType)
    Starts a new transaction on this connection.
    void checkPassword​(java.lang.String password)
    Checks whether the supplied password is valid for the role associated with this connection.
    void clear()
    Clears the content of this data store -- that is, it clears all data and rules so the logical state of the data store is the same as after initialisation.
    void clearRulesAxiomsExplicateFacts()
    Clears all rules and turns all facts in the data store into EDB facts.
    void close()
    Closes the data store connection by freeing all resources associated with it.
    void commit()
    Deprecated. 
    void commitTransaction()
    Commits the transaction associated with this connection.
    void compact()
    Compact the data in the data store.
    boolean containsDataSource​(java.lang.String dataSourceName)
    Checks whether the data store contains a data source with the specified name.
    boolean containsDataSourceTable​(java.lang.String dataSourceName, java.lang.String dataSourceTableName)
    Checks whether the specified data source in the data store contains a data source table with the specified name.
    boolean containsStatistics​(java.lang.String statisticsName)
    Checks whether the data store contains the statistics with the specified name.
    boolean containsTupleTable​(java.lang.String tupleTableName)
    Checks whether the data store contains a tuple table with the specified name.
    Cursor createCursor​(java.lang.String baseIRI, Prefixes prefixes, java.lang.String queryText, java.util.Map<java.lang.String,​java.lang.String> compilationParameters)
    Creates a cursor over the results of the given query with the default fetch window size of 100.
    Cursor createCursor​(java.lang.String baseIRI, Prefixes prefixes, java.lang.String queryText, java.util.Map<java.lang.String,​java.lang.String> compilationParameters, int fetchWindowSize)
    Creates a cursor over the results of the given query.
    Cursor createCursor​(Query query, java.util.Map<java.lang.String,​java.lang.String> compilationParameters)
    Creates a cursor over the results of the given query with the default fetch window size of 100.
    Cursor createCursor​(Query query, java.util.Map<java.lang.String,​java.lang.String> compilationParameters, int fetchWindowSize)
    Creates a cursor over the results of the given query.
    void createExplanation​(java.lang.String baseIRI, Prefixes prefixes, java.lang.String factText, int maxDistanceFromRoot, int maxRuleInstancesPerFact, ExplanationType explanationType, java.io.OutputStream outputStream)
    Computes an explanation for a given fact and saves it in JSON format to the given output stream.
    void createExplanation​(Prefixes prefixes, TupleTableAtom fact, int maxDistanceFromRoot, int maxRuleInstancesPerFact, ExplanationType explanationType, java.io.OutputStream outputStream)
    Computes an explanation for a given fact and saves it in JSON format to the given output stream.
    void createStatistics​(java.lang.String statisticsName, java.util.Map<java.lang.String,​java.lang.String> statisticsParameters)
    Creates the statistics in a data store.
    void createTupleTable​(java.lang.String tupleTableName, java.util.Map<java.lang.String,​java.lang.String> tupleTableParameters)
    Creates a tuple table in a data store.
    long deleteRule​(Rule rule)
    Deletes a rule to the data store.
    long deleteRules​(java.util.Collection<Rule> datalogProgram)
    Deletes a collection of rules to the data store.
    void deleteStatistics​(java.lang.String statisticsName)
    Deletes the data store statistics with the specified name from the data store.
    void deleteTupleTable​(java.lang.String tupleTableName)
    Deletes the tuple table with the specified name from the data store.
    void deregisterDataSource​(java.lang.String dataSourceName)
    Deregisters the data source table with the specified name from the data store.
    DataSourceInfo describeDataSource​(java.lang.String dataSourceName)
    Returns information about the data source with the given name.
    DataSourceTableInfo describeDataSourceTable​(java.lang.String dataSourceName, java.lang.String dataSourceTableName)
    Returns information about the data source table of the specified data source in the data store.
    StatisticsInfo describeStatistics​(java.lang.String statisticsName)
    Returns information about the specific statistics of the data store.
    TupleTableInfo describeTupleTable​(java.lang.String tupleTableName)
    Returns information about the tuple table with the given name.
    DataStoreConnection duplicate()
    Creates a new connection to the same data store.
    StatementResult evaluateQuery​(java.lang.String baseIRI, Prefixes prefixes, java.lang.String queryText, java.util.Map<java.lang.String,​java.lang.String> compilationParameters, QueryAnswerMonitor queryAnswerMonitor)
    Evaluates a query and calls the supplied QueryAnswerMonitor instance for each tuple in the result.
    StatementResult evaluateQuery​(Query query, java.util.Map<java.lang.String,​java.lang.String> compilationParameters, QueryAnswerMonitor queryAnswerMonitor)
    Evaluates a query and calls the supplied QueryAnswerMonitor instance for each tuple in the result.
    StatementResult evaluateStatement​(java.lang.String baseIRI, Prefixes prefixes, java.lang.String statementText, java.util.Map<java.lang.String,​java.lang.String> compilationParameters, java.io.File file, java.lang.String queryAnswerFormatName)
    Evaluates a statement and serialises the result to the supplied file using the specified format.
    StatementResult evaluateStatement​(java.lang.String baseIRI, Prefixes prefixes, java.lang.String statementText, java.util.Map<java.lang.String,​java.lang.String> compilationParameters, java.io.OutputStream outputStream, java.lang.String queryAnswerFormatName)
    Evaluates a statement and serialises the result to the supplied output stream using the specified format.
    StatementResult evaluateStatement​(Prefixes prefixes, Statement statement, java.util.Map<java.lang.String,​java.lang.String> compilationParameters, java.io.File file, java.lang.String queryAnswerFormatName)
    Evaluates a statement and serialises the result to the supplied file using the specified format.
    StatementResult evaluateStatement​(Prefixes prefixes, Statement statement, java.util.Map<java.lang.String,​java.lang.String> compilationParameters, java.io.OutputStream outputStream, java.lang.String queryAnswerFormatName)
    Evaluates a statement and serialises the result to the supplied output stream using the specified format.
    StatementResult evaluateUpdate​(java.lang.String baseIRI, Prefixes prefixes, java.lang.String updateText, java.util.Map<java.lang.String,​java.lang.String> compilationParameters)
    Evaluates an update.
    StatementResult evaluateUpdate​(Update update, java.util.Map<java.lang.String,​java.lang.String> compilationParameters)
    Evaluates an update.
    StatementResult evaluateUpdates​(java.util.List<Update> updates, java.util.Map<java.lang.String,​java.lang.String> compilationParameters)
    Evaluates a list of updates.
    void exportData​(Prefixes prefixes, java.io.File file, java.lang.String formatName, java.util.Map<java.lang.String,​java.lang.String> parameters)
    Exports the data in the data store using the given format.
    void exportData​(Prefixes prefixes, java.io.OutputStream outputStream, java.lang.String formatName, java.util.Map<java.lang.String,​java.lang.String> parameters)
    Exports the data in the data store using the given format.
    ComponentInfo getComponentInfo​(boolean extended)
    Returns diagnostic information about the data store as a tree of objects each providing detailed information about the data store.
    ResourceValue[][] getDataSourceTableData​(java.lang.String dataSourceName, java.lang.String dataSourceTableName, int numberOfRows)
    Returns a sample of the data from the specified data source table.
    long getDataStoreVersion()
    Returns the version of the data store, which is an number that is incremented every time the data store is updated.
    long getDataStoreVersionAfterLastOperation()
    Returns the version that the data store had after the last operation on this connection.
    long getDictionaryVersion()
    Returns the version of the data store dictionary, which is an number that is incremented every time the data store dictionary is cleared.
    long getEndResourceID()
    Returns the one plus the maximum resource ID that can be stored in tuple tables of this data store.
    EqualityAxiomatization getEqualityAxiomatization()
    Returns a flag that determines how the data store deals with equality reasoning.
    int getID()
    Returns an integer that uniquely identifies the data store within the server.
    long getLockTimeout()
    Returns the time in milliseconds that the system will wait for when it needs to acquire a lock on a data store.
    java.lang.String getName()
    Returns the name of the data store inside the server.
    long getNextOperationMustMatchDataStoreVersion()
    Returns the data store version that the next operation on this connection should expect.
    long getNextOperationMustNotMatchDataStoreVersion()
    Returns the data store version that the next operation on this connection should not expect.
    java.util.Map<java.lang.String,​java.lang.String> getParameters()
    Returns the parameters that the data store was created with.
    Resource getResource​(long resourceID)
    Looks up the resource with the given IDs.
    boolean getResources​(long[] resourceIDs, int startIndex, int endIndex, Resource[] resources)
    Looks up the resources with the given IDs.
    ResourceValue getResourceValue​(long resourceID)
    Looks up the resource with the given ID.
    boolean getResourceValues​(long[] resourceIDs, int startIndex, int endIndex, ResourceValue[] resourceValues)
    Looks up the resources with the given IDs.
    java.lang.String getRoleName()
    Returns the name of the role currently associated with this connection.
    TransactionState getTransactionState()
    Returns the state of the transaction associated with this connection.
    java.lang.String getUniqueID()
    Returns a string that uniquely identifies the data store.
    ImportResult importAxiomsFromTriples​(java.lang.String sourceGraphName, boolean translateAssertions, java.lang.String destinationGraphName, UpdateType updateType)
    Parses the given source graph into OWL axioms, and imports the axioms into the destination graph.
    ImportResult importAxiomsFromTriples​(java.lang.String sourceGraphName, boolean translateAssertions, java.lang.String destinationGraphName, UpdateType updateType, ImportNotificationMonitor importNotificationMonitor)
    Parses the given source graph into OWL axioms, and imports the axioms into the destination graph.
    ImportResult importData​(java.lang.String defaultGraphName, UpdateType updateType, Prefixes prefixes, java.io.File file)
    Imports the data from the given file into the current data store.
    ImportResult importData​(java.lang.String defaultGraphName, UpdateType updateType, Prefixes prefixes, java.io.InputStream inputStream)
    Imports the data from the given input stream into the current data store.
    ImportResult importData​(java.lang.String defaultGraphName, UpdateType updateType, Prefixes prefixes, java.lang.String content)
    Imports the data from the given string into the current data store.
    ImportResult importData​(java.lang.String defaultGraphName, UpdateType updateType, Prefixes prefixes, java.util.Collection<InputSourceFactory> inputSourceFactories, java.lang.String formatName, ImportNotificationMonitor importNotificationMonitor)
    Imports the data described by the given input source factories into the current data store.
    ImportResult importData​(java.lang.String defaultGraphName, UpdateType updateType, Prefixes prefixes, InputSourceFactory inputSourceFactory, java.lang.String formatName, ImportNotificationMonitor importNotificationMonitor)
    Imports the data described by the given input source factory into the current data store The graph with the specified name is used as a default graph.
    ImportResult importData​(UpdateType updateType, Prefixes prefixes, java.io.File file)
    Imports the data from the given file into the current data store.
    ImportResult importData​(UpdateType updateType, Prefixes prefixes, java.io.InputStream inputStream)
    Imports the data from the given input stream into the current data store.
    ImportResult importData​(UpdateType updateType, Prefixes prefixes, java.lang.String content)
    Imports the data from the given string into the current data store.
    ImportResult importData​(UpdateType updateType, Prefixes prefixes, java.util.Collection<InputSourceFactory> inputSourceFactories, java.lang.String formatName, ImportNotificationMonitor importNotificationMonitor)
    Imports the data described by the given input source factories into the current data store.
    ImportResult importData​(UpdateType updateType, Prefixes prefixes, InputSourceFactory inputSourceFactory, java.lang.String formatName, ImportNotificationMonitor importNotificationMonitor)
    Imports the data described by the given input source factory into the current data store.
    void interrupt()
    Tries to interrupt an operation that is running in parallel on this connection.
    boolean isConcurrent()
    Returns true if the data store supports concurrent access.
    boolean isPersistent()
    Returns true if the data store is persistent.
    java.util.List<DataSourceInfo> listDataSources()
    Returns information about the data sources currently present in the data store.
    java.util.List<DataSourceTableInfo> listDataSourceTables​(java.lang.String dataSourceName)
    Returns information about the data source tables of the specified data source in the data store.
    java.util.List<RuleInfo> listRules()
    Returns the information about the rules currently loaded into the data store.
    java.util.List<StatisticsInfo> listStatistics()
    Returns information about all statistics currently managed by the data store.
    java.util.List<TupleTableInfo> listTupleTables()
    Returns information about the tuple tables currently present in the data store.
    void recompileRules()
    Recompiles the rules using the currently available statistics.
    void recomputeMaterialization()
    Recomputes the materialization from scratch — that is, deletes all derived facts and applies all rules as if the data had just been freshly imported.
    void registerDataSource​(java.lang.String dataSourceName, java.util.Map<java.lang.String,​java.lang.String> dataSourceParameters)
    Registers a data source with a data store.
    boolean requiresIncrementalReasoning()
    Returns true if the next data store update must be performed using incremental reasoning (rather than standard using the standard datalog materialization "from scratch" algorithm).
    void rollback()
    Deprecated. 
    void rollbackTransaction()
    Rolls back the transaction associated with this connection.
    void setLockTimeout​(long timeout)
    Sets the time in milliseconds that the system will wait for when it needs to acquire a lock on a data store.
    void setNextOperationMustMatchDataStoreVersion​(long dataStoreVersion)
    Configures this connection so that the next operation is accepted only if the data store has the given version before the operation commences.
    void setNextOperationMustNotMatchDataStoreVersion​(long dataStoreVersion)
    Configures this connection so that the next operation is accepted only if the data store does not have the given version before the operation commences.
    boolean transactionRequiresRollback()
    Returns true if a transaction is active on this connection and this transaction must be rolled back (i.e., it cannot be committed).
    void updateMaterialization()
    Updates the materialization so that all and only the consequences of the explicitly stated facts and the rules are derived.
    void updateStatistics()
    Updates all statistics that the data store uses to plan queries and rules.
    void updateStatistics​(java.lang.String statisticsName)
    Updates the statistics with the given name that the data store uses to plan queries and rules.

  • Field Details

  • Method Details

    • close

      void close()
      Closes the data store connection by freeing all resources associated with it. Once a connection is closed, it cannot be used any further. Calling this method in parallel with any other method runs a very high risk of crashing the JVM.
      Specified by:
      close in interface java.lang.AutoCloseable

    • getLockTimeout

      long getLockTimeout() throws JRDFoxException
      Returns the time in milliseconds that the system will wait for when it needs to acquire a lock on a data store. See setLockTimeout(long) for more detail.
      Returns:
      the current timeout value
      Throws:
      JRDFoxException - thrown if an error is encountered

    • setLockTimeout

      void setLockTimeout​(long timeout) throws JRDFoxException
      Sets the time in milliseconds that the system will wait for when it needs to acquire a lock on a data store. The value of WAIT_FOREVER specifies that the system should wait indefinitely. When successful completion of an operation (e.g., adding data to a data store) requires locking a store and the lock cannot be acquired within the timeout period, a LockTimeoutException is thrown.
      Parameters:
      timeout - the new timeout value
      Throws:
      JRDFoxException - thrown if an error is encountered

    • duplicate

      DataStoreConnection duplicate() throws JRDFoxException
      Creates a new connection to the same data store. The new connection inherits the role name and the lock timeout from this one. Regardless of whether a transaction is active on this connection, the new connection will not have an active transaction. The main use of this method is to avoid having to specify the user credentials again.
      Returns:
      a new connection to the same data store
      Throws:
      JRDFoxException - thrown if an error is encountered

    • interrupt

      void interrupt() throws JRDFoxException
      Tries to interrupt an operation that is running in parallel on this connection. RDFox will make a best effort to interrupt an operation, but there are no guarantees that the operation will indeed be interrupted. An operation will throw an OperationInterruptedException exception. This method can be called concurrently with any other method apart from close().
      Throws:
      JRDFoxException - thrown if an error is encountered

    • getRoleName

      java.lang.String getRoleName() throws JRDFoxException
      Returns the name of the role currently associated with this connection.
      Returns:
      the name of the role currently associated with this connection
      Throws:
      JRDFoxException - thrown if there is an error

    • checkPassword

      void checkPassword​(java.lang.String password) throws JRDFoxException
      Checks whether the supplied password is valid for the role associated with this connection. On failure, an exception is thrown and the connection remains valid.
      Parameters:
      password - the password of the new user
      Throws:
      JRDFoxException - thrown if there is an error

    • getName

      java.lang.String getName() throws JRDFoxException
      Returns the name of the data store inside the server.
      Returns:
      the name of the data store
      Throws:
      JRDFoxException - thrown if an error is encountered

    • getID

      int getID() throws JRDFoxException
      Returns an integer that uniquely identifies the data store within the server. This number will be as low as possible, thus allowing for easy indexing of data stores using arrays. When a data store is deleted and a new data store is created, the same ID can be assigned to the new data store.
      Returns:
      an integer that uniquely identifies this data store within the server
      Throws:
      JRDFoxException - thrown if an error is encountered

    • getUniqueID

      java.lang.String getUniqueID() throws JRDFoxException
      Returns a string that uniquely identifies the data store. Each time a data store is created, a fresh random string is associated to the data store. This string aims to be unique across servers and data stores.
      Returns:
      a string that uniquely identifies this data store
      Throws:
      JRDFoxException - thrown if an error is encountered

    • getDataStoreVersion

      long getDataStoreVersion() throws JRDFoxException
      Returns the version of the data store, which is an number that is incremented every time the data store is updated. Hence, by recording the value of this counter and checking it later again, clients can detect whether the data store changed in between.
      Returns:
      the generation counter of the data store
      Throws:
      JRDFoxException - thrown if an error is encountered

    • getParameters

      java.util.Map<java.lang.String,​java.lang.String> getParameters() throws JRDFoxException
      Returns the parameters that the data store was created with.
      Returns:
      the parameters of the data store
      Throws:
      JRDFoxException - thrown if an error is encountered

    • getEndResourceID

      long getEndResourceID() throws JRDFoxException
      Returns the one plus the maximum resource ID that can be stored in tuple tables of this data store. In some data stores this number can be larger than 263 - 1, in which case this method returns 263 - 1 (i.e., the maximum signed long integer).
      Returns:
      the maximum resource ID that can be stored in tuple tables of this data store
      Throws:
      JRDFoxException - thrown if an error is encountered

    • isConcurrent

      boolean isConcurrent() throws JRDFoxException
      Returns true if the data store supports concurrent access. If not, then all access to the data store will be serialised.
      Returns:
      true if the data store supports concurrent access
      Throws:
      JRDFoxException - thrown if an error is encountered

    • isPersistent

      boolean isPersistent() throws JRDFoxException
      Returns true if the data store is persistent.
      Returns:
      true if the data store is persistent
      Throws:
      JRDFoxException - thrown if an error is encountered

    • getEqualityAxiomatization

      EqualityAxiomatization getEqualityAxiomatization() throws JRDFoxException
      Returns a flag that determines how the data store deals with equality reasoning.
      Returns:
      determines the way in which equality is handled by the data store
      Throws:
      JRDFoxException - thrown if an error is encountered

    • getComponentInfo

      ComponentInfo getComponentInfo​(boolean extended) throws JRDFoxException
      Returns diagnostic information about the data store as a tree of objects each providing detailed information about the data store. Note: This information should be used for diagnostics purposes only. The content of ComponentInfo is subject to change in future version. Callers should not rely on named property or a specific subcomponent being present.
      Parameters:
      extended - if true, returns extensive information about various subcomponents about the data store (mainly used for troubleshooting)
      Returns:
      information about the data store
      Throws:
      JRDFoxException - thrown if an error is encountered

    • listTupleTables

      java.util.List<TupleTableInfo> listTupleTables() throws JRDFoxException
      Returns information about the tuple tables currently present in the data store.
      Returns:
      information about the tuple tables currently present in the data store
      Throws:
      JRDFoxException - thrown if an error is encountered

    • containsTupleTable

      boolean containsTupleTable​(java.lang.String tupleTableName) throws JRDFoxException
      Checks whether the data store contains a tuple table with the specified name.
      Parameters:
      tupleTableName - the name of the tuple table to be checked
      Returns:
      true if the data store contains a tuple table with the given name
      Throws:
      JRDFoxException - thrown if an error is encountered

    • createTupleTable

      void createTupleTable​(java.lang.String tupleTableName, java.util.Map<java.lang.String,​java.lang.String> tupleTableParameters) throws JRDFoxException
      Creates a tuple table in a data store. The type of the tuple table is described by the supplied parameters. By using appropriate parameters, this method can be used to mount a tuple table from a data source. This operation can be invoked only if no transaction is active on the connection.
      Parameters:
      tupleTableName - the name of the tuple table to be created
      tupleTableParameters - the key-value pairs that describe the tuple table to be created
      Throws:
      JRDFoxException - thrown if an error is encountered

    • deleteTupleTable

      void deleteTupleTable​(java.lang.String tupleTableName) throws JRDFoxException
      Deletes the tuple table with the specified name from the data store. A tuple table can be deleted only if it is not used in the body or head of any rule currently loaded in the data store. This operation can be invoked only if no transaction is active on the connection.
      Parameters:
      tupleTableName - the name of the tuple table to be deleted
      Throws:
      JRDFoxException - thrown if an error is encountered

    • describeTupleTable

      TupleTableInfo describeTupleTable​(java.lang.String tupleTableName) throws JRDFoxException
      Returns information about the tuple table with the given name.
      Parameters:
      tupleTableName - the name of the tuple table whose information is to be returned
      Returns:
      information about the tuple table
      Throws:
      JRDFoxException - thrown if an error is encountered

    • listDataSources

      java.util.List<DataSourceInfo> listDataSources() throws JRDFoxException
      Returns information about the data sources currently present in the data store.
      Returns:
      information about the tuple tables currently present in the data store
      Throws:
      JRDFoxException - thrown if an error is encountered

    • containsDataSource

      boolean containsDataSource​(java.lang.String dataSourceName) throws JRDFoxException
      Checks whether the data store contains a data source with the specified name.
      Parameters:
      dataSourceName - the name of the data source to be checked
      Returns:
      true if the data store contains a data source with the given name
      Throws:
      JRDFoxException - thrown if an error is encountered

    • registerDataSource

      void registerDataSource​(java.lang.String dataSourceName, java.util.Map<java.lang.String,​java.lang.String> dataSourceParameters) throws JRDFoxException
      Registers a data source with a data store. The new data source is described using the supplied key-value pairs. This operation can be invoked only if no transaction is active on the connection.
      Parameters:
      dataSourceName - the name of the data source to be created
      dataSourceParameters - the key-value pairs that describe the data source to be created
      Throws:
      JRDFoxException - thrown if an error is encountered

    • deregisterDataSource

      void deregisterDataSource​(java.lang.String dataSourceName) throws JRDFoxException
      Deregisters the data source table with the specified name from the data store. This operation can be invoked only if no transaction is active on the connection.
      Parameters:
      dataSourceName - the name of the data source to be deleted
      Throws:
      JRDFoxException - thrown if an error is encountered

    • describeDataSource

      DataSourceInfo describeDataSource​(java.lang.String dataSourceName) throws JRDFoxException
      Returns information about the data source with the given name.
      Parameters:
      dataSourceName - the name of the data source whose information is to be returned
      Returns:
      information about the data source
      Throws:
      JRDFoxException - thrown if an error is encountered

    • listDataSourceTables

      java.util.List<DataSourceTableInfo> listDataSourceTables​(java.lang.String dataSourceName) throws JRDFoxException
      Returns information about the data source tables of the specified data source in the data store.
      Parameters:
      dataSourceName - the name of the data source whose tables are to be listed
      Returns:
      information about the data source tables of the specified data source
      Throws:
      JRDFoxException - thrown if an error is encountered

    • containsDataSourceTable

      boolean containsDataSourceTable​(java.lang.String dataSourceName, java.lang.String dataSourceTableName) throws JRDFoxException
      Checks whether the specified data source in the data store contains a data source table with the specified name.
      Parameters:
      dataSourceName - the name of the data source
      dataSourceTableName - the name of the data source table
      Returns:
      true if the specified data source contains the specified data source table
      Throws:
      JRDFoxException - thrown if an error is encountered

    • describeDataSourceTable

      DataSourceTableInfo describeDataSourceTable​(java.lang.String dataSourceName, java.lang.String dataSourceTableName) throws JRDFoxException
      Returns information about the data source table of the specified data source in the data store.
      Parameters:
      dataSourceName - the name of the data source
      dataSourceTableName - the name of the data source table
      Returns:
      information about the data source table
      Throws:
      JRDFoxException - thrown if an error is encountered

    • getDataSourceTableData

      ResourceValue[][] getDataSourceTableData​(java.lang.String dataSourceName, java.lang.String dataSourceTableName, int numberOfRows) throws JRDFoxException
      Returns a sample of the data from the specified data source table. This method is not designed for efficient importation of data from a data source. Rather, its main purpose is to allow applications to view the data in the source before mounting an appropriate tuple table.
      Parameters:
      dataSourceName - the name of the data source
      dataSourceTableName - the name of the data source table
      numberOfRows - the maximum number of rows to be returned
      Returns:
      a sample of the data from the data source table
      Throws:
      JRDFoxException - thrown if an error is encountered

    • listStatistics

      java.util.List<StatisticsInfo> listStatistics() throws JRDFoxException
      Returns information about all statistics currently managed by the data store.
      Returns:
      information about all statistics that the data store currently manages
      Throws:
      JRDFoxException - thrown if an error is encountered

    • containsStatistics

      boolean containsStatistics​(java.lang.String statisticsName) throws JRDFoxException
      Checks whether the data store contains the statistics with the specified name.
      Parameters:
      statisticsName - the name of the statistics
      Returns:
      true if the data store contains the specified statistics
      Throws:
      JRDFoxException - thrown if an error is encountered

    • createStatistics

      void createStatistics​(java.lang.String statisticsName, java.util.Map<java.lang.String,​java.lang.String> statisticsParameters) throws JRDFoxException
      Creates the statistics in a data store. The name of the statistics determines their type; thus, a data store can contain at most one statistics of a particular type, and the type corresponds to the statistics name. The way in which the statistics are gathered is influenced by the the supplied key-value pairs. This operation can be invoked only if no transaction is active on the connection.
      Parameters:
      statisticsName - the name of the data source to be created
      statisticsParameters - the key-value pairs that describe the statistics to be created
      Throws:
      JRDFoxException - thrown if an error is encountered

    • deleteStatistics

      void deleteStatistics​(java.lang.String statisticsName) throws JRDFoxException
      Deletes the data store statistics with the specified name from the data store. This operation can be invoked only if no transaction is active on the connection.
      Parameters:
      statisticsName - the name of the data store statistics to be deleted
      Throws:
      JRDFoxException - thrown if an error is encountered

    • describeStatistics

      StatisticsInfo describeStatistics​(java.lang.String statisticsName) throws JRDFoxException
      Returns information about the specific statistics of the data store.
      Parameters:
      statisticsName - the name of the statistics whose information should be returned
      Returns:
      information about the statistics
      Throws:
      JRDFoxException - thrown if an error is encountered

    • updateStatistics

      void updateStatistics() throws JRDFoxException
      Updates all statistics that the data store uses to plan queries and rules. This operation should be invoked after large additions to the data store, or after a large number of facts has been derived. This operation can be invoked if either no transaction is active, or a read/write transaction is active. In the latter case, rolling back a transaction does not restore the statistics to their original state.
      Throws:
      JRDFoxException - thrown if an error is encountered

    • setNextOperationMustMatchDataStoreVersion

      void setNextOperationMustMatchDataStoreVersion​(long dataStoreVersion) throws JRDFoxException
      Configures this connection so that the next operation is accepted only if the data store has the given version before the operation commences. If the data store version does not match when the operation is invoked, the operation will throw DataStoreVersionDoesNotMatchException. Note that the version is not checked during this operation: this simply sets up the connection so that the next operation is checked. This mechanism can be used to make sure that each operation uses an expected version of the data.
      Parameters:
      dataStoreVersion - the desired version (or 0 to not expect any specific data store version)
      Throws:
      JRDFoxException - thrown if an error is encountered

    • getNextOperationMustMatchDataStoreVersion

      long getNextOperationMustMatchDataStoreVersion() throws JRDFoxException
      Returns the data store version that the next operation on this connection should expect.
      Returns:
      the desired data store version for the next operation (or 0 if any version can be accepted)
      Throws:
      JRDFoxException - thrown if an error is encountered

    • setNextOperationMustNotMatchDataStoreVersion

      void setNextOperationMustNotMatchDataStoreVersion​(long dataStoreVersion) throws JRDFoxException
      Configures this connection so that the next operation is accepted only if the data store does not have the given version before the operation commences. If the data store version matches when the operation is invoked, the operation will throw DataStoreVersionMatchesException. Note that the version is not checked during this operation: this simply sets up the connection so that the next operation is checked. This mechanism can be used to make sure that the next operation succeeds only if the data store has changed.
      Parameters:
      dataStoreVersion - the desired version (or 0 to not expect any specific data store version)
      Throws:
      JRDFoxException - thrown if an error is encountered

    • getNextOperationMustNotMatchDataStoreVersion

      long getNextOperationMustNotMatchDataStoreVersion() throws JRDFoxException
      Returns the data store version that the next operation on this connection should not expect.
      Returns:
      the undesired data store version for the next operation (or 0 if any version can be accepted)
      Throws:
      JRDFoxException - thrown if an error is encountered

    • getDataStoreVersionAfterLastOperation

      long getDataStoreVersionAfterLastOperation() throws JRDFoxException
      Returns the version that the data store had after the last operation on this connection. If a transaction is active, the current data store version is returned. Note that rolling back a transaction does not restore the data store version.
      Returns:
      the version that the data store had after the last transaction on this connection (or 0 if no transaction was performed on this connection)
      Throws:
      JRDFoxException - thrown if an error is encountered

    • updateStatistics

      void updateStatistics​(java.lang.String statisticsName) throws JRDFoxException
      Updates the statistics with the given name that the data store uses to plan queries and rules. This operation should be invoked after large additions to the data store, or after a large number of facts has been derived. This operation can be invoked if either no transaction is active, or a read/write transaction is active. In the latter case, rolling back a transaction does not restore the statistics to their original state.
      Parameters:
      statisticsName - the name of the statistics that should be updated
      Throws:
      JRDFoxException - thrown if an error is encountered

    • getTransactionState

      TransactionState getTransactionState() throws JRDFoxException
      Returns the state of the transaction associated with this connection.
      Returns:
      the state of the transaction
      Throws:
      JRDFoxException - thrown if an error is encountered

    • transactionRequiresRollback

      boolean transactionRequiresRollback() throws JRDFoxException
      Returns true if a transaction is active on this connection and this transaction must be rolled back (i.e., it cannot be committed). This happens when certain operations invoked in a transaction result in an error.
      Returns:
      true if the currently active transaction must be committed
      Throws:
      JRDFoxException - thrown if an error is encountered

    • beginTransaction

      void beginTransaction​(TransactionType transactionType) throws JRDFoxException
      Starts a new transaction on this connection.
      Parameters:
      transactionType - determines the type of the transaction (i.e., whether a read-only or a read/write transaction is requested)
      Throws:
      JRDFoxException - thrown if an error is encountered

    • commitTransaction

      void commitTransaction() throws JRDFoxException
      Commits the transaction associated with this connection. If an exception is thrown during a commit operation, transactionRequiresRollback() will return true, and the transaction should be explicitly rolled back using rollbackTransaction().
      Throws:
      JRDFoxException - thrown if an error is encountered

    • rollbackTransaction

      void rollbackTransaction() throws JRDFoxException
      Rolls back the transaction associated with this connection.
      Throws:
      JRDFoxException - thrown if an error is encountered

    • clear

      void clear() throws JRDFoxException
      Clears the content of this data store -- that is, it clears all data and rules so the logical state of the data store is the same as after initialisation. This operation, however, does not clear the data store dictionary, so clients that have cached any resource IDs can still use them. This operation can be called inside a transaction, but, depending on the circumstances, requiresIncrementalReasoning() can subsequently return true, — that is, subsequent materialization will not be performed using the standard "from scratch" algorithm, which can affect efficiency. In contrast, if this operation is performed outside a transaction, then subsequent materialization will necessarily be performed using the standard "from scratch" algorithm.
      Throws:
      JRDFoxException - thrown if an error is encountered

    • clearRulesAxiomsExplicateFacts

      void clearRulesAxiomsExplicateFacts() throws JRDFoxException
      Clears all rules and turns all facts in the data store into EDB facts. After this operation, the data store is in the same state as if all derived facts have been imported from a file. This operation can be invoked only if no transaction is active.
      Throws:
      JRDFoxException - thrown if an error is encountered

    • compact

      void compact() throws JRDFoxException
      Compact the data in the data store. This involves removing all deleted triples, and possibly sorting the data in order to facilitate faster access. This may result in reduced memory usage and/or disk usage for persisted data stores. This operation can be invoked only if no transaction is active.
      Throws:
      JRDFoxException - thrown if an error is encountered

    • exportData

      void exportData​(Prefixes prefixes, java.io.OutputStream outputStream, java.lang.String formatName, java.util.Map<java.lang.String,​java.lang.String> parameters) throws JRDFoxException
      Exports the data in the data store using the given format. The format determines which subset of the store data is to be exported; for example, the Turtle format can store triples, but not facts in other tuple tables or the rules. It is possible to pass a set of prefixes that will be used to abbreviate IRIs in the output (provided that the output format supports IRI abbreviations). This object is not modified by this method.
      Parameters:
      prefixes - the prefixes used to abbreviate IRIs in the output (provided that the output format supports IRI abbreviation)
      outputStream - receives the exported data
      formatName - the name of the output format
      parameters - key-value pairs that, depending on the format, customise the export process
      Throws:
      JRDFoxException - thrown if an error is encountered

    • exportData

      void exportData​(Prefixes prefixes, java.io.File file, java.lang.String formatName, java.util.Map<java.lang.String,​java.lang.String> parameters) throws JRDFoxException
      Exports the data in the data store using the given format. The format determines which subset of the store data is to be exported; for example, the Turtle format can store triples, but not facts in other tuple tables or the rules. It is possible to pass a set of prefixes that will be used to abbreviate IRIs in the output (provided that the output format supports IRI abbreviations). This object is not modified by this method.
      Parameters:
      prefixes - the prefixes used to abbreviate IRIs in the output (provided that the output format supports IRI abbreviation)
      file - receives the exported data
      formatName - the name of the output format
      parameters - key-value pairs that, depending on the format, customise the export process
      Throws:
      JRDFoxException - thrown if an error is encountered

    • importData

      ImportResult importData​(UpdateType updateType, Prefixes prefixes, InputSourceFactory inputSourceFactory, java.lang.String formatName, ImportNotificationMonitor importNotificationMonitor) throws JRDFoxException
      Imports the data described by the given input source factory into the current data store. The prefixes from the supplied Prefixes object are conceptually treated as if they were present at the beginning of the input. Any prefixes found in the input are added to the supplied Prefixes object.
      Parameters:
      updateType - specifies whether the imported data should be added or removed from the data store
      prefixes - provides the prefixes that are considered declared in advance, and receives the prefixes from the input
      inputSourceFactory - the content being imported
      formatName - the name of the format of the data
      importNotificationMonitor - receives errors/warnings encountered during import
      Returns:
      provides information about the importation process
      Throws:
      JRDFoxException - thrown if an error is encountered

    • importData

      ImportResult importData​(UpdateType updateType, Prefixes prefixes, java.util.Collection<InputSourceFactory> inputSourceFactories, java.lang.String formatName, ImportNotificationMonitor importNotificationMonitor) throws JRDFoxException
      Imports the data described by the given input source factories into the current data store. If this server is configured to use more than one thread, then sources are parsed and imported in parallel. The prefixes from the supplied Prefixes object are conceptually treated as if they were present at the beginning of each input. Any prefixes found in some input are added to the supplied Prefixes object.
      Parameters:
      updateType - specifies whether the imported data should be added or removed from the data store
      prefixes - provides the prefixes that are considered declared in advance, and receives the prefixes from all inputs
      inputSourceFactories - the content being imported
      formatName - the name of the format of the data
      importNotificationMonitor - receives errors/warnings encountered during import
      Returns:
      provides information about the importation process
      Throws:
      JRDFoxException - thrown if an error is encountered

    • importData

      ImportResult importData​(UpdateType updateType, Prefixes prefixes, java.io.File file) throws JRDFoxException
      Imports the data from the given file into the current data store. The prefixes from the supplied Prefixes object are conceptually treated as if they were present at the beginning of the file. Any prefixes found in the file are added to the supplied Prefixes object.
      Parameters:
      updateType - specifies whether the imported data should be added or removed from the data store
      prefixes - provides the prefixes that are considered declared in advance, and receives the prefixes from all the file
      file - the content being imported
      Returns:
      provides information about the importation process
      Throws:
      JRDFoxException - thrown if an error is encountered

    • importData

      ImportResult importData​(UpdateType updateType, Prefixes prefixes, java.lang.String content) throws JRDFoxException
      Imports the data from the given string into the current data store. The prefixes from the supplied Prefixes object are conceptually treated as if they were present at the beginning of the string. Any prefixes found in the string are added to the supplied Prefixes object.
      Parameters:
      updateType - specifies whether the imported data should be added or removed from the data store
      prefixes - provides the prefixes that are considered declared in advance, and receives the prefixes from all the string
      content - the content being imported
      Returns:
      provides information about the importation process
      Throws:
      JRDFoxException - thrown if an error is encountered

    • importData

      ImportResult importData​(UpdateType updateType, Prefixes prefixes, java.io.InputStream inputStream) throws JRDFoxException
      Imports the data from the given input stream into the current data store. The prefixes from the supplied Prefixes object are conceptually treated as if they were present at the beginning of the input stream. Any prefixes found in the input stream are added to the supplied Prefixes object.
      Parameters:
      updateType - specifies whether the imported data should be added or removed from the data store
      prefixes - provides the prefixes that are considered declared in advance, and receives the prefixes from the input stream
      inputStream - the content being imported
      Returns:
      provides information about the importation process
      Throws:
      JRDFoxException - thrown if an error is encountered

    • importData

      ImportResult importData​(java.lang.String defaultGraphName, UpdateType updateType, Prefixes prefixes, InputSourceFactory inputSourceFactory, java.lang.String formatName, ImportNotificationMonitor importNotificationMonitor) throws JRDFoxException
      Imports the data described by the given input source factory into the current data store The graph with the specified name is used as a default graph. The prefixes from the supplied Prefixes object are conceptually treated as if they were present at the beginning of the input. Any prefixes found in the input are added to the supplied Prefixes object.
      Parameters:
      defaultGraphName - the name of the default graph
      updateType - specifies whether the imported data should be added or removed from the data store
      prefixes - provides the prefixes that are considered declared in advance, and receives the prefixes from the input
      inputSourceFactory - the content being imported
      formatName - the name of the format of the data
      importNotificationMonitor - receives errors/warnings encountered during import
      Returns:
      provides information about the importation process
      Throws:
      JRDFoxException - thrown if an error is encountered

    • importData

      ImportResult importData​(java.lang.String defaultGraphName, UpdateType updateType, Prefixes prefixes, java.util.Collection<InputSourceFactory> inputSourceFactories, java.lang.String formatName, ImportNotificationMonitor importNotificationMonitor) throws JRDFoxException
      Imports the data described by the given input source factories into the current data store. The graph with the specified name is used as a default graph. If this server is configured to use more than one thread, then sources are parsed and imported in parallel. The prefixes from the supplied Prefixes object are conceptually treated as if they were present at the beginning of each input. Any prefixes found in some input are added to the supplied Prefixes object.
      Parameters:
      defaultGraphName - the name of the default graph
      updateType - specifies whether the imported data should be added or removed from the data store
      prefixes - provides the prefixes that are considered declared in advance, and receives the prefixes from all inputs
      inputSourceFactories - the content being imported
      formatName - the name of the format of the data
      importNotificationMonitor - receives errors/warnings encountered during import
      Returns:
      provides information about the importation process
      Throws:
      JRDFoxException - thrown if an error is encountered

    • importData

      ImportResult importData​(java.lang.String defaultGraphName, UpdateType updateType, Prefixes prefixes, java.io.File file) throws JRDFoxException
      Imports the data from the given file into the current data store. The graph with the specified name is used as a default graph. The prefixes from the supplied Prefixes object are conceptually treated as if they were present at the beginning of the file. Any prefixes found in the file are added to the supplied Prefixes object.
      Parameters:
      defaultGraphName - the name of the default graph
      updateType - specifies whether the imported data should be added or removed from the data store
      prefixes - provides the prefixes that are considered declared in advance, and receives the prefixes from the file
      file - the content being imported
      Returns:
      provides information about the importation process
      Throws:
      JRDFoxException - thrown if an error is encountered

    • importData

      ImportResult importData​(java.lang.String defaultGraphName, UpdateType updateType, Prefixes prefixes, java.lang.String content) throws JRDFoxException
      Imports the data from the given string into the current data store. The graph with the specified name is used as a default graph. The prefixes from the supplied Prefixes object are conceptually treated as if they were present at the beginning of the string. Any prefixes found in the string are added to the supplied Prefixes object.
      Parameters:
      defaultGraphName - the name of the default graph
      updateType - specifies whether the imported data should be added or removed from the data store
      prefixes - provides the prefixes that are considered declared in advance, and receives the prefixes from the string
      content - the content being imported
      Returns:
      provides information about the importation process
      Throws:
      JRDFoxException - thrown if an error is encountered

    • importData

      ImportResult importData​(java.lang.String defaultGraphName, UpdateType updateType, Prefixes prefixes, java.io.InputStream inputStream) throws JRDFoxException
      Imports the data from the given input stream into the current data store. The graph with the specified name is used as a default graph. The prefixes from the supplied Prefixes object are conceptually treated as if they were present at the beginning of the input stream. Any prefixes found in the input stream are added to the supplied Prefixes object.
      Parameters:
      defaultGraphName - the name of the default graph
      updateType - specifies whether the imported data should be added or removed from the data store
      prefixes - provides the prefixes that are considered declared in advance, and receives the prefixes from the input stream
      inputStream - the content being imported
      Returns:
      provides information about the importation process
      Throws:
      JRDFoxException - thrown if an error is encountered

    • importAxiomsFromTriples

      ImportResult importAxiomsFromTriples​(java.lang.String sourceGraphName, boolean translateAssertions, java.lang.String destinationGraphName, UpdateType updateType, ImportNotificationMonitor importNotificationMonitor) throws JRDFoxException
      Parses the given source graph into OWL axioms, and imports the axioms into the destination graph.
      Parameters:
      sourceGraphName - the name of source graph
      translateAssertions - assertions are translated if this parameter is true
      destinationGraphName - the name of destination graph
      updateType - specifies whether the imported data should be added or removed from the data store
      importNotificationMonitor - receives errors/warnings encountered during import
      Returns:
      provides information about the importation process
      Throws:
      JRDFoxException - thrown if an error is encountered

    • importAxiomsFromTriples

      ImportResult importAxiomsFromTriples​(java.lang.String sourceGraphName, boolean translateAssertions, java.lang.String destinationGraphName, UpdateType updateType) throws JRDFoxException
      Parses the given source graph into OWL axioms, and imports the axioms into the destination graph.
      Parameters:
      sourceGraphName - the name of source graph
      translateAssertions - assertions are translated if this parameter is true
      destinationGraphName - the name of destination graph
      updateType - specifies whether the imported data should be added or removed from the data store
      Returns:
      provides information about the importation process
      Throws:
      JRDFoxException - thrown if an error is encountered

    • listRules

      java.util.List<RuleInfo> listRules() throws JRDFoxException
      Returns the information about the rules currently loaded into the data store.
      Returns:
      information about the rules currently loaded into the data store
      Throws:
      JRDFoxException - thrown if an error is encountered

    • addRule

      long addRule​(Rule rule) throws JRDFoxException
      Adds a rule to the data store.
      Parameters:
      rule - the rule to be added
      Returns:
      the number of rules that were changed
      Throws:
      JRDFoxException - thrown if an error is encountered

    • addRules

      long addRules​(java.util.Collection<Rule> datalogProgram) throws JRDFoxException
      Adds a collection of rules to the data store.
      Parameters:
      datalogProgram - the rules to be added
      Returns:
      the number of rules that were changed
      Throws:
      JRDFoxException - thrown if an error is encountered

    • deleteRule

      long deleteRule​(Rule rule) throws JRDFoxException
      Deletes a rule to the data store.
      Parameters:
      rule - the rule to be deleted
      Returns:
      the number of rules that were changed
      Throws:
      JRDFoxException - thrown if an error is encountered

    • deleteRules

      long deleteRules​(java.util.Collection<Rule> datalogProgram) throws JRDFoxException
      Deletes a collection of rules to the data store.
      Parameters:
      datalogProgram - the rules to be deleted
      Returns:
      the number of rules that were changed
      Throws:
      JRDFoxException - thrown if an error is encountered

    • recompileRules

      void recompileRules() throws JRDFoxException
      Recompiles the rules using the currently available statistics. This method should be called after bulk updates to a data store in order to ensure that the rules are evaluated using efficient query plans. TThis operation can be invoked if either no transaction is active, or a read/write transaction is active.
      Throws:
      JRDFoxException - thrown if an error is encountered

    • requiresIncrementalReasoning

      boolean requiresIncrementalReasoning() throws JRDFoxException
      Returns true if the next data store update must be performed using incremental reasoning (rather than standard using the standard datalog materialization "from scratch" algorithm).
      Returns:
      true if the next data store update must be performed using incremental reasoning
      Throws:
      JRDFoxException - thrown if an error is encountered

    • updateMaterialization

      void updateMaterialization() throws JRDFoxException
      Updates the materialization so that all and only the consequences of the explicitly stated facts and the rules are derived. This operation is automatically applied internally so that all queries are always evaluated with respect to the updated materialization. However, requesting an update explicitly can be beneficial in some cases (e.g., when benchmarking reasoning algorithms). This operation can be invoked only if a read/write transaction is active.
      Throws:
      JRDFoxException - thrown if an error is encountered

    • recomputeMaterialization

      void recomputeMaterialization() throws JRDFoxException
      Recomputes the materialization from scratch — that is, deletes all derived facts and applies all rules as if the data had just been freshly imported. This operation can be used when the data in a data source attached to a data store changes: since there is no way for an external data source to notify the data store of data changes, the only option is to recompute everything afresh. This operation can be invoked only if no transaction is active.
      Throws:
      JRDFoxException - thrown if an error is encountered

    • createExplanation

      void createExplanation​(java.lang.String baseIRI, Prefixes prefixes, java.lang.String factText, int maxDistanceFromRoot, int maxRuleInstancesPerFact, ExplanationType explanationType, java.io.OutputStream outputStream) throws JRDFoxException
      Computes an explanation for a given fact and saves it in JSON format to the given output stream.
      Parameters:
      baseIRI - the base IRI that should be used while parsing the fact (if null, a default is used)
      prefixes - provides the prefixes that should be used to parse the fact and write the explanation
      factText - the fact to be explained
      maxDistanceFromRoot - specifies how far in the proof tree to look
      maxRuleInstancesPerFact - specifies the maximum number of rule instances deriving a particular fact to consider
      explanationType - determines the type of explanation that should be produced
      outputStream - receives the explanation
      Throws:
      JRDFoxException - thrown if an error is encountered

    • createExplanation

      void createExplanation​(Prefixes prefixes, TupleTableAtom fact, int maxDistanceFromRoot, int maxRuleInstancesPerFact, ExplanationType explanationType, java.io.OutputStream outputStream) throws JRDFoxException
      Computes an explanation for a given fact and saves it in JSON format to the given output stream.
      Parameters:
      prefixes - provides the prefixes that should be used to write the explanation
      fact - the fact to be explained
      maxDistanceFromRoot - specifies how far in the proof tree to look
      maxRuleInstancesPerFact - specifies the maximum number of rule instances deriving a particular fact to consider
      explanationType - determines the type of explanation that should be produced
      outputStream - receives the explanation
      Throws:
      JRDFoxException - thrown if an error is encountered

    • createCursor

      Cursor createCursor​(java.lang.String baseIRI, Prefixes prefixes, java.lang.String queryText, java.util.Map<java.lang.String,​java.lang.String> compilationParameters, int fetchWindowSize) throws JRDFoxException
      Creates a cursor over the results of the given query. Since calling C++ from Java is expensive, JRDFox cursors have the option to retrieve answers in batches, and the batch size is governed by the fetchWindowSize parameter. Please note that data store version checking is performed only on each access to the C++ cursor; thus, if the batch size is different from one, then a JRDFox cursor might detect a data store change with a delay. The prefixes from the supplied Prefixes object are conceptually treated as if they were present at the beginning of the query. Any prefixes found in the query are added to the supplied Prefixes object.
      Parameters:
      baseIRI - the base IRI for the query (if null, a default is used)
      prefixes - provides the prefixes that are considered declared in advance, and receives the prefixes from the query
      queryText - the query to be evaluated
      compilationParameters - the key-value pairs guiding query compilation
      fetchWindowSize - the number of answers that will be retrieved from C++ in each cursor operation
      Returns:
      the cursor over the query results
      Throws:
      JRDFoxException - thrown if an error is encountered

    • createCursor

      Cursor createCursor​(java.lang.String baseIRI, Prefixes prefixes, java.lang.String queryText, java.util.Map<java.lang.String,​java.lang.String> compilationParameters) throws JRDFoxException
      Creates a cursor over the results of the given query with the default fetch window size of 100. The prefixes from the supplied Prefixes object are conceptually treated as if they were present at the beginning of the query. Any prefixes found in the query are added to the supplied Prefixes object.
      Parameters:
      baseIRI - the base IRI for the query (if null, a default is used)
      prefixes - provides the prefixes that are considered declared in advance, and receives the prefixes from the query
      queryText - the query to be evaluated
      compilationParameters - the key-value pairs guiding query compilation
      Returns:
      the cursor over the query results
      Throws:
      JRDFoxException - thrown if an error is encountered

    • createCursor

      Cursor createCursor​(Query query, java.util.Map<java.lang.String,​java.lang.String> compilationParameters, int fetchWindowSize) throws JRDFoxException
      Creates a cursor over the results of the given query. Since calling C++ from Java is expensive, JRDFox cursors have the option to retrieve answers in batches, and the batch size is governed by the fetchWindowSize parameter. Please note that data store version checking is performed only on each access to the C++ cursor; thus, if the batch size is different from one, then a JRDFox cursor might detect a data store change with a delay.
      Parameters:
      query - the query to be evaluated
      compilationParameters - the key-value pairs guiding query compilation
      fetchWindowSize - the number of answers that will be retrieved from C++ in each cursor operation
      Returns:
      the cursor over the query results
      Throws:
      JRDFoxException - thrown if an error is encountered

    • createCursor

      Cursor createCursor​(Query query, java.util.Map<java.lang.String,​java.lang.String> compilationParameters) throws JRDFoxException
      Creates a cursor over the results of the given query with the default fetch window size of 100.
      Parameters:
      query - the query to be evaluated
      compilationParameters - the key-value pairs guiding query compilation
      Returns:
      the cursor over the query results
      Throws:
      JRDFoxException - thrown if an error is encountered

    • evaluateQuery

      StatementResult evaluateQuery​(java.lang.String baseIRI, Prefixes prefixes, java.lang.String queryText, java.util.Map<java.lang.String,​java.lang.String> compilationParameters, QueryAnswerMonitor queryAnswerMonitor) throws JRDFoxException
      Evaluates a query and calls the supplied QueryAnswerMonitor instance for each tuple in the result. The prefixes from the supplied Prefixes object are conceptually treated as if they were present at the beginning of the query. Any prefixes found in the query are added to the supplied Prefixes object.
      Parameters:
      baseIRI - the base IRI for the query (if null, a default is used)
      prefixes - provides the prefixes that are considered declared in advance, and receives the prefixes from the query
      queryText - the query to be evaluated
      compilationParameters - the key-value pairs guiding query compilation
      queryAnswerMonitor - an interface containing a callback method that is called for each tuple in the result
      Returns:
      provides information about the number of results produced
      Throws:
      JRDFoxException - thrown if an error is encountered

    • evaluateQuery

      StatementResult evaluateQuery​(Query query, java.util.Map<java.lang.String,​java.lang.String> compilationParameters, QueryAnswerMonitor queryAnswerMonitor) throws JRDFoxException
      Evaluates a query and calls the supplied QueryAnswerMonitor instance for each tuple in the result.
      Parameters:
      query - the query to be evaluated
      compilationParameters - the key-value pairs guiding query compilation
      queryAnswerMonitor - an interface containing a callback method that is called for each tuple in the result
      Returns:
      provides information about the number of results produced
      Throws:
      JRDFoxException - thrown if an error is encountered

    • evaluateUpdate

      StatementResult evaluateUpdate​(java.lang.String baseIRI, Prefixes prefixes, java.lang.String updateText, java.util.Map<java.lang.String,​java.lang.String> compilationParameters) throws JRDFoxException
      Evaluates an update. The prefixes from the supplied Prefixes object are conceptually treated as if they were present at the beginning of the update. Any prefixes found in the update are added to the supplied Prefixes object.
      Parameters:
      baseIRI - the base IRI for the query (if null, a default is used)
      prefixes - provides the prefixes that are considered declared in advance, and receives the prefixes from the update
      updateText - the update to be evaluated
      compilationParameters - the key-value pairs guiding statement compilation
      Returns:
      provides information about the number of results produced
      Throws:
      JRDFoxException - thrown if an error is encountered

    • evaluateUpdate

      StatementResult evaluateUpdate​(Update update, java.util.Map<java.lang.String,​java.lang.String> compilationParameters) throws JRDFoxException
      Evaluates an update.
      Parameters:
      update - the update to be evaluated
      compilationParameters - the key-value pairs guiding statement compilation
      Returns:
      provides information about the number of results produced
      Throws:
      JRDFoxException - thrown if an error is encountered

    • evaluateUpdates

      StatementResult evaluateUpdates​(java.util.List<Update> updates, java.util.Map<java.lang.String,​java.lang.String> compilationParameters) throws JRDFoxException
      Evaluates a list of updates.
      Parameters:
      updates - the list of updates to be evaluated
      compilationParameters - the key-value pairs guiding statement compilation
      Returns:
      provides information about the number of results produced
      Throws:
      JRDFoxException - thrown if an error is encountered

    • evaluateStatement

      StatementResult evaluateStatement​(java.lang.String baseIRI, Prefixes prefixes, java.lang.String statementText, java.util.Map<java.lang.String,​java.lang.String> compilationParameters, java.io.OutputStream outputStream, java.lang.String queryAnswerFormatName) throws JRDFoxException
      Evaluates a statement and serialises the result to the supplied output stream using the specified format. The prefixes from the supplied Prefixes object are conceptually treated as if they were present at the beginning of the statement. Any prefixes found in the update are added to the supplied Prefixes object, and this extended set of prefixes will be used to abbreviate IRIs (in case the answer format supports IRI abbreviation).
      Parameters:
      baseIRI - the base IRI for the query (if null, a default is used)
      prefixes - provides the prefixes that are considered declared in advance, and receives the prefixes from the statement
      statementText - the statement to be evaluated
      compilationParameters - the key-value pairs guiding statement compilation
      outputStream - receives the statement result
      queryAnswerFormatName - specifies the name of the answer format in case of a query
      Returns:
      provides information about the number of results produced
      Throws:
      JRDFoxException - thrown if an error is encountered

    • evaluateStatement

      StatementResult evaluateStatement​(Prefixes prefixes, Statement statement, java.util.Map<java.lang.String,​java.lang.String> compilationParameters, java.io.OutputStream outputStream, java.lang.String queryAnswerFormatName) throws JRDFoxException
      Evaluates a statement and serialises the result to the supplied output stream using the specified format. The prefixes from the supplied Prefixes object will be used to abbreviate IRIs (in case the answer format supports IRI abbreviation), and the object will not change.
      Parameters:
      prefixes - used to abbreviate IRIs in the output (the object is not modified)
      statement - the statement to be evaluated
      compilationParameters - the key-value pairs guiding statement compilation
      outputStream - receives the query result
      queryAnswerFormatName - specifies the name of the answer format in case of a query
      Returns:
      provides information about the number of results produced
      Throws:
      JRDFoxException - thrown if an error is encountered

    • evaluateStatement

      StatementResult evaluateStatement​(java.lang.String baseIRI, Prefixes prefixes, java.lang.String statementText, java.util.Map<java.lang.String,​java.lang.String> compilationParameters, java.io.File file, java.lang.String queryAnswerFormatName) throws JRDFoxException
      Evaluates a statement and serialises the result to the supplied file using the specified format. The prefixes from the supplied Prefixes object are conceptually treated as if they were present at the beginning of the statement. Any prefixes found in the update are added to the supplied Prefixes object, and this extended set of prefixes will be used to abbreviate IRIs (in case the answer format supports IRI abbreviation).
      Parameters:
      baseIRI - the base IRI for the query (if null, a default is used)
      prefixes - provides the prefixes that are considered declared in advance, and receives the prefixes from the statement
      statementText - the statement to be evaluated
      compilationParameters - the key-value pairs guiding statement compilation
      file - receives the query result
      queryAnswerFormatName - specifies the name of the answer format in case of a query
      Returns:
      provides information about the number of results produced
      Throws:
      JRDFoxException - thrown if an error is encountered

    • evaluateStatement

      StatementResult evaluateStatement​(Prefixes prefixes, Statement statement, java.util.Map<java.lang.String,​java.lang.String> compilationParameters, java.io.File file, java.lang.String queryAnswerFormatName) throws JRDFoxException
      Evaluates a statement and serialises the result to the supplied file using the specified format. The prefixes from the supplied Prefixes object will be used to abbreviate IRIs (in case the answer format supports IRI abbreviation), and the object will not change.
      Parameters:
      prefixes - used to abbreviate IRIs in the output (the object is not modified)
      statement - the statement to be evaluated
      compilationParameters - the key-value pairs guiding statement compilation
      file - receives the query result
      queryAnswerFormatName - specifies the name of the answer format in case of a query
      Returns:
      provides information about the number of results produced
      Throws:
      JRDFoxException - thrown if an error is encountered

    • getDictionaryVersion

      long getDictionaryVersion() throws JRDFoxException
      Returns the version of the data store dictionary, which is an number that is incremented every time the data store dictionary is cleared. By recording the value of this counter and checking it later again, clients can detect whether the resource IDs resolved earlier are still valid.
      Returns:
      the generation counter of the data store
      Throws:
      JRDFoxException - thrown if an error is encountered

    • getResourceValue

      ResourceValue getResourceValue​(long resourceID) throws JRDFoxException
      Looks up the resource with the given ID.
      Parameters:
      resourceID - the resource ID that should be looked up
      Returns:
      the resource term, or null if the resource ID cannot be looked up
      Throws:
      JRDFoxException - thrown if an error is encountered

    • getResourceValues

      boolean getResourceValues​(long[] resourceIDs, int startIndex, int endIndex, ResourceValue[] resourceValues) throws JRDFoxException
      Looks up the resources with the given IDs. The length of the resourceValues array must be at least endIndex so that each resource ID at some index in resourceIDs can be resolved to a resource at the same position in resources.
      Parameters:
      resourceIDs - the resource IDs that should be looked up
      startIndex - the first index in resourceIDs to look up
      endIndex - the index after the last in resourceIDs to look up
      resourceValues - receives the information about the resources
      Returns:
      true if all IDs were successfully looked up
      Throws:
      JRDFoxException - thrown if an error is encountered

    • getResource

      Resource getResource​(long resourceID) throws JRDFoxException
      Looks up the resource with the given IDs.
      Parameters:
      resourceID - the resource ID that should be looked up
      Returns:
      the resource, or null if the resource ID cannot be looked up
      Throws:
      JRDFoxException - thrown if an error is encountered

    • getResources

      boolean getResources​(long[] resourceIDs, int startIndex, int endIndex, Resource[] resources) throws JRDFoxException
      Looks up the resources with the given IDs. The length of the resources array must be at least endIndex so that each resource ID at some index in resourceIDs can be resolved to a resource at the same position in resources.
      Parameters:
      resourceIDs - the resource IDs that should be looked up
      startIndex - the first index in resourceIDs to look up
      endIndex - the index after the last in resourceIDs to look up
      resources - receives the resources
      Returns:
      true if all IDs were successfully looked up
      Throws:
      JRDFoxException - thrown if an error is encountered

    • begin

      @Deprecated void begin​(TransactionType transactionType) throws JRDFoxException
      Deprecated.
      Starts a new transaction on this connection.
      Parameters:
      transactionType - determines the type of the transaction (i.e., whether a read-only or a read/write transaction is requested)
      Throws:
      JRDFoxException - thrown if an error is encountered

    • commit

      @Deprecated void commit() throws JRDFoxException
      Deprecated.
      Commits the transaction associated with this connection. If an exception is thrown during a commit operation, transactionRequiresRollback() will return true, and the transaction should be explicitly rolled back using rollbackTransaction().
      Throws:
      JRDFoxException - thrown if an error is encountered

    • rollback

      @Deprecated void rollback() throws JRDFoxException
      Deprecated.
      Rolls back the transaction associated with this connection.
      Throws:
      JRDFoxException - thrown if an error is encountered