re-db.core — re-db 0.1.14

*db-log* cljs

*notify* cljs

*prevent-notify* cljs

add-map-datoms cljs

(add-map-datoms datoms id m prev-m db-snap)

add-map-indexes cljs

(add-map-indexes db-snap id m prev-m)

conj-set cljs

contains? cljs

(contains? db-snap id)

Returns true if entity with given id exists in db.

create cljs

(create)

(create schema)

Create a new db, with optional schema, which should be a mapping of attribute keys to the following options:

:db/index [true, :db.index/unique] :db/cardinality [:db.cardinality/many]

db-log clj/s macro

(db-log & body)

entities cljs

(entities db-snap qs)

entity cljs

(entity db-snap id)

Returns entity for resolved id.

entity-ids cljs

(entity-ids db-snap qs)

get cljs

(get db-snap id attr)

(get db-snap id attr not-found)

Get attribute in entity with given id.

get-in cljs

(get-in db-snap id ks)

(get-in db-snap id ks not-found)

Get-in the entity with given id.

get-in* clj/s macro

(get-in* m ks)

(get-in* m ks not-found)

Compiled version of get-in, small performance boost over the get-in function.

get-schema cljs

(get-schema db-snap a)

index? cljs

(index? schema)

(index? db-snap a)

Returns true if attribute is indexed.

into-set cljs

listen cljs

(listen db f)

(listen db patterns f)

Adds listener for transactions which contain datom(s) matching the provided pattern. If patterns not provided, matches all transactions.

Patterns should be a map containing any of the following keys, each containing a collection of patterns:

:e__ entity [id _ _] :ea_ entity-attribute [id attr _] :_av attribute-value [_ attr val] :a attribute [_ attr _]

many? cljs

(many? schema)

(many? db-snap a)

Returns true for attributes with cardinality many, which store a set of values for each attribute.

merge-schema! cljs

(merge-schema! db schema)

Merge additional schema options into a db. Indexes are not created for existing data.

peek clj/s macro

(peek & body)

Evaluates body without tracking read patterns.

ref? cljs

(ref? schema)

resolve-id cljs

(resolve-id db-snap id)

(resolve-id db-snap attr val)

Returns id, resolving lookup refs (vectors of the form [attribute value]) to ids. Lookup refs are only supported for indexed attributes. The 3-arity version is for known lookup refs, and does not check for uniqueness.

select-keys cljs

(select-keys db-snap id ks)

Select keys from entity of id

touch cljs

(touch db-snap {:keys [db/id] :as entity})

Add refs to entity

transact! cljs

(transact! db txs)

(transact! db txs {:keys [notify log-datoms] :or {notify true}})

unique-id cljs

(unique-id)

Returns a unique id (string).

unique? cljs

(unique? schema)

(unique? db-snap a)

Returns true for attributes where :db/index is :db.index/unique.

unlisten cljs

(unlisten db f)

(unlisten db patterns f)

Remove listener from patterns (if provided) or :tx-log.