Index

Modules: norm, norm/model, norm/pool, norm/postgres, norm/pragmas, norm/private/dot, norm/private/log, norm/private/postgres/dbtypes, norm/private/postgres/llexec, norm/private/postgres/rowutils, norm/private/sqlite/dbtypes, norm/private/sqlite/rowutils, norm/private/utils, norm/sqlite, norm/types.

API symbols

`$`:

• types: proc `$`[T](s: PaddedStringOfCap[T]): string
• types: proc `$`[T](s: StringOfCap[T]): string

`==`:

• types: proc `==`[T](x, y: PaddedStringOfCap[T]): bool
• types: proc `==`[T](x, y: StringOfCap[T]): bool

add:

• pool: proc add[T: sqlite.DbConn | postgres.DbConn](pool: var Pool; dbConn: T)

checkRo:

• model: proc checkRo(T: typedesc[Model])

close:

• pool: proc close(pool: var Pool)

col:

• model: proc col[T: Model](obj: T; fld: string): string
• model: proc col(T: typedesc[Model]; fld: string): string

cols:

• model: proc cols[T: Model](obj: T; force = false): seq[string]

ConflictPolicy:

• model: enum ConflictPolicy

count:

• postgres: proc count(dbConn: DbConn; T: typedesc[Model]; col = "*"; dist = false; cond = "TRUE"; params: varargs[DbValue, dbValue]): int64
• sqlite: proc count(dbConn: DbConn; T: typedesc[Model]; col = "*"; dist = false; cond = "1"; params: varargs[DbValue, dbValue]): int64

cpIgnore:

• model: ConflictPolicy.cpIgnore

cpRaise:

• model: ConflictPolicy.cpRaise

cpReplace:

• model: ConflictPolicy.cpReplace

createSchema:

• postgres: proc createSchema[T: Model](dbConn: DbConn; obj: T)
• sqlite: proc createSchema[T: Model](dbConn: DbConn; obj: T)

createTables:

• postgres: proc createTables[T: Model](dbConn: DbConn; obj: T)
• sqlite: proc createTables[T: Model](dbConn: DbConn; obj: T)

dbHostEnv:

• postgres: const dbHostEnv
• sqlite: const dbHostEnv

dbNameEnv:

• postgres: const dbNameEnv

dbPassEnv:

• postgres: const dbPassEnv

dbType:

• dbtypes: proc dbType(T: typedesc[int32 | enum]): string
• dbtypes: proc dbType(T: typedesc[int64 | Positive | int | Natural]): string
• dbtypes: proc dbType(T: typedesc[bool]): string
• dbtypes: proc dbType(T: typedesc[DateTime]): string
• dbtypes: proc dbType(T: typedesc[float32]): string
• dbtypes: proc dbType(T: typedesc[float64]): string
• dbtypes: proc dbType(T: typedesc[int16]): string
• dbtypes: proc dbType(T: typedesc[Model]): string
• dbtypes: proc dbType[T](_: typedesc[Option[T]]): string
• dbtypes: proc dbType[C](_: typedesc[PaddedStringOfCap[C]]): string
• dbtypes: proc dbType(T: typedesc[string]): string
• dbtypes: proc dbType[C](_: typedesc[StringOfCap[C]]): string
• dbtypes: proc dbType(T: typedesc[SomeInteger | enum]): string
• dbtypes: proc dbType(T: typedesc[bool]): string
• dbtypes: proc dbType(T: typedesc[DateTime]): string
• dbtypes: proc dbType(T: typedesc[DbBlob]): string
• dbtypes: proc dbType(T: typedesc[Model]): string
• dbtypes: proc dbType[T](_: typedesc[Option[T]]): string
• dbtypes: proc dbType[C](_: typedesc[PaddedStringOfCap[C]]): string
• dbtypes: proc dbType(T: typedesc[SomeFloat]): string
• dbtypes: proc dbType(T: typedesc[string]): string
• dbtypes: proc dbType[C](_: typedesc[StringOfCap[C]]): string

dbUserEnv:

• postgres: const dbUserEnv

dbValue:

• dbtypes: proc dbValue(val: typeof(nil)): DbValue
• dbtypes: proc dbValue[T: Model](val: Option[T]): DbValue
• dbtypes: proc dbValue[T](val: PaddedStringOfCap[T]): DbValue
• dbtypes: proc dbValue[T](val: StringOfCap[T]): DbValue
• dbtypes: proc dbValue[T: Model](val: T): DbValue
• dbtypes: proc dbValue(val: typeof(nil)): DbValue
• dbtypes: proc dbValue(val: bool): DbValue
• dbtypes: proc dbValue(val: DateTime): DbValue
• dbtypes: proc dbValue(val: Option[bool]): DbValue
• dbtypes: proc dbValue(val: Option[DateTime]): DbValue
• dbtypes: proc dbValue[T: Model](val: Option[T]): DbValue
• dbtypes: proc dbValue[T](val: PaddedStringOfCap[T]): DbValue
• dbtypes: proc dbValue[T](val: StringOfCap[T]): DbValue
• dbtypes: proc dbValue[T: Model](val: T): DbValue

defaultSize:

• pool: proc defaultSize(pool: Pool): Natural

delete:

• postgres: proc delete[T: Model](dbConn: DbConn; objs: var openArray[T])
• postgres: proc delete[T: Model](dbConn: DbConn; obj: var T)
• sqlite: proc delete[T: Model](dbConn: DbConn; objs: var openArray[T])
• sqlite: proc delete[T: Model](dbConn: DbConn; obj: var T)

dot:

• dot: macro dot(obj: typed; fld: string): untyped

dropDb:

• postgres: proc dropDb()
• sqlite: proc dropDb()

execExpectTuplesOk:

• llexec: proc execExpectTuplesOk(db: DbConn; query: SqlQuery; args: seq[DbValue])

exists:

• postgres: proc exists(dbConn: DbConn; T: typedesc[Model]; cond = "TRUE"; params: varargs[DbValue, dbValue]): bool
• sqlite: proc exists(dbConn: DbConn; T: typedesc[Model]; cond = "1"; params: varargs[DbValue, dbValue]): bool

fCol:

• model: proc fCol[T: Model](obj: T; fld: string): string
• model: proc fCol[T: Model](obj: T; fld, tAls: string): string
• model: proc fCol(T: typedesc[Model]; fld: string): string
• model: proc fCol(T: typedesc[Model]; fld, tAls: string): string

fk:

• pragmas: template fk(val: typed)

fromRow:

• rowutils: proc fromRow[T: ref object](obj: var T; row: Row)
• rowutils: proc fromRow[T: ref object](obj: var T; row: Row)

getDb:

• postgres: proc getDb(): DbConn
• sqlite: proc getDb(): DbConn

getRelatedFieldNameTo:

• model: proc getRelatedFieldNameTo[S: Model; T: Model](source: typedesc[S]; target: typedesc[T]): string

hasField:

• dot: template hasField(t: typed; fieldName: static string): bool

index:

• pragmas: template index(val: string)

insert:

• postgres: proc insert[T: Model](dbConn: DbConn; objs: var openArray[T]; force = false)
• postgres: proc insert[T: Model](dbConn: DbConn; obj: var T; force = false; conflictPolicy = cpRaise)
• sqlite: proc insert[T: Model](dbConn: DbConn; objs: var openArray[T]; force = false; conflictPolicy = cpRaise)
• sqlite: proc insert[T: Model](dbConn: DbConn; obj: var T; force = false; conflictPolicy = cpRaise)

isEmptyColumn:

• rowutils: proc isEmptyColumn(row: Row; index: int): bool
• rowutils: proc isEmptyColumn(row: Row; index: int): bool

isModel:

• model: proc isModel[T: Model](val: Option[T]): bool
• model: proc isModel[T: Model](val: T): bool
• model: proc isModel[T](val: T): bool

isRefObject:

