Class ContextAwareConnection

    • Field Detail

      • ALL_CONTEXTS

        private static final IRI[] ALL_CONTEXTS
      • includeInferred

        private boolean includeInferred
      • maxQueryTime

        private int maxQueryTime
      • baseURI

        private java.lang.String baseURI
      • readContexts

        private IRI[] readContexts
      • addContexts

        private IRI[] addContexts
      • removeContexts

        private IRI[] removeContexts
      • archiveContexts

        private IRI[] archiveContexts
      • insertContext

        private IRI insertContext
    • Method Detail

      • isIncludeInferred

        public boolean isIncludeInferred()
        if false, no inferred statements are considered; if true, inferred statements are considered if available
      • setIncludeInferred

        public void setIncludeInferred​(boolean includeInferred)
        if false, no inferred statements are considered; if true, inferred statements are considered if available
      • getMaxQueryTime

        public int getMaxQueryTime()
      • setMaxQueryTime

        public void setMaxQueryTime​(int maxQueryTime)
      • setQueryLanguage

        public void setQueryLanguage​(QueryLanguage ql)
      • getBaseURI

        public java.lang.String getBaseURI()
        Returns:
        Returns the default baseURI.
      • setBaseURI

        public void setBaseURI​(java.lang.String baseURI)
        Parameters:
        baseURI - The default baseURI to set.
      • getReadContexts

        public IRI[] getReadContexts()
        The default 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.
      • setReadContexts

        public void setReadContexts​(IRI... readContexts)
        The default 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.
      • getAddContexts

        @Deprecated
        public IRI[] getAddContexts()
        Deprecated.
        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 a context. If one or more contexts are specified each statement is added to these contexts, ignoring any context information in the statement itself.
      • setAddContexts

        @Deprecated
        public void setAddContexts​(IRI... addContexts)
        Deprecated.
        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 a context. If one or more contexts are specified each statement is added to these contexts, ignoring any context information in the statement itself.
      • getRemoveContexts

        public IRI[] getRemoveContexts()
        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.
      • setRemoveContexts

        public void setRemoveContexts​(IRI... removeContexts)
        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.
      • getArchiveContexts

        @Deprecated
        public IRI[] getArchiveContexts()
        Deprecated.
        Before Statements are removed, they are first copied to these contexts.
      • setArchiveContexts

        @Deprecated
        public void setArchiveContexts​(IRI... archiveContexts)
        Deprecated.
        Before Statements are removed, they are first copied to these contexts.
      • getInsertContext

        public IRI getInsertContext()
        The default context to add the statements to. For INSERT/add operations Each statement is added to any context specified in the statement, or if the statement contains no context, it is added with the context specified here.
      • setInsertContext

        public void setInsertContext​(IRI insertContext)
        The default context to add the statements to. For INSERT/add operations Each statement is added to any context specified in the statement, or if the statement contains no context, it is added with the context specified here.
      • add

        public void add​(java.io.File file,
                        RDFFormat dataFormat,
                        Resource... contexts)
                 throws java.io.IOException,
                        RDFParseException,
                        RepositoryException
        Description copied from interface: RepositoryConnection
        Adds RDF data from the specified file to a specific contexts in the repository.
        Parameters:
        file - A file containing RDF data.
        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.
        Throws:
        java.io.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.
      • add

        public void add​(java.io.File file,
                        java.lang.String baseURI,
                        RDFFormat dataFormat,
                        Resource... contexts)
                 throws java.io.IOException,
                        RDFParseException,
                        RepositoryException
        Description copied from interface: RepositoryConnection
        Adds RDF data from the specified file to a specific contexts in the repository.
        Specified by:
        add in interface RepositoryConnection
        Overrides:
        add in class RepositoryConnectionWrapper
        Parameters:
        file - 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.
        Throws:
        java.io.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.
      • add

        public void add​(java.io.InputStream in,
                        RDFFormat dataFormat,
                        Resource... contexts)
                 throws java.io.IOException,
                        RDFParseException,
                        RepositoryException
        Description copied from interface: RepositoryConnection
        Adds RDF data from an InputStream to the repository, optionally to one or more named contexts.
        Parameters:
        in - An InputStream from which RDF data can be read.
        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.
        Throws:
        java.io.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.
      • add

        public void add​(java.io.InputStream in,
                        java.lang.String baseURI,
                        RDFFormat dataFormat,
                        Resource... contexts)
                 throws java.io.IOException,
                        RDFParseException,
                        RepositoryException
        Description copied from interface: RepositoryConnection
        Adds RDF data from an InputStream to the repository, optionally to one or more named contexts.
        Specified by:
        add in interface RepositoryConnection
        Overrides:
        add in class RepositoryConnectionWrapper
        Parameters:
        in - 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.
        Throws:
        java.io.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.
      • add

        public void add​(java.lang.Iterable<? extends Statement> statements,
                        Resource... contexts)
                 throws RepositoryException
        Description copied from interface: RepositoryConnection
        Adds the supplied statements to this repository, optionally to one or more named contexts.
        Specified by:
        add in interface RepositoryConnection
        Overrides:
        add in class RepositoryConnectionWrapper
        Parameters:
        statements - The statements that should be added. In case the iterable is NamespaceAware and the target repository supports it, the iterable's namespaces are also added to the repository, without overwriting existing ones.
        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.
        Throws:
        RepositoryException - If the statements could not be added to the repository, for example because the repository is not writable.
      • add

        public <E extends java.lang.Exception> void add​(Iteration<? extends Statement,​E> statementIter,
                                                        Resource... contexts)
                                                 throws RepositoryException,
                                                        E extends java.lang.Exception
        Description copied from interface: RepositoryConnection
        Adds the supplied statements to this repository, optionally to one or more named contexts.
        Specified by:
        add in interface RepositoryConnection
        Overrides:
        add in class RepositoryConnectionWrapper
        Parameters:
        statementIter - The statements to add. In case the iteration is a CloseableIteration, it will be closed before this method returns.
        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.
        Throws:
        RepositoryException - If the statements could not be added to the repository, for example because the repository is not writable.
        E extends java.lang.Exception
      • add

        public void add​(java.io.Reader reader,
                        RDFFormat dataFormat,
                        Resource... contexts)
                 throws java.io.IOException,
                        RDFParseException,
                        RepositoryException
        Description copied from interface: RepositoryConnection
        Adds RDF data from a Reader to the repository, optionally to one or more named contexts. Note: using a Reader to upload byte-based data means that you have to be careful not to destroy the data's character encoding by enforcing a default character encoding upon the bytes. If possible, adding such data using an InputStream is to be preferred.
        Parameters:
        reader - A Reader from which RDF data can be read.
        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.
        Throws:
        java.io.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.
      • add

        public void add​(java.io.Reader reader,
                        java.lang.String baseURI,
                        RDFFormat dataFormat,
                        Resource... contexts)
                 throws java.io.IOException,
                        RDFParseException,
                        RepositoryException
        Description copied from interface: RepositoryConnection
        Adds RDF data from a Reader to the repository, optionally to one or more named contexts. Note: using a Reader to upload byte-based data means that you have to be careful not to destroy the data's character encoding by enforcing a default character encoding upon the bytes. If possible, adding such data using an InputStream is to be preferred.
        Specified by:
        add in interface RepositoryConnection
        Overrides:
        add in class RepositoryConnectionWrapper
        Parameters:
        reader - 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.
        Throws:
        java.io.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.
      • add

        public void add​(Resource subject,
                        IRI predicate,
                        Value object,
                        Resource... contexts)
                 throws RepositoryException
        Description copied from interface: RepositoryConnection
        Adds a statement with the specified subject, predicate and object to this repository, optionally to one or more named contexts.
        Specified by:
        add in interface RepositoryConnection
        Overrides:
        add in class RepositoryConnectionWrapper
        Parameters:
        subject - The statement's subject.
        predicate - The statement's predicate.
        object - The statement's object.
        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.
        Throws:
        RepositoryException - If the data could not be added to the repository, for example because the repository is not writable.
      • add

        public void add​(Statement st,
                        Resource... contexts)
                 throws RepositoryException
        Description copied from interface: RepositoryConnection
        Adds the supplied statement to this repository, optionally to one or more named contexts.
        Specified by:
        add in interface RepositoryConnection
        Overrides:
        add in class RepositoryConnectionWrapper
        Parameters:
        st - 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.
        Throws:
        RepositoryException - If the statement could not be added to the repository, for example because the repository is not writable.
      • add

        public void add​(java.net.URL url,
                        RDFFormat dataFormat,
                        Resource... contexts)
                 throws java.io.IOException,
                        RDFParseException,
                        RepositoryException
        Description copied from interface: RepositoryConnection
        Adds the RDF data that can be found at the specified URL to the repository, optionally to one or more named contexts.
        Parameters:
        url - The URL of the RDF data.
        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.
        Throws:
        java.io.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.
      • add

        public void add​(java.net.URL url,
                        java.lang.String baseURI,
                        RDFFormat dataFormat,
                        Resource... contexts)
                 throws java.io.IOException,
                        RDFParseException,
                        RepositoryException
        Description copied from interface: RepositoryConnection
        Adds the RDF data that can be found at the specified URL to the repository, optionally to one or more named contexts.
        Specified by:
        add in interface RepositoryConnection
        Overrides:
        add in class RepositoryConnectionWrapper
        Parameters:
        url - 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.
        Throws:
        java.io.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.
      • clear

        public void clear​(Resource... contexts)
                   throws RepositoryException
        Description copied from interface: RepositoryConnection
        Removes all statements from a specific contexts in the repository.
        Specified by:
        clear in interface RepositoryConnection
        Overrides:
        clear in class RepositoryConnectionWrapper
        Parameters:
        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 entire repository.
        Throws:
        RepositoryException - If the statements could not be removed from the repository, for example because the repository is not writable.
      • exportStatements

        public void exportStatements​(Resource subj,
                                     IRI pred,
                                     Value obj,
                                     boolean includeInferred,
                                     RDFHandler handler,
                                     Resource... contexts)
                              throws RepositoryException,
                                     RDFHandlerException
        Description copied from interface: RepositoryConnection
        Exports all statements with a specific subject, predicate and/or object from the repository, optionally from the specified contexts. This method supplies the RDFHandler with all namespace declarations available in the repository.
        Specified by:
        exportStatements in interface RepositoryConnection
        Overrides:
        exportStatements in class RepositoryConnectionWrapper
        Parameters:
        subj - 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 available
        handler - 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.
        Throws:
        RDFHandlerException - If the handler encounters an unrecoverable error.
        RepositoryException
      • getStatements

        public RepositoryResult<Statement> getStatements​(Resource subj,
                                                         IRI pred,
                                                         Value obj,
                                                         Resource... contexts)
                                                  throws RepositoryException
        Gets all statements with a specific subject, predicate and/or object from the repository. The result is optionally restricted to the specified set of named contexts.
        Parameters:
        subj - A Resource specifying the subject, or null for a wildcard.
        pred - A URI specifying the predicate, or null for a wildcard.
        obj - A Value specifying the object, or null for a wildcard.
        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.
        Returns:
        The statements matching the specified pattern. The result object is a RepositoryResult object, a lazy Iterator-like object containing Statements and optionally throwing a RepositoryException when an error when a problem occurs during retrieval.
        Throws:
        RepositoryException
        See Also:
        getReadContexts(), isIncludeInferred()
      • getStatements

        public RepositoryResult<Statement> getStatements​(Resource subj,
                                                         IRI pred,
                                                         Value obj,
                                                         boolean includeInferred,
                                                         Resource... contexts)
                                                  throws RepositoryException
        Description copied from interface: RepositoryConnection
        Gets all statements with a specific subject, predicate and/or object from the repository. The result is optionally restricted to the specified set of named contexts.
        Specified by:
        getStatements in interface RepositoryConnection
        Overrides:
        getStatements in class RepositoryConnectionWrapper
        Parameters:
        subj - 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.
        Returns:
        The statements matching the specified pattern. The result object is a RepositoryResult object, a lazy Iterator-like object containing Statements and optionally throwing a RepositoryException when an error when a problem occurs during retrieval.
        Throws:
        RepositoryException
      • hasStatement

        public boolean hasStatement​(Resource subj,
                                    IRI pred,
                                    Value obj,
                                    boolean includeInferred,
                                    Resource... contexts)
                             throws RepositoryException
        Description copied from interface: RepositoryConnection
        Checks whether the repository contains statements with a specific subject, predicate and/or object, optionally in the specified contexts.
        Specified by:
        hasStatement in interface RepositoryConnection
        Overrides:
        hasStatement in class RepositoryConnectionWrapper
        Parameters:
        subj - 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 available
        contexts - 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.
        Returns:
        true If a matching statement is in the repository in the specified context, false otherwise.
        Throws:
        RepositoryException
      • hasStatement

        public boolean hasStatement​(Statement st,
                                    boolean includeInferred,
                                    Resource... contexts)
                             throws RepositoryException
        Description copied from interface: RepositoryConnection
        Checks whether the repository contains the specified statement, optionally in the specified contexts.
        Specified by:
        hasStatement in interface RepositoryConnection
        Overrides:
        hasStatement in class RepositoryConnectionWrapper
        Parameters:
        st - The statement to look for. Context information in the statement is ignored.
        includeInferred - if false, no inferred statements are considered; if true, inferred statements are considered if available
        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.
        Returns:
        true If the repository contains the specified statement, false otherwise.
        Throws:
        RepositoryException
      • hasStatement

        public boolean hasStatement​(Resource subj,
                                    IRI pred,
                                    Value obj,
                                    Resource... contexts)
                             throws RepositoryException
        Checks whether the repository contains statements with a specific subject, predicate and/or object, optionally in the specified contexts.
        Parameters:
        subj - A Resource specifying the subject, or null for a wildcard.
        pred - A URI specifying the predicate, or null for a wildcard.
        obj - A Value specifying the object, or null for a wildcard.
        Returns:
        true If a matching statement is in the repository in the specified context, false otherwise.
        Throws:
        RepositoryException
        See Also:
        getReadContexts(), isIncludeInferred()
      • hasStatement

        public boolean hasStatement​(Statement st,
                                    Resource... contexts)
                             throws RepositoryException
        Checks whether the repository contains the specified statement, optionally in the specified contexts.
        Parameters:
        st - The statement to look for. Context information in the statement is ignored.
        Returns:
        true If the repository contains the specified statement, false otherwise.
        Throws:
        RepositoryException
        See Also:
        getReadContexts(), isIncludeInferred()
      • remove

        public void remove​(java.lang.Iterable<? extends Statement> statements,
                           Resource... contexts)
                    throws RepositoryException
        Description copied from interface: RepositoryConnection
        Removes the supplied statements from the specified contexts in this repository.
        Specified by:
        remove in interface RepositoryConnection
        Overrides:
        remove in class RepositoryConnectionWrapper
        Parameters:
        statements - 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.
        Throws:
        RepositoryException - If the statements could not be added to the repository, for example because the repository is not writable.
      • remove

        public <E extends java.lang.Exception> void remove​(Iteration<? extends Statement,​E> statementIter,
                                                           Resource... contexts)
                                                    throws RepositoryException,
                                                           E extends java.lang.Exception
        Removes the supplied statements from a specific context in this repository, ignoring any context information carried by the statements themselves.
        Specified by:
        remove in interface RepositoryConnection
        Overrides:
        remove in class RepositoryConnectionWrapper
        Parameters:
        statementIter - The statements to remove. In case the iterator is a CloseableIteration, it will be closed before this method returns.
        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.
        Throws:
        RepositoryException - If the statements could not be removed from the repository, for example because the repository is not writable.
        E extends java.lang.Exception
        See Also:
        getRemoveContexts()
      • remove

        public void remove​(Resource subject,
                           IRI predicate,
                           Value object,
                           Resource... contexts)
                    throws RepositoryException
        Removes the statement with the specified subject, predicate and object from the repository, optionally restricted to the specified contexts.
        Specified by:
        remove in interface RepositoryConnection
        Overrides:
        remove in class RepositoryConnectionWrapper
        Parameters:
        subject - The statement's subject.
        predicate - The statement's predicate.
        object - The statement's object.
        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 entire repository.
        Throws:
        RepositoryException - If the statement could not be removed from the repository, for example because the repository is not writable.
        See Also:
        getRemoveContexts()
      • remove

        public void remove​(Statement st,
                           Resource... contexts)
                    throws RepositoryException
        Removes the supplied statement from the specified contexts in the repository.
        Specified by:
        remove in interface RepositoryConnection
        Overrides:
        remove in class RepositoryConnectionWrapper
        Parameters:
        st - 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.
        Throws:
        RepositoryException - If the statement could not be removed from the repository, for example because the repository is not writable.
        See Also:
        getRemoveContexts()
      • size

        public long size​(Resource... contexts)
                  throws RepositoryException
        Returns the number of (explicit) statements that are in the specified contexts in this repository.
        Specified by:
        size in interface RepositoryConnection
        Overrides:
        size in class RepositoryConnectionWrapper
        Parameters:
        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.
        Returns:
        The number of explicit statements from the specified contexts in this repository.
        Throws:
        RepositoryException
        See Also:
        getReadContexts()
      • initQuery

        private <O extends Query> O initQuery​(O query)
      • initOperation

        private <O extends Operation> O initOperation​(O op)
      • isNilContext

        private boolean isNilContext​(Resource[] contexts)
      • isAllContext

        private boolean isAllContext​(Resource[] contexts)