asami.query — org.clojars.quoll/asami 0.4.9

Implements query operations based on data accessible through the Graph protocol.

*env* clj/s

*plan-options* clj/s

*select-distinct* clj/s

add-to-graph clj/s

(add-to-graph graph data)

Inputs: [graph data :- Results]

aggregate-fns clj/s

Map of aggregate symbols to functions that accept a seq of data to be aggregated

aggregate-over clj/s

(aggregate-over selection partial-results)

Inputs: [selection :- [s/Any] partial-results :- [Results]] Returns: Results

For each seq of results, aggregates individually, and then together

aggregate-query clj/s

(aggregate-query find bindings with where graph project-fn)

Inputs: [find bindings with where graph project-fn]

binding-join clj/s

(binding-join graph part [[op & args :as expr] bnd-var])

Inputs: [graph part :- Results [[op & args :as expr] bnd-var] :- EvalPattern]

Uses row bindings as arguments for an expression that uses the names in that binding. Binds a new var to the result of the expression and adds it to the complete results.

conforms? clj/s

(conforms? t d)

conjunction clj/s

(conjunction graph part [_ & patterns])

Inputs: [graph part :- Results [_ & patterns]]

Reorders arguments for left-join and drop the AND operator

context-execute-query clj/s

(context-execute-query graph context [op & args :as where])

Inputs: [graph context :- Results [op & args :as where] :- Pattern]

For each line in a context, execute a query specified by the where clause

create-binding clj/s

(create-binding nm values)

Inputs: [nm :- InSpec values] Returns: Bindings

Creates a bindings between a name and a set of values. If the name is singular, then that name is bound to the singular element found in values. If the name is a seq, then each name in the seq is bound to the corresponding offset in each value.

create-bindings clj/s

(create-bindings in values)

Inputs: [in :- [InSpec] values :- (s/cond-pre (s/protocol Storage) s/Any)] Returns: [(s/one (s/maybe Bindings) "The bindings for other params") (s/one (s/maybe StorageType) "The default storage")]

Converts user provided data for a query into bindings

delete-from-graph clj/s

(delete-from-graph graph data)

Inputs: [graph data :- Results]

disjunction clj/s

(disjunction graph part [_ & patterns])

Inputs: [graph part :- Results [_ & patterns]]

Implements an OR operation by repeating a join across each arm of the operation, and concatenating the results

empty-bindings clj/s

execute-query clj/s

(execute-query selection constraints bindings graph project-fn)

Inputs: [selection constraints bindings graph project-fn]

filter-join clj/s

(filter-join graph part [[op & args :as fltr]])

Inputs: [graph part :- Results [[op & args :as fltr]] :- FilterPattern]

Uses row bindings in a partial result as arguments to a function whose parameters are defined by those names. Those rows whose bindings return true/truthy are kept and the remainder are removed.

find-vars clj/s

(find-vars f)

Inputs: [f]

gate-fn clj/s

(gate-fn graph constraints)

Inputs: [graph constraints :- [Pattern]]

Returns a function that allows data through it or not, based on the results of a series of NOT operations. If any operation returns results, then nothing may get through.

identity-binding clj/s

InSpec clj/s

join-patterns clj/s≠

clj

(join-patterns graph patterns bindings & options)

cljs

(join-patterns G__19594 G__19595 G__19596 & rest19597)

Inputs: [graph patterns :- [Pattern] bindings :- (s/maybe Bindings) & options] Returns: Results

Joins the resolutions for a series of patterns into a single result.

left-join clj/s

(left-join pattern results graph)

Joins a partial result (on the left) to a pattern (on the right). The pattern type will determine dispatch.

minus clj/s

(minus graph part [_ & [fpattern :as patterns]])

Inputs: [graph part :- Results [_ & [fpattern :as patterns]]]

Removes matches. For each line in the current results, performs a subquery with NOT clause. When the NOT clause returns data then that line in the results should be removed.

modify-pattern clj/s

(modify-pattern existing mapping pattern)

Inputs: [existing :- [Value] mapping :- #:s{Num s/Num} pattern :- EPVPattern] Returns: [s/Any]

Creates a new EPVPattern from an existing one, based on existing bindings. Uses the mapping to copy from columns in 'existing' to overwrite variables in 'pattern'. The variable locations have already been found and are in the 'mapping' argument

newl clj/s≠

clj

(newl s & remaining)

cljs

(newl G__19638 & rest19639)

Inputs: [s :- (s/maybe s/Str) & remaining] Returns: s/Str

op-error clj/s

(op-error pattern)

operators clj/s

outer-product clj/s

(outer-product leftb rightb)

Inputs: [leftb :- Bindings rightb :- Bindings] Returns: Bindings

Creates an outer product between 2 sets of bindings

pattern-error clj/s

(pattern-error pattern)

pattern-left-join clj/s

(pattern-left-join graph part pattern)

Inputs: [graph part :- Results pattern :- EPVPattern] Returns: Results

Takes a partial result, and does an inner join against the resolution of a pattern. Iterates over the partial result, using the bindings to update the pattern to search the index. Each row in the partial result is then repeated to match the rows returned from the index lookup. If no variables match, then the result will be an outer product of the partial result, and the rows returned from an index lookup of the unmodified pattern. The final result has metadata with the columns from the partial result, and all new vars from the pattern.

prebound-left-join clj/s

(prebound-left-join part bindings)

Inputs: [part :- Results bindings :- Results] Returns: Results

Takes a bindings (Results) and joins on the current results. This is similar to the pattern-left-join but instead of taking a pattern to be applied to an indexed graph, it takes unindexed data that is already bound. The join is done by indexing the bindings and using the same algorithm that joins rows in pattern-left-join

prepend clj/s

(prepend element pattern)

Inputs: [element pattern :- Pattern]

query-entry clj/s

(query-entry query empty-store empty-graph inputs)

Inputs: [query empty-store empty-graph inputs]

Main entry point of user queries

query-keys clj/s

query-map clj/s

(query-map query)

Inputs: [query]

Parses a query into it's main components. Queries can be a sequence, a map, or an EDN string. These are based on Datomic-style queries. The return map contains: :find - The elements to be projected from a query. :all - true if duplicates are to be returned, false otherwise. Defaults to false. :in - A list of data sources. Optional. :with - list of variables for grouping. :where - A sequence of constraints for the query.

query-validator clj/s

(query-validator {:keys [find in with where] :as query})

Inputs: [{:keys [find in with where], :as query} :- #:s{Keyword (s/cond-pre s/Bool [s/Any])}]

result-label clj/s

(result-label e)

Inputs: [e] Returns: s/Symbol

Convert an element from a select/find clause into an appropriate label. Note that duplicate columns are not considered

run-simple-query clj/s

(run-simple-query graph [fpattern & patterns :as all-patterns])

Inputs: [graph [fpattern & patterns :as all-patterns] :- [PatternOrBindings]]

select-planner clj/s

(select-planner options)

Inputs: [options]

Selects a query planner function, based on user-selected options

symb? clj/s

(symb? s)

Inputs: [s]

Similar to symbol? but excludes the special ... form

vconj clj/s

(vconj c v)

Used to update a value to be a vector with the new element conj'ed. If the value starts as nil, then create a new vector to hold the element.

without clj/s

(without e s)

Inputs: [e :- s/Any s :- [s/Any]] Returns: [s/Any]

Returns a sequence minus a specific element