Index

Modules: boogie, boogie/stores/columnar, boogie/stores/docstore, boogie/stores/graphstore, boogie/stores/kv, boogie/stores/rdbms, boogie/stores/vectorstore, boogie/wal.

API symbols

`$`:

• rdbms: proc `$`(v: Value): string

`==`:

• rdbms: proc `==`(a, b: RowRecord): bool
• rdbms: proc `==`(a, b: Value): bool

AggKind:

• columnar: enum AggKind

aggregate:

• columnar: proc aggregate(s: ColumnarStore; table: string; specs: seq[AggregateSpec]; filters: seq[Filter] = @[]): JsonNode

AggregateSpec:

• columnar: object AggregateSpec

akAvg:

• columnar: AggKind.akAvg

akCount:

• columnar: AggKind.akCount

akMax:

• columnar: AggKind.akMax

akMin:

• columnar: AggKind.akMin

akSum:

• columnar: AggKind.akSum

all:

• vectorstore: iterator all(c: VectorCollection): (string, seq[float32])

allRows:

• rdbms: iterator allRows(t: DbTable): (string, RowData)

allRowsByPk:

• rdbms: iterator allRowsByPk(t: DbTable): (string, RowData)

append:

• wal: proc append(w: var Wal; entry: WalEntry; sync: bool = true): uint64

beginTx:

• graphstore: proc beginTx(s: GraphStore): GraphTx

ccDictionary:

• columnar: CompressionCodec.ccDictionary

ccNone:

• columnar: CompressionCodec.ccNone

ccRle:

• columnar: CompressionCodec.ccRle

checkpoint:

• columnar: proc checkpoint(s: var ColumnarStore)
• docstore: proc checkpoint(store: var DocumentStore)
• kv: proc checkpoint(s: KvStore)
• rdbms: proc checkpoint(s: Store)
• vectorstore: proc checkpoint(s: VectorStore)

closeGraphStore:

• graphstore: proc closeGraphStore(s: GraphStore)

ColumnarError:

• columnar: object ColumnarError

ColumnarStore:

• columnar: object ColumnarStore

ColumnDef:

• rdbms: object ColumnDef

ColumnSchema:

• columnar: object ColumnSchema

ColumnType:

• columnar: enum ColumnType

commit:

• graphstore: proc commit(tx: var GraphTx)

CompressionCodec:

• columnar: enum CompressionCodec

createCollection:

• vectorstore: proc createCollection(s: VectorStore; c: VectorCollection)

createIndex:

• rdbms: proc createIndex(t: DbTable; column: string)

createNode:

• graphstore: proc createNode(tx: var GraphTx; labels: seq[string] = @[]; props: JsonNode = newJObject()): uint64

createRelationship:

• graphstore: proc createRelationship(tx: var GraphTx; fromId, toId: uint64; relType: string; props: JsonNode = newJObject()): uint64

createTable:

• columnar: proc createTable(s: var ColumnarStore; schema: TableSchema; sync: bool = true)
• rdbms: proc createTable(s: Store; t: DbTable)

createTableIfNotExist:

• rdbms: proc createTableIfNotExist(s: Store; t: DbTable)

ctBool:

• columnar: ColumnType.ctBool

ctFloat64:

• columnar: ColumnType.ctFloat64

ctInt64:

• columnar: ColumnType.ctInt64

ctJson:

• columnar: ColumnType.ctJson

ctString:

• columnar: ColumnType.ctString

DataType:

• rdbms: enum DataType

DbTable:

• rdbms: type DbTable

deBson:

• docstore: DocumentEncoding.deBson

deJson:

• docstore: DocumentEncoding.deJson

delete:

• docstore: proc delete(store: var DocumentStore; key: string; sync = true): bool
• kv: proc delete(s: KvStore; key: string): bool
• vectorstore: proc delete(s: VectorStore; collection, pk: string): bool

deleteNode:

• graphstore: proc deleteNode(tx: var GraphTx; id: uint64)

deleteRelationship:

• graphstore: proc deleteRelationship(tx: var GraphTx; id: uint64)

deleteRow:

• rdbms: proc deleteRow(t: DbTable; pk: string): bool
• rdbms: proc deleteRow(s: Store; tableName: string; pk: string): bool

DistanceMetric:

• vectorstore: enum DistanceMetric

dmCosine:

• vectorstore: DistanceMetric.dmCosine

dmDot:

• vectorstore: DistanceMetric.dmDot

dmL2:

• vectorstore: DistanceMetric.dmL2

DocumentEncoding:

• docstore: enum DocumentEncoding

DocumentStore:

• docstore: object DocumentStore

DocumentStoreError:

• docstore: object DocumentStoreError

dropCollection:

• vectorstore: proc dropCollection(s: VectorStore; name: string)

dropTable:

• columnar: proc dropTable(s: var ColumnarStore; table: string; sync: bool = true)
• rdbms: proc dropTable(s: Store; name: string)

dtBool:

• rdbms: DataType.dtBool

dtFloat:

• rdbms: DataType.dtFloat

dtInt:

• rdbms: DataType.dtInt

dtJson:

• rdbms: DataType.dtJson

dtNull:

• rdbms: DataType.dtNull

dtText:

• rdbms: DataType.dtText

entries:

• wal: iterator entries(w: Wal): WalEntry

Filter:

• columnar: object Filter

FilterOp:

• columnar: enum FilterOp

findNodesByLabel:

• graphstore: proc findNodesByLabel(s: GraphStore; label: string): seq[GraphNode]

fkaRestrict:

• rdbms: ForeignKeyAction.fkaRestrict

flush:

• wal: proc flush(w: var Wal)

foEq:

• columnar: FilterOp.foEq

foGt:

• columnar: FilterOp.foGt

foGte:

• columnar: FilterOp.foGte

foIn:

• columnar: FilterOp.foIn

foLt:

• columnar: FilterOp.foLt

foLte:

• columnar: FilterOp.foLte

foNe:

• columnar: FilterOp.foNe

ForeignKeyAction:

• rdbms: enum ForeignKeyAction

ForeignKeyDef:

• rdbms: object ForeignKeyDef

get:

• docstore: proc get(store: DocumentStore; key: string): Option[JsonNode]
• kv: proc get(s: KvStore; key: string): Option[string]
• vectorstore: proc get(c: VectorCollection; pk: string): Option[seq[float32]]
• vectorstore: proc get(s: VectorStore; collection, pk: string): Option[seq[float32]]

getBson:

• docstore: proc getBson(store: DocumentStore; key: string; version: int32 = 1'i32): Option[ BSONDocument]

getCollection:

• vectorstore: proc getCollection(s: VectorStore; name: string): Option[VectorCollection]

getNode:

• graphstore: proc getNode(s: GraphStore; id: uint64; outNode: var GraphNode): bool

getObj:

• docstore: proc getObj[T](store: DocumentStore; key: string; _: typedesc[T]): Option[T]

getRelationship:

• graphstore: proc getRelationship(s: GraphStore; id: uint64; outRel: var Relationship): bool

getRow:

• rdbms: proc getRow(t: DbTable; pk: string): Option[RowData]
• rdbms: proc getRow(s: Store; tableName: string; pk: string): Option[RowData]

getTable:

• rdbms: proc getTable(s: Store; name: string): Option[DbTable]

GraphError:

• graphstore: object GraphError

GraphNode:

• graphstore: object GraphNode

GraphStore:

• graphstore: type GraphStore

GraphTx:

• graphstore: object GraphTx

hasCollection:

• vectorstore: proc hasCollection(s: VectorStore; name: string): bool

hasKey:

• docstore: proc hasKey(store: DocumentStore; key: string): bool
• kv: proc hasKey(s: KvStore; key: string): bool

hasTable:

• rdbms: proc hasTable(s: Store; name: string): bool

insert:

• docstore: proc insert(store: var DocumentStore; key: string; doc: JsonNode; sync = true; enc: DocumentEncoding = deJson)
• vectorstore: proc insert(s: VectorStore; collection, pk: string; vec: seq[float32])

insertBatch:

• columnar: proc insertBatch(s: var ColumnarStore; table: string; rows: seq[JsonNode]; sync: bool = true)

insertRow:

• rdbms: proc insertRow(t: DbTable; data: RowData): string
• rdbms: proc insertRow(t: DbTable; pk: string; data: RowData)
• rdbms: proc insertRow(s: Store; tableName: string; data: RowData): string
• rdbms: proc insertRow(s: Store; tableName: string; pk: string; data: RowData)

isEmpty:

• kv: proc isEmpty(s: KvStore): bool
• rdbms: proc isEmpty(t: DbTable): bool

join:

• columnar: proc join(s: ColumnarStore; joinType: JoinType; leftTable, rightTable: string): seq[ JsonNode]

JoinType:

• columnar: enum JoinType

jtCross:

• columnar: JoinType.jtCross

jtFull:

• columnar: JoinType.jtFull

jtInner:

• columnar: JoinType.jtInner

jtLeft:

• columnar: JoinType.jtLeft

jtRight:

• columnar: JoinType.jtRight

ksmDisk:

• kv: KvStorageMode.ksmDisk

ksmInMemory:

• kv: KvStorageMode.ksmInMemory

KvStorageMode:

• kv: enum KvStorageMode

KvStore:

• kv: type KvStore

KvStoreError:

• kv: object KvStoreError

len:

• docstore: proc len(store: DocumentStore): int
• kv: proc len(s: KvStore): int

nearest:

• vectorstore: proc nearest(c: VectorCollection; query: seq[float32]; k: int; metric: DistanceMetric = dmCosine): seq[(string, float32)]
• vectorstore: proc nearest(s: VectorStore; collection: string; query: seq[float32]; k: int; metric: DistanceMetric = dmCosine): seq[(string, float32)]

neighbors:

• graphstore: proc neighbors(s: GraphStore; nodeId: uint64; relType = ""): seq[uint64]

newBoolValue:

• rdbms: proc newBoolValue(v: bool): Value

newCollection:

• vectorstore: proc newCollection(name: string; dimension: int): VectorCollection

newColumn:

• rdbms: proc newColumn(name: string; kind: DataType; nullable: bool): ColumnDef

newFloatValue:

• rdbms: proc newFloatValue(v: float64): Value

newForeignKey:

• rdbms: proc newForeignKey(name, column, refTable, refColumn: string; onDelete: ForeignKeyAction = fkaRestrict): ForeignKeyDef

newInMemoryKvStore:

• kv: proc newInMemoryKvStore(): KvStore

newInMemoryStore:

• rdbms: proc newInMemoryStore(): Store

newInMemoryVectorStore:

• vectorstore: proc newInMemoryVectorStore(): VectorStore

newIntValue:

• rdbms: proc newIntValue(v: int64): Value

newJSONValue:

• rdbms: proc newJSONValue(v: JsonNode): Value

newKvStore:

• kv: proc newKvStore(path: string; mode: KvStorageMode = ksmDisk; enableWal: bool = true; checkpointEveryOps: uint32 = 0'u32; walFlushEveryOps: uint32 = 1000'u32): KvStore

newNullValue:

• rdbms: proc newNullValue(): Value

newStore:

• rdbms: proc newStore(path: string; mode: StorageMode = smDisk; enableWal: bool = true; checkpointEveryOps: uint32 = 0'u32; walFlushEveryOps: uint32 = 1000'u32): Store

newTable:

• rdbms: proc newTable(name: string; primaryKey: string; columns: openArray[ColumnDef]; primaryKeyMode: PrimaryKeyMode = pkmSerial; foreignKeys: openArray[ForeignKeyDef] = []): DbTable

newTextValue:

• rdbms: proc newTextValue(v: string): Value

newVectorStore:

• vectorstore: proc newVectorStore(path: string; mode: VectorStorageMode = smDisk; enableWal: bool = true; checkpointEveryOps: uint32 = 0'u32; walFlushEveryOps: uint32 = 1000'u32): VectorStore

openBSONDocument:

• docstore: proc openBSONDocument(store: var DocumentStore; key, path: string; sync = true): bool

openColumnarStore:

• columnar: proc openColumnarStore(rootDir: string; walPath: string = ""; walFlushEveryOps: int = 100): ColumnarStore

openDocumentStore:

• docstore: proc openDocumentStore(path: string; name = "documents"; defaultEncoding = deJson; enableSnapshots = true; checkpointEveryOps: uint32 = 1000'u32; walFlushEveryOps: uint32 = 1000'u32): DocumentStore

openGraphStore:

• graphstore: proc openGraphStore(rootDir: string): GraphStore

openWal:

• wal: proc openWal(path: string): Wal

outgoing:

• graphstore: proc outgoing(s: GraphStore; nodeId: uint64; relType = ""): seq[Relationship]

pairs:

• docstore: iterator pairs(store: DocumentStore): (string, JsonNode)

pairsUnordered:

• kv: iterator pairsUnordered(s: KvStore): (string, string)

pkmManual:

• rdbms: PrimaryKeyMode.pkmManual

pkmSerial:

• rdbms: PrimaryKeyMode.pkmSerial

PrimaryKeyMode:

• rdbms: enum PrimaryKeyMode

put:

• kv: proc put(s: KvStore; key, value: string)

putObj:

• docstore: proc putObj[T: object | ref object](store: var DocumentStore; key: string; value: T; sync = true; enc: DocumentEncoding = deJson)

recoverFromWal:

• docstore: proc recoverFromWal(s: var DocumentStore)
• kv: proc recoverFromWal(s: KvStore)
• rdbms: proc recoverFromWal(s: Store)
• vectorstore: proc recoverFromWal(s: VectorStore)

Relationship:

• graphstore: object Relationship

replay:

• wal: proc replay(w: Wal; onEntry: proc (e: WalEntry))

reset:

• wal: proc reset(w: var Wal)

rollback:

• graphstore: proc rollback(tx: var GraphTx)

row:

• rdbms: proc row(pairs: openArray[(string, Value)]): RowData

RowData:

• rdbms: type RowData

RowIndex:

• rdbms: type RowIndex

scan:

• columnar: proc scan(s: ColumnarStore; table: string; projectedColumns: seq[string]; filters: seq[Filter] = @[]; limit: int = 0): seq[JsonNode]

smDisk:

• rdbms: StorageMode.smDisk
• vectorstore: VectorStorageMode.smDisk

smInMemory:

• rdbms: StorageMode.smInMemory
• vectorstore: VectorStorageMode.smInMemory

StorageMode:

• rdbms: enum StorageMode

Store:

• rdbms: type Store

StoreError:

• rdbms: object StoreError

TableSchema:

• columnar: object TableSchema

traverseBfs:

• graphstore: proc traverseBfs(s: GraphStore; startNode: uint64; maxDepth: int; relType = ""): seq[ uint64]

upsert:

• docstore: proc upsert(store: var DocumentStore; key: string; doc: JsonNode; sync = true; enc: DocumentEncoding = deJson)

upsertNode:

• graphstore: proc upsertNode(tx: var GraphTx; node: GraphNode)

upsertRelationship:

• graphstore: proc upsertRelationship(tx: var GraphTx; r: Relationship)

Value:

• rdbms: object Value

VectorCollection:

• vectorstore: type VectorCollection

VectorStorageMode:

• vectorstore: enum VectorStorageMode

VectorStore:

• vectorstore: type VectorStore

VectorStoreError:

• vectorstore: object VectorStoreError

Wal:

• wal: object Wal

WalEntry:

• wal: object WalEntry

WalError:

• wal: object WalError

WalMagic:

• wal: let WalMagic

WalOp:

• wal: enum WalOp

where:

• rdbms: proc where(t: DbTable; column: string; value: Value): seq[(string, RowData)]

woCreateTable:

• wal: WalOp.woCreateTable

woDeleteRow:

• wal: WalOp.woDeleteRow

woDropTable:

• wal: WalOp.woDropTable

woInsertRow:

• wal: WalOp.woInsertRow

woUpdateRow:

• wal: WalOp.woUpdateRow

writeBSONDocument:

• docstore: proc writeBSONDocument(store: DocumentStore; key, path: string; version: int32 = 1'i32): bool