org.apache.marmotta.kiwi.persistence

Class KiWiConnection

java.lang.Object

org.apache.marmotta.kiwi.persistence.KiWiConnection

All Implemented Interfaces:

AutoCloseable

Direct Known Subclasses:

KiWiReasoningConnection, KiWiVersioningConnection

public class KiWiConnection
extends Object
implements AutoCloseable

A KiWiConnection offers methods for storing and retrieving KiWiTriples, KiWiNodes, and KiWiNamespaces in the database. It wraps a JDBC connection which will be committed on commit(), rolled back on rollback() and closed on close();

Author: Sebastian Schaffert

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected static interface	KiWiConnection.RetryCommand<T>
protected class	KiWiConnection.RetryExecution<T> A generic implementation of an SQL command that might fail (e.g.

Field Summary

Fields

Modifier and Type	Field and Description
protected CacheManager	cacheManager
protected Connection	connection
protected KiWiDialect	dialect
protected KiWiPersistence	persistence
protected TripleTable<KiWiTriple>	tripleBatch

Constructor Summary

Constructors

Constructor and Description
KiWiConnection(KiWiPersistence persistence, KiWiDialect dialect, CacheManager cacheManager)

Method Summary

Methods

Modifier and Type	Method and Description
void	close() Releases this Connection object's database and JDBC resources immediately instead of waiting for them to be automatically released.
void	commit() Makes all changes made since the previous commit/rollback permanent and releases any database locks currently held by this Connection object.
protected KiWiNamespace	constructNamespaceFromDatabase(ResultSet row)
protected KiWiNode	constructNodeFromDatabase(ResultSet row) Construct an appropriate KiWiNode from the result of an SQL query.
protected KiWiTriple	constructTripleFromDatabase(ResultSet row) Construct a KiWiTriple from the result of an SQL query.
protected String	constructTripleQuery(KiWiResource subject, KiWiUriResource predicate, KiWiNode object, KiWiResource context, boolean inferred, boolean wildcardContext) Construct the SQL query string from the query pattern passed as arguments
protected List<KiWiTriple>	constructTriplesFromDatabase(ResultSet row, int maxPrefetch) Construct a batch of KiWiTriples from the result of an SQL query.
void	deleteAll() Mark all triples contained in the triple store as deleted, setting the "deleted" flag to true and updating the timestamp value of "deletedAt".
void	deleteContext(KiWiResource ctx) Mark all triples contained in the context passed as argument as deleted, setting the "deleted" flag to true and updating the timestamp value of "deletedAt".
void	deleteNamespace(KiWiNamespace namespace) Delete the namespace passed as argument from the database and from the caches.
void	deleteTriple(KiWiTriple triple) Mark the triple passed as argument as deleted, setting the "deleted" flag to true and updating the timestamp value of "deletedAt".
void	flushBatch()
boolean	getAutoCommit() Retrieves the current auto-commit mode for this Connection object.
int	getBatchSize() Return the size of a batch for batched commits.
CacheManager	getCacheManager() Return the cache manager used by this connection
KiWiConfiguration	getConfiguration()
Set<String>	getDatabaseTables() Return a collection of database tables contained in the database.
int	getDatabaseVersion() Return the KiWi version of the database this connection is operating on.
KiWiDialect	getDialect()
Connection	getJDBCConnection() Get direct access to the JDBC connection used by this KiWiConnection.
protected static Locale	getLocale(String language)
String	getMetadata(String key) Return the metadata value with the given key; can be used by KiWi modules to retrieve module-specific metadata.
long	getNextSequence() Get next number in a sequence; for databases without sequence support (e.g.
PreparedStatement	getPreparedStatement(String key) Return the prepared statement with the given identifier; first looks in the statement cache and if it does not exist there create a new statement.
PreparedStatement	getPreparedStatement(String key, int numberOfArguments) Return the prepared statement with the given identifier; first looks in the statement cache and if it does not exist there create a new statement.
long	getSize() Count all non-deleted triples in the triple store
long	getSize(KiWiResource context) Count all non-deleted triples in the triple store
long	getTransactionId() Return the current transaction ID
long	getTripleId(KiWiResource subject, KiWiUriResource predicate, KiWiNode object, KiWiResource context) Return the identifier of the triple with the given subject, predicate, object and context, or null if this triple does not exist.
boolean	isBatchCommit() Return true if batched commits are enabled.
boolean	isClosed() Retrieves whether this Connection object has been closed.
info.aduna.iteration.CloseableIteration<KiWiResource,SQLException>	listContexts() List all contexts used in this triple store.
info.aduna.iteration.CloseableIteration<KiWiNamespace,SQLException>	listNamespaces()
info.aduna.iteration.CloseableIteration<KiWiResource,SQLException>	listResources() List all contexts used in this triple store.
info.aduna.iteration.CloseableIteration<KiWiUriResource,SQLException>	listResources(String prefix) List all contexts used in this triple store.
org.openrdf.repository.RepositoryResult<org.openrdf.model.Statement>	listTriples(KiWiResource subject, KiWiUriResource predicate, KiWiNode object, KiWiResource context, boolean inferred, boolean wildcardContext) Return a Sesame RepositoryResult of statements according to the query pattern given in the arguments.
KiWiAnonResource	loadAnonResource(String id) Load a KiWiAnonResource by anonymous ID.
KiWiBooleanLiteral	loadLiteral(boolean value) Load a boolean literal with the boolean value given as argument if it exists.
KiWiDateLiteral	loadLiteral(org.joda.time.DateTime date) Load a literal with the date value given as argument if it exists.
KiWiDoubleLiteral	loadLiteral(double value) Load a double literal with the double value given as argument if it exists.
KiWiIntLiteral	loadLiteral(long value) Load a integer literal with the long value given as argument if it exists.
KiWiLiteral	loadLiteral(String value, String lang, KiWiUriResource ltype) Load a literal based on the value, language and type passed as argument.
KiWiNamespace	loadNamespaceByPrefix(String prefix) Load a KiWiNamespace with the given prefix, or null if the namespace does not exist.
KiWiNamespace	loadNamespaceByUri(String uri) Load a KiWiNamespace with the given uri, or null if the namespace does not exist.
KiWiNode	loadNodeById(long id) Load a KiWiNode by database ID.
KiWiNode[]	loadNodesByIds(long... ids) Batch load the nodes with the given ids.
KiWiTriple	loadTripleById(long id)
KiWiUriResource	loadUriResource(String uri) Load a KiWiUriResource by URI.
protected void	requireJDBCConnection() This method must be called by all methods as soon as they actually require a JDBC connection.
void	rollback() Undoes all changes made in the current transaction and releases any database locks currently held by this Connection object.
void	setAutoCommit(boolean autoCommit) Sets this connection's auto-commit mode to the given state.
void	setBatchCommit(boolean batchCommit) Enabled batched commits.
void	setBatchSize(int batchSize) Set the size of a batch for batched commits.
void	setMetadata(String key, String value) Update the metadata value for the given key; can be used by KiWi modules to set module-specific metadata.
void	storeNamespace(KiWiNamespace namespace) Store the namespace passed as argument in the database.
void	storeNode(KiWiNode node) Store a new node in the database.
void	storeTriple(KiWiTriple triple) Store a triple in the database.
void	undeleteTriple(KiWiTriple triple) Mark the triple passed as argument as not deleted, setting the "deleted" flag to false and clearing the timestamp value of "deletedAt".

Methods inherited from class java.lang.Object

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

Field Detail

dialect

protected KiWiDialect dialect

connection

protected Connection connection

persistence

protected KiWiPersistence persistence

cacheManager

protected CacheManager cacheManager

tripleBatch

protected TripleTable<KiWiTriple> tripleBatch

Constructor Detail

KiWiConnection

public KiWiConnection(KiWiPersistence persistence,
              KiWiDialect dialect,
              CacheManager cacheManager)
               throws SQLException

Throws:

SQLException

Method Detail

requireJDBCConnection

protected void requireJDBCConnection()
                              throws SQLException

This method must be called by all methods as soon as they actually require a JDBC connection. This allows more efficient implementations in case the queries can be answered directly from the cache.

Throws:

SQLException

getJDBCConnection

public Connection getJDBCConnection()
                             throws SQLException

Get direct access to the JDBC connection used by this KiWiConnection.

Returns:

Throws:

SQLException

getCacheManager

public CacheManager getCacheManager()

Return the cache manager used by this connection

Returns:

getDialect

public KiWiDialect getDialect()

getConfiguration

public KiWiConfiguration getConfiguration()

loadNamespaceByPrefix

public KiWiNamespace loadNamespaceByPrefix(String prefix)
                                    throws SQLException

Load a KiWiNamespace with the given prefix, or null if the namespace does not exist. The method will first look in the node cache for cached nodes. If no cache entry is found, it will run a database query ("load.namespace_prefix").

Parameters:

prefix - the prefix to look for

Returns:

the KiWiNamespace with this prefix or null if it does not exist

Throws:

SQLException

loadNamespaceByUri

public KiWiNamespace loadNamespaceByUri(String uri)
                                 throws SQLException

Load a KiWiNamespace with the given uri, or null if the namespace does not exist. The method will first look in the node cache for cached nodes. If no cache entry is found, it will run a database query ("load.namespace_prefix").

Parameters:

uri - the uri to look for

Returns:

the KiWiNamespace with this uri or null if it does not exist

Throws:

SQLException

storeNamespace

public void storeNamespace(KiWiNamespace namespace)
                    throws SQLException

Store the namespace passed as argument in the database. The database might enfore unique constraints and thus throw an exception in case the prefix or URI is already used.

Parameters:

namespace - the namespace to store

Throws:

SQLException - the prefix or URI is already used, or a database error occurred

deleteNamespace

public void deleteNamespace(KiWiNamespace namespace)
                     throws SQLException

Delete the namespace passed as argument from the database and from the caches.

Parameters:

namespace - the namespace to delete

Throws:

SQLException - in case a database error occurred

getSize

public long getSize()
             throws SQLException

Count all non-deleted triples in the triple store

Returns:

Throws:

SQLException

getSize

public long getSize(KiWiResource context)
             throws SQLException

Count all non-deleted triples in the triple store

Returns:

Throws:

SQLException

loadNodeById

public KiWiNode loadNodeById(long id)
                      throws SQLException

Load a KiWiNode by database ID. The method will first look in the node cache for cached nodes. If no cache entry is found, it will run a database query ('load.node_by_id') on the NODES table and construct an appropriate subclass instance of KiWiNode with the obtained values. The result will be constructed based on the value of the NTYPE column as follows:

• 'uri' - KiWiUriResource using the id and svalue (as URI) columns
• 'bnode' - KiWiAnonResource using the id and svalue (as AnonId) columns
• 'string' - KiWiStringLiteral using the id, svalue (literal value), lang (literal language) and ltype (literal type) columns
• 'int' - KiWiIntLiteral using the id, svalue (string value), ivalue (integer value) and ltype (literal type) columns
• 'double' - KiWiDoubleLiteral using the id, svalue (string value), dvalue (double value) and ltype (literal type) columns
• 'boolean' - KiWiBooleanLiteral using the id, svalue (string value), bvalue (boolean value) and ltype (literal type) columns
• 'date' - KiWiDateLiteral using the id, svalue (string value), tvalue (time value) and ltype (literal type) columns

When a node is loaded from the database, it will be added to the different caches to speed up subsequent requests.

Parameters:

id - the database id of the node to load

Returns:

an instance of a KiWiNode subclass representing the node with the given database id; type depends on value of the ntype column

Throws:

SQLException

loadNodesByIds

public KiWiNode[] loadNodesByIds(long... ids)
                          throws SQLException

Batch load the nodes with the given ids. This method aims to offer performance improvements by reducing database roundtrips.

Parameters:

ids - array of ids to retrieve

Returns:

array of nodes corresponding to these ids (in the same order)

Throws:

SQLException

loadTripleById

public KiWiTriple loadTripleById(long id)
                          throws SQLException

Throws:

SQLException

loadUriResource

public KiWiUriResource loadUriResource(String uri)
                                throws SQLException

Load a KiWiUriResource by URI. The method will first look in the node cache for cached nodes. If no cache entry is found, it will run a database query ('load.uri_by_uri') on the NODES table and construct a new KiWiUriResource using the values of the id and svalue columns.

When a node is loaded from the database, it will be added to the different caches to speed up subsequent requests.

Parameters:

uri - the URI of the resource to load

Returns:

the KiWiUriResource identified by the given URI or null if it does not exist

Throws:

SQLException

loadAnonResource

public KiWiAnonResource loadAnonResource(String id)
                                  throws SQLException

Load a KiWiAnonResource by anonymous ID. The method will first look in the node cache for cached nodes. If no cache entry is found, it will run a database query ('load.bnode_by_anonid') on the NODES table and construct a new KiWiAnonResource using the values of the id and svalue columns.

When a node is loaded from the database, it will be added to the different caches to speed up subsequent requests.

Parameters:

id - the anonymous ID of the resource to load

Returns:

the KiWiAnonResource identified by the given internal ID or null if it does not exist

Throws:

SQLException

loadLiteral

public KiWiLiteral loadLiteral(String value,
                      String lang,
                      KiWiUriResource ltype)
                        throws SQLException

Load a literal based on the value, language and type passed as argument. The method will first look in the node cache for cached nodes. If no cache entry is found, it will run a database query ("load.literal_by_v") on the NODES table and construct a new KiWiLiteral using the values of the literal columns (svalue, ivalue, ...). The type of literal returned depends on the value of the ntype column.

When a node is loaded from the database, it will be added to the different caches to speed up subsequent requests.

Parameters:

value - string value of the literal to load

lang - language of the literal to load (optional, 2-letter language code with optional country)

ltype - the type of the literal to load (optional)

Returns:

the literal matching the given arguments or null if it does not exist

Throws:

SQLException

loadLiteral

public KiWiDateLiteral loadLiteral(org.joda.time.DateTime date)
                            throws SQLException

Load a literal with the date value given as argument if it exists. The method will first look in the node cache for cached nodes. If no cache entry is found, it will run a database query ("load.literal_by_tv") on the NODES table and construct a new KiWiLiteral using the values of the literal columns (svalue, ivalue, ...). The type of literal returned depends on the value of the ntype column.

When a node is loaded from the database, it will be added to the different caches to speed up subsequent requests.

Parameters:

date - the date of the date literal to load

Returns:

a KiWiDateLiteral with the correct date, or null if it does not exist

Throws:

SQLException

loadLiteral

public KiWiIntLiteral loadLiteral(long value)
                           throws SQLException

Load a integer literal with the long value given as argument if it exists. The method will first look in the node cache for cached nodes. If no cache entry is found, it will run a database query ("load.literal_by_iv") on the NODES table and construct a new KiWiLiteral using the values of the literal columns (svalue, ivalue, ...). The type of literal returned depends on the value of the ntype column.

When a node is loaded from the database, it will be added to the different caches to speed up subsequent requests.

Parameters:

value - the value of the integer literal to load

Returns:

a KiWiIntLiteral with the correct value, or null if it does not exist

Throws:

SQLException

loadLiteral

public KiWiDoubleLiteral loadLiteral(double value)
                              throws SQLException

Load a double literal with the double value given as argument if it exists. The method will first look in the node cache for cached nodes. If no cache entry is found, it will run a database query ("load.literal_by_dv") on the NODES table and construct a new KiWiLiteral using the values of the literal columns (svalue, ivalue, ...). The type of literal returned depends on the value of the ntype column.

When a node is loaded from the database, it will be added to the different caches to speed up subsequent requests.

Parameters:

value - the value of the integer literal to load

Returns:

a KiWiDoubleLiteral with the correct value, or null if it does not exist

Throws:

SQLException

loadLiteral

public KiWiBooleanLiteral loadLiteral(boolean value)
                               throws SQLException

Load a boolean literal with the boolean value given as argument if it exists. The method will first look in the node cache for cached nodes. If no cache entry is found, it will run a database query ("load.literal_by_bv") on the NODES table and construct a new KiWiLiteral using the values of the literal columns (svalue, ivalue, ...). The type of literal returned depends on the value of the ntype column.

When a node is loaded from the database, it will be added to the different caches to speed up subsequent requests.

Parameters:

value - the value of the integer literal to load

Returns:

a KiWiBooleanLiteral with the correct value, or null if it does not exist

Throws:

SQLException

storeNode

public void storeNode(KiWiNode node)
               throws SQLException

Store a new node in the database. The method will retrieve a new database id for the node and update the passed object. Afterwards, the node data will be inserted into the database using appropriate INSERT statements. The caller must make sure the connection is committed and closed properly.

If the node already has an ID, the method will do nothing (assuming that it is already persistent)

Parameters:

node -

Throws:

SQLException

storeTriple

public void storeTriple(KiWiTriple triple)
                 throws SQLException

Store a triple in the database. This method assumes that all nodes used by the triple are already persisted.

Parameters:

triple - the triple to store

Throws:

SQLException

NullPointerException - in case the subject, predicate, object or context have not been persisted

getTripleId

public long getTripleId(KiWiResource subject,
               KiWiUriResource predicate,
               KiWiNode object,
               KiWiResource context)
                 throws SQLException

Return the identifier of the triple with the given subject, predicate, object and context, or null if this triple does not exist. Used for quick existance checks of triples.

Parameters:

subject -

predicate -

object -

context -

Returns:

Throws:

SQLException

deleteTriple

public void deleteTriple(KiWiTriple triple)
                  throws SQLException

Mark the triple passed as argument as deleted, setting the "deleted" flag to true and updating the timestamp value of "deletedAt".

The triple remains in the database, because other entities might still reference it (e.g. a version). Use the method cleanupTriples() to fully remove all deleted triples without references.

Parameters:

triple -

Throws:

SQLException

deleteContext

public void deleteContext(KiWiResource ctx)
                   throws SQLException

Mark all triples contained in the context passed as argument as deleted, setting the "deleted" flag to true and updating the timestamp value of "deletedAt".

The triple remains in the database, because other entities might still reference it (e.g. a version). Use the method cleanupTriples() to fully remove all deleted triples without references.

Warning: this method skips some concurrency and transaction safeguards for performance and therefore should only be called if run in an isolated transaction!

Parameters:

ctx - resource identifying the context to be deleted

Throws:

SQLException

deleteAll

public void deleteAll()
               throws SQLException

Mark all triples contained in the triple store as deleted, setting the "deleted" flag to true and updating the timestamp value of "deletedAt".

The triple remains in the database, because other entities might still reference it (e.g. a version). Use the method cleanupTriples() to fully remove all deleted triples without references.

Warning: this method skips some concurrency and transaction safeguards for performance and therefore should only be called if run in an isolated transaction!

Throws:

SQLException

undeleteTriple

public void undeleteTriple(KiWiTriple triple)
                    throws SQLException

Mark the triple passed as argument as not deleted, setting the "deleted" flag to false and clearing the timestamp value of "deletedAt".

Note that this operation should only be called if the triple was deleted before in the same transaction!

Parameters:

triple -

Throws:

SQLException

listContexts

public info.aduna.iteration.CloseableIteration<KiWiResource,SQLException> listContexts()
                                                                                throws SQLException

List all contexts used in this triple store. See query.contexts .

Returns:

Throws:

SQLException

listResources

public info.aduna.iteration.CloseableIteration<KiWiResource,SQLException> listResources()
                                                                                 throws SQLException

List all contexts used in this triple store. See query.contexts .

Returns:

Throws:

SQLException

listResources

public info.aduna.iteration.CloseableIteration<KiWiUriResource,SQLException> listResources(String prefix)
                                                                                    throws SQLException

List all contexts used in this triple store. See query.contexts .

Returns:

Throws:

SQLException

listNamespaces

public info.aduna.iteration.CloseableIteration<KiWiNamespace,SQLException> listNamespaces()
                                                                                   throws SQLException

Throws:

SQLException

listTriples

public org.openrdf.repository.RepositoryResult<org.openrdf.model.Statement> listTriples(KiWiResource subject,
                                                                               KiWiUriResource predicate,
                                                                               KiWiNode object,
                                                                               KiWiResource context,
                                                                               boolean inferred,
                                                                               boolean wildcardContext)
                                                                                 throws SQLException

Return a Sesame RepositoryResult of statements according to the query pattern given in the arguments. Each of the parameters subject, predicate, object and context may be null, indicating a wildcard query. If the boolean parameter "inferred" is set to true, the result will also include inferred triples, if it is set to false only base triples.

The RepositoryResult holds a direct connection to the database and needs to be closed properly, or otherwise the system might run out of resources. The returned RepositoryResult will try its best to clean up when the iteration has completed or the garbage collector calls the finalize() method, but this can take longer than necessary.

Parameters:

subject - the subject to query for, or null for a wildcard query

predicate - the predicate to query for, or null for a wildcard query

object - the object to query for, or null for a wildcard query

context - the context to query for, or null for a wildcard query

inferred - if true, the result will also contain triples inferred by the reasoner, if false not

wildcardContext - if true, a null context will be interpreted as a wildcard, if false, a null context will be interpreted as "no context"

Returns:

a new RepositoryResult with a direct connection to the database; the result should be properly closed by the caller

Throws:

SQLException

constructTripleQuery

protected String constructTripleQuery(KiWiResource subject,
                          KiWiUriResource predicate,
                          KiWiNode object,
                          KiWiResource context,
                          boolean inferred,
                          boolean wildcardContext)

Construct the SQL query string from the query pattern passed as arguments

Parameters:

subject - the subject to query for, or null for a wildcard query

predicate - the predicate to query for, or null for a wildcard query

object - the object to query for, or null for a wildcard query

context - the context to query for, or null for a wildcard query

inferred - if true, the result will also contain triples inferred by the reasoner, if false not

Returns:

an SQL query string representing the triple pattern

constructNamespaceFromDatabase

protected KiWiNamespace constructNamespaceFromDatabase(ResultSet row)
                                                throws SQLException

Throws:

SQLException

constructNodeFromDatabase

protected KiWiNode constructNodeFromDatabase(ResultSet row)
                                      throws SQLException

Construct an appropriate KiWiNode from the result of an SQL query. The method will not change the ResultSet iterator, only read its values, so it needs to be executed for each row separately.

Parameters:

row -

Returns:

Throws:

SQLException

constructTripleFromDatabase

protected KiWiTriple constructTripleFromDatabase(ResultSet row)
                                          throws SQLException

Construct a KiWiTriple from the result of an SQL query. The query result is expected to contain the following columns:

• id: the database id of the triple (long value)
• subject: the database id of the subject (long value); the node will be loaded using the loadNodeById method
• predicate: the database id of the predicate (long value); the node will be loaded using the loadNodeById method
• object: the database id of the object (long value); the node will be loaded using the loadNodeById method
• context: the database id of the context (long value); the node will be loaded using the loadNodeById method
• creator: the database id of the creator (long value); the node will be loaded using the loadNodeById method; may be null
• deleted: a flag (boolean) indicating whether this triple has been deleted
• inferred: a flag (boolean) indicating whether this triple has been inferred by the KiWi reasoner
• createdAt: a timestamp representing the creation date of the triple
• createdAt: a timestamp representing the deletion date of the triple (null in case triple is not deleted)

The method will not change the ResultSet iterator, only read its values, so it needs to be executed for each row separately.

Parameters:

row - a database result containing the columns described above

Returns:

a KiWiTriple representation of the database result

Throws:

SQLException

constructTriplesFromDatabase

protected List<KiWiTriple> constructTriplesFromDatabase(ResultSet row,
                                            int maxPrefetch)
                                                 throws SQLException

Construct a batch of KiWiTriples from the result of an SQL query. This query differs from constructTripleFromDatabase in that it does a batch-prefetching for optimized performance

Parameters:

row - a database result containing the columns described above

Returns:

a KiWiTriple representation of the database result

Throws:

SQLException

getLocale

protected static Locale getLocale(String language)

getPreparedStatement

public PreparedStatement getPreparedStatement(String key)
                                       throws SQLException

Return the prepared statement with the given identifier; first looks in the statement cache and if it does not exist there create a new statement.

Parameters:

key - the id of the statement in statements.properties

Returns:

Throws:

SQLException

getPreparedStatement

public PreparedStatement getPreparedStatement(String key,
                                     int numberOfArguments)
                                       throws SQLException

Return the prepared statement with the given identifier; first looks in the statement cache and if it does not exist there create a new statement. This method is used for building statements with variable argument numbers (e.g. in an IN).

Parameters:

key - the id of the statement in statements.properties

Returns:

Throws:

SQLException

getNextSequence

public long getNextSequence()
                     throws SQLException

Get next number in a sequence; for databases without sequence support (e.g. MySQL), this method will first update a sequence table and then return the value.

Returns:

a new sequence ID

Throws:

SQLException

getDatabaseTables

public Set<String> getDatabaseTables()
                              throws SQLException

Return a collection of database tables contained in the database. This query is used for checking whether the database needs to be created when initialising the system.

Returns:

Throws:

SQLException

getMetadata

public String getMetadata(String key)
                   throws SQLException

Return the metadata value with the given key; can be used by KiWi modules to retrieve module-specific metadata.

Parameters:

key -

Returns:

Throws:

SQLException

setMetadata

public void setMetadata(String key,
               String value)
                 throws SQLException

Update the metadata value for the given key; can be used by KiWi modules to set module-specific metadata.

Parameters:

key -

Throws:

SQLException

getDatabaseVersion

public int getDatabaseVersion()
                       throws SQLException

Return the KiWi version of the database this connection is operating on. This query is necessary for checking proper state of a database when initialising the system.

Returns:

Throws:

SQLException

setAutoCommit

public void setAutoCommit(boolean autoCommit)
                   throws SQLException

Sets this connection's auto-commit mode to the given state. If a connection is in auto-commit mode, then all its SQL statements will be executed and committed as individual transactions. Otherwise, its SQL statements are grouped into transactions that are terminated by a call to either the method commit or the method rollback. By default, new connections are in auto-commit mode.

The commit occurs when the statement completes. The time when the statement completes depends on the type of SQL Statement:

• For DML statements, such as Insert, Update or Delete, and DDL statements, the statement is complete as soon as it has finished executing.
• For Select statements, the statement is complete when the associated result set is closed.
• For CallableStatement objects or for statements that return multiple results, the statement is complete when all of the associated result sets have been closed, and all update counts and output parameters have been retrieved.

NOTE: If this method is called during a transaction and the auto-commit mode is changed, the transaction is committed. If setAutoCommit is called and the auto-commit mode is not changed, the call is a no-op.

Parameters:

autoCommit - true to enable auto-commit mode; false to disable it

Throws:

SQLException - if a database access error occurs, setAutoCommit(true) is called while participating in a distributed transaction, or this method is called on a closed connection

See Also:

getAutoCommit()

getAutoCommit

public boolean getAutoCommit()
                      throws SQLException

Retrieves the current auto-commit mode for this Connection object.

Returns:

the current state of this Connection object's auto-commit mode

Throws:

SQLException - if a database access error occurs or this method is called on a closed connection

See Also:

setAutoCommit(boolean)

isBatchCommit

public boolean isBatchCommit()

Return true if batched commits are enabled. Batched commits will try to group database operations and keep a memory log while storing triples. This can considerably improve the database performance.

Returns:

setBatchCommit

public void setBatchCommit(boolean batchCommit)

Enabled batched commits. Batched commits will try to group database operations and keep a memory log while storing triples. This can considerably improve the database performance.

getBatchSize

public int getBatchSize()

Return the size of a batch for batched commits. Batched commits will try to group database operations and keep a memory log while storing triples. This can considerably improve the database performance.

Returns:

setBatchSize

public void setBatchSize(int batchSize)

Set the size of a batch for batched commits. Batched commits will try to group database operations and keep a memory log while storing triples. This can considerably improve the database performance.

Parameters:

batchSize -

commit

public void commit()
            throws SQLException

Makes all changes made since the previous commit/rollback permanent and releases any database locks currently held by this Connection object. This method should be used only when auto-commit mode has been disabled.

Throws:

SQLException - if a database access error occurs, this method is called while participating in a distributed transaction, if this method is called on a closed conection or this Connection object is in auto-commit mode

See Also:

setAutoCommit(boolean)

rollback

public void rollback()
              throws SQLException

Undoes all changes made in the current transaction and releases any database locks currently held by this Connection object. This method should be used only when auto-commit mode has been disabled.

Throws:

SQLException - if a database access error occurs, this method is called while participating in a distributed transaction, this method is called on a closed connection or this Connection object is in auto-commit mode

See Also:

setAutoCommit(boolean)

isClosed

public boolean isClosed()
                 throws SQLException

Retrieves whether this Connection object has been closed. A connection is closed if the method close has been called on it or if certain fatal errors have occurred. This method is guaranteed to return true only when it is called after the method Connection.close has been called.

This method generally cannot be called to determine whether a connection to a database is valid or invalid. A typical client can determine that a connection is invalid by catching any exceptions that might be thrown when an operation is attempted.

Returns:

true if this Connection object is closed; false if it is still open

Throws:

SQLException - if a database access error occurs

close

public void close()
           throws SQLException

Releases this Connection object's database and JDBC resources immediately instead of waiting for them to be automatically released.

Calling the method close on a Connection object that is already closed is a no-op.

It is strongly recommended that an application explicitly commits or rolls back an active transaction prior to calling the close method. If the close method is called and there is an active transaction, the results are implementation-defined.

Specified by:

close in interface AutoCloseable

Throws:

SQLException - SQLException if a database access error occurs

flushBatch

public void flushBatch()
                throws SQLException

Throws:

SQLException

getTransactionId

public long getTransactionId()

Return the current transaction ID

Returns: