fluree.db.query.fql — com.fluree/db 1.0.0-rc4

ad-hoc-group-by clj/s

(ad-hoc-group-by {:keys [headers tuples] :as res} groupBy)

add-fuel clj/s

(add-fuel fuel n max-fuel)

Adds a n amount of fuel and will throw if max fuel exceeded.

compare-fn clj/s

(compare-fn a b)

component-follow? clj/s

(component-follow? pred-spec select-spec)

construct-triples clj/s

(construct-triples {:keys [construct] :as query-map}
                   {:keys [headers tuples] :as where-result})

flake->recur clj/s

(flake->recur db flake select-spec acc fuel max-fuel cache)

flake-select clj/s

(flake-select db cache fuel max-fuel select-spec flakes)

(flake-select db cache fuel max-fuel select-spec flakes limit)

(flake-select db cache fuel max-fuel select-spec flakes limit offset)

Runs a select statement based on a sequence of flakes.

flakes->res clj/s

(flakes->res db cache fuel max-fuel base-select-spec flakes)

Takes a sequence of flakes of the same subject and composes them into a map result based on the 'select' spec provided. Optionally, also follows components or recurs.

format-filter-tuples clj/s

(format-filter-tuples db
                      tuples
                      {:keys [prettyPrint select inVector? expandMaps?]
                       :as select-spec}
                      headers
                      vars
                      opts)

format-tuple clj/s

(format-tuple functionArray tuple)

fuel-flake-transducer clj/s

(fuel-flake-transducer fuel max-fuel)

Can sit in a flake pipeline and accumulate a count of 1 for every flake pulled.

Inputs are:

• fuel - volatile! that holds fuel counter
• max-fuel - throw exception if @fuel ever exceeds this number

To get final count, just deref fuel volatile when when where is complete.

fuel-flakes-transducer clj/s

(fuel-flakes-transducer fuel max-fuel)

Can sit in a flake group pipeline and accumulate a count of 1 for every flake pulled.

Supply with a volatile!

To get final count, just deref volatile when when where is complete.

full-select-spec clj/s

(full-select-spec db cache base-pred-spec subject-id)

Resolves a full predicate select spec in case there are any namespace lookups (:ns-lookup) in the map that need to be resolved for this given subject.

get-ad-hoc-select-spec clj/s

(get-ad-hoc-select-spec headers
                        vars
                        {:keys [selectOne select selectDistinct selectReduced]}
                        opts)

get-header-idx clj/s

(get-header-idx headers select)

get-pretty-print-keys clj/s

(get-pretty-print-keys select)

order-offset-and-limit-results clj/s

(order-offset-and-limit-results orderBy
                                {:keys [headers tuples] :as res}
                                offset
                                limit)

Order By can be:

• Single variable, ?favNums
• Two-tuple, [ASC, ?favNums]

parse-map clj/s

(parse-map x valid-var)

parse-select clj/s

(parse-select vars interim-vars select-smt)

process-ad-hoc-group clj/s

(process-ad-hoc-group db res select-spec opts)

(process-ad-hoc-group db
                      {:keys [vars] :as res}
                      {:keys [aggregates orderBy offset groupBy select limit
                              selectDistinct? inVector? prettyPrint]
                       :as select-spec}
                      group-limit
                      opts)

process-ad-hoc-res clj/s

(process-ad-hoc-res db
                    {:keys [headers vars] :as res}
                    {:keys [groupBy orderBy limit selectOne? selectDistinct?
                            inVector? offset]
                     :as select-spec}
                    opts)

query clj/s

(query db query-map)

Returns core async channel with results

resolve-reverse-refs clj/s

(resolve-reverse-refs db cache fuel max-fuel subject-id reverse-refs-specs)

Resolves all reverse references into a result map.

select-spec->reverse-pred-specs clj/s

(select-spec->reverse-pred-specs select-spec)

sort-offset-and-limit-res clj/s

(sort-offset-and-limit-res sortPred sortOrder offset limit res)

We only need to do this if there is an orderBy, otherwise limit and offset were performed in index-range.

subject-select clj/s

(subject-select db cache fuel max-fuel select-spec subjects)

(subject-select db cache fuel max-fuel select-spec subjects limit)

(subject-select db cache fuel max-fuel select-spec subjects limit offset)

Like flake select, but takes a collection of subject ids which we then find collections of flakes for.

valid-where-predicate? clj/s

(valid-where-predicate? db p)

wildcard-pred-spec clj/s

(wildcard-pred-spec db cache p compact?)

Just uses query cache to avoid constant lookups.