org.apache.marmotta.kiwi.reasoner.persistence

Class KiWiReasoningConnection

java.lang.Object

org.apache.marmotta.kiwi.persistence.KiWiConnection

org.apache.marmotta.kiwi.reasoner.persistence.KiWiReasoningConnection

All Implemented Interfaces:

AutoCloseable

public class KiWiReasoningConnection
extends KiWiConnection

Extends the basic KiWiConnection by functionalities for storing, deleting and querying reasoner programs and rules as well as justification information.

Author: Sebastian Schaffert

Nested Class Summary

Nested classes/interfaces inherited from class org.apache.marmotta.kiwi.persistence.KiWiConnection

KiWiConnection.RetryCommand<T>, KiWiConnection.RetryExecution<T>

Field Summary

Fields inherited from class org.apache.marmotta.kiwi.persistence.KiWiConnection

cacheManager, connection, dialect, persistence, tripleBatch

Constructor Summary

Constructors

Constructor and Description
KiWiReasoningConnection(KiWiPersistence persistence, KiWiDialect dialect, CacheManager cacheManager, org.openrdf.model.ValueFactory valueFactory)

Method Summary

Methods

Modifier and Type	Method and Description
protected Justification	constructJustificationFromDatabase(ResultSet row)
protected Program	constructProgramFromDatabase(ResultSet row)
protected Rule	constructRuleFromDatabase(ResultSet row, Map<String,String> namespaces)
void	deleteJustifications() Delete all justifications.
void	deleteJustifications(Iterable<Justification> justifications) Delete the justifications given as argument (batch operation).
void	deleteJustifications(info.aduna.iteration.Iteration<Justification,SQLException> justifications) Delete the justifications given as argument (batch operation).
void	deleteJustifications(KiWiTriple triple) Delete the justifications referring to a certain triple given as argument.
void	deleteJustifications(Rule rule) Delete the justifications referring to a certain rule given as argument.
void	deleteProgram(Program program) Delete the (persistent) program given as argument from the database, including all rules, justifications and namespaces refenced by the program or its rules.
info.aduna.iteration.CloseableIteration<Justification,SQLException>	listJustificationsBySupporting(KiWiTriple triple) List all justifications supported by the given triple.
info.aduna.iteration.CloseableIteration<Justification,SQLException>	listJustificationsBySupporting(Rule rule) List all justifications supported by the given rule.
info.aduna.iteration.CloseableIteration<Justification,SQLException>	listJustificationsForTriple(KiWiTriple triple) List all justifications supporting the given triple.
info.aduna.iteration.CloseableIteration<Justification,SQLException>	listJustificationsForTriple(long tripleId) List all justifications supporting the given triple.
info.aduna.iteration.CloseableIteration<Program,SQLException>	listPrograms() List all currently existing programs in the database.
info.aduna.iteration.CloseableIteration<KiWiTriple,SQLException>	listUnsupportedTriples() List all triples that are not supported by at least one justification.
Program	loadProgram(Long id) Load and return the program with the ID given as argument.
Program	loadProgram(String name) Load and return the program with the name given as argument.
Rule	loadRuleById(long ruleId, Map<String,String> namespaces) Load the rule with the given database ID from the database.
info.aduna.iteration.CloseableIteration<Rule,SQLException>	loadRulesByProgram(long programId, Map<String,String> namespaces) Load the rule with the given database ID from the database.
info.aduna.iteration.CloseableIteration<QueryResult,SQLException>	query(Collection<Pattern> patterns, QueryResult initialBindings, Set<Filter> filters, List<VariableField> orderBy, boolean justifications) Evaluate a query on the triple store.
void	removeRule(Rule rule) Remove the rule given as argument from the database.
void	storeJustifications(Iterable<Justification> justifications) Store a collection of new justification in the database.
void	storeProgram(Program program) Store the program given as argument in the database.
void	storeRule(Rule rule, Map<String,String> namespaces) Store the rule given as argument in the database.
void	updateProgram(Program program) Store the program given as argument in the database.

Methods inherited from class org.apache.marmotta.kiwi.persistence.KiWiConnection

