stardog.core — stardog-clj 7.4.0.1

add-ns! clj

(add-ns! connection prefix rdf-ns)

Adds a namespace prefix

ask clj

(ask connection text & args)

Executes a boolean query. Optional parameters may be provided as a map or named parameters. Parameter names are:

• base, parameters, reasoning, limit, offset, converter, key-converter.

assert-args clj macro

(assert-args & pairs)

Duplicates the functionality of the private clojure.core/assert-args

binding->map clj

(binding->map key-fn value-fn mb)

Converts a BindingSet into a map.

check-arg clj

(check-arg pred [f & r :as a])

clojure-data clj

(clojure-data results)

(clojure-data results keyfn valfn)

Converts query results into Clojure data. Optionally uses functions for interpreting names and value bindings in results.

ClojureResult clj protocol

clojure-data* clj

(clojure-data* results keyfn valfn)

Typed dispatched conversion of query results into Clojure data

configure-query clj

(configure-query q {:keys [parameters reasoning limit offset dataset]})

Configures a query is the valid parameters for that type of query

Connectable clj protocol

connect clj

(connect c)

Creates a connection with the given parameters

convert-to-map clj

(convert-to-map [f & r :as args])

Converts an arguments array into a map. The arguments are either positional, named, or already in map form. This function is a fixpoint.

create-db-spec clj

(create-db-spec db url user pass reasoning)

Helper function to create a dbspec with sensible defaults for nontypical parameters

create-query clj

(create-query new-with-base new-without-base {:keys [base] :as args})

Creates a query using a map of optional arguments. new-with-base: Function that creates the query with a base URI. new-without-base: Function that creates the query without a base URI. args: A map containing any of the following: base, parameters, reasoning, limit, offset

execute clj

(execute q & args)

Executes a query that has already been created and configured. Valid parameters are key-converter and converter. Query configuration parameters are ignored.

execute* clj

(execute* q
          {:keys [key-converter converter]
           :or {key-converter keyword converter values/standardize}})

graph clj

(graph connection text & args)

Executes a graph query. Optional parameters may be provided as a map or named parameters. Parameter names are:

• base, parameters, reasoning, limit, offset, converter, key-converter.

insert! clj

(insert! connection triple-list)

(insert! connection triple-list graph-uri)

Inserts a statement (subject, predicate, object) represented as a 3 item vector. If a graph URI is specified, the statements will be added to the named graph.

key-map-results clj

(key-map-results keyfn valfn results)

Converts a Iteration of bindings into a seq of keymaps.

list-namespaces clj

(list-namespaces connection)

Lists configured namespaces in the database

make-datasource clj

(make-datasource db-spec)

Creates a Stardog datasource, i.e. ConnectionPool

query clj

(query connection text & args)

Executes a query and returns results. When constructing a query from text, the parameters are:

• connection: The connection to query over (required).
• text: The text of the connection (String - required). Remaining argument are optional, and may be positional args, a map of args, or named args. Mapped and named args use the keys:
• base, parameters, reasoning, limit, offset, converter, key-converter Positional arguments are in order:
• base: The base URI for the query (String).
• parameters: A parameter map to bind parameters in the query (Map).
• reasoning: boolean true/false for reasoning, or not
• converter: A function to convert returned values with (Function).
• key-converter: A function to convert returned binding names with (Function).
• limit: The limit for the result. Must be present to use offset (integer).
• offset: The offset to start the result (integer).

query-keys clj

remove! clj

(remove! connection triple-list)

(remove! connection triple-list graph-uri)

Remove a statement from the database; nil's can be used in any position to indicate a wildcard matching anything in that position, thereby removing multiple statements. If a graph URI is specified, all statements matching the given SPO pattern will be removed from the named graph.

remove-all! clj

(remove-all! connection)

Delete the entire contents of the database.

remove-named-graph! clj

(remove-named-graph! connection)

(remove-named-graph! connection graph-uri)

Remove the named graph and all the statements within from the database. If no graph URI is provided this will remove the default graph (no context). If you want to remove everything in the database regardless of context, use remove-all!.

remove-ns! clj

(remove-ns! connection prefix)

Removes a namespace prefix

statement->map clj

(statement->map value-fn mb)

Converts a Statement into a map.

transact clj

(transact pool func)

(transact pool (something con ..)) Executes a function over a connection pool and transaction

update! clj

(update! connection text & args)

Executes an update operation. Optional parameters may be provided as a map or named parameters. Parameter names are:

• base, parameters, reasoning, converter.

vector-map-results clj

(vector-map-results valfn results)

Converts a Graph of statements into a seq of vectors.

with-connection-pool clj macro

(with-connection-pool bindings & body)

(with-connection-pool [con pool] .. con, body ..) Evaluates body in the context of an active connection

with-connection-tx clj macro

(with-connection-tx bindings & body)

(with-connection-tx binding-forms body) Establishes a connection and a transaction to execute the body within.

with-transaction clj macro

(with-transaction connections & body)

(with-transaction [connection...] body) Executes the body with a transaction on each of the connections. At completion of the body the transaction is committed. If the body fails due to exception, the transaction is rolled back. This macro intentionally restricts connections to be symbols, to encourage them to be bindings in with-open.