• utils: proc isRefObject[T](val: Option[T]): bool
• utils: proc isRefObject[T](val: T): bool
• utils: proc isRefObject[T](val: typedesc[Option[T]]): bool
• utils: proc isRefObject[T](val: typedesc[T]): bool

joinGroups:

• model: proc joinGroups[T: Model](obj: T; flds: seq[string] = @[]): seq[ tuple[tbl, tAls, lFld, rFld: string]]

log:

• log: proc log(msg: string)
• log: proc log(qry, paramstr: string)

LoggingError:

• log: object LoggingError

Model:

• model: type Model

model:

• model: proc model[T: Model](val: Option[T]): Option[T]
• model: proc model[T: Model](val: T): Option[T]
• model: proc model[T](val: T): Option[Model]

newPaddedStringOfCap:

• types: proc newPaddedStringOfCap[C: static[int]](val = ""): PaddedStringOfCap[C]

newPool:

• pool: proc newPool[T: sqlite.DbConn](defaultSize: Positive; getDbProc = sqlite.getDb; poolExhaustedPolicy = pepRaise): Pool[T]
• pool: proc newPool[T: postgres.DbConn](defaultSize: Positive; getDbProc = postgres.getDb; poolExhaustedPolicy = pepRaise): Pool[T]

newStringOfCap:

• types: proc newStringOfCap[C: static[int]](val = ""): StringOfCap[C]

NotFoundError:

• postgres: object NotFoundError
• sqlite: object NotFoundError

onDelete:

• pragmas: template onDelete(val: string)

PaddedStringOfCap:

• types: type PaddedStringOfCap

pepExtend:

• pool: PoolExhaustedPolicy.pepExtend

pepRaise:

• pool: PoolExhaustedPolicy.pepRaise

pk:

• pragmas: template pk()

Pool:

• pool: type Pool

PoolExhaustedError:

• pool: object PoolExhaustedError

PoolExhaustedPolicy:

• pool: enum PoolExhaustedPolicy

pop:

• pool: proc pop[T: sqlite.DbConn | postgres.DbConn](pool: var Pool[T]): T

rawSelect:

• postgres: proc rawSelect[T: ref object](dbConn: DbConn; qry: string; objs: var seq[T]; params: varargs[DbValue, dbValue])
• postgres: proc rawSelect[T: ref object](dbConn: DbConn; qry: string; obj: var T; params: varargs[DbValue, dbValue])
• sqlite: proc rawSelect[T: ref object](dbConn: DbConn; qry: string; objs: var seq[T]; params: varargs[DbValue, dbValue])
• sqlite: proc rawSelect[T: ref object](dbConn: DbConn; qry: string; obj: var T; params: varargs[DbValue, dbValue])

readOnly:

• pragmas: template readOnly()

reset:

• pool: proc reset(pool: var Pool)

rfCols:

• model: proc rfCols[T: Model](obj: T; flds: seq[string] = @[]): seq[string]

ro:

• pragmas: template ro()

rollback:

• postgres: proc rollback()
• sqlite: proc rollback()

RollbackError:

• postgres: object RollbackError
• sqlite: object RollbackError

schema:

• model: proc schema(T: typedesc[Model]): Option[string]

schemaName:

• pragmas: template schemaName(val: string)

select:

• postgres: proc select[T: Model](dbConn: DbConn; objs: var seq[T]; cond: string; params: varargs[DbValue, dbValue])
• postgres: proc select[T: Model](dbConn: DbConn; obj: var T; cond: string; params: varargs[DbValue, dbValue])
• postgres: proc select[T: Model](dbConn: DbConn; typ: typedesc[T]; cond: string; params: varargs[DbValue, dbValue]): seq[T]
• sqlite: proc select[T: Model](dbConn: DbConn; objs: var seq[T]; cond: string; params: varargs[DbValue, dbValue])
• sqlite: proc select[T: Model](dbConn: DbConn; obj: var T; cond: string; params: varargs[DbValue, dbValue])
• sqlite: proc select[T: Model](dbConn: DbConn; typ: typedesc[T]; cond: string; params: varargs[DbValue, dbValue]): seq[T]

selectAll:

• postgres: proc selectAll[T: Model](dbConn: DbConn; objs: var seq[T])
• postgres: proc selectAll[T: Model](dbConn: DbConn; typ: typedesc[T]): seq[T]
• sqlite: proc selectAll[T: Model](dbConn: DbConn; objs: var seq[T])
• sqlite: proc selectAll[T: Model](dbConn: DbConn; typ: typedesc[T]): seq[T]

selectManyToMany:

• postgres: proc selectManyToMany[M1: Model; J: Model; M2: Model](dbConn: DbConn; queryStartEntry: M1; joinModelEntries: var seq[J]; queryEndEntries: var seq[M2])
• postgres: proc selectManyToMany[M1: Model; J: Model; M2: Model](dbConn: DbConn; queryStartEntry: M1; joinModelEntries: var seq[J]; queryEndEntries: var seq[M2]; fkColumnFromJoinToManyStart: static string; fkColumnFromJoinToManyEnd: static string)
• postgres: proc selectManyToMany[M1: Model; J: Model; M2: Model](dbConn: DbConn; queryStartEntries: seq[M1]; joinModelEntries: var seq[J]; queryEndEntries: var Table[int64, seq[M2]])
• postgres: proc selectManyToMany[M1: Model; J: Model; M2: Model](dbConn: DbConn; queryStartEntries: seq[M1]; joinModelEntries: var seq[J]; queryEndEntries: var Table[int64, seq[M2]]; fkColumnFromJoinToManyStart: static string; fkColumnFromJoinToManyEnd: static string)
• sqlite: proc selectManyToMany[M1: Model; J: Model; M2: Model](dbConn: DbConn; queryStartEntry: M1; joinModelEntries: var seq[J]; queryEndEntries: var seq[M2])
• sqlite: proc selectManyToMany[M1: Model; J: Model; M2: Model](dbConn: DbConn; queryStartEntry: M1; joinModelEntries: var seq[J]; queryEndEntries: var seq[M2]; fkColumnFromJoinToManyStart: static string; fkColumnFromJoinToManyEnd: static string)
• sqlite: proc selectManyToMany[M1: Model; J: Model; M2: Model](dbConn: DbConn; queryStartEntries: seq[M1]; joinModelEntries: var seq[J]; queryEndEntries: var Table[int64, seq[M2]])
• sqlite: proc selectManyToMany[M1: Model; J: Model; M2: Model](dbConn: DbConn; queryStartEntries: seq[M1]; joinModelEntries: var seq[J]; queryEndEntries: var Table[int64, seq[M2]]; fkColumnFromJoinToManyStart: static string; fkColumnFromJoinToManyEnd: static string)

selectOneToMany:

• postgres: proc selectOneToMany[O: Model; M: Model](dbConn: DbConn; oneEntry: O; relatedEntries: var seq[M])
• postgres: proc selectOneToMany[O: Model; M: Model](dbConn: DbConn; oneEntry: O; relatedEntries: var seq[M]; foreignKeyFieldName: static string)
• postgres: proc selectOneToMany[O: Model; M: Model](dbConn: DbConn; oneEntries: seq[O]; relatedEntries: var seq[M])
• postgres: proc selectOneToMany[O: Model; M: Model](dbConn: DbConn; oneEntries: seq[O]; relatedEntries: var Table[int64, seq[M]]; foreignKeyFieldName: static string)
• sqlite: proc selectOneToMany[O: Model; M: Model](dbConn: DbConn; oneEntry: O; relatedEntries: var seq[M])
• sqlite: proc selectOneToMany[O: Model; M: Model](dbConn: DbConn; oneEntry: O; relatedEntries: var seq[M]; foreignKeyFieldName: static string)
• sqlite: proc selectOneToMany[O: Model; M: Model](dbConn: DbConn; oneEntries: seq[O]; relatedEntries: var seq[M])
• sqlite: proc selectOneToMany[O: Model; M: Model](dbConn: DbConn; oneEntries: seq[O]; relatedEntries: var Table[int64, seq[M]]; foreignKeyFieldName: static string)

