Index

Modules: lowdb, lowdb/postgres, lowdb/sqlite, lowdb/wrappers/libpq, lowdb/wrappers/sqlite3.

API symbols

`$`:

• postgres: proc `$`(v: DbValue): string
• sqlite: proc `$`(v: DbValue): string

`==`:

• postgres: proc `==`(a: DbValue; b: DbValue): bool
• sqlite: proc `==`(a: DbBlob; b: DbBlob): bool
• sqlite: proc `==`(a: DbValue; b: DbValue): bool

`?`:

• postgres: template `?`(v: typed): DbValue
• sqlite: template `?`(v: typed): DbValue

`[]`:

• sqlite: proc `[]`(row: InstantRow; col: int32; T: typedesc = string): T:type

close:

• postgres: proc close(db: DbConn)
• sqlite: proc close(db: DbConn)

CMDSTATUS_LEN:

• libpq: const CMDSTATUS_LEN

CONNECTION_AUTH_OK:

• libpq: ConnStatusType.CONNECTION_AUTH_OK

CONNECTION_AWAITING_RESPONSE:

• libpq: ConnStatusType.CONNECTION_AWAITING_RESPONSE

CONNECTION_BAD:

• libpq: ConnStatusType.CONNECTION_BAD

CONNECTION_MADE:

• libpq: ConnStatusType.CONNECTION_MADE

CONNECTION_NEEDED:

• libpq: ConnStatusType.CONNECTION_NEEDED

CONNECTION_OK:

• libpq: ConnStatusType.CONNECTION_OK

CONNECTION_SETENV:

• libpq: ConnStatusType.CONNECTION_SETENV

CONNECTION_SSL_STARTUP:

• libpq: ConnStatusType.CONNECTION_SSL_STARTUP

CONNECTION_STARTED:

• libpq: ConnStatusType.CONNECTION_STARTED

ConnStatusType:

• libpq: enum ConnStatusType

DbBlob:

• sqlite: type DbBlob

DbConn:

• postgres: type DbConn
• sqlite: type DbConn

dbError:

• postgres: proc dbError(db: DbConn)
• sqlite: proc dbError(db: DbConn)

db_handle:

• sqlite3: proc db_handle(para1: PStmt): PSqlite3

DbNull:

• postgres: object DbNull
• sqlite: object DbNull

DbOther:

• postgres: object DbOther

dbQuote:

• postgres: proc dbQuote(s: string): string
• sqlite: proc dbQuote(s: DbBlob): string
• sqlite: proc dbQuote(s: string): string

DbValue:

• postgres: object DbValue

dbValue:

• postgres: proc dbValue(v: bool): DbValue
• postgres: proc dbValue(v: DateTime): DbValue
• postgres: proc dbValue(v: DbValue): DbValue
• postgres: proc dbValue(v: float64): DbValue
• postgres: proc dbValue[T](v: Option[T]): DbValue
• postgres: proc dbValue(v: string): DbValue
• postgres: proc dbValue(v: SomeSignedInt | uint8 | uint16 | uint32 | enum): DbValue
• postgres: proc dbValue(v: DbNull | type(nil)): DbValue

DbValue:

• sqlite: object DbValue

dbValue:

• sqlite: proc dbValue(v: DbBlob): DbValue
• sqlite: proc dbValue(v: DbValue): DbValue
• sqlite: proc dbValue(v: float64): DbValue
• sqlite: proc dbValue[T](v: Option[T]): DbValue
• sqlite: proc dbValue(v: string): DbValue
• sqlite: proc dbValue(v: SomeSignedInt | uint8 | uint16 | uint32 | enum): DbValue
• sqlite: proc dbValue(v: DbNull | type(nil)): DbValue

DbValueKind:

• postgres: enum DbValueKind
• sqlite: enum DbValueKind

DbValueTypes:

• postgres: type DbValueTypes
• sqlite: type DbValueTypes

dvkBlob:

• sqlite: DbValueKind.dvkBlob

dvkBool:

• postgres: DbValueKind.dvkBool

dvkFloat:

• postgres: DbValueKind.dvkFloat
• sqlite: DbValueKind.dvkFloat

dvkInt:

• postgres: DbValueKind.dvkInt
• sqlite: DbValueKind.dvkInt

dvkNull:

• postgres: DbValueKind.dvkNull
• sqlite: DbValueKind.dvkNull

dvkOther:

• postgres: DbValueKind.dvkOther

dvkString:

• postgres: DbValueKind.dvkString
• sqlite: DbValueKind.dvkString

dvkTimestamptz:

• postgres: DbValueKind.dvkTimestamptz

ERROR_MSG_LENGTH:

• libpq: const ERROR_MSG_LENGTH

exec:

• postgres: proc exec(db: DbConn; query: SqlQuery; args: varargs[DbValue, dbValue])
• sqlite: proc exec(db: DbConn; query: SqlQuery; args: varargs[DbValue, dbValue])

execAffectedRows:

• sqlite: proc execAffectedRows(db: DbConn; query: SqlQuery; args: varargs[DbValue, dbValue]): int64

ExecStatusType:

• libpq: enum ExecStatusType

fastRows:

• postgres: iterator fastRows(db: DbConn; query: SqlQuery; args: varargs[DbValue, dbValue]): Row
• sqlite: iterator fastRows(db: DbConn; query: SqlQuery; args: varargs[DbValue, dbValue]): Row

getAllRows:

• postgres: proc getAllRows(db: DbConn; query: SqlQuery; args: varargs[DbValue, dbValue]): seq[ Row]
• sqlite: proc getAllRows(db: DbConn; query: SqlQuery; args: varargs[DbValue, dbValue]): seq[ Row]

getRow:

• postgres: proc getRow(db: DbConn; query: SqlQuery; args: varargs[DbValue, dbValue]): Option[Row]
• sqlite: proc getRow(db: DbConn; query: SqlQuery; args: varargs[DbValue, dbValue]): Option[Row]

getValue:

• sqlite: proc getValue[T: DbValueTypes | DbValue](db: DbConn; query: SqlQuery; args: varargs[DbValue, dbValue]): Option[T]
• sqlite: proc getValue(db: DbConn; T: typedesc; query: SqlQuery; args: varargs[DbValue, dbValue]): Option[T]

insertID:

• postgres: proc insertID(db: DbConn; query: SqlQuery; args: varargs[DbValue, dbValue]): int64
• sqlite: proc insertID(db: DbConn; query: SqlQuery; args: varargs[DbValue, dbValue]): int64

InstantRow:

• postgres: object InstantRow
• sqlite: type InstantRow

instantRows:

• sqlite: iterator instantRows(db: DbConn; columns: var DbColumns; query: SqlQuery; args: varargs[DbValue, dbValue]): InstantRow
• sqlite: iterator instantRows(db: DbConn; query: SqlQuery; args: varargs[DbValue, dbValue]): InstantRow

len:

• sqlite: proc len(row: InstantRow): int32

lo_close:

• libpq: proc lo_close(conn: PPGconn; fd: int32): int32

lo_creat:

• libpq: proc lo_creat(conn: PPGconn; mode: int32): Oid

lo_export:

• libpq: proc lo_export(conn: PPGconn; lobjId: Oid; filename: cstring): int32

lo_import:

• libpq: proc lo_import(conn: PPGconn; filename: cstring): Oid

lo_lseek:

• libpq: proc lo_lseek(conn: PPGconn; fd: int32; offset: int32; whence: int32): int32

lo_open:

• libpq: proc lo_open(conn: PPGconn; lobjId: Oid; mode: int32): int32

lo_read:

• libpq: proc lo_read(conn: PPGconn; fd: int32; buf: cstring; length: int): int32

lo_tell:

• libpq: proc lo_tell(conn: PPGconn; fd: int32): int32

lo_unlink:

• libpq: proc lo_unlink(conn: PPGconn; lobjId: Oid): int32

