Index

Modules: boogie, boogie/store, boogie/wal.

API symbols

`$`:

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

`==`:

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

allRows:

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

allRowsByPk:

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

append:

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

checkpoint:

• store: proc checkpoint(s: Store)

ColumnDef:

• store: object ColumnDef

createIndex:

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

createTable:

• store: proc createTable(s: Store; t: DbTable)

DataType:

• store: enum DataType

DbTable:

• store: type DbTable

deleteRow:

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

dropTable:

• store: proc dropTable(s: Store; name: string)

dtBool:

• store: DataType.dtBool

dtFloat:

• store: DataType.dtFloat

dtInt:

• store: DataType.dtInt

dtJson:

• store: DataType.dtJson

dtNull:

• store: DataType.dtNull

dtText:

• store: DataType.dtText

entries:

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

flush:

• wal: proc flush(w: var Wal)

getRow:

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

getTable:

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

hasTable:

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

insertRow:

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

isEmpty:

• store: proc isEmpty(t: DbTable): bool

newBoolValue:

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

newColumn:

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

newFloatValue:

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

newInMemoryStore:

• store: proc newInMemoryStore(): Store

newIntValue:

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

newJSONValue:

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

newNullValue:

• store: proc newNullValue(): Value

newStore:

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

newTable:

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

newTextValue:

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

openWal:

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

pkmManual:

• store: PrimaryKeyMode.pkmManual

pkmSerial:

• store: PrimaryKeyMode.pkmSerial

PrimaryKeyMode:

• store: enum PrimaryKeyMode

recoverFromWal:

• store: proc recoverFromWal(s: Store)

replay:

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

reset:

• wal: proc reset(w: var Wal)

row:

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

RowData:

• store: type RowData

RowIndex:

• store: type RowIndex

smDisk:

• store: StorageMode.smDisk

smInMemory:

• store: StorageMode.smInMemory

StorageMode:

• store: enum StorageMode

Store:

• store: type Store

StoreError:

• store: object StoreError

Value:

• store: object Value

Wal:

• wal: object Wal

WalEntry:

• wal: object WalEntry

WalError:

• wal: object WalError

WalMagic:

• wal: let WalMagic

WalOp:

• wal: enum WalOp

where:

• store: 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