size:

• pool: proc size(pool: Pool): Natural

StringOfCap:

• types: type StringOfCap

sum:

• postgres: proc sum(dbConn: DbConn; T: typedesc[Model]; col: string; dist = false; cond = "TRUE"; params: varargs[DbValue, dbValue]): float
• sqlite: proc sum(dbConn: DbConn; T: typedesc[Model]; col: string; dist = false; cond = "1"; params: varargs[DbValue, dbValue]): float

table:

• model: proc table(T: typedesc[Model]): string

tableName:

• pragmas: template tableName(val: string)

to:

• dbtypes: proc to(dbVal: DbValue; T: typedesc[SomeInteger | enum]): T:type
• dbtypes: proc to(dbVal: DbValue; T: typedesc[bool]): T:type
• dbtypes: proc to(dbVal: DbValue; T: typedesc[DateTime]): T:type
• dbtypes: proc to(dbVal: DbValue; T: typedesc[Model]): T:type
• dbtypes: proc to[T](dbVal: DbValue; O: typedesc[Option[T]]): O:type
• dbtypes: proc to[T1](dbVal: DbValue; T2: typedesc[PaddedStringOfCap[T1]]): T2:type
• dbtypes: proc to(dbVal: DbValue; T: typedesc[SomeFloat]): T:type
• dbtypes: proc to(dbVal: DbValue; T: typedesc[string]): T:type
• dbtypes: proc to[T1](dbVal: DbValue; T2: typedesc[StringOfCap[T1]]): T2:type
• dbtypes: proc to(dbVal: DbValue; T: typedesc[SomeInteger | enum]): T:type
• dbtypes: proc to(dbVal: DbValue; T: typedesc[bool]): T:type
• dbtypes: proc to(dbVal: DbValue; T: typedesc[DateTime]): T:type
• dbtypes: proc to(dbVal: DbValue; T: typedesc[DbBlob]): T:type
• dbtypes: proc to(dbVal: DbValue; T: typedesc[Model]): T:type
• dbtypes: proc to[T](dbVal: DbValue; O: typedesc[Option[T]]): O:type
• dbtypes: proc to[T1](dbVal: DbValue; T2: typedesc[PaddedStringOfCap[T1]]): T2:type
• dbtypes: proc to(dbVal: DbValue; T: typedesc[SomeFloat]): T:type
• dbtypes: proc to(dbVal: DbValue; T: typedesc[string]): T:type
• dbtypes: proc to[T1](dbVal: DbValue; T2: typedesc[StringOfCap[T1]]): T2:type

toOptional:

• utils: proc toOptional[T: ref object](val: Option[T]): Option[T]
• utils: proc toOptional[T: ref object](val: T): Option[T]

toRow:

• rowutils: proc toRow[T: Model](obj: T; force = false): Row
• rowutils: proc toRow[T: Model](obj: T; force = false): Row

transaction:

• postgres: template transaction(dbConn; body: untyped): untyped
• sqlite: template transaction(dbConn; body: untyped): untyped

unique:

• pragmas: template unique()

uniqueGroup:

• pragmas: template uniqueGroup()

uniqueIndex:

• pragmas: template uniqueIndex(val: string)

update:

• postgres: proc update[T: Model](dbConn: DbConn; objs: var openArray[T])
• postgres: proc update[T: Model](dbConn: DbConn; obj: var T)
• sqlite: proc update[T: Model](dbConn: DbConn; objs: var openArray[T])
• sqlite: proc update[T: Model](dbConn: DbConn; obj: var T)

validateFkField:

• model: proc validateFkField[S, T: Model](fkFieldName: static string; source: typedesc[S]; target: typedesc[T]): bool

validateJoinModelFkField:

• model: proc validateJoinModelFkField[S, T: Model](fkFieldName: static string; joinModel: typedesc[S]; target: typedesc[T]): bool

withDb:

• pool: template withDb(pool: var Pool; body: untyped): untyped
• postgres: template withDb(body: untyped): untyped
• sqlite: template withDb(body: untyped): untyped