asami.memory — org.clojars.quoll/asami 2.3.2

A storage implementation over in-memory indexing.

as-database clj/s

(as-database graph)

Inputs: [graph :- GraphType] Returns: DatabaseType

Creates a Database around an existing Graph. graph: The graph to build a database around.

as-of* clj/s

(as-of* {:keys [graph history timestamp] :as db} t)

Inputs: [{:keys [graph history timestamp], :as db} :- DatabaseType t :- (s/cond-pre s/Int (s/pred instant?))] Returns: DatabaseType

Retrieves the database as of a given moment, inclusive. The t value may be an instant, or a transaction ID. The database returned will be whatever database was the latest at the specified time or transaction.

as-of-t* clj/s

(as-of-t* {history :history :as db})

Inputs: [{history :history, :as db} :- DatabaseType] Returns: s/Int

Returns the as-of point for a database, or nil if none

as-of-time* clj/s

(as-of-time* {:keys [timestamp]})

Inputs: [{:keys [timestamp]} :- DatabaseType] Returns: s/Int

Returns the timestamp for a database

db* clj/s

(db* connection)

Inputs: [connection :- ConnectionType] Returns: DatabaseType

Retrieves the most recent value of the database for reading.

DBsBeforeAfter clj/s

delete-database* clj/s

(delete-database* {:keys [state] :as connection})

Inputs: [{:keys [state], :as connection} :- ConnectionType] Returns: s/Bool

Reverts the state of a connection to an empty database, resetting the initialization time.

empty-graph clj/s

empty-multi-graph clj/s

entity* clj/s

(entity* {graph :graph :as db} id nested?)

Inputs: [{graph :graph, :as db} id nested?] Returns: (s/maybe #:s{Any s/Any})

Returns an entity based on an identifier, either the :db/id or a :db/ident if this is available. This eagerly retrieves the entity. Objects may be nested, but references to top level objects will be nil in order to avoid loops.

get-url* clj/s

(get-url* {:keys [name state]})

Inputs: [{:keys [name state]} :- ConnectionType] Returns: s/Str

graph* clj/s

(graph* database)

Inputs: [database :- DatabaseType] Returns: GraphType

Returns the Graph object associated with a Database

MemoryConnection clj/s

MemoryDatabase clj/s

new-connection clj/s

(new-connection name gr)

Inputs: [name :- s/Str gr :- GraphType] Returns: ConnectionType

Creates a memory Connection object

next-tx* clj/s

(next-tx* connection)

Inputs: [connection :- ConnectionType] Returns: s/Num

since* clj/s

(since* {:keys [graph history timestamp] :as db} t)

Inputs: [{:keys [graph history timestamp], :as db} :- DatabaseType t :- (s/cond-pre s/Int (s/pred instant?))] Returns: (s/maybe DatabaseType)

Returns the value of the database since some point t, exclusive. t can be a transaction number, or instant.

since-t* clj/s

(since-t* {history :history :as db})

Inputs: [{history :history, :as db} :- DatabaseType] Returns: s/Int

Returns the since point of a database, or nil if none

transact-data* clj/s≠

clj

(transact-data* conn updates! generator-fn)

(transact-data* conn updates! asserts retracts)

cljs

(transact-data* G__19895 G__19896 G__19897)

(transact-data* G__19888 G__19889 G__19890 G__19891)

Inputs: ([conn :- ConnectionType updates! :- UpdateData asserts :- [Triple] retracts :- [Triple]] [conn :- ConnectionType updates! :- UpdateData generator-fn]) Returns: DBsBeforeAfter

Removes a series of tuples from the latest graph, and asserts new tuples into the graph. Updates the connection to the new graph.

transact-update* clj/s

(transact-update* conn update-fn)

Inputs: [conn :- ConnectionType update-fn :- (s/pred fn?)] Returns: DBsBeforeAfter

Updates a graph with a function, updating the connection to the new graph. The function accepts a graph and a transaction ID. Returns a triple containing the old database, the new one, and any adjunect data the statement generator may have created.