aarondb

Types

BodyClause

pub type BodyClause =
  ast.BodyClause

Db

pub type Db =
  process.Subject(transactor.Message)

DbState

pub type DbState =
  state.DbState

DiffScanError

pub type DiffScanError {
  InvalidDiffRange
  InvalidDiffScanLimit
  DiffScanBudgetExceeded
}

Constructors

```
InvalidDiffRange
```
```
InvalidDiffScanLimit
```
```
DiffScanBudgetExceeded
```

PullPattern

pub type PullPattern =
  List(ast.PullItem)

PullResult

pub type PullResult =
  query_types.PullResult

QueryResult

pub type QueryResult =
  query_types.QueryResult

SpeculativeResult

pub type SpeculativeResult {
  SpeculativeResult(
    state: state.DbState,
    datoms: List(fact.Datom),
  )
}

Constructors

SpeculativeResult(state: state.DbState, datoms: List(fact.Datom))

TemporalScanError

pub type TemporalScanError {
  InvalidTemporalScanLimit
  TemporalScanBudgetExceeded
}

Constructors

```
InvalidTemporalScanLimit
```
```
TemporalScanBudgetExceeded
```

TemporalScanLimits

Explicit limits for a local temporal history scan.

max_datoms is a hard upper bound: bounded APIs return an error rather than a partial answer when the current local history exceeds it.

pub type TemporalScanLimits {
  TemporalScanLimits(max_datoms: Int)
}

Constructors

```
TemporalScanLimits(max_datoms: Int)
```

Values

as_of

pub fn as_of(
  db: process.Subject(transactor.Message),
  tx: Int,
  q_clauses: List(ast.BodyClause),
) -> query_types.QueryResult

as_of_bitemporal

pub fn as_of_bitemporal(
  db: process.Subject(transactor.Message),
  tx: Int,
  valid_time: Int,
  q_clauses: List(ast.BodyClause),
) -> query_types.QueryResult

as_of_bitemporal_bounded

pub fn as_of_bitemporal_bounded(
  db: process.Subject(transactor.Message),
  tx: Int,
  valid_time: Int,
  q_clauses: List(ast.BodyClause),
  limits: TemporalScanLimits,
) -> Result(query_types.QueryResult, TemporalScanError)

Runs a bitemporal snapshot after checking the local history scan budget.

as_of_bounded

pub fn as_of_bounded(
  db: process.Subject(transactor.Message),
  tx: Int,
  q_clauses: List(ast.BodyClause),
  limits: TemporalScanLimits,
) -> Result(query_types.QueryResult, TemporalScanError)

as_of_valid

pub fn as_of_valid(
  db: process.Subject(transactor.Message),
  valid_time: Int,
  q_clauses: List(ast.BodyClause),
) -> query_types.QueryResult

as_of_valid_bounded

pub fn as_of_valid_bounded(
  db: process.Subject(transactor.Message),
  valid_time: Int,
  q_clauses: List(ast.BodyClause),
  limits: TemporalScanLimits,
) -> Result(query_types.QueryResult, TemporalScanError)

Runs a valid-time snapshot after checking the local history scan budget.

connect

pub fn connect(
  name: String,
) -> Result(process.Subject(transactor.Message), String)

diff

pub fn diff(
  db: process.Subject(transactor.Message),
  from_tx: Int,
  to_tx: Int,
) -> List(fact.Datom)

Returns all local datoms committed in (from_tx, to_tx].

This compatibility API has no scan budget and may return index-dependent order. Use diff_bounded for a typed, deterministically ordered result.

diff_bounded

pub fn diff_bounded(
  db: process.Subject(transactor.Message),
  from_tx: Int,
  to_tx: Int,
  limits: DiffScanLimits,
) -> Result(List(fact.Datom), DiffScanError)

Returns a complete, transaction-ordered diff for (from_tx, to_tx] or a typed error. The bounded API never returns a partial change set.

diff_scan_limits

pub fn diff_scan_limits(
  max_datoms: Int,
) -> Result(DiffScanLimits, DiffScanError)

execute

pub fn execute(
  db: process.Subject(transactor.Message),
  query: ast.Query,
) -> query_types.QueryResult

explain_speculation

pub fn explain_speculation(
  res: Result(SpeculativeResult, String),
) -> String

Provides a human-readable explanation of a speculative result or failure.

get

pub fn get(
  db: process.Subject(transactor.Message),
  eid: fact.Eid,
  attr: String,
) -> List(fact.Value)

get_one

