ribelo.doxa — com.github.ribelo/doxa 0.0.63

*atom-fn* clj/s

*empty-map* clj/s

*id-sufixes* clj/s

-->cache-kw clj/s

(-->cache-kw query id env)

-datoms-match-datom? clj/s

(-datoms-match-datom? txs-datoms datom)

-datoms-match-query? clj/s

(-datoms-match-query? txs-datoms pq)

-datoms-match-where? clj/s

(-datoms-match-where? txs-datoms datoms)

-edits->datoms clj/s

(-edits->datoms edits)

-ident? clj/s

(-ident? x)

-idents? clj/s

(-idents? xs)

-key clj/s macro

(-key m)

-match-two-datoms clj/s

(-match-two-datoms d1 d2)

-pull clj/s

(-pull db query)

(-pull db query parent)

(-pull db query parent env)

-q clj/s macro

(-q {:keys [find first? mapcat? pull keys limit xf] :as pq} db)

-submit-commit clj/s

(-submit-commit db tx)

apply transactions to db.

-val clj/s macro

(-val m)

-valid-query? clj/s

(-valid-query? pq)

BaseCache cljs

build-args-map clj/s

(build-args-map {:keys [in args] :as pq})

build-meander-query clj/s

(build-meander-query m)

collect-args clj/s

(collect-args xs)

commit clj/s

(commit db txs)

(commit db txs tx-meta)

apply transactions to db. txs can be either a single transaction or a vector of transactions. returns a modified db. transaction report is stored in the db metadata.

usage: [:dx/put|delete|conj|update|match [table eid] ?m | (?k ?v)]

put: entire map|s with entity id [:dx/put {:person/id :ivan :name "ivan" :age 30}] [:dx/put [{:person/id :ivan :name "ivan" :age 30} ...]]

entire map, without entity id
[:dx/put [:person/id :ivan] {:name "ivan" :age 30}]

ident|s
[:dx/put [:person/id :ivan] :friend [:person/id :petr]]
[:dx/put [:person/id :ivan] :friend [[:person/id :petr] ...]]

reference map|s
[:dx/put [:person/id :ivan] :friend {:person/id :petr :name "petr"}]
[:dx/put [:person/id :ivan] :friend [{:person/id :petr :name "petr"} ...]]

key value
[:dx/put [:person/id :ivan] :age 12]

delete: ident [:dx/delete [:person/id :ivan]]

entity|s
[:dx/delete {:person/id :ivan ...}]
[:dx/delete [{:person/id :ivan ...} ...]]

key
[:dx/delete [:person/id :ivan] :age]

value - like disj
[:dx/delete [:person/id :ivan] :aka "tupen"]

conj: value [:dx/conj [:person/id :ivan] :aka "tupen"]

ident|s
[:dx/conj [:person/id :ivan] :friend [:person/id :petr]]
[:dx/conj [:person/id :ivan] :friend [[:person/id :petr] ...]]

entity|s
[:dx/conj [:person/id :ivan] :friend {:person/id :petr ...}]
[:dx/conj [:person/id :ivan] :friend [{:person/id :petr ...} ...]]

update: entity [:dx/update [:person/id :ivan] (fn [entity] (f entity)]

key
[:dx/update [:person/id :ivan] :age inc]

match: entity [:dx/match [:person/id :ivan] {:person/id :ivan ...}]

key value
[:dx/match [:person/id :ivan] :age 30]

key fn
[:dx/match [:person/id :ivan] :salary #(> % 10000)]

commit! clj/s

(commit! db_ txs)

(commit! db_ txs tx-meta)

accepts an atom with db, see commit

comp-some clj/s

(comp-some & fns)

conjv clj/s

returns a vector even if the argument is nil

create-dx clj/s

(create-dx)

(create-dx data)

(create-dx data opts)

creates a db, can take a map, which is written to the metadata

datalog->meander clj/s

(datalog->meander {:keys [where in args] :as q})

db-with clj/s

(db-with data)

(db-with db data)

delete-cached-results! clj/s

(delete-cached-results! db kw)

denormalize clj/s

(denormalize data)

(denormalize db data)

(denormalize db data max-level)

turns a flat map into a nested one. to avoid stackoverflow and infinite loop, it takes a maximum nesting level as an additional argument

dxs_ clj/s

get-dx clj/s

(get-dx k)

get-dx! clj/s

(get-dx! k)

haul clj/s

(haul db)

(haul db x)

(haul db x max-level)

into-map clj/s

returns a map even if the argument is nil

ITransactions clj/s protocol

-datoms-since clj/s

(-datoms-since _ udt)

-ltt clj/s

(-ltt _)

-next-id clj/s

(-next-id _)

-prepend! clj/s

(-prepend! _ tx)

-txs clj/s

(-txs _)

join-rules clj/s

(join-rules rules)

listen! clj/s

(listen! db_ cb)

(listen! db_ k cb)

listens for changes in the db. each time changes are made via commit, the callback is called with the db. the transaction report is written to the db metadata, and may include, depending on the configuration, the transaction time, the difference between the old and new db, the db hash. calling listen twice with the same k overwrites the previous callback.

normalize clj/s

(normalize data)

turns a nested map into a flat collection with references.

parse-find clj/s

(parse-find args)

parse-query clj/s

(parse-query q & args)

parse-query-elem clj/s

(parse-query-elem elem args-map)

patch clj/s

(patch db edits)

(patch db edits time)

patch db using ediscript edits

patch! clj/s

(patch! db_ edits)

(patch! db_ edits time)

patch db inside atom, see patch

pull clj/s macro

(pull db query id)

(pull db query id env)

pull->datalog clj/s

(pull->datalog query ids)

pull-one clj/s

(pull-one db query)

(pull-one db query id)

q clj/s macro

(q q' db & args)

qsymbol? clj/s

(qsymbol? x)

query clj

(query args)

reg-dx! clj/s

(reg-dx! id store)

replace-all-args clj/s

(replace-all-args body args)

reverse-search clj/s

(reverse-search db id)

(reverse-search db k id)

rewrite-all-args clj/s

rewrite-arg clj/s

(rewrite-arg arg)

simplify-where clj/s

(simplify-where where args-map)

TickedCacheEntry cljs

Transaction cljs

Transactions cljs

unlisten! clj/s

(unlisten! db_ k)

remove registered listener

valid-id? clj/s

(valid-id? id)

with-commit clj/s

(with-commit db txs)

with-dx clj/s macro

(with-dx bindings & body)

with-dx! clj/s macro

(with-dx! bindings & body)

with-time-ms clj/s macro

(with-time-ms & body)

macro establishes the execution time of the body and returns a result with attached metadata, with key execution-time in milliseconds

wrap-or-args-with-let clj/s

(wrap-or-args-with-let xs)