asami.entities.writer — org.clojars.quoll/asami 2.3.2

Converts external data into a graph format (triples).

*current-entity* clj/s

*current-graph* clj/s

*id-map* clj/s

*limit* clj/s

*top-level-entities* clj/s

*triples* clj/s

add-subentity-relationship clj/s

(add-subentity-relationship node)

Adds a sub-entity relationship for a provided node. Returns the node

add-triples! clj/s

(add-triples! op data)

backtrack-unlink-top-entities clj/s

(backtrack-unlink-top-entities top-entities triples)

Goes back through generated triples and removes sub-entity links to entities that were later determined to be top-level entities.

entities->triples clj/s≠

clj

(entities->triples graph entities)

(entities->triples graph entities id-map)

cljs

(entities->triples G__20025 G__20026)

(entities->triples G__20030 G__20031 G__20032)

Inputs: ([graph :- GraphType entities :- [EntityMap]] [graph :- GraphType entities :- [EntityMap] id-map :- #:s{Any s/Any}]) Returns: [Triple]

Converts objects into a sequence of triples.

entity-update->triples clj/s

(entity-update->triples graph node-ref entity)

Inputs: [graph :- GraphType node-ref entity] Returns: [(s/one [Triple] "assertions") (s/one [Triple] "retractions")]

Takes a single structure and converts it into triples to be added and triples to be retracted to create a change

existing-triples clj/s

(existing-triples graph node-ref [k v])

Inputs: [graph :- GraphType node-ref [k v]]

get-ref clj/s

(get-ref {id :db/id ident :db/ident ident2 :id :as data})

Inputs: [{id :db/id, ident :db/ident, ident2 :id, :as data} :- EntityMap]

Returns the reference (a node-id) for an object, and a flag that is false if a new reference was generated

ident-map->triples clj/s≠

clj

(ident-map->triples j)

(ident-map->triples graph j)

(ident-map->triples graph j id-map top-level-ids limit)

cljs

(ident-map->triples G__20007)

(ident-map->triples G__19994 G__19995)

(ident-map->triples G__19999 G__20000 G__20001 G__20002 G__20003)

Inputs: ([graph :- GraphType j :- EntityMap] [graph :- GraphType j :- EntityMap id-map :- #:s{Any s/Any} top-level-ids :- #{s/Any} limit :- (s/maybe s/Num)] [j :- EntityMap])

Converts a single map to triples for an ID'ed map

identity-prop? clj/s

Tests if a property is a identifier property

list-triples clj/s

(list-triples vlist)

Creates the triples for a list. Returns a node and list of nodes representing contents of the list.

lookup-ref? clj/s

(lookup-ref? i)

Tests if i is a lookup ref. Similar to https://blog.datomic.com/2014/02/datomic-lookup-refs.html

map->triples clj/s

(map->triples data)

Inputs: [data :- EntityMap]

Converts a single map to triples. Returns the entity reference or node id. The triples are built up statefully in the volatile triples.

name-for clj/s

(name-for id)

Convert an id (probably a number) to a keyword for identification

new-node clj/s

(new-node id)

property-vals clj/s

(property-vals entity-ref [property value])

Inputs: [entity-ref :- s/Any [property value] :- KeyValue]

Takes a property-value pair associated with an entity, and builds triples around it

resolve-ref clj/s

(resolve-ref [prop id])

top-level-entity? clj/s

(top-level-entity? node)

Triple clj/s

value-triples clj/s

(value-triples v)

Converts a value into a list of triples. Return the entity ID of the data.

value-triples-list clj/s

(value-triples-list vlist)

Inputs: [vlist :- [s/Any]]