pub fn get_one(
  db: process.Subject(transactor.Message),
  eid: fact.Eid,
  attr: String,
) -> Result(fact.Value, Nil)

get_state

pub fn get_state(
  db: process.Subject(transactor.Message),
) -> state.DbState

history

pub fn history(
  db: process.Subject(transactor.Message),
  eid: fact.Eid,
) -> List(fact.Datom)

new

pub fn new() -> process.Subject(transactor.Message)

Compatibility constructor. This convenience API returns a Db directly and therefore cannot report actor startup failures. New integrations should call start_link/2 and handle its Result instead.

new_with_adapter

pub fn new_with_adapter(
  adapter: option.Option(storage.StorageAdapter),
) -> process.Subject(transactor.Message)

new_with_adapter_and_timeout

pub fn new_with_adapter_and_timeout(
  adapter: option.Option(storage.StorageAdapter),
  timeout_ms: Int,
) -> process.Subject(transactor.Message)

p

pub fn p(triple: #(ast.Part, String, ast.Part)) -> ast.BodyClause

prune

pub fn prune(
  db: process.Subject(transactor.Message),
  threshold: Int,
  sovereign: List(String),
) -> Int

pull

pub fn pull(
  db: process.Subject(transactor.Message),
  eid: fact.Eid,
  pattern: List(ast.PullItem),
) -> query_types.PullResult

pull_all

pub fn pull_all() -> List(ast.PullItem)

pull_attr

pub fn pull_attr(attr: String) -> List(ast.PullItem)

pull_except

pub fn pull_except(
  exclusions: List(String),
) -> List(ast.PullItem)

pull_recursive

pub fn pull_recursive(
  attr: String,
  depth: Int,
) -> List(ast.PullItem)

q

pub fn q(
  db: process.Subject(transactor.Message),
  q_builder: q.QueryBuilder,
) -> query_types.QueryResult

query

pub fn query(
  db: process.Subject(transactor.Message),
  q_clauses: List(ast.BodyClause),
) -> query_types.QueryResult

query_at

pub fn query_at(
  db: process.Subject(transactor.Message),
  q_clauses: List(ast.BodyClause),
  as_of_tx: option.Option(Int),
  as_of_valid: option.Option(Int),
) -> query_types.QueryResult

query_state

pub fn query_state(
  state: state.DbState,
  q_clauses: List(ast.BodyClause),
) -> query_types.QueryResult

query_state_at

pub fn query_state_at(
  state: state.DbState,
  q_clauses: List(ast.BodyClause),
  as_of_tx: option.Option(Int),
  as_of_valid: option.Option(Int),
) -> query_types.QueryResult

query_state_with_rules

pub fn query_state_with_rules(
  state: state.DbState,
  q_clauses: List(ast.BodyClause),
  rules: List(ast.Rule),
) -> query_types.QueryResult

query_with_rules

pub fn query_with_rules(
  db: process.Subject(transactor.Message),
  q_clauses: List(ast.BodyClause),
  rules: List(ast.Rule),
) -> query_types.QueryResult

register_composite

pub fn register_composite(
  db: process.Subject(transactor.Message),
  attrs: List(String),
) -> Result(Nil, String)

register_composite_with_timeout

pub fn register_composite_with_timeout(
  db: process.Subject(transactor.Message),
  attrs: List(String),
  timeout_ms: Int,
) -> Result(Nil, String)

register_function

pub fn register_function(
  db: process.Subject(transactor.Message),
  name: String,
  func: fn(state.DbState, Int, Int, List(fact.Value)) -> List(
    #(fact.Eid, String, fact.Value),
  ),
) -> Nil

register_function_with_timeout

pub fn register_function_with_timeout(
  db: process.Subject(transactor.Message),
  name: String,
  func: fn(state.DbState, Int, Int, List(fact.Value)) -> List(
    #(fact.Eid, String, fact.Value),
  ),
  timeout_ms: Int,
) -> Result(Nil, String)

register_predicate

pub fn register_predicate(
  db: process.Subject(transactor.Message),
  name: String,
  pred: fn(fact.Value) -> Bool,
) -> Nil

Compatibility registration helper. This function cannot surface an actor timeout. New integrations should use register_predicate_with_timeout/4.

register_predicate_with_timeout

pub fn register_predicate_with_timeout(
  db: process.Subject(transactor.Message),
  name: String,
  pred: fn(fact.Value) -> Bool,
  timeout_ms: Int,
) -> Result(Nil, String)

retract

pub fn retract(
  db: process.Subject(transactor.Message),
  facts: List(#(fact.Eid, String, fact.Value)),
) -> Result(state.DbState, String)

retract_at

pub fn retract_at(
  db: process.Subject(transactor.Message),
  facts: List(#(fact.Eid, String, fact.Value)),
  valid_time: Int,
) -> Result(state.DbState, String)

retract_entity

pub fn retract_entity(
  db: process.Subject(transactor.Message),
  eid: fact.Eid,
) -> Result(state.DbState, String)

set_config

pub fn set_config(
  db: process.Subject(transactor.Message),
  config: state.Config,
) -> Nil

set_config_with_timeout

pub fn set_config_with_timeout(
  db: process.Subject(transactor.Message),
  config: state.Config,
  timeout_ms: Int,
) -> Result(Nil, String)

set_schema

pub fn set_schema(
  db: process.Subject(transactor.Message),
  attr: String,
  config: fact.AttributeConfig,
) -> Result(Nil, String)

set_schema_with_timeout

pub fn set_schema_with_timeout(
  db: process.Subject(transactor.Message),
  attr: String,
  config: fact.AttributeConfig,
  timeout_ms: Int,
) -> Result(Nil, String)

start_distributed

pub fn start_distributed(
  name: String,
  adapter: option.Option(storage.StorageAdapter),
) -> Result(process.Subject(transactor.Message), actor.StartError)

start_link

pub fn start_link(
  adapter: option.Option(storage.StorageAdapter),
  timeout_ms: Int,
) -> Result(process.Subject(transactor.Message), actor.StartError)

start_named

pub fn start_named(
  name: String,
  adapter: option.Option(storage.StorageAdapter),
) -> Result(process.Subject(transactor.Message), actor.StartError)

store_rule

pub fn store_rule(
  db: process.Subject(transactor.Message),
  rule: ast.Rule,
) -> Result(Nil, String)

store_rule_with_timeout

pub fn store_rule_with_timeout(
  db: process.Subject(transactor.Message),
  rule: ast.Rule,
  timeout_ms: Int,
) -> Result(Nil, String)

pub fn subscribe(
  db: process.Subject(transactor.Message),
  query: ast.Query,
  subscriber: process.Subject(query_types.ReactiveDelta),
) -> Nil

Subscribe to local reactive query updates.

The initial result and later deltas are emitted by the reactive actor in mailbox order. Delivery is unbounded BEAM mailbox delivery: it does not block writers or drop updates, so callers must drain their own mailbox. Call unsubscribe when finished; stopped subscribers are also removed on the next notification.

subscribe_wal

pub fn subscribe_wal(
  db: process.Subject(transactor.Message),
  subscriber: process.Subject(List(fact.Datom)),
) -> Nil

sync

pub fn sync(db: process.Subject(transactor.Message)) -> Nil

temporal_scan_limits

pub fn temporal_scan_limits(
  max_datoms: Int,
) -> Result(TemporalScanLimits, TemporalScanError)

transact

pub fn transact(
  db: process.Subject(transactor.Message),
  facts: List(#(fact.Eid, String, fact.Value)),
) -> Result(state.DbState, String)

transact_at

pub fn transact_at(
  db: process.Subject(transactor.Message),
  facts: List(#(fact.Eid, String, fact.Value)),
  valid_time: Int,
) -> Result(state.DbState, String)

transact_with_timeout

pub fn transact_with_timeout(
  db: process.Subject(transactor.Message),
  facts: List(#(fact.Eid, String, fact.Value)),
  timeout_ms: Int,
) -> Result(state.DbState, String)

traverse

pub fn traverse(
  db: process.Subject(transactor.Message),
  eid: fact.Eid,
  path: List(ast.Step),
  max_depth: Int,
) -> Result(List(fact.Value), String)

trigger_eviction

pub fn trigger_eviction(
  db: process.Subject(transactor.Message),
) -> Result(Nil, String)

unsubscribe

pub fn unsubscribe(
  db: process.Subject(transactor.Message),
  subscriber: process.Subject(query_types.ReactiveDelta),
) -> Nil

Stop local reactive updates for a subscriber.

Unsubscription is ordered with notifications received by the reactive actor: deltas already sent to the subscriber remain in its mailbox, while later actor notifications do not produce new deltas for it.

with_facts

pub fn with_facts(
  state: state.DbState,
  facts: List(#(fact.Eid, String, fact.Value)),
) -> Result(SpeculativeResult, String)