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

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

*env* clj/s

*override-restrictions* clj/s

*plan-options* clj/s

*select-distinct* clj/s

agg-label clj/s

(agg-label [op v])

Inputs: [[op v]] Returns: s/Symbol

Converts an aggregate operation on a symbol into a symbol name

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 with partial-results)

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

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

aggregate-query clj/s

(aggregate-query find
                 bindings
                 with
                 where
                 graph
                 project-fn
                 {:keys [query-plan] :as options})

AuditableResults clj/s

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]]

Iterates over the arguments to perform a left-join on each

context-execute-query clj/s

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

Inputs: [graph grouping-vars :- #{Var} 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] Returns: [(s/one (s/maybe Bindings) "The bindings for other params") (s/one (s/maybe s/Any) "The default graph")]

Converts user provided data for a query into bindings

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

distinct-fn clj/s

(distinct-fn op)

Returns a function that may deduplicate results, depending on the type of operator

empty-bindings clj/s

execute-query clj/s

(execute-query selection
               constraints
               bindings
               graph
               project-fn
               {:keys [query-plan] :as options})

Inputs: [selection constraints bindings graph project-fn {:keys [query-plan], :as options}]

expand-shortened-pattern-constraints clj/s

(expand-shortened-pattern-constraints {:keys [where] :as query})

Inputs: [{:keys [where], :as query}]

In the :where sequence of query expand EPV patterns of the form [E] and [E P] to [E ?P ?V] and [E ?P ?V] respectively where ?P and ?V are fresh variables.

extended-query-keys clj/s

Fcn clj/s

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)

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

(join-patterns graph patterns bindings {:keys [query-plan] :as options})

Inputs: [graph patterns :- [Pattern] bindings :- (s/maybe Bindings) {:keys [query-plan], :as options}] Returns: AuditableResults

Joins the resolutions for a series of patterns into a single result. If options contains :path-plan then returns the plan and does not execute

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.

missing clj/s

(missing var-index arg)

Inputs: [var-index :- VarIndex arg :- s/Any] Returns: (s/maybe Var)

Returns a value when it is a var that does not appear in the var index var-index.

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__19376 & rest19377)

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

null-value clj/s

op-error clj/s

(op-error pattern)

operand-vars clj/s

(operand-vars o)

operators clj/s

optional clj/s

(optional graph part [_ & patterns :as operation])

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

Performs a left-outer-join, similarly to a conjunction

outer-product clj/s

(outer-product leftb rightb)

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

Creates an outer product between 2 sets of bindings

parse clj/s

(parse x)

Inputs: [x]

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.

plain-var clj/s

(plain-var v)

plain-vars clj/s

(plain-vars v)

Plan clj/s

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-graph inputs plan?)

Inputs: [query empty-graph inputs plan?]

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 where] :as query})

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

resolve-op clj/s

(resolve-op s)

Inputs: [s :- s/Symbol] Returns: (s/maybe Fcn)

Resolves a symbol to an associated function. Symbols without a namespace are presumed to be in clojure.core

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

retrieve-op clj/s

(retrieve-op op var-index part)

Inputs: [op var-index :- VarIndex part] Returns: Fcn

Retrieves a function for a provided operation. An op can be a variable, a function, a symbol for a function, or a string.

rewrite-wildcards clj/s

(rewrite-wildcards {:keys [where] :as query})

Inputs: [{:keys [where], :as query}]

In the :where sequence of query replace all occurrences of _ with unique variables.

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 {:keys [planner] :as options})

Inputs: [{:keys [planner], :as options}]

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

seq-group-by clj/s

(seq-group-by group-select xs)

Does a group-by style of operation, but it streams over the input and provides a sequence of groups. The input data must already be in a groupable order, meaning that once a grouping variable has stopped appearing, the group is finished. group-select is a function for selecting the data to group by.

split-with* clj/s

(split-with* pred coll)

Same as clojure.core/split-with but only executes the predicate once on each matching element. Returns the same as [(vec (take-while pred coll)) (drop-while pred coll)]

symb? clj/s

(symb? s)

Inputs: [s]

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

VarIndex clj/s

vars clj/s

(vars s)

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