lo_write:

• libpq: proc lo_write(conn: PPGconn; fd: int32; buf: cstring; length: int): int32

Oid:

• libpq: type Oid

open:

• postgres: proc open(connection, user, password, database: string): DbConn
• sqlite: proc open(connection, user, password, database: string): DbConn

PConnStatusType:

• libpq: type PConnStatusType

PExecStatusType:

• libpq: type PExecStatusType

PGconn:

• libpq: object PGconn

PGlobjfuncs:

• libpq: object PGlobjfuncs

pgNotify:

• libpq: object pgNotify

PGresAttDesc:

• libpq: object PGresAttDesc

PGresAttValue:

• libpq: object PGresAttValue

PGRES_BAD_RESPONSE:

• libpq: ExecStatusType.PGRES_BAD_RESPONSE

PGRES_COMMAND_OK:

• libpq: ExecStatusType.PGRES_COMMAND_OK

PGRES_COPY_IN:

• libpq: ExecStatusType.PGRES_COPY_IN

PGRES_COPY_OUT:

• libpq: ExecStatusType.PGRES_COPY_OUT

PGRES_EMPTY_QUERY:

• libpq: ExecStatusType.PGRES_EMPTY_QUERY

PGRES_FATAL_ERROR:

• libpq: ExecStatusType.PGRES_FATAL_ERROR

PGRES_NONFATAL_ERROR:

• libpq: ExecStatusType.PGRES_NONFATAL_ERROR

PGRES_POLLING_ACTIVE:

• libpq: PostgresPollingStatusType.PGRES_POLLING_ACTIVE

PGRES_POLLING_FAILED:

• libpq: PostgresPollingStatusType.PGRES_POLLING_FAILED

PGRES_POLLING_OK:

• libpq: PostgresPollingStatusType.PGRES_POLLING_OK

PGRES_POLLING_READING:

• libpq: PostgresPollingStatusType.PGRES_POLLING_READING

PGRES_POLLING_WRITING:

• libpq: PostgresPollingStatusType.PGRES_POLLING_WRITING

PGRES_TUPLES_OK:

• libpq: ExecStatusType.PGRES_TUPLES_OK

PGresult:

• libpq: object PGresult

PGTransactionStatusType:

• libpq: enum PGTransactionStatusType

PGVerbosity:

• libpq: enum PGVerbosity

POid:

• libpq: type POid

PostgresPollingStatusType:

• libpq: enum PostgresPollingStatusType

PostgreSQL:

• postgres: Module postgres

PPGconn:

• libpq: type PPGconn

PPGlobjfuncs:

• libpq: type PPGlobjfuncs

PPGNotify:

• libpq: type PPGNotify

PPGresAttDesc:

• libpq: type PPGresAttDesc

PPGresAttValue:

• libpq: type PPGresAttValue

PPGresult:

• libpq: type PPGresult

PPGTransactionStatusType:

• libpq: type PPGTransactionStatusType

PPGVerbosity:

• libpq: type PPGVerbosity

PPostgresPollingStatusType:

• libpq: type PPostgresPollingStatusType

PPPGresAttDesc:

• libpq: type PPPGresAttDesc

PPPGresAttValue:

• libpq: type PPPGresAttValue

PPQArgBlock:

• libpq: type PPQArgBlock

Ppqbool:

• libpq: type Ppqbool

PPQconninfoOption:

• libpq: type PPQconninfoOption

PPQprintOpt:

• libpq: type PPQprintOpt

PQArgBlock:

• libpq: object PQArgBlock

pqbackendPID:

• libpq: proc pqbackendPID(conn: PPGconn): int32

pqbinaryTuples:

• libpq: proc pqbinaryTuples(res: PPGresult): int32

pqbool:

• libpq: type pqbool

pqclear:

• libpq: proc pqclear(res: PPGresult)

pqclientEncoding:

• libpq: proc pqclientEncoding(conn: PPGconn): int32

pqcmdStatus:

