public class SPARQLConnection extends AbstractRepositoryConnection implements HttpClientDependent
RepositoryConnection interface to any SPARQL endpoint.logger| Constructor and Description |
|---|
SPARQLConnection(SPARQLRepository repository,
SPARQLProtocolSession client) |
SPARQLConnection(SPARQLRepository repository,
SPARQLProtocolSession client,
boolean quadMode) |
| Modifier and Type | Method and Description |
|---|---|
void |
add(File file,
String baseURI,
RDFFormat dataFormat,
Resource... contexts)
Adds RDF data from the specified file to a specific contexts in the repository.
|
void |
add(InputStream in,
String baseURI,
RDFFormat dataFormat,
Resource... contexts)
Adds RDF data from an InputStream to the repository, optionally to one or more named contexts.
|
void |
add(Iterable<? extends Statement> statements,
Resource... contexts)
Adds the supplied statements to this repository, optionally to one or more named contexts.
|
void |
add(Reader reader,
String baseURI,
RDFFormat dataFormat,
Resource... contexts)
Adds RDF data from a Reader to the repository, optionally to one or more named contexts.
|
void |
add(Statement st,
Resource... contexts)
Adds the supplied statement to this repository, optionally to one or more named contexts.
|
void |
add(URL url,
String baseURI,
RDFFormat dataFormat,
Resource... contexts)
Adds the RDF data that can be found at the specified URL to the repository, optionally to one or more named
contexts.
|
protected void |
addWithoutCommit(Resource subject,
IRI predicate,
Value object,
Resource... contexts) |
protected void |
addWithoutCommit(Statement st,
Resource... contexts) |
void |
begin()
Begins a new transaction, requiring
RepositoryConnection.commit() or RepositoryConnection.rollback() to be called to end the transaction. |
void |
clear(Resource... contexts)
Removes all statements from a specific contexts in the repository.
|
void |
clearNamespaces()
Removes all namespace declarations from the repository.
|
void |
close()
Closes the connection, freeing resources.
|
void |
commit()
Commits the active transaction.
|
void |
enableSilentMode(boolean flag)
Deprecated.
since 3.6.0 - use
setSilentClear(boolean) instead. |
void |
exportStatements(Resource subj,
IRI pred,
Value obj,
boolean includeInferred,
RDFHandler handler,
Resource... contexts)
Exports all statements with a specific subject, predicate and/or object from the repository, optionally from the
specified contexts.
|
RepositoryResult<Resource> |
getContextIDs()
Gets all resources that are used as content identifiers.
|
org.apache.http.client.HttpClient |
getHttpClient()
HttpClient that has been assigned or has been used by this object. |
String |
getNamespace(String prefix)
Gets the namespace that is associated with the specified prefix, if any.
|
RepositoryResult<Namespace> |
getNamespaces()
Gets all declared namespaces as a RepositoryResult of
Namespace objects. |
SPARQLRepository |
getRepository()
Returns the Repository object to which this connection belongs.
|
RepositoryResult<Statement> |
getStatements(Resource subj,
IRI pred,
Value obj,
boolean includeInferred,
Resource... contexts)
Gets all statements with a specific subject, predicate and/or object from the repository.
|
boolean |
hasStatement(Resource subj,
IRI pred,
Value obj,
boolean includeInferred,
Resource... contexts)
Checks whether the repository contains statements with a specific subject, predicate and/or object, optionally in
the specified contexts.
|
boolean |
isActive()
Indicates if a transaction is currently active on the connection.
|
boolean |
isEmpty()
Returns true if this repository does not contain any (explicit) statements.
|
protected boolean |
isQuadMode()
Shall graph information also be retrieved, e.g.
|
protected boolean |
isSilentClear() |
void |
prepare()
Checks for an error state in the active transaction that would force the transaction to be rolled back.
|
BooleanQuery |
prepareBooleanQuery(QueryLanguage ql,
String query,
String base)
Prepares queries that return true or false.
|
GraphQuery |
prepareGraphQuery(QueryLanguage ql,
String query,
String base)
Prepares queries that produce RDF graphs.
|
Query |
prepareQuery(QueryLanguage ql,
String query,
String base)
Prepares a query for evaluation on this repository (optional operation).
|
TupleQuery |
prepareTupleQuery(QueryLanguage ql,
String query,
String base)
Prepares a query that produces sets of value tuples.
|
Update |
prepareUpdate(QueryLanguage ql,
String update,
String baseURI)
Prepares an Update operation.
|
void |
remove(Iterable<? extends Statement> statements,
Resource... contexts)
Removes the supplied statements from the specified contexts in this repository.
|
void |
remove(Statement st,
Resource... contexts)
Removes the supplied statement from the specified contexts in the repository.
|
void |
removeNamespace(String prefix)
Removes a namespace declaration by removing the association between a prefix and a namespace name.
|
protected void |
removeWithoutCommit(Resource subject,
IRI predicate,
Value object,
Resource... contexts) |
protected void |
removeWithoutCommit(Statement st,
Resource... contexts) |
void |
rollback()
Rolls back all updates in the active transaction.
|
void |
setHttpClient(org.apache.http.client.HttpClient httpClient)
Assign an
HttpClient that this object should use. |
void |
setNamespace(String prefix,
String name)
Sets the prefix for a namespace.
|
void |
setParserConfig(ParserConfig parserConfig)
Set the parser configuration this connection should use for RDFParser-based operations.
|
void |
setSilentClear(boolean silent)
Configure the connection to execute
clear(Resource...) operations silently: the remote endpoint will not
respond with an error if the supplied named graph does not exist on the endpoint. |
long |
size(Resource... contexts)
Returns the number of (explicit) statements that are in the specified contexts in this repository.
|
protected Iteration<Statement,QueryEvaluationException> |
toStatementIteration(TupleQueryResult iter,
Resource subj,
IRI pred,
Value obj)
Converts a
TupleQueryResult resulting from the EVERYTHING_WITH_GRAPH to a statement by using the
respective values from the BindingSet or (if provided) the ones from the arguments. |
String |
toString() |
add, add, begin, conditionalCommit, conditionalRollback, export, getIsolationLevel, getParserConfig, getValueFactory, hasStatement, isAutoCommit, isOpen, prepareBooleanQuery, prepareGraphQuery, prepareQuery, prepareTupleQuery, prepareUpdate, remove, remove, setAutoCommit, setIsolationLevel, startLocalTransactionclone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, waitadd, add, add, add, add, add, add, add, begin, getStatements, getStatements, hasStatement, prepareBooleanQuery, prepareGraphQuery, prepareQuery, prepareTupleQuery, prepareUpdate, remove, removepublic SPARQLConnection(SPARQLRepository repository, SPARQLProtocolSession client)
public SPARQLConnection(SPARQLRepository repository, SPARQLProtocolSession client, boolean quadMode)
public void setSilentClear(boolean silent)
clear(Resource...) operations silently: the remote endpoint will not
respond with an error if the supplied named graph does not exist on the endpoint.
By default, the SPARQL connection executes the clear(Resource...) API operation by converting it to a
SPARQL `CLEAR GRAPH` update operation. This operation has an optional SILENT modifier, which can be
enabled by setting this flag to true. The behavior of this modifier is speficied as follows in the
SPARQL 1.1 Recommendation:
If the store records the existence of empty graphs, then the SPARQL 1.1 Update service, by default, SHOULD return failure if the specified graph does not exist. If SILENT is present, the result of the operation will always be success.Note that in most SPARQL endpoint implementations not recording empty graphs is the default behavior, and setting this flag toStores that do not record empty graphs will always return success.
true will have no effect. Setting this flag will have no effect on any other errors or
other API or SPARQL operations: only the behavior of the clear(Resource...) API
operation is modified to respond with a success message when removing a non-existent named graph.silent - the value to set this to.https://www.w3.org/TR/sparql11-update/#clear@Deprecated public void enableSilentMode(boolean flag)
setSilentClear(boolean) instead.clear(Resource...) operations silently: the remote endpoint will not
respond with an error if the supplied named graph does not exist on the endpoint.
By default, the SPARQL connection executes the clear(Resource...) API operation by converting it to a
SPARQL `CLEAR GRAPH` update operation. This operation has an optional SILENT modifier, which can be
enabled by setting this flag to true. The behavior of this modifier is speficied as follows in the
SPARQL 1.1 Recommendation:
If the store records the existence of empty graphs, then the SPARQL 1.1 Update service, by default, SHOULD return failure if the specified graph does not exist. If SILENT is present, the result of the operation will always be success.Note that in most SPARQL endpoint implementations not recording empty graphs is the default behavior, and setting this flag toStores that do not record empty graphs will always return success.
true will have no effect. Setting this flag will have no effect on any other errors or
other API or SPARQL operations: only the behavior of the clear(Resource...) API
operation is modified to respond with a success message when removing a non-existent named graph.silent - the value to set this to.https://www.w3.org/TR/sparql11-update/#clearpublic void setParserConfig(ParserConfig parserConfig)
RepositoryConnectionsetParserConfig in interface RepositoryConnectionsetParserConfig in class AbstractRepositoryConnectionparserConfig - a Rio RDF Parser configuration.public final org.apache.http.client.HttpClient getHttpClient()
HttpClientDependentHttpClient that has been assigned or has been used by this object. The life cycle might not be or might
be tied to this object, depending on whether HttpClient was passed to or created by this object
respectively.getHttpClient in interface HttpClientDependentHttpClient instance or nullpublic void setHttpClient(org.apache.http.client.HttpClient httpClient)
HttpClientDependentHttpClient that this object should use. The life cycle of the given HttpClient is
independent of this object. Closing or shutting down this object does not have any impact on the given client.
Callers must ensure that the given client is properly closed elsewhere.setHttpClient in interface HttpClientDependentpublic void close()
throws RepositoryException
RepositoryConnectiontransaction is active on the
connection, all non-committed operations will be lost by actively calling RepositoryConnection.rollback() on any active
transactions.
Implementation note: All implementations must override this method if they have any resources that they need to free.
close in interface AutoCloseableclose in interface RepositoryConnectionclose in class AbstractRepositoryConnectionRepositoryException - If the connection could not be closed.public void exportStatements(Resource subj, IRI pred, Value obj, boolean includeInferred, RDFHandler handler, Resource... contexts) throws RepositoryException, RDFHandlerException
RepositoryConnectionexportStatements in interface RepositoryConnectionsubj - The subject, or null if the subject doesn't matter.pred - The predicate, or null if the predicate doesn't matter.obj - The object, or null if the object doesn't matter.includeInferred - if false, no inferred statements are returned; if true, inferred statements are returned
if availablehandler - The handler that will handle the RDF data.contexts - The context(s) to get the data from. Note that this parameter is a vararg and as such is
optional. If no contexts are supplied the method operates on the entire repository.RDFHandlerException - If the handler encounters an unrecoverable error.RepositoryExceptionpublic RepositoryResult<Resource> getContextIDs() throws RepositoryException
RepositoryConnectionRepositoryResult is closed to free any resources that it keeps hold of.getContextIDs in interface RepositoryConnectionRepositoryExceptionpublic String getNamespace(String prefix) throws RepositoryException
RepositoryConnectiongetNamespace in interface RepositoryConnectionprefix - A namespace prefix, or an empty string in case of the default namespace.RepositoryException - If the namespace could not be read from the repository.public RepositoryResult<Namespace> getNamespaces() throws RepositoryException
RepositoryConnectionNamespace objects. Each Namespace object consists
of a prefix and a namespace name.getNamespaces in interface RepositoryConnectionRepositoryException - If the namespaces could not be read from the repository.public boolean isEmpty()
throws RepositoryException
RepositoryConnectionisEmpty in interface RepositoryConnectionisEmpty in class AbstractRepositoryConnectionRepositoryException - If the repository could not be checked to be empty.public long size(Resource... contexts) throws RepositoryException
RepositoryConnectionsize in interface RepositoryConnectioncontexts - The context(s) to get the data from. Note that this parameter is a vararg and as such is
optional. If no contexts are supplied the method operates on the entire repository.RepositoryExceptionpublic RepositoryResult<Statement> getStatements(Resource subj, IRI pred, Value obj, boolean includeInferred, Resource... contexts) throws RepositoryException
RepositoryConnectiongetStatements in interface RepositoryConnectionsubj - A Resource specifying the subject, or null for a wildcard.pred - An IRI specifying the predicate, or null for a wildcard.obj - A Value specifying the object, or null for a wildcard.includeInferred - if false, no inferred statements are returned; if true, inferred statements are returned
if available. The default is true.contexts - The context(s) to get the data from. Note that this parameter is a vararg and as such is
optional. If no contexts are supplied the method operates on the entire repository.RepositoryResult object, a
lazy Iterator-like object containing Statements and optionally throwing a
RepositoryException when an error when a problem occurs during retrieval.RepositoryExceptionpublic boolean hasStatement(Resource subj, IRI pred, Value obj, boolean includeInferred, Resource... contexts) throws RepositoryException
RepositoryConnectionhasStatement in interface RepositoryConnectionhasStatement in class AbstractRepositoryConnectionsubj - A Resource specifying the subject, or null for a wildcard.pred - An IRI specifying the predicate, or null for a wildcard.obj - A Value specifying the object, or null for a wildcard.includeInferred - if false, no inferred statements are considered; if true, inferred statements are
considered if availablecontexts - The context(s) the need to be searched. Note that this parameter is a vararg and as such
is optional. If no contexts are supplied the method operates on the entire repository.RepositoryExceptionpublic SPARQLRepository getRepository()
RepositoryConnectiongetRepository in interface RepositoryConnectiongetRepository in class AbstractRepositoryConnectionpublic Query prepareQuery(QueryLanguage ql, String query, String base) throws RepositoryException, MalformedQueryException
RepositoryConnection
If you already know the type of query, using the more specific RepositoryConnection.prepareTupleQuery(java.lang.String),
RepositoryConnection.prepareGraphQuery(java.lang.String) or RepositoryConnection.prepareBooleanQuery(java.lang.String) is likely to be more efficient.
prepareQuery in interface RepositoryConnectionql - The query language in which the query is formulated.query - The query string.base - The base URI to resolve any relative URIs that are in the query against, can be null if
the query does not contain any relative URIs.MalformedQueryException - If the supplied query is malformed.RepositoryExceptionpublic BooleanQuery prepareBooleanQuery(QueryLanguage ql, String query, String base) throws RepositoryException, MalformedQueryException
RepositoryConnectionprepareBooleanQuery in interface RepositoryConnectionql - The query language in which the query is formulated.query - The query string.base - The base URI to resolve any relative URIs that are in the query against, can be null if
the query does not contain any relative URIs.BooleanQuery ready to be evaluated on this RepositoryConnection.MalformedQueryException - If the supplied query is malformed.RepositoryExceptionpublic GraphQuery prepareGraphQuery(QueryLanguage ql, String query, String base) throws RepositoryException, MalformedQueryException
RepositoryConnectionprepareGraphQuery in interface RepositoryConnectionql - The query language in which the query is formulated.query - The query string.base - The base URI to resolve any relative URIs that are in the query against, can be null if
the query does not contain any relative URIs.GraphQuery ready to be evaluated on this RepositoryConnection.MalformedQueryException - If the supplied query is malformed.RepositoryExceptionpublic TupleQuery prepareTupleQuery(QueryLanguage ql, String query, String base) throws RepositoryException, MalformedQueryException
RepositoryConnectionprepareTupleQuery in interface RepositoryConnectionql - The query language in which the query is formulated.query - The query string.base - The base URI to resolve any relative URIs that are in the query against, can be null if
the query does not contain any relative URIs.TupleQuery ready to be evaluated on this RepositoryConnection.MalformedQueryException - If the supplied query is malformed.RepositoryExceptionpublic void prepare()
throws RepositoryException
RepositoryConnectionRepositoryConnection.commit() or
RepositoryConnection.rollback(). A call to this method must be followed by (in the same thread) with a call to
RepositoryConnection.prepare() , RepositoryConnection.commit(), RepositoryConnection.rollback(), or RepositoryConnection.close() . This method may be called
multiple times within the same transaction by the same thread. If this method returns normally, the caller can
reasonably expect that a subsequent call to RepositoryConnection.commit() will also return normally. If this method returns
with an exception the caller should treat the exception as if it came from a call to RepositoryConnection.commit().prepare in interface RepositoryConnectionUnknownTransactionStateException - If the transaction state can not be determined (this can happen for
instance when communication between client and server fails or
times-out). It does not indicate a problem with the integrity of the
store.RepositoryException - If there is an active transaction and it cannot be committed.RepositoryConnection.commit(),
RepositoryConnection.begin(),
RepositoryConnection.rollback()public void commit()
throws RepositoryException
RepositoryConnectioncommit in interface RepositoryConnectionUnknownTransactionStateException - if the transaction state can not be determined. This can happen for
instance when communication with a repository fails or times out.RepositoryException - If the connection could not be committed, or if the connection does not
have an active transaction.RepositoryConnection.isActive(),
RepositoryConnection.begin(),
RepositoryConnection.rollback(),
RepositoryConnection.prepare()public void rollback()
throws RepositoryException
RepositoryConnectionrollback in interface RepositoryConnectionUnknownTransactionStateException - if the transaction state can not be determined. This can happen for
instance when communication with a repository fails or times out.RepositoryException - If the transaction could not be rolled back, or if the connection does
not have an active transaction.RepositoryConnection.isActive(),
RepositoryConnection.begin(),
RepositoryConnection.commit()public void begin()
throws RepositoryException
RepositoryConnectionRepositoryConnection.commit() or RepositoryConnection.rollback() to be called to end the transaction.
The transaction will use the currently set isolation level for this connection.begin in interface RepositoryConnectionRepositoryException - If the connection could not start the transaction. One possible reason this may
happen is if a transaction is already active on the current
connection.RepositoryConnection.begin(IsolationLevel),
RepositoryConnection.isActive(),
RepositoryConnection.commit(),
RepositoryConnection.rollback(),
RepositoryConnection.setIsolationLevel(IsolationLevel)public void add(File file, String baseURI, RDFFormat dataFormat, Resource... contexts) throws IOException, RDFParseException, RepositoryException
RepositoryConnectionadd in interface RepositoryConnectionadd in class AbstractRepositoryConnectionfile - A file containing RDF data.baseURI - The base URI to resolve any relative URIs that are in the data against. This defaults to the
value of file.toURI() if the value is set to null.
Note that if the data contains an embedded base URI, that embedded base URI will overrule the value supplied here (see RFC 3986 section 5.1 for details).
dataFormat - The serialization format of the data. If set to null, the format will be automatically
determined by examining the file name extension of the supplied File.contexts - The contexts to add the data to. Note that this parameter is a vararg and as such is optional.
If no contexts are specified, the data is added to any context specified in the actual data
file, or if the data contains no context, it is added without context. If one or more contexts
are specified the data is added to these contexts, ignoring any context information in the data
itself.IOException - If an I/O error occurred while reading from the file.RDFParseException - If an error was found while parsing the RDF data.RepositoryException - If the data could not be added to the repository, for example because the
repository is not writable.public void add(URL url, String baseURI, RDFFormat dataFormat, Resource... contexts) throws IOException, RDFParseException, RepositoryException
RepositoryConnectionadd in interface RepositoryConnectionadd in class AbstractRepositoryConnectionurl - The URL of the RDF data.baseURI - The base URI to resolve any relative URIs that are in the data against. This defaults to the
value of url.toExternalForm() if the value is set to
null.
Note that if the data contains an embedded base URI, that embedded base URI will overrule the value supplied here (see RFC 3986 section 5.1 for details).
dataFormat - The serialization format of the data. If set to null, the format will be automatically
determined by examining the content type in the HTTP response header, and failing that, the
file name extension of the supplied URL.contexts - The contexts to add the data to. If one or more contexts are specified the data is added to
these contexts, ignoring any context information in the data itself.IOException - If an I/O error occurred while reading from the URL.RDFParseException - If an error was found while parsing the RDF data.RepositoryException - If the data could not be added to the repository, for example because the
repository is not writable.public void add(InputStream in, String baseURI, RDFFormat dataFormat, Resource... contexts) throws IOException, RDFParseException, RepositoryException
RepositoryConnectionadd in interface RepositoryConnectionadd in class AbstractRepositoryConnectionin - An InputStream from which RDF data can be read.baseURI - The base URI to resolve any relative URIs that are in the data against. May be
null.
Note that if the data contains an embedded base URI, that embedded base URI will overrule the value supplied here (see RFC 3986 section 5.1 for details).
dataFormat - The serialization format of the data.contexts - The contexts to add the data to. If one or more contexts are supplied the method ignores
contextual information in the actual data. If no contexts are supplied the contextual
information in the input stream is used, if no context information is available the data is
added without any context.IOException - If an I/O error occurred while reading from the input stream.RDFParseException - If an error was found while parsing the RDF data.RepositoryException - If the data could not be added to the repository, for example because the
repository is not writable.public void add(Reader reader, String baseURI, RDFFormat dataFormat, Resource... contexts) throws IOException, RDFParseException, RepositoryException
RepositoryConnectionadd in interface RepositoryConnectionadd in class AbstractRepositoryConnectionreader - A Reader from which RDF data can be read.baseURI - The base URI to resolve any relative URIs that are in the data against. May be
null.
Note that if the data contains an embedded base URI, that embedded base URI will overrule the value supplied here (see RFC 3986 section 5.1 for details).
dataFormat - The serialization format of the data.contexts - The contexts to add the data to. If one or more contexts are specified the data is added to
these contexts, ignoring any context information in the data itself.IOException - If an I/O error occurred while reading from the reader.RDFParseException - If an error was found while parsing the RDF data.RepositoryException - If the data could not be added to the repository, for example because the
repository is not writable.public void add(Statement st, Resource... contexts) throws RepositoryException
RepositoryConnectionadd in interface RepositoryConnectionadd in class AbstractRepositoryConnectionst - The statement to add.contexts - The contexts to add the statements to. Note that this parameter is a vararg and as such is
optional. If no contexts are specified, the statement is added to any context specified in each
statement, or if the statement contains no context, it is added without context. If one or more
contexts are specified the statement is added to these contexts, ignoring any context information
in the statement itself.RepositoryException - If the statement could not be added to the repository, for example because the
repository is not writable.public void add(Iterable<? extends Statement> statements, Resource... contexts) throws RepositoryException
RepositoryConnectionadd in interface RepositoryConnectionadd in class AbstractRepositoryConnectionstatements - The statements that should be added.contexts - The contexts to add the statements to. Note that this parameter is a vararg and as such is
optional. If no contexts are specified, each statement is added to any context specified in the
statement, or if the statement contains no context, it is added without context. If one or more
contexts are specified each statement is added to these contexts, ignoring any context
information in the statement itself. ignored.RepositoryException - If the statements could not be added to the repository, for example because the
repository is not writable.public void clear(Resource... contexts) throws RepositoryException
RepositoryConnectionclear in interface RepositoryConnectionclear in class AbstractRepositoryConnectioncontexts - The context(s) to remove the data from. Note that this parameter is a vararg and as such is
optional. If no contexts are supplied the method operates on the entire repository.RepositoryException - If the statements could not be removed from the repository, for example because the
repository is not writable.public void clearNamespaces()
throws RepositoryException
RepositoryConnectionclearNamespaces in interface RepositoryConnectionRepositoryException - If the namespace declarations could not be removed.public void remove(Statement st, Resource... contexts) throws RepositoryException
RepositoryConnectionremove in interface RepositoryConnectionremove in class AbstractRepositoryConnectionst - The statement to remove.contexts - The context(s) to remove the data from. Note that this parameter is a vararg and as such is
optional. If no contexts are supplied the method operates on the contexts associated with the
statement itself, and if no context is associated with the statement, on the entire repository.RepositoryException - If the statement could not be removed from the repository, for example because the
repository is not writable.public void remove(Iterable<? extends Statement> statements, Resource... contexts) throws RepositoryException
RepositoryConnectionremove in interface RepositoryConnectionremove in class AbstractRepositoryConnectionstatements - The statements that should be added.contexts - The context(s) to remove the data from. Note that this parameter is a vararg and as such is
optional. If no contexts are supplied the method operates on the contexts associated with the
statement itself, and if no context is associated with the statement, on the entire repository.RepositoryException - If the statements could not be added to the repository, for example because the
repository is not writable.public void removeNamespace(String prefix) throws RepositoryException
RepositoryConnectionremoveNamespace in interface RepositoryConnectionprefix - The namespace prefix, or an empty string in case of the default namespace.RepositoryException - If the namespace prefix could not be removed.public void setNamespace(String prefix, String name) throws RepositoryException
RepositoryConnectionsetNamespace in interface RepositoryConnectionprefix - The new prefix, or an empty string in case of the default namespace.name - The namespace name that the prefix maps to.RepositoryException - If the namespace could not be set in the repository, for example because the
repository is not writable.public Update prepareUpdate(QueryLanguage ql, String update, String baseURI) throws RepositoryException, MalformedQueryException
RepositoryConnectionprepareUpdate in interface RepositoryConnectionql - The query language in which the update operation is formulated.update - The update operation string.baseURI - The base URI to resolve any relative URIs that are in the update against, can be null if
the update does not contain any relative URIs.Update ready to be executed on this RepositoryConnection.MalformedQueryException - If the supplied update operation string is malformed.RepositoryExceptionpublic boolean isActive()
throws UnknownTransactionStateException,
RepositoryException
RepositoryConnectionRepositoryConnection.begin() has
been called, and becomes inactive after RepositoryConnection.commit() or RepositoryConnection.rollback() has been called.isActive in interface RepositoryConnectiontrue iff a transaction is active, false iff no transaction is active.UnknownTransactionStateException - if the transaction state can not be determined. This can happen for
instance when communication with a repository fails or times out.RepositoryExceptionprotected void addWithoutCommit(Statement st, Resource... contexts) throws RepositoryException
addWithoutCommit in class AbstractRepositoryConnectionRepositoryExceptionprotected void addWithoutCommit(Resource subject, IRI predicate, Value object, Resource... contexts) throws RepositoryException
addWithoutCommit in class AbstractRepositoryConnectionRepositoryExceptionprotected void removeWithoutCommit(Statement st, Resource... contexts) throws RepositoryException
removeWithoutCommit in class AbstractRepositoryConnectionRepositoryExceptionprotected void removeWithoutCommit(Resource subject, IRI predicate, Value object, Resource... contexts) throws RepositoryException
removeWithoutCommit in class AbstractRepositoryConnectionRepositoryExceptionprotected boolean isQuadMode()
getStatements(Resource, IRI, Value, boolean, Resource...)protected boolean isSilentClear()
protected Iteration<Statement,QueryEvaluationException> toStatementIteration(TupleQueryResult iter, Resource subj, IRI pred, Value obj)
TupleQueryResult resulting from the EVERYTHING_WITH_GRAPH to a statement by using the
respective values from the BindingSet or (if provided) the ones from the arguments.iter - the TupleQueryResultsubj - the subject Resource used as input or null if wildcard was usedpred - the predicate IRI used as input or null if wildcard was usedobj - the object Value used as input or null if wildcard was usedCopyright © 2015-2021 Eclipse Foundation. All Rights Reserved.