aarondb/fact

Types

Attribute

pub type Attribute =
  String

AttributeConfig

pub type AttributeConfig {
  AttributeConfig(
    unique: Bool,
    component: Bool,
    retention: Retention,
    cardinality: Cardinality,
    check: option.Option(String),
    composite_group: option.Option(String),
    layout: StorageLayout,
    tier: StorageTier,
    eviction: EvictionPolicy,
  )
}

Constructors

AttributeConfig(
  unique: Bool,
  component: Bool,
  retention: Retention,
  cardinality: Cardinality,
  check: option.Option(String),
  composite_group: option.Option(String),
  layout: StorageLayout,
  tier: StorageTier,
  eviction: EvictionPolicy,
)

Cardinality

pub type Cardinality {
  One
  Many
}

Constructors

```
One
```
```
Many
```

Datom

pub type Datom {
  Datom(
    entity: EntityId,
    attribute: String,
    value: Value,
    tx: Int,
    tx_index: Int,
    valid_time: Int,
    operation: Operation,
  )
}

Constructors

Datom(
  entity: EntityId,
  attribute: String,
  value: Value,
  tx: Int,
  tx_index: Int,
  valid_time: Int,
  operation: Operation,
)

DbFunction

pub type DbFunction(state) =
  fn(state, Int, Int, List(Value)) -> List(#(Eid, String, Value))

Eid

pub type Eid {
  Lookup(#(String, Value))
  Uid(EntityId)
}

Constructors

```
Lookup(#(String, Value))
```
```
Uid(EntityId)
```

Entity

pub type Entity =
  EntityId

EntityId

pub type EntityId {
  EntityId(Int)
}

Constructors

```
EntityId(Int)
```

EvictionPolicy

pub type EvictionPolicy {
  AlwaysInMemory
  LRU(Int)
  LruToDisk
}

Constructors

```
AlwaysInMemory
```
```
LRU(Int)
```
```
LruToDisk
```

Fact

A Fact is #(Eid, Attribute, Value) for assertion, or a more explicit Tuple for retractions.

pub type Fact =
  #(Eid, String, Value)

LookupRef

pub type LookupRef =
  #(String, Value)

Operation

pub type Operation {
  Assert
  Retract
}

Constructors

```
Assert
```
```
Retract
```

Retention

pub type Retention {
  All
  LatestOnly
  Last(Int)
}

Constructors

```
All
```
```
LatestOnly
```
```
Last(Int)
```

StorageLayout

pub type StorageLayout {
  Row
  Columnar
}

Constructors

```
Row
```
```
Columnar
```

StorageTier

pub type StorageTier {
  Memory
  Disk
}

Constructors

```
Memory
```
```
Disk
```

Transaction

pub type Transaction =
  Int

Value

pub type Value {
  Str(String)
  Int(Int)
  Float(Float)
  Bool(Bool)
  List(List(Value))
  Vec(List(Float))
  Ref(EntityId)
  Map(dict.Dict(String, Value))
  Blob(BitArray)
}

Constructors

```
Str(String)
```
```
Int(Int)
```
```
Float(Float)
```
```
Bool(Bool)
```
```
List(List(Value))
```
```
Vec(List(Float))
```
```
Ref(EntityId)
```
```
Map(dict.Dict(String, Value))
```
```
Blob(BitArray)
```

Values

compare

pub fn compare(v1: Value, v2: Value) -> order.Order

decode_compact

pub fn decode_compact(
  bits: BitArray,
) -> Result(#(Value, BitArray), Nil)

decode_datom

pub fn decode_datom(
  bits: BitArray,
) -> Result(#(Datom, BitArray), Nil)

deterministic_uid

pub fn deterministic_uid(data: a) -> Eid

Create a deterministic Entity ID based on a hash of the data. This enables idempotent transaction semantics.

eid_to_integer

pub fn eid_to_integer(eid: EntityId) -> Int

encode_compact

pub fn encode_compact(v: Value) -> BitArray

encode_datom

pub fn encode_datom(d: Datom) -> BitArray

event_uid

pub fn event_uid(event_type: String, timestamp: Int) -> Eid

Create a unique, deterministic Entity ID for an event based on its type and timestamp. This ensures that the same event instance (e.g. from retries) always gets the same ID.

integer_to_eid

pub fn integer_to_eid(i: Int) -> EntityId

new_datom

pub fn new_datom(
  entity entity: EntityId,
  attribute attribute: String,
  value value: Value,
  tx tx: Int,
  tx_index tx_index: Int,
  operation operation: Operation,
) -> Datom

Create a new Datom with default valid_time = 0.

phash2

pub fn phash2(data: a) -> Int

ref

pub fn ref(id: Int) -> EntityId

to_string

pub fn to_string(v: Value) -> String

to_uid

pub fn to_uid(id: EntityId) -> Eid

uid

pub fn uid(id: Int) -> Eid