close, commit, constructNamespaceFromDatabase, constructNodeFromDatabase, constructTripleFromDatabase, constructTripleQuery, constructTriplesFromDatabase, deleteAll, deleteContext, deleteNamespace, deleteTriple, flushBatch, getAutoCommit, getBatchSize, getCacheManager, getConfiguration, getDatabaseTables, getDatabaseVersion, getDialect, getJDBCConnection, getLocale, getMetadata, getNextSequence, getPreparedStatement, getPreparedStatement, getSize, getSize, getTransactionId, getTripleId, isBatchCommit, isClosed, listContexts, listNamespaces, listResources, listResources, listTriples, loadAnonResource, loadLiteral, loadLiteral, loadLiteral, loadLiteral, loadLiteral, loadNamespaceByPrefix, loadNamespaceByUri, loadNodeById, loadNodesByIds, loadTripleById, loadUriResource, requireJDBCConnection, rollback, setAutoCommit, setBatchCommit, setBatchSize, setMetadata, storeNamespace, storeNode, storeTriple, undeleteTriple

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

KiWiReasoningConnection

public KiWiReasoningConnection(KiWiPersistence persistence,
                       KiWiDialect dialect,
                       CacheManager cacheManager,
                       org.openrdf.model.ValueFactory valueFactory)
                        throws SQLException

Throws:

SQLException

Method Detail

storeRule

public void storeRule(Rule rule,
             Map<String,String> namespaces)
               throws SQLException

Store the rule given as argument in the database. This method will always create a new entry in the database and does not check if a rule with the same name or content already exists.

Parameters:

rule -

Throws:

SQLException

loadRuleById

public Rule loadRuleById(long ruleId,
                Map<String,String> namespaces)
                  throws SQLException

Load the rule with the given database ID from the database.

Parameters:

ruleId -

Returns:

Throws:

SQLException

loadRulesByProgram

public info.aduna.iteration.CloseableIteration<Rule,SQLException> loadRulesByProgram(long programId,
                                                                            Map<String,String> namespaces)
                                                                              throws SQLException,
                                                                                     ParseException

Load the rule with the given database ID from the database.

Returns:

Throws:

SQLException

ParseException

constructRuleFromDatabase

protected Rule constructRuleFromDatabase(ResultSet row,
                             Map<String,String> namespaces)
                                  throws SQLException,
                                         ParseException

Throws:

SQLException

ParseException

removeRule

public void removeRule(Rule rule)
                throws SQLException

Remove the rule given as argument from the database. This will also trigger removing all justifications depending on this rule. The reasoner afterwards needs to clean up in a separate run all inferred triples t hat are no longer justified.

Parameters:

rule -

Throws:

SQLException

storeProgram

public void storeProgram(Program program)
                  throws SQLException

Store the program given as argument in the database. In case the program does not exist yet, it is created together with all rules and namespace definitions. In case the program already exists, an exception is thrown.

Parameters:

program -

Throws:

SQLException

updateProgram

public void updateProgram(Program program)
                   throws SQLException

Store the program given as argument in the database. In case the program does not exist yet, it is created together with all rules and namespace definitions. In case the program already exists, it is updated according to the new program specification (i.e. rules and namespaces).

We assume that the program has been newly parsed, so it does not have a database ID yet. To find the existing program in the database, we therefore need to use the program name instead.

Parameters:

program - the program to update

Throws:

SQLException

loadProgram

public Program loadProgram(String name)
                    throws SQLException

Load and return the program with the name given as argument. Constructing the program requires to invoke the sKWRL parser to parse the textual rule representation.

Parameters:

name - the name of the program to load

Returns:

the loaded program, or null in case the program does not exist

Throws:

SQLException - in case of a database problem or an unparsable program

loadProgram

public Program loadProgram(Long id)
                    throws SQLException

Load and return the program with the ID given as argument. Constructing the program requires to invoke the sKWRL parser to parse the textual rule representation.

Returns:

Throws:

SQLException

constructProgramFromDatabase

protected Program constructProgramFromDatabase(ResultSet row)
                                        throws SQLException,
                                               ParseException

Throws:

SQLException

ParseException

listPrograms

public info.aduna.iteration.CloseableIteration<Program,SQLException> listPrograms()
                                                                           throws SQLException

List all currently existing programs in the database.

Returns:

Throws:

SQLException

deleteProgram