• libpq: proc pqcmdStatus(res: PPGresult): cstring

pqcmdTuples:

• libpq: proc pqcmdTuples(res: PPGresult): cstring

pqconndefaults:

• libpq: proc pqconndefaults(): PPQconninfoOption

pqconnectdb:

• libpq: proc pqconnectdb(conninfo: cstring): PPGconn

pqconnectPoll:

• libpq: proc pqconnectPoll(conn: PPGconn): PostgresPollingStatusType

pqconnectStart:

• libpq: proc pqconnectStart(conninfo: cstring): PPGconn

pqconninfoFree:

• libpq: proc pqconninfoFree(connOptions: PPQconninfoOption)

PQconninfoOption:

• libpq: object PQconninfoOption

pqconsumeInput:

• libpq: proc pqconsumeInput(conn: PPGconn): int32

pqdb:

• libpq: proc pqdb(conn: PPGconn): cstring

pqdisplayTuples:

• libpq: proc pqdisplayTuples(res: PPGresult; fp: File; fillAlign: int32; fieldSep: cstring; printHeader: int32; quiet: int32)

pqendcopy:

• libpq: proc pqendcopy(conn: PPGconn): int32

pqenv2encoding:

• libpq: proc pqenv2encoding(): int32

pqerrorMessage:

• libpq: proc pqerrorMessage(conn: PPGconn): cstring

PQERRORS_DEFAULT:

• libpq: PGVerbosity.PQERRORS_DEFAULT

PQERRORS_TERSE:

• libpq: PGVerbosity.PQERRORS_TERSE

PQERRORS_VERBOSE:

• libpq: PGVerbosity.PQERRORS_VERBOSE

pqescapeBytea:

• libpq: proc pqescapeBytea(bintext: cstring; binlen: int; bytealen: var int): cstring

pqescapeString:

• libpq: proc pqescapeString(till, from: cstring; len: int): int

pqexec:

• libpq: proc pqexec(conn: PPGconn; query: cstring): PPGresult

pqexecParams:

• libpq: proc pqexecParams(conn: PPGconn; command: cstring; nParams: int; paramTypes: POid; paramValues: cstringArray; paramLengths, paramFormats: ptr int32; resultFormat: int32): PPGresult

pqexecPrepared:

• libpq: proc pqexecPrepared(conn: PPGconn; stmtName: cstring; nParams: int32; paramValues: cstringArray; paramLengths, paramFormats: ptr int32; resultFormat: int32): PPGresult

pqfformat:

• libpq: proc pqfformat(res: PPGresult; field_num: int32): int32

pqfinish:

• libpq: proc pqfinish(conn: PPGconn)

pqflush:

• libpq: proc pqflush(conn: PPGconn): int32

pqfmod:

• libpq: proc pqfmod(res: PPGresult; field_num: int32): int32

pqfn:

• libpq: proc pqfn(conn: PPGconn; fnid: int32; result_buf, result_len: ptr int32; result_is_int: int32; args: PPQArgBlock; nargs: int32): PPGresult

pqfname:

• libpq: proc pqfname(res: PPGresult; field_num: int32): cstring

pqfnumber:

• libpq: proc pqfnumber(res: PPGresult; field_name: cstring): int32

pqfreemem:

• libpq: proc pqfreemem(p: pointer)

pqfsize:

• libpq: proc pqfsize(res: PPGresult; field_num: int32): int32

pqftable:

• libpq: proc pqftable(res: PPGresult; field_num: int32): Oid

pqftablecol:

• libpq: proc pqftablecol(res: PPGresult; field_num: int32): int32

pqftype:

• libpq: proc pqftype(res: PPGresult; field_num: int32): Oid

pqgetCopyData:

• libpq: proc pqgetCopyData(conn: PPGconn; buffer: cstringArray; async: int32): int32

pqgetisnull:

• libpq: proc pqgetisnull(res: PPGresult; tup_num: int32; field_num: int32): int32

pqgetlength:

• libpq: proc pqgetlength(res: PPGresult; tup_num: int32; field_num: int32): int32

pqgetline:

• libpq: proc pqgetline(conn: PPGconn; str: cstring; len: int32): int32

pqgetlineAsync:

• libpq: proc pqgetlineAsync(conn: PPGconn; buffer: cstring; bufsize: int32): int32

pqgetResult:

• libpq: proc pqgetResult(conn: PPGconn): PPGresult

pqgetvalue:

• libpq: proc pqgetvalue(res: PPGresult; tup_num: int32; field_num: int32): cstring

pqhost:

• libpq: proc pqhost(conn: PPGconn): cstring

pqinitOpenSSL:

• libpq: proc pqinitOpenSSL(do_ssl: int32; do_crypto: int32)

pqisBusy:

• libpq: proc pqisBusy(conn: PPGconn): int32

pqisnonblocking:

• libpq: proc pqisnonblocking(conn: PPGconn): int32

pqmakeEmptyPGresult:

• libpq: proc pqmakeEmptyPGresult(conn: PPGconn; status: ExecStatusType): PPGresult

pqmblen:

• libpq: proc pqmblen(s: cstring; encoding: int32): int32

pqnfields:

• libpq: proc pqnfields(res: PPGresult): int32

PQnoticeProcessor:

• libpq: type PQnoticeProcessor

PQnoticeReceiver:

• libpq: type PQnoticeReceiver

pqnotifies:

• libpq: proc pqnotifies(conn: PPGconn): PPGNotify

pqntuples:

• libpq: proc pqntuples(res: PPGresult): int32

pqoidStatus:

• libpq: proc pqoidStatus(res: PPGresult): cstring

pqoidValue:

• libpq: proc pqoidValue(res: PPGresult): Oid

pqoptions:

• libpq: proc pqoptions(conn: PPGconn): cstring

pqparameterStatus:

• libpq: proc pqparameterStatus(conn: PPGconn; paramName: cstring): cstring

pqpass:

• libpq: proc pqpass(conn: PPGconn): cstring

pqport:

• libpq: proc pqport(conn: PPGconn): cstring

pqprepare:

• libpq: proc pqprepare(conn: PPGconn; stmtName, query: cstring; nParams: int32; paramTypes: POid): PPGresult

pqprint:

• libpq: proc pqprint(fout: File; res: PPGresult; ps: PPQprintOpt)

PQprintOpt:

• libpq: object PQprintOpt

pqprintTuples:

• libpq: proc pqprintTuples(res: PPGresult; fout: File; printAttName: int32; terseOutput: int32; width: int32)

pqprotocolVersion:

• libpq: proc pqprotocolVersion(conn: PPGconn): int32

pqputCopyData:

• libpq: proc pqputCopyData(conn: PPGconn; buffer: cstring; nbytes: int32): int32

pqputCopyEnd:

• libpq: proc pqputCopyEnd(conn: PPGconn; errormsg: cstring): int32

pqputline:

• libpq: proc pqputline(conn: PPGconn; str: cstring): int32

pqputnbytes:

• libpq: proc pqputnbytes(conn: PPGconn; buffer: cstring; nbytes: int32): int32

pqrequestCancel:

• libpq: proc pqrequestCancel(conn: PPGconn): int32

pqreset:

• libpq: proc pqreset(conn: PPGconn)

pqresetPoll:

• libpq: proc pqresetPoll(conn: PPGconn): PostgresPollingStatusType

pqresetStart:

• libpq: proc pqresetStart(conn: PPGconn): int32

pqresStatus:

• libpq: proc pqresStatus(status: ExecStatusType): cstring

pqresultErrorField:

• libpq: proc pqresultErrorField(res: PPGresult; fieldcode: int32): cstring

pqresultErrorMessage:

• libpq: proc pqresultErrorMessage(res: PPGresult): cstring

pqresultStatus:

• libpq: proc pqresultStatus(res: PPGresult): ExecStatusType

pqsendQuery:

• libpq: proc pqsendQuery(conn: PPGconn; query: cstring): int32

