fluree.db.query.analytical — com.fluree/db 1.0.0-rc1

add-aggregate-cols clj/s

(add-aggregate-cols res aggregate)

add-fuel clj/s

(add-fuel add-amount fuel max-fuel)

aggregate? clj/s

(aggregate? x)

all-functions clj/s

bind-clause->vars clj/s

(bind-clause->vars res clause)

built-in-aggregates clj/s

calculate-aggregate clj/s

(calculate-aggregate res agg)

clause->keys clj/s

(clause->keys clause)

clause->rel clj/s

(clause->rel db interm-vars clause)

Given any interm-vars, such as {?article 351843720901583} and an fdb clause, such as ["?article", "articles/leadInstitutionOrg", "?org"],

Returns a map with the following keys:

• search - a vector that will be passed to query-range/search, i.e. [ nil "articles/leadInstitutionOrg" nil ]
• rel - a map with any variables (that are not present in interm-vars) and their idx, i.e. {?org 2}
• opts - search opts, currently recur, if the predicate is recurred, and object-fn, if there is an object function.

clause->tuples clj/s

(clause->tuples db
                {:keys [prefixes] :as q-map}
                {:keys [vars] :as res}
                clause
                r
                optional?
                fuel
                max-fuel
                opts)

Tuples and optional? are only used for Wikidata, because need to both limit calls to Wikidata, and ensure that returned results are as limited as possible (but still relevant).

collection->tuples clj/s

(collection->tuples db res clause)

db-ident? clj/s

(db-ident? source)

escaped-string? clj/s

(escaped-string? form)

expand-map clj/s

(expand-map tuple-map)

fdb-clause->tuples clj/s

(fdb-clause->tuples db
                    {:keys [headers tuples vars] :as res}
                    clause
                    fuel
                    max-fuel)

find-match clj/s

(find-match a-tuple a-idxs b-tuples b-idxs b-not-idxs)

Given a single tuple from A, a-idxs, b-idxs, b-not-idxs, and b-tuples, return any tuples in b that match.

find-match+row-nums clj/s

(find-match+row-nums a-tuple a-idxs b-tuples b-idxs b-not-idxs)

Given a single tuple from A, a-idxs, b-idxs, b-not-idxs, and b-tuples, return any tuples in b that match. Along with their row-numbers

follow-all-original-subject-paths clj/s

(follow-all-original-subject-paths subjects tuple-map)

full-text->tuples clj/s

(full-text->tuples db res clause)

get-ns-arrays clj/s

(get-ns-arrays ns arrays)

get-source-clause clj/s

(get-source-clause db clause)

(get-source-clause db clause prefixes opts)

get-vars clj/s

(get-vars filter-code)

inner-join clj/s

(inner-join a-res b-res)

interm-aggregate? clj/s

(interm-aggregate? x)

internal-filter? clj/s

(internal-filter? form)

intersecting-keys-tuples clj/s

(intersecting-keys-tuples a-tuples b-tuples)

intersecting-keys-tuples-clause clj/s

(intersecting-keys-tuples-clause tuples clause)

left-outer-join clj/s

(left-outer-join a-tuples b-tuples)

OPTIONAL clause is equivalent to a left outer join. If there are no matches in the b-tuples, we just return a 'match' where each element of the match from b-tuple is nil.

optional->left-outer-joins clj/s

(optional->left-outer-joins db
                            q-map
                            optional-clauses
                            where-tuples
                            fuel
                            max-fuel
                            opts)

outer-union clj/s

(outer-union a-tuples b-tuples)

UNION clause takes a left-hand side, which is inner-joined, and a right-hand side, which is inner-joined. Any tuples unbound by the other set are included.

parse-aggregate clj/s

(parse-aggregate x valid-var)

parse-block-from-source clj/s

(parse-block-from-source block)

q clj/s

(q q-map fuel max-fuel db opts)

recur-map->tuples clj/s

(recur-map->tuples subjects recur-map)

replace-vars-wikidata clj/s

(replace-vars-wikidata all-wd intersecting-vars vars)

res-absorb-vars clj/s

(res-absorb-vars res)

resolve-where-clause clj/s

(resolve-where-clause db where q-map vars fuel max-fuel)

(resolve-where-clause db where q-map vars fuel max-fuel opts)

safe-read-string clj/s

(safe-read-string string)

select-from-tuples clj/s

(select-from-tuples vars tuples)

symbolize-keys clj/s

(symbolize-keys q-map)

tuples->filter-optional clj/s

(tuples->filter-optional headers tuples valid-vars filter-code-opts)

tuples->filter-required clj/s

(tuples->filter-required headers tuples valid-vars filter-code-req)

tuples->filtered clj/s

(tuples->filtered {:keys [headers vars tuples] :as tuple-map} filters optional?)

tuples->map clj/s

(tuples->map start-map tuples)

tuples->recur clj/s

(tuples->recur db predicate recur-map depth var-first?)

variable? clj/s

(variable? form)

wikidata->tuples clj/s

(wikidata->tuples q-map clause r {:keys [vars] :as res} optional? fuel max-fuel)