aarondb

Types

BodyClause

pub type BodyClause =
  ast.BodyClause

Db

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

DbState

pub type DbState =
  state.DbState

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))

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_valid

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

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)

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)

is_leader

pub fn is_leader(db: process.Subject(transactor.Message)) -> Bool

new

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

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_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_predicate

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

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_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)

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

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

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)

with_facts

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