A forward-chaining inferencer that infers new statements using a
SPARQL graph query.

A forward-chaining inferencer that infers the direct-type hierarchy
relations sesame:directSubClassOf, sesame:directSubPropertyOf and
sesame:directType.

adds the specified data to a sparql repository.  if the first
argument is a repository that object is used, otherwise the first
and remaining arguments are assumed to be
grafter-2.core/ITripleWriteable and are loaded into a sesame
memorystore sail-repo.

this function is most useful for loading fixture data from files e.g.

(fixture-repo "test-data.trig" "more-test-data.trig")

Given a URL as a String return a Sesame HTTPRepository for e.g.
interacting with the OpenRDF Workbench.

Build a dataset to act as a graph restriction.  You can specify for
both `:default-graph` and `:named-graphs`.  Both of which take sequences
of URI strings.

Instantiate a sesame RDF MemoryStore.

Instantiate a sesame RDF NativeStore.

Wrap the given repository in an RDF4j NotifyingRepositoryWrapper.
Once wrapped you can capture events on the underlying repository.

Supports two arities:

- Takes just a repo to wrap.
- Takes a repo to wrap and a boolean indicating whether to report
  deltas on operations.

Low level function to prepare (parse, but not process) a sesame RDF
query.  Takes a repository a query string and an optional sesame
Dataset to act as a query restriction.

Prepared queries still need to be evaluated with evaluate.

Prepare (parse but don't process) a SPARQL update request.

Prepared updates still need to be evaluated with evaluate.

Run an arbitrary SPARQL query.  Works with ASK, DESCRIBE, CONSTRUCT
and SELECT queries.

You can call this on a Repository however if you do you may in some
cases cause a resource leak, for example if the sequence of results
isn't fully consumed.

To use this without leaking resources it is recommended that you
call ->connection on your repository, inside a with-open; and then
consume all your results inside of a nested doseq/dorun/etc...

e.g.

````
(with-open [conn (->connection repo)]
   (doseq [res (query conn "SELECT * WHERE { ?s ?p ?o .}")]
      (println res)))
````

Takes a repo and sparql string and an optional set of k/v argument
pairs, and executes the sparql query on the repository.

Options are:

- `:default-graph` a seq of URI strings representing named graphs to be set
  as the default union graph for the query.

- `:named-graphs` a seq of URI strings representing the named graphs in
  to be used in the query.

If no options are passed then we use the default of no graph
restrictions whilst the union graph is the union of all graphs.

Returns a Sesame ForwardChainingRDFSInferencer using the rules from
the RDF Semantics Recommendation (10 February 2004).

You can instantiate a repository with a memory store or a native
store or with any SAIL that returns InferencerConnections.  e.g. to
instantiate a repository with a memory-store:

`(repo (rdfs-inferencer (memory-store)))`

Like fixture repo but assumes all supplied data is on the java
resource path.  For example:

(repo/resource-repo "grafter/rdf/sparql/sparql-data.trig"
                    "grafter/rdf/rdf-types.trig")

Will load the supplied RDF files from the resource path into a
single memory repository for testing.

If you want to use a custom repository the first argument can be a
repository.

Given a sesame Sail of some type, return a sesame SailRepository.

Finally you can also optionally supply a sesame sail to wrap the
repository, which can be used to configure a sesame NativeStore.

By default this function will return a repository initialised with a
Sesame MemoryStore.

Cleanly shutsdown the repository.

Given a query-url (String or IURI) and an optional update-url String
or IURI, return a Sesame SPARQLRepository for communicating with
remote repositories.

Throw a more helpful error message alerting people to the need to
change code.

This is technically a breaking change, but it should indicate sites
which have a bug in them anyway.

Wraps the given forms in a transaction on the supplied repository.
Exceptions are rolled back on failure.