public void deleteProgram(Program program)
                   throws SQLException

Delete the (persistent) program given as argument from the database, including all rules, justifications and namespaces refenced by the program or its rules.

Parameters:

program -

Throws:

SQLException

storeJustifications

public void storeJustifications(Iterable<Justification> justifications)
                         throws SQLException

Store a collection of new justification in the database. Uses an SQL batch operation to speed up database insertion.

Parameters:

justifications -

Throws:

SQLException

deleteJustifications

public void deleteJustifications(Iterable<Justification> justifications)
                          throws SQLException

Delete the justifications given as argument (batch operation).

Parameters:

justifications -

Throws:

SQLException

deleteJustifications

public void deleteJustifications(info.aduna.iteration.Iteration<Justification,SQLException> justifications)
                          throws SQLException

Delete the justifications given as argument (batch operation).

Parameters:

justifications -

Throws:

SQLException

deleteJustifications

public void deleteJustifications(Rule rule)
                          throws SQLException

Delete the justifications referring to a certain rule given as argument.

Parameters:

rule -

Throws:

SQLException

deleteJustifications

public void deleteJustifications(KiWiTriple triple)
                          throws SQLException

Delete the justifications referring to a certain triple given as argument.

Parameters:

triple -

Throws:

SQLException

deleteJustifications

public void deleteJustifications()
                          throws SQLException

Delete all justifications.

Throws:

SQLException

listJustificationsBySupporting

public info.aduna.iteration.CloseableIteration<Justification,SQLException> listJustificationsBySupporting(Rule rule)
                                                                                                   throws SQLException

List all justifications supported by the given rule.

Parameters:

rule -

Returns:

Throws:

SQLException

listJustificationsBySupporting

public info.aduna.iteration.CloseableIteration<Justification,SQLException> listJustificationsBySupporting(KiWiTriple triple)
                                                                                                   throws SQLException

List all justifications supported by the given triple.

Parameters:

triple -

Returns:

Throws:

SQLException

listJustificationsForTriple

public info.aduna.iteration.CloseableIteration<Justification,SQLException> listJustificationsForTriple(KiWiTriple triple)
                                                                                                throws SQLException

List all justifications supporting the given triple.

Parameters:

triple -

Returns:

Throws:

SQLException

listJustificationsForTriple

public info.aduna.iteration.CloseableIteration<Justification,SQLException> listJustificationsForTriple(long tripleId)
                                                                                                throws SQLException

List all justifications supporting the given triple.

Parameters:

tripleId -

Returns:

Throws:

SQLException

constructJustificationFromDatabase

protected Justification constructJustificationFromDatabase(ResultSet row)
                                                    throws SQLException

Throws:

SQLException

listUnsupportedTriples

public info.aduna.iteration.CloseableIteration<KiWiTriple,SQLException> listUnsupportedTriples()
                                                                                        throws SQLException

List all triples that are not supported by at least one justification.

Returns:

Throws:

SQLException

query

public info.aduna.iteration.CloseableIteration<QueryResult,SQLException> query(Collection<Pattern> patterns,
                                                                      QueryResult initialBindings,
                                                                      Set<Filter> filters,
                                                                      List<VariableField> orderBy,
                                                                      boolean justifications)
                                                                        throws SQLException

Evaluate a query on the triple store. The query parameters passed to the method call are translated into database queries in HQL and directly evaluated by a single database query that yields the query bindings.

The query patterns may share variable fields, in which case the database query will evaluate a join. In case the optional parameter is true, the database query will succeed even if the query does not yield a value.

Parameters:

patterns - the set of patterns to query; patterns are considered to be connected by AND; occurrences of the same variable in multiple patterns will be evaluated as a join

initialBindings - initial bindings of variable fields may be used in case some bindings are already available to further restrict the results; the purpose of this parameter is to support query-by-example queries as well as to speed up e.g. incremental reasoning

filters - a set of filters to apply to the result before returning the bindings; depending on the kind of filter, filtering will be carried out by the database or in memory

orderBy - list of variables by whose bindings the result rows should be ordered; variables at the beginning of the list take precedence over variables that are further behind

Returns:

a list of bindings matching the query patterns and filters, ordered by the specified variables and offset and limited by the parameters given

Throws:

SQLException