Index

Modules: debby, debby/common, debby/mysql, debby/pools, debby/postgres, debby/sqlite.

API symbols

add:

• pools: proc add(pool: Pool; t: Db)

Argument:

• common: object Argument

borrow:

• pools: proc borrow(pool: Pool): Db

Bytes:

• common: type Bytes

checkTable:

• mysql: proc checkTable[T: ref object](db: Db; t: typedesc[T])
• pools: template checkTable[T: ref object](pool: Pool; t: typedesc[T])
• postgres: proc checkTable[T: ref object](db: Db; t: typedesc[T])
• sqlite: proc checkTable[T: ref object](db: Db; t: typedesc[T])

close:

• mysql: proc close(db: Db)
• pools: template close(pool: Pool)
• postgres: proc close(db: Db)
• sqlite: proc close(db: Db)

CONNECTION_AUTH_OK:

• postgres: ConnStatusType.CONNECTION_AUTH_OK

CONNECTION_AWAITING_RESPONSE:

• postgres: ConnStatusType.CONNECTION_AWAITING_RESPONSE

CONNECTION_BAD:

• postgres: ConnStatusType.CONNECTION_BAD

CONNECTION_CHECK_TARGET:

• postgres: ConnStatusType.CONNECTION_CHECK_TARGET

CONNECTION_CHECK_WRITABLE:

• postgres: ConnStatusType.CONNECTION_CHECK_WRITABLE

CONNECTION_CONSUME:

• postgres: ConnStatusType.CONNECTION_CONSUME

CONNECTION_GSS_STARTUP:

• postgres: ConnStatusType.CONNECTION_GSS_STARTUP

CONNECTION_MADE:

• postgres: ConnStatusType.CONNECTION_MADE

CONNECTION_NEEDED:

• postgres: ConnStatusType.CONNECTION_NEEDED

CONNECTION_OK:

• postgres: ConnStatusType.CONNECTION_OK

CONNECTION_SETENV:

• postgres: ConnStatusType.CONNECTION_SETENV

CONNECTION_SSL_STARTUP:

• postgres: ConnStatusType.CONNECTION_SSL_STARTUP

CONNECTION_STARTED:

• postgres: ConnStatusType.CONNECTION_STARTED

ConnStatusType:

• postgres: enum ConnStatusType

createIndex:

• common: template createIndex[T: ref object](db: Db; t: typedesc[T]; params: varargs[string])

createIndexIfNotExists:

• common: template createIndexIfNotExists[T: ref object](db: Db; t: typedesc[T]; params: varargs[string])

createIndexStatement:

• mysql: proc createIndexStatement[T: ref object](db: Db; t: typedesc[T]; ifNotExists: bool; params: varargs[string]): string
• postgres: proc createIndexStatement[T: ref object](db: Db; t: typedesc[T]; ifNotExists: bool; params: varargs[string]): string
• sqlite: proc createIndexStatement[T: ref object](db: Db; t: typedesc[T]; ifNotExists: bool; params: varargs[string]): string

createTable:

• common: proc createTable[T: ref object](db: Db; t: typedesc[T])
• pools: proc createTable[T: ref object](pool: Pool; t: typedesc[T])

createTableStatement:

• mysql: proc createTableStatement[T: ref object](db: Db; t: typedesc[T]): string
• postgres: proc createTableStatement[T: ref object](db: Db; t: typedesc[T]): string
• sqlite: proc createTableStatement[T: ref object](db: Db; t: typedesc[T]): string

Db:

• common: type Db

DbError:

• common: object DbError

dbError:

• common: proc dbError(msg: string)
• mysql: proc dbError(db: Db)
• postgres: proc dbError(db: Db)
• sqlite: proc dbError(db: Db)

delete:

• common: proc delete[T: ref object](db: Db; obj: T)
• common: template delete[T: ref object](db: Db; objs: seq[T])
• pools: proc delete[T: ref object](pool: Pool; obj: T)
• pools: template delete[T: ref object](pool: Pool; objs: seq[T])

