crux.api — juxt/crux-core 20.01-1.6.2-alpha

Public API of Crux.

new-api-client clj

(new-api-client url)

Creates a new remote API client ICruxAPI. The remote client requires valid and transaction time to be specified for all calls to db.

NOTE: requires crux-http-client on the classpath, see crux.remote-api-client/internal-http-request-fn for more information.

url the URL to a Crux HTTP end-point.

returns a remote API client.

new-ingest-client clj

(new-ingest-client options)

Starts an ingest client for transacting into Kafka without running a full local node with index.

For valid options, see crux.kafka/default-options. Options are specified as keywords using their long format name, like :crux.kafka/bootstrap-servers etc.

options {:crux.kafka/bootstrap-servers "kafka-cluster-kafka-brokers.crux.svc.cluster.local:9092" :crux.kafka/group-id "group-id" :crux.kafka/tx-topic "crux-transaction-log" :crux.kafka/doc-topic "crux-docs" :crux.kafka/create-topics true :crux.kafka/doc-partitions 1 :crux.kafka/replication-factor 1}

Returns a crux.api.ICruxIngestAPI component that implements java.io.Closeable, which allows the client to be stopped by calling close.

PCruxAsyncIngestClient clj protocol

Provides API access to Crux async ingestion.

submit-tx-async clj

(submit-tx-async node tx-ops)

Writes transactions to the log for processing tx-ops datalog style transactions. Non-blocking. Returns a deref with map with details about the submitted transaction, including tx-time and tx-id.

PCruxDatasource clj protocol

Represents the database as of a specific valid and transaction time.

entity clj

(entity db eid)

(entity db snapshot eid)

queries a document map for an entity. eid is an object which can be coerced into an entity id. returns the entity document map.

entity-tx clj

(entity-tx db eid)

returns the transaction details for an entity. Details include tx-id and tx-time. eid is an object that can be coerced into an entity id.

history-ascending clj

(history-ascending db snapshot eid)

Retrieves entity history lazily in chronological order from and including the valid time of the db while respecting transaction time. Includes the documents.

history-descending clj

(history-descending db snapshot eid)

Retrieves entity history lazily in reverse chronological order from and including the valid time of the db while respecting transaction time. Includes the documents.

new-snapshot clj

(new-snapshot db)

Returns a new implementation specific snapshot allowing for lazy query results in a try-with-resources block using (q db snapshot query)}. Can also be used for (history-ascending db snapshot eid) and (history-descending db snapshot eid) returns an implementation specific snapshot

q clj

(q db query)

(q db snapshot query)

q[uery] a Crux db. query param is a datalog query in map, vector or string form. First signature will evaluate eagerly and will return a set or vector of result tuples. Second signature accepts a db snapshot, see new-snapshot. Evaluates lazily consequently returns lazy sequence of result tuples.

transaction-time clj

(transaction-time db)

returns the time of the latest transaction applied to this db value. If a tx time was specified when db value was acquired then returns the specified time.

valid-time clj

(valid-time db)

returns the valid time of the db. If valid time wasn't specified at the moment of the db value retrieval then valid time will be time of the latest transaction.

PCruxIngestClient clj protocol

Provides API access to Crux ingestion.

new-tx-log-context clj

(new-tx-log-context node)

Returns a new transaction log context allowing for lazy reading of the transaction log in a try-with-resources block using (tx-log ^Closeable tx-Log-context, from-tx-id, boolean with-ops?).

Returns an implementation specific context.

submit-tx clj

(submit-tx node tx-ops)

Writes transactions to the log for processing tx-ops datalog style transactions. Returns a map with details about the submitted transaction, including tx-time and tx-id.

tx-log clj

(tx-log node tx-log-context from-tx-id with-ops?)

Reads the transaction log lazily. Optionally includes operations, which allow the contents under the :crux.api/tx-ops key to be piped into (submit-tx tx-ops) of another Crux instance.

tx-log-context a context from (new-tx-log-context node) from-tx-id optional transaction id to start from. with-ops? should the operations with documents be included?

Returns a lazy sequence of the transaction log.

PCruxNode clj protocol

Provides API access to Crux.

history-range clj

(history-range node
               eid
               valid-time-start
               transaction-time-start
               valid-time-end
               transaction-time-end)

Returns the transaction history of an entity, ordered by valid time / transaction time in chronological order, earliest first. Includes corrections, but does not include the actual documents.

Giving nil as any of the date arguments makes the range open ended for that value.

submitted-tx-corrected-entity? clj

(submitted-tx-corrected-entity? node submitted-tx valid-time eid)

Checks if a submitted tx did correct an entity as of valid time. submitted-tx must be a map returned from submit-tx valid-time valid time of the correction to check. eid is an object that can be coerced into an entity id. Returns true if the entity was updated in this transaction.

db clj

(db node)

(db node valid-time)

(db node valid-time transaction-time)

Will return the latest value of the db currently known. Non-blocking.

When a valid time is specified then returned db value contains only those documents whose valid time is before the specified time. Non-blocking.

When both valid and transaction time are specified returns a db value as of the valid time and the latest transaction time indexed at or before the specified transaction time. Non-blocking. The index may not yet contain a transaction with the specified transaction time.

attribute-stats clj

(attribute-stats node)

Returns frequencies map for indexed attributes

history clj

(history node eid)

Returns the transaction history of an entity, in reverse chronological order. Includes corrections, but does not include the actual documents.

sync clj

(sync node timeout)

(sync node transaction-time timeout)

If the transaction-time is supplied, blocks until indexing has processed a tx with a greater-than transaction-time, otherwise blocks until the node has caught up indexing the tx-log backlog. Will throw an exception on timeout. The returned date is the latest index time when this node has caught up as of this call. This can be used as the second parameter in (db valid-time, transaction-time) for consistent reads.

timeout – max time to wait, can be nil for the default. Returns the latest known transaction time.

submitted-tx-updated-entity? clj

(submitted-tx-updated-entity? node submitted-tx eid)

Checks if a submitted tx did update an entity. submitted-tx must be a map returned from submit-tx eid is an object that can be coerced into an entity id. Returns true if the entity was updated in this transaction.

documents clj

(documents node content-hashes-set)

Reads the set of documents from the document store based on their respective content hashes. Returns a map content-hash->document

document clj

(document node content-hash)

Reads a document from the document store based on its content hash.

status clj

(status node)

Returns the status of this node as a map.

start-node clj

(start-node options)

NOTE: requires any dependendies on the classpath that the Crux modules may need.

options {:crux.node/topology e.g. "crux.standalone/topology"}

Options are specified as keywords using their long format name, like :crux.kafka/bootstrap-servers etc. See the individual modules used in the specified topology for option descriptions.

returns a node which implements ICruxAPI and java.io.Closeable. Latter allows the node to be stopped by calling (.close node).

throws IndexVersionOutOfSyncException if the index needs rebuilding. throws NonMonotonicTimeException if the clock has moved backwards since last run. Only applicable when using the event log.

tx-op clj multimethod