Like query, but queries are batched from the server by wrapping
them in a SPARQL SELECT query with a limit/offset.

NOTE: Though this function returns a lazy sequence, it is intended
to be used eagerly, perhaps inside something that eagerly loads the
results and manages the connection resources inside a with-open.

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.rdf.protocols/itriplereadable 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.

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)))`

DEPRECATED: Use sail-repo or fixture-repo instead.

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

This function also supports initialising the repository with some
data that can be loaded from anything grafter.rdf/statements can
coerce.  Additionally the data can also be a sequence of
grafter.rdf.protocols/Quad's.

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.

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.

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