dropTable:

• common: proc dropTable[T](db: Db; t: typedesc[T])
• pools: proc dropTable[T](pool: Pool; t: typedesc[T])

dropTableIfExists:

• common: proc dropTableIfExists[T](db: Db; t: typedesc[T])
• pools: proc dropTableIfExists[T](pool: Pool; t: typedesc[T])

ExecStatusType:

• postgres: enum ExecStatusType

FIELD:

• mysql: object FIELD

filter:

• common: proc filter[T](db: Db; t: typedesc[T]): seq[T]
• common: template filter[T: ref object](db: Db; t: typedesc[T]; expression: untyped): untyped
• pools: proc filter[T](pool: Pool; t: typedesc[T]): seq[T]
• pools: template filter[T: ref object](pool: Pool; t: typedesc[T]; expression: untyped): untyped

get:

• common: proc get[T, V](db: Db; t: typedesc[T]; id: V): T
• pools: proc get[T, V](pool: Pool; t: typedesc[T]; id: V): T

hexNibble:

• common: proc hexNibble(ch: char): int

innerSelect:

• common: proc innerSelect[T: ref object](db: Db; it: T; where: string; args: varargs[Argument, toArgument]): seq[T]

insert:

• common: template insert[T: ref object](db: Db; objs: seq[T])
• mysql: proc insert[T: ref object](db: Db; obj: T)
• pools: template insert[T: ref object](pool: Pool; objs: seq[T])
• pools: template insert[T: ref object](pool: Pool; obj: T)
• postgres: proc insert[T: ref object](db: Db; obj: T)
• sqlite: proc insert[T: ref object](db: Db; obj: T)

insertInner:

• common: proc insertInner[T: ref object](db: Db; obj: T; extra = ""): seq[Row]

mysql_close:

• mysql: proc mysql_close(sock: Db)

mysql_error:

• mysql: proc mysql_error(MySQL: Db): cstring

mysql_fetch_field_direct:

• mysql: proc mysql_fetch_field_direct(res: PRES; fieldnr: cuint): PFIELD

mysql_fetch_row:

• mysql: proc mysql_fetch_row(result: PRES): cstringArray

mysql_free_result:

• mysql: proc mysql_free_result(result: PRES)

mysql_init:

• mysql: proc mysql_init(MySQL: Db): Db

mysql_insert_id:

• mysql: proc mysql_insert_id(MySQL: Db): uint64

mysql_num_fields:

• mysql: proc mysql_num_fields(res: PRES): cuint

mysql_num_rows:

• mysql: proc mysql_num_rows(res: PRES): uint64

mysql_query:

• mysql: proc mysql_query(MySQL: Db; q: cstring): cint

mysql_real_connect:

• mysql: proc mysql_real_connect(MySQL: Db; host: cstring; user: cstring; passwd: cstring; db: cstring; port: cuint; unix_socket: cstring; clientflag: int): int

mysql_real_escape_string:

• mysql: proc mysql_real_escape_string(MySQL: Db; fto: cstring; from: cstring; len: int): int

mysql_store_result:

• mysql: proc mysql_store_result(MySQL: Db): PRES

newPool:

• pools: proc newPool(): Pool

openDatabase:

• mysql: proc openDatabase(database: string; host = "localhost"; port = 3306; user = "root"; password = ""): Db
• postgres: proc openDatabase(host, user, password, database: string; port = ""): Db
• sqlite: proc openDatabase(path: string): Db

PFIELD:

• mysql: type PFIELD

PGRES_BAD_RESPONSE:

• postgres: ExecStatusType.PGRES_BAD_RESPONSE

PGRES_COMMAND_OK:

• postgres: ExecStatusType.PGRES_COMMAND_OK

PGRES_COPY_BOTH:

• postgres: ExecStatusType.PGRES_COPY_BOTH

PGRES_COPY_IN:

• postgres: ExecStatusType.PGRES_COPY_IN

PGRES_COPY_OUT:

• postgres: ExecStatusType.PGRES_COPY_OUT

PGRES_EMPTY_QUERY:

• postgres: ExecStatusType.PGRES_EMPTY_QUERY

PGRES_FATAL_ERROR:

• postgres: ExecStatusType.PGRES_FATAL_ERROR

PGRES_NONFATAL_ERROR:

• postgres: ExecStatusType.PGRES_NONFATAL_ERROR

PGRES_SINGLE_TUPLE:

• postgres: ExecStatusType.PGRES_SINGLE_TUPLE

PGRES_TUPLES_OK:

• postgres: ExecStatusType.PGRES_TUPLES_OK

Pool:

• pools: type Pool

PQclear:

• postgres: proc PQclear(res: Result)

PQerrorMessage:

• postgres: proc PQerrorMessage(conn: Db): cstring

PQexec:

• postgres: proc PQexec(conn: Db; query: cstring): Result

PQexecParams:

• postgres: proc PQexecParams(conn: Db; command: cstring; nParams: int32; paramTypes: ptr int32; paramValues: cstringArray; paramLengths: ptr int32; paramFormats: ptr int32; resultFormat: int32): Result

PQfinish:

• postgres: proc PQfinish(conn: Db)

PQfname:

• postgres: proc PQfname(res: Result; field_num: int32): cstring

PQgetvalue:

• postgres: proc PQgetvalue(res: Result; tup_num: int32; field_num: int32): cstring

PQnfields:

• postgres: proc PQnfields(res: Result): int32

PQntuples:

• postgres: proc PQntuples(res: Result): int32

PQresultStatus:

• postgres: proc PQresultStatus(res: Result): ExecStatusType

PQsetdbLogin:

• postgres: proc PQsetdbLogin(pghost: cstring; pgport: cstring; pgoptions: cstring; pgtty: cstring; dbName: cstring; login: cstring; pwd: cstring): Db

PQstatus:

• postgres: proc PQstatus(conn: Db): ConnStatusType

query:

• mysql: proc query(db: Db; query: string; args: varargs[Argument, toArgument]): seq[Row]
• mysql: proc query[T](db: Db; t: typedesc[T]; query: string; args: varargs[Argument, toArgument]): seq[T]
• pools: template query(pool: Pool; sql: string; args: varargs[Argument, toArgument]): seq[Row]
• pools: template query[T](pool: Pool; t: typedesc[T]; sql: string; args: varargs[Argument, toArgument]): seq[T]
• postgres: proc query(db: Db; query: string; args: varargs[Argument, toArgument]): seq[Row]
• postgres: proc query[T](db: Db; t: typedesc[T]; query: string; args: varargs[Argument, toArgument]): seq[T]
• sqlite: proc query(db: Db; query: string; args: varargs[Argument, toArgument]): seq[Row]
• sqlite: proc query[T](db: Db; t: typedesc[T]; query: string; args: varargs[Argument, toArgument]): seq[T]

ReservedNames:

• common: const ReservedNames

Result:

• postgres: type Result

Row:

• common: type Row

sqlDumpHook:

• common: proc sqlDumpHook[T: SomeFloat | SomeInteger](v: T): string
• common: proc sqlDumpHook[T: string](v: T): string
• common: proc sqlDumpHook[T: distinct](v: T): string
• common: proc sqlDumpHook[T: enum](v: T): string
• mysql: proc sqlDumpHook(v: bool): string
• mysql: proc sqlDumpHook(data: Bytes): string
• postgres: proc sqlDumpHook(v: bool): string
• postgres: proc sqlDumpHook(data: Bytes): string
• sqlite: proc sqlDumpHook(v: bool): string

sqlite3_bind_text:

• sqlite: proc sqlite3_bind_text(stmt: Statement; index: int32; text: cstring; size: int32; destructor: pointer): int32

sqlite3_close:

• sqlite: proc sqlite3_close(db: Db): int32

sqlite3_column_blob:

• sqlite: proc sqlite3_column_blob(stmt: Statement; iCol: int32): pointer

sqlite3_column_bytes:

• sqlite: proc sqlite3_column_bytes(stmt: Statement; iCol: int32): int32

sqlite3_column_count:

• sqlite: proc sqlite3_column_count(stmt: Statement): int32

sqlite3_column_name:

• sqlite: proc sqlite3_column_name(stmt: Statement; iCol: int32): cstring

sqlite3_errmsg:

• sqlite: proc sqlite3_errmsg(db: Db): cstring

sqlite3_finalize:

• sqlite: proc sqlite3_finalize(stmt: Statement): int32

sqlite3_last_insert_rowid:

• sqlite: proc sqlite3_last_insert_rowid(db: Db): int64

sqlite3_open:

• sqlite: proc sqlite3_open(filename: cstring; db: var Db): int32

sqlite3_prepare_v2:

• sqlite: proc sqlite3_prepare_v2(db: Db; zSql: cstring; nByte: int32; pStatement: var Statement; pzTail: ptr cstring): int32

sqlite3_step:

• sqlite: proc sqlite3_step(stmt: Statement): int32

SQLITE_OK:

• sqlite: const SQLITE_OK

SQLITE_ROW:

• sqlite: const SQLITE_ROW

sqlParse:

• common: proc sqlParse[T](data: string; v: var T)

sqlParseHook:

• common: proc sqlParseHook[T: string](data: string; v: var T)
• common: proc sqlParseHook[T: SomeFloat](data: string; v: var T)
• common: proc sqlParseHook[T: SomeUnsignedInt](data: string; v: var T)
• common: proc sqlParseHook[T: SomeSignedInt](data: string; v: var T)
• common: proc sqlParseHook[T: enum](data: string; v: var T)
• common: proc sqlParseHook[T: distinct](data: string; v: var T)
• mysql: proc sqlParseHook(data: string; v: var bool)
• mysql: proc sqlParseHook(data: string; v: var Bytes)
• postgres: proc sqlParseHook(data: string; v: var bool)
• postgres: proc sqlParseHook(data: string; v: var Bytes)
• sqlite: proc sqlParseHook(data: string; v: var bool)

Statement:

• postgres: type Statement
• sqlite: type Statement

tableExists:

• mysql: proc tableExists[T](db: Db; t: typedesc[T]): bool
• postgres: proc tableExists[T](db: Db; t: typedesc[T]): bool
• sqlite: proc tableExists[T](db: Db; t: typedesc[T]): bool

tableName:

• common: proc tableName[T](t: typedesc[T]): string

toArgument:

• common: proc toArgument[T](v: T): Argument

toSnakeCase:

• common: proc toSnakeCase(s: string): string

update:

• common: proc update[T: ref object](db: Db; obj: T)
• common: template update[T: ref object](db: Db; objs: seq[T])
• pools: proc update[T: ref object](pool: Pool; obj: T)
• pools: template update[T: ref object](pool: Pool; objs: seq[T])

upsert:

• common: template upsert[T: ref object](db: Db; objs: seq[T])
• common: template upsert[T: ref object](db: Db; obj: T)
• pools: template upsert[T: ref object](pool: Pool; objs: seq[T])
• pools: template upsert[T: ref object](pool: Pool; obj: T)

validateObj:

• common: proc validateObj[T: ref object](t: typedesc[T])

withDb:

• pools: template withDb(pool: Pool; body: untyped)

withTransaction:

• mysql: template withTransaction(db: Db; body)
• postgres: template withTransaction(db: Db; body)
• sqlite: template withTransaction(db: Db; body)