pqsendQueryParams:

• libpq: proc pqsendQueryParams(conn: PPGconn; command: cstring; nParams: int32; paramTypes: POid; paramValues: cstringArray; paramLengths, paramFormats: ptr int32; resultFormat: int32): int32

pqsendQueryPrepared:

• libpq: proc pqsendQueryPrepared(conn: PPGconn; stmtName: cstring; nParams: int32; paramValues: cstringArray; paramLengths, paramFormats: ptr int32; resultFormat: int32): int32

pqsetClientEncoding:

• libpq: proc pqsetClientEncoding(conn: PPGconn; encoding: cstring): int32

pqsetdb:

• libpq: proc pqsetdb(M_PGHOST, M_PGPORT, M_PGOPT, M_PGTTY, M_DBNAME: cstring): PPGconn

pqsetdbLogin:

• libpq: proc pqsetdbLogin(pghost: cstring; pgport: cstring; pgoptions: cstring; pgtty: cstring; dbName: cstring; login: cstring; pwd: cstring): PPGconn

pqsetErrorVerbosity:

• libpq: proc pqsetErrorVerbosity(conn: PPGconn; verbosity: PGVerbosity): PGVerbosity

pqsetnonblocking:

• libpq: proc pqsetnonblocking(conn: PPGconn; arg: int32): int32

pqsetNoticeProcessor:

• libpq: proc pqsetNoticeProcessor(conn: PPGconn; theProc: PQnoticeProcessor; arg: pointer): PQnoticeProcessor

pqsetNoticeReceiver:

• libpq: proc pqsetNoticeReceiver(conn: PPGconn; theProc: PQnoticeReceiver; arg: pointer): PQnoticeReceiver

pqsocket:

• libpq: proc pqsocket(conn: PPGconn): int32

pqstatus:

• libpq: proc pqstatus(conn: PPGconn): ConnStatusType

pqtrace:

• libpq: proc pqtrace(conn: PPGconn; debug_port: File)

pqtransactionStatus:

• libpq: proc pqtransactionStatus(conn: PPGconn): PGTransactionStatusType

PQTRANS_ACTIVE:

• libpq: PGTransactionStatusType.PQTRANS_ACTIVE

PQTRANS_IDLE:

• libpq: PGTransactionStatusType.PQTRANS_IDLE

PQTRANS_INERROR:

• libpq: PGTransactionStatusType.PQTRANS_INERROR

PQTRANS_INTRANS:

• libpq: PGTransactionStatusType.PQTRANS_INTRANS

PQTRANS_UNKNOWN:

• libpq: PGTransactionStatusType.PQTRANS_UNKNOWN

pqtty:

• libpq: proc pqtty(conn: PPGconn): cstring

pqunescapeBytea:

• libpq: proc pqunescapeBytea(strtext: cstring; retbuflen: var int): cstring

pquntrace:

• libpq: proc pquntrace(conn: PPGconn)

pquser:

• libpq: proc pquser(conn: PPGconn): cstring

Row:

• postgres: type Row
• sqlite: type Row

RowOld:

• postgres: type RowOld

rows:

• postgres: iterator rows(db: DbConn; query: SqlQuery; args: varargs[DbValue, dbValue]): Row
• sqlite: iterator rows(db: DbConn; query: SqlQuery; args: varargs[DbValue, dbValue]): Row

setEncoding:

• postgres: proc setEncoding(connection: DbConn; encoding: string): bool
• sqlite: proc setEncoding(connection: DbConn; encoding: string): bool

SockAddr:

• libpq: type SockAddr

SQLite:

• sqlite: Module sqlite

SqlPrepared:

• postgres: type SqlPrepared

tryExec:

• sqlite: proc tryExec(db: DbConn; query: SqlQuery; args: varargs[DbValue, dbValue]): bool

tryInsertID:

• sqlite: proc tryInsertID(db: DbConn; query: SqlQuery; args: varargs[DbValue, dbValue]): int64