async_postgres/pg_types/accessors

Search:
Group by:

Procs

proc `$`(cr: CommandResult): string {.inline, ...raises: [], tags: [], forbids: [].}
proc `==`(cr: CommandResult; s: string): bool {.inline, ...raises: [], tags: [],
    forbids: [].}
proc `[]`(row: Row; col: int): Option[seq[byte]] {....raises: [PgTypeError],
    tags: [], forbids: [].}
Backward-compatible cell access. Returns a copy of the cell data. 
proc affectedRows(cr: CommandResult): int64 {.inline, ...raises: [], tags: [],
    forbids: [].}
Extract the number of affected rows from the command result. 
proc columnIndex(fields: seq[FieldDescription]; name: string): int {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
Find the index of a column by name. Raises PgTypeError if not found. 
proc columnIndex(row: Row; name: string): int {....raises: [PgTypeError], tags: [],
    forbids: [].}
Find the index of a column by name using a cached name→index table on the row's underlying RowData. The table is built lazily on first access. Raises PgTypeError if the metadata is not available (e.g. the Row was constructed manually) or the column name is not found. 
proc columnMap(fields: seq[FieldDescription]): Table[string, int] {....raises: [],
    tags: [], forbids: [].}
Build a name-to-index mapping for all columns. 
proc contains(cr: CommandResult; s: string): bool {.inline, ...raises: [],
    tags: [], forbids: [].}
Check if the command tag contains the given string. 
proc get(row: Row; col: int; T: typedesc[bool]): bool
proc get(row: Row; col: int; T: typedesc[float32]): float32
proc get(row: Row; col: int; T: typedesc[float64]): float64
proc get(row: Row; col: int; T: typedesc[int16]): int16
Generic typed accessor. Usage: row.get(0, int16) 
proc get(row: Row; col: int; T: typedesc[int32]): int32
Generic typed accessor. Usage: row.get(0, int32) 
proc get(row: Row; col: int; T: typedesc[int64]): int64
proc get(row: Row; col: int; T: typedesc[JsonNode]): JsonNode
proc get(row: Row; col: int; T: typedesc[PgBit]): PgBit
proc get(row: Row; col: int; T: typedesc[PgBox]): PgBox
proc get(row: Row; col: int; T: typedesc[PgCidr]): PgCidr
proc get(row: Row; col: int; T: typedesc[PgCircle]): PgCircle
proc get(row: Row; col: int; T: typedesc[PgHstore]): PgHstore
proc get(row: Row; col: int; T: typedesc[PgInet]): PgInet
proc get(row: Row; col: int; T: typedesc[PgInterval]): PgInterval
proc get(row: Row; col: int; T: typedesc[PgLine]): PgLine
proc get(row: Row; col: int; T: typedesc[PgLseg]): PgLseg
proc get(row: Row; col: int; T: typedesc[PgMacAddr8]): PgMacAddr8
proc get(row: Row; col: int; T: typedesc[PgMacAddr]): PgMacAddr
proc get(row: Row; col: int; T: typedesc[PgMoney]; conv: PgMoneyConventions): PgMoney
Generic money accessor under known lc_monetary conventions. 
proc get(row: Row; col: int; T: typedesc[PgMoney]; scale: int = 2): PgMoney
Generic money accessor with scale forwarding. Defaults to 2; pass the server lc_monetary frac_digits when it differs. 
proc get(row: Row; col: int; T: typedesc[PgNumeric]): PgNumeric
proc get(row: Row; col: int; T: typedesc[PgPath]): PgPath
proc get(row: Row; col: int; T: typedesc[PgPoint]): PgPoint
proc get(row: Row; col: int; T: typedesc[PgPolygon]): PgPolygon
proc get(row: Row; col: int; T: typedesc[PgTime]): PgTime
proc get(row: Row; col: int; T: typedesc[PgTimeTz]): PgTimeTz
proc get(row: Row; col: int; T: typedesc[PgTsQuery]): PgTsQuery
proc get(row: Row; col: int; T: typedesc[PgTsVector]): PgTsVector
proc get(row: Row; col: int; T: typedesc[PgUuid]): PgUuid
proc get(row: Row; col: int; T: typedesc[PgXml]): PgXml
proc get(row: Row; col: int; T: typedesc[seq[bool]]): seq[bool]
proc get(row: Row; col: int; T: typedesc[seq[byte]]): seq[byte]
proc get(row: Row; col: int; T: typedesc[seq[float32]]): seq[float32]
proc get(row: Row; col: int; T: typedesc[seq[float64]]): seq[float64]
proc get(row: Row; col: int; T: typedesc[seq[int16]]): seq[int16]
proc get(row: Row; col: int; T: typedesc[seq[int32]]): seq[int32]
proc get(row: Row; col: int; T: typedesc[seq[int64]]): seq[int64]
proc get(row: Row; col: int; T: typedesc[seq[JsonNode]]): seq[JsonNode]
proc get(row: Row; col: int; T: typedesc[seq[Option[bool]]]): seq[Option[bool]]
proc get(row: Row; col: int; T: typedesc[seq[Option[float32]]]): seq[
    Option[float32]]
proc get(row: Row; col: int; T: typedesc[seq[Option[float64]]]): seq[
    Option[float64]]
proc get(row: Row; col: int; T: typedesc[seq[Option[int16]]]): seq[Option[int16]]
proc get(row: Row; col: int; T: typedesc[seq[Option[int32]]]): seq[Option[int32]]
proc get(row: Row; col: int; T: typedesc[seq[Option[int64]]]): seq[Option[int64]]
proc get(row: Row; col: int; T: typedesc[seq[Option[string]]]): seq[
    Option[string]]
proc get(row: Row; col: int; T: typedesc[seq[PgBit]]): seq[PgBit]
proc get(row: Row; col: int; T: typedesc[seq[PgBox]]): seq[PgBox]
proc get(row: Row; col: int; T: typedesc[seq[PgCidr]]): seq[PgCidr]
proc get(row: Row; col: int; T: typedesc[seq[PgCircle]]): seq[PgCircle]
proc get(row: Row; col: int; T: typedesc[seq[PgHstore]]): seq[PgHstore]
proc get(row: Row; col: int; T: typedesc[seq[PgInet]]): seq[PgInet]
proc get(row: Row; col: int; T: typedesc[seq[PgInterval]]): seq[PgInterval]
proc get(row: Row; col: int; T: typedesc[seq[PgLine]]): seq[PgLine]
proc get(row: Row; col: int; T: typedesc[seq[PgLseg]]): seq[PgLseg]
proc get(row: Row; col: int; T: typedesc[seq[PgMacAddr8]]): seq[PgMacAddr8]
proc get(row: Row; col: int; T: typedesc[seq[PgMacAddr]]): seq[PgMacAddr]
proc get(row: Row; col: int; T: typedesc[seq[PgMoney]]; conv: PgMoneyConventions): seq[
    PgMoney]
Generic money array accessor under known lc_monetary conventions. 
proc get(row: Row; col: int; T: typedesc[seq[PgMoney]]; scale: int = 2): seq[
    PgMoney]
Generic money array accessor with scale forwarding. 
proc get(row: Row; col: int; T: typedesc[seq[PgNumeric]]): seq[PgNumeric]
proc get(row: Row; col: int; T: typedesc[seq[PgPath]]): seq[PgPath]
proc get(row: Row; col: int; T: typedesc[seq[PgPoint]]): seq[PgPoint]
proc get(row: Row; col: int; T: typedesc[seq[PgPolygon]]): seq[PgPolygon]
proc get(row: Row; col: int; T: typedesc[seq[PgTime]]): seq[PgTime]
proc get(row: Row; col: int; T: typedesc[seq[PgTimeTz]]): seq[PgTimeTz]
proc get(row: Row; col: int; T: typedesc[seq[PgTsQuery]]): seq[PgTsQuery]
proc get(row: Row; col: int; T: typedesc[seq[PgTsVector]]): seq[PgTsVector]
proc get(row: Row; col: int; T: typedesc[seq[PgUuid]]): seq[PgUuid]
proc get(row: Row; col: int; T: typedesc[seq[PgXml]]): seq[PgXml]
proc get(row: Row; col: int; T: typedesc[seq[seq[byte]]]): seq[seq[byte]]
proc get(row: Row; col: int; T: typedesc[seq[string]]): seq[string]
proc get(row: Row; col: int; T: typedesc[string]): string
proc get(row: Row; name: string; T: typedesc[PgMoney]; conv: PgMoneyConventions): PgMoney
Generic money accessor by column name under known conventions. 
proc get(row: Row; name: string; T: typedesc[PgMoney]; scale: int = 2): PgMoney
Generic money accessor by column name with scale forwarding. 
proc get(row: Row; name: string; T: typedesc[seq[PgMoney]];
         conv: PgMoneyConventions): seq[PgMoney]
Generic money array accessor by column name under known conventions. 
proc get(row: Row; name: string; T: typedesc[seq[PgMoney]]; scale: int = 2): seq[
    PgMoney]
Generic money array accessor by column name with scale forwarding. 
proc get[T](row: Row; name: string; _: typedesc[T]): T
Generic typed accessor by column name. Usage: row.get("id", int32) 
proc getArrayND[T](row: Row; col: int): PgArray[T]

Read an N-dimensional PostgreSQL array column as a PgArray[T]. Requires binary column format; text-format multi-dimensional arrays are not supported. Raises PgTypeError when the column is NULL, or when the wire elemOid does not match the registered OID for T (JsonNode: json/jsonb; string: all character types; PgBit: bit/varbit).

Validation looks only at the wire elemOid carried in the array payload, not at the column's field OID from RowDescription. A bind mismatch (e.g. reading a text[] column as getArrayND[int32]) is caught by the elemOid check; reading e.g. int4[] via getArrayND[int32] against a column declared as int8[] succeeds as long as the wire bytes match the requested T. For JsonNode, the leading jsonb version byte is stripped only when elemOid == jsonb; json payloads pass through unchanged, and any other wire elemOid (e.g. int4) is rejected by the OID check so calling getArrayND[JsonNode] on a non-JSON column raises rather than silently misinterpreting the bytes.

proc getArrayNDOpt[T](row: Row; col: int): Option[PgArray[T]]
NULL-safe column-level variant of getArrayND[T]. 
proc getBit(row: Row; col: int): PgBit {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
Get a column value as PgBit. Handles both text and binary format. In binary format the column OID must be bit or varbit. 
proc getBitArray(row: Row; col: int): seq[PgBit] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getBitArrayOpt(row`gensym509: Row; col`gensym509: int): Option[seq[PgBit]] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getBitOpt(row`gensym219: Row; col`gensym219: int): Option[PgBit] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getBool(row: Row; col: int): bool {.
    ...raises: [PgTypeError, PgProtocolError, PgTypeError], tags: [], forbids: [].}
Get a column value as bool. Handles binary format directly. Raises PgTypeError on NULL. In binary format the column OID must be bool. 
proc getBoolArray(row: Row; col: int): seq[bool] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getBoolArrayElemOpt(row: Row; col: int): seq[Option[bool]] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getBoolArrayElemOptOpt(row`gensym541: Row; col`gensym541: int): Option[
    seq[Option[bool]]] {....raises: [PgTypeError, PgError, PgProtocolError],
                         tags: [], forbids: [].}
proc getBoolArrayOpt(row`gensym507: Row; col`gensym507: int): Option[seq[bool]] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getBoolOpt(row`gensym201: Row; col`gensym201: int): Option[bool] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}
proc getBox(row: Row; col: int): PgBox {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
Get a column value as PgBox. Handles binary format. In binary format the column OID must be box. 
proc getBoxArray(row: Row; col: int): seq[PgBox] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getBoxArrayOpt(row`gensym528: Row; col`gensym528: int): Option[seq[PgBox]] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getBoxOpt(row`gensym224: Row; col`gensym224: int): Option[PgBox] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getBytes(row: Row; col: int): seq[byte] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}
Get a column value as raw bytes. Decodes bytea text output in both hex (\xDEADBEEF) and legacy escape formats. Raises PgTypeError on NULL. In binary format the column OID must be bytea. 
proc getBytesArray(row: Row; col: int): seq[seq[byte]] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getBytesArrayOpt(row`gensym523: Row; col`gensym523: int): Option[
    seq[seq[byte]]] {....raises: [PgTypeError, PgError, PgProtocolError], tags: [],
                      forbids: [].}
proc getBytesOpt(row`gensym202: Row; col`gensym202: int): Option[seq[byte]] {.
    ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}
proc getCidr(row: Row; col: int): PgCidr {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
Get a column value as PgCidr (CIDR network address). Handles binary format. In binary format the column OID must be cidr. 
proc getCidrArray(row: Row; col: int): seq[PgCidr] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getCidrArrayOpt(row`gensym518: Row; col`gensym518: int): Option[seq[PgCidr]] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getCidrOpt(row`gensym213: Row; col`gensym213: int): Option[PgCidr] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getCircle(row: Row; col: int): PgCircle {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
Get a column value as PgCircle. Handles binary format. In binary format the column OID must be circle. 
proc getCircleArray(row: Row; col: int): seq[PgCircle] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getCircleArrayOpt(row`gensym531: Row; col`gensym531: int): Option[
    seq[PgCircle]] {....raises: [PgTypeError, PgError, PgProtocolError], tags: [],
                     forbids: [].}
proc getCircleOpt(row`gensym227: Row; col`gensym227: int): Option[PgCircle] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getDate(row: Row; col: int): DateTime {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [TimeEffect],
    forbids: [].}
Get a column value as DateTime. Handles binary date format. In binary format the column OID must be date. 
proc getDateArray(row: Row; col: int): seq[DateTime] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [TimeEffect],
    forbids: [].}
proc getDateArrayOpt(row`gensym512: Row; col`gensym512: int): Option[
    seq[DateTime]] {....raises: [PgTypeError, PgError, PgProtocolError],
                     tags: [TimeEffect], forbids: [].}
proc getDateOpt(row`gensym207: Row; col`gensym207: int): Option[DateTime] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [TimeEffect],
    forbids: [].}
proc getFloat(row: Row; col: int): float64 {....raises: [PgTypeError], tags: [],
    forbids: [].}
Get a column value as float64. Handles binary float4/8 directly. Raises PgTypeError on NULL. In binary format the column OID must be float8 or float4. 
proc getFloat32(row: Row; col: int): float32 {....raises: [PgTypeError], tags: [],
    forbids: [].}
Get a column value as float32. Handles binary float4 directly. Raises PgTypeError on NULL. In binary format the column OID must be float4. 
proc getFloat32Array(row: Row; col: int): seq[float32] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getFloat32ArrayElemOpt(row: Row; col: int): seq[Option[float32]] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getFloat32ArrayElemOptOpt(row`gensym540: Row; col`gensym540: int): Option[
    seq[Option[float32]]] {....raises: [PgTypeError, PgError, PgProtocolError],
                            tags: [], forbids: [].}
proc getFloat32ArrayOpt(row`gensym506: Row; col`gensym506: int): Option[
    seq[float32]] {....raises: [PgTypeError, PgError, PgProtocolError], tags: [],
                    forbids: [].}
proc getFloat32Opt(row`gensym197: Row; col`gensym197: int): Option[float32] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getFloatArray(row: Row; col: int): seq[float64] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getFloatArrayElemOpt(row: Row; col: int): seq[Option[float64]] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getFloatArrayElemOptOpt(row`gensym539: Row; col`gensym539: int): Option[
    seq[Option[float64]]] {....raises: [PgTypeError, PgError, PgProtocolError],
                            tags: [], forbids: [].}
proc getFloatArrayOpt(row`gensym505: Row; col`gensym505: int): Option[
    seq[float64]] {....raises: [PgTypeError, PgError, PgProtocolError], tags: [],
                    forbids: [].}
proc getFloatOpt(row`gensym196: Row; col`gensym196: int): Option[float64] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getHstore(row: Row; col: int): PgHstore {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
Get a column value as PgHstore. Handles both text and binary format. hstore uses a dynamic OID assigned at CREATE EXTENSION time, so no column OID check applies here (mirrors anyArrayElemOid on the array path). 
proc getHstoreArray(row: Row; col: int): seq[PgHstore] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getHstoreArrayOpt(row`gensym535: Row; col`gensym535: int): Option[
    seq[PgHstore]] {....raises: [PgTypeError, PgError, PgProtocolError], tags: [],
                     forbids: [].}
proc getHstoreOpt(row`gensym220: Row; col`gensym220: int): Option[PgHstore] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getInet(row: Row; col: int): PgInet {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
Get a column value as PgInet (IP address with mask). Handles binary format. In binary format the column OID must be inet. 
proc getInetArray(row: Row; col: int): seq[PgInet] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getInetArrayOpt(row`gensym517: Row; col`gensym517: int): Option[seq[PgInet]] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getInetOpt(row`gensym212: Row; col`gensym212: int): Option[PgInet] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getInt(row: Row; col: int): int32 {....raises: [PgTypeError, PgTypeError],
    tags: [], forbids: [].}
Get a column value as int32. Handles binary int2/int4 directly. Raises PgTypeError on NULL. In binary format the column OID must be int2 or int4; other same-length types (e.g. float4, date) raise PgTypeError instead of decoding silently. 
proc getInt16(row: Row; col: int): int16 {....raises: [PgTypeError, PgTypeError],
    tags: [], forbids: [].}
Get a column value as int16. Handles binary int2 directly. Raises PgTypeError on NULL. In binary format the column OID must be int2. 
proc getInt16Array(row: Row; col: int): seq[int16] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getInt16ArrayElemOpt(row: Row; col: int): seq[Option[int16]] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getInt16ArrayElemOptOpt(row`gensym537: Row; col`gensym537: int): Option[
    seq[Option[int16]]] {....raises: [PgTypeError, PgError, PgProtocolError],
                          tags: [], forbids: [].}
proc getInt16ArrayOpt(row`gensym503: Row; col`gensym503: int): Option[seq[int16]] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getInt16Opt(row`gensym194: Row; col`gensym194: int): Option[int16] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getInt64(row: Row; col: int): int64 {....raises: [PgTypeError, PgTypeError],
    tags: [], forbids: [].}
Get a column value as int64. Handles binary int2/4/8 directly. Raises PgTypeError on NULL. In binary format the column OID must be int8, int4, or int2. 
proc getInt64Array(row: Row; col: int): seq[int64] {.
    ...raises: [PgTypeError, PgError, PgProtocolError, CatchableError], tags: [],
    forbids: [].}
proc getInt64ArrayElemOpt(row: Row; col: int): seq[Option[int64]] {.
    ...raises: [PgTypeError, PgError, PgProtocolError, CatchableError], tags: [],
    forbids: [].}
proc getInt64ArrayElemOptOpt(row`gensym538: Row; col`gensym538: int): Option[
    seq[Option[int64]]] {....raises: [PgTypeError, PgError, PgProtocolError,
                                   CatchableError], tags: [], forbids: [].}
proc getInt64ArrayOpt(row`gensym504: Row; col`gensym504: int): Option[seq[int64]] {.
    ...raises: [PgTypeError, PgError, PgProtocolError, CatchableError], tags: [],
    forbids: [].}
proc getInt64Opt(row`gensym195: Row; col`gensym195: int): Option[int64] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getIntArray(row: Row; col: int): seq[int32] {.
    ...raises: [PgTypeError, PgError, PgProtocolError, CatchableError], tags: [],
    forbids: [].}
proc getIntArrayElemOpt(row: Row; col: int): seq[Option[int32]] {.
    ...raises: [PgTypeError, PgError, PgProtocolError, CatchableError], tags: [],
    forbids: [].}
proc getIntArrayElemOptOpt(row`gensym536: Row; col`gensym536: int): Option[
    seq[Option[int32]]] {....raises: [PgTypeError, PgError, PgProtocolError,
                                   CatchableError], tags: [], forbids: [].}
proc getIntArrayOpt(row`gensym502: Row; col`gensym502: int): Option[seq[int32]] {.
    ...raises: [PgTypeError, PgError, PgProtocolError, CatchableError], tags: [],
    forbids: [].}
proc getInterval(row: Row; col: int): PgInterval {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
Get a column value as PgInterval. Handles binary interval format. In binary format the column OID must be interval. 
proc getIntervalArray(row: Row; col: int): seq[PgInterval] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getIntervalArrayOpt(row`gensym515: Row; col`gensym515: int): Option[
    seq[PgInterval]] {....raises: [PgTypeError, PgError, PgProtocolError],
                       tags: [], forbids: [].}
proc getIntervalOpt(row`gensym211: Row; col`gensym211: int): Option[PgInterval] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getIntOpt(row`gensym193: Row; col`gensym193: int): Option[int32] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getJson(row: Row; col: int): JsonNode {....raises: [PgTypeError,
    PgProtocolError, IOError, OSError, ValueError, PgError, IOError, OSError,
    ValueError, PgTypeError], tags: [ReadIOEffect, WriteIOEffect], forbids: [].}
Get a column value as a parsed JsonNode. Handles binary json/jsonb format. In binary format the column OID must be json or jsonb. 
proc getJsonArray(row: Row; col: int): seq[JsonNode] {....raises: [PgTypeError,
    PgError, PgProtocolError, IOError, OSError, ValueError],
    tags: [ReadIOEffect, WriteIOEffect], forbids: [].}
proc getJsonArrayOpt(row`gensym524: Row; col`gensym524: int): Option[
    seq[JsonNode]] {....raises: [PgTypeError, PgError, PgProtocolError, IOError,
                              OSError, ValueError],
                     tags: [ReadIOEffect, WriteIOEffect], forbids: [].}
proc getJsonOpt(row`gensym203: Row; col`gensym203: int): Option[JsonNode] {....raises: [
    PgTypeError, PgProtocolError, IOError, OSError, ValueError, PgError],
    tags: [ReadIOEffect, WriteIOEffect], forbids: [].}
proc getLine(row: Row; col: int): PgLine {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
Get a column value as PgLine. Handles binary format. In binary format the column OID must be line. 
proc getLineArray(row: Row; col: int): seq[PgLine] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getLineArrayOpt(row`gensym526: Row; col`gensym526: int): Option[seq[PgLine]] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getLineOpt(row`gensym222: Row; col`gensym222: int): Option[PgLine] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getLseg(row: Row; col: int): PgLseg {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
Get a column value as PgLseg. Handles binary format. In binary format the column OID must be lseg. 
proc getLsegArray(row: Row; col: int): seq[PgLseg] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getLsegArrayOpt(row`gensym527: Row; col`gensym527: int): Option[seq[PgLseg]] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getLsegOpt(row`gensym223: Row; col`gensym223: int): Option[PgLseg] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getMacAddr(row: Row; col: int): PgMacAddr {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
Get a column value as PgMacAddr. Handles binary format. In binary format the column OID must be macaddr. 
proc getMacAddr8(row: Row; col: int): PgMacAddr8 {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
Get a column value as PgMacAddr8 (EUI-64). Handles binary format. In binary format the column OID must be macaddr8. 
proc getMacAddr8Array(row: Row; col: int): seq[PgMacAddr8] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getMacAddr8ArrayOpt(row`gensym520: Row; col`gensym520: int): Option[
    seq[PgMacAddr8]] {....raises: [PgTypeError, PgError, PgProtocolError],
                       tags: [], forbids: [].}
proc getMacAddr8Opt(row`gensym215: Row; col`gensym215: int): Option[PgMacAddr8] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getMacAddrArray(row: Row; col: int): seq[PgMacAddr] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getMacAddrArrayOpt(row`gensym519: Row; col`gensym519: int): Option[
    seq[PgMacAddr]] {....raises: [PgTypeError, PgError, PgProtocolError], tags: [],
                      forbids: [].}
proc getMacAddrOpt(row`gensym214: Row; col`gensym214: int): Option[PgMacAddr] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getMoney(row: Row; col: int; conv: PgMoneyConventions): PgMoney {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
Get a column value as PgMoney under known lc_monetary conventions. conv.fracDigits is the scale the wire format does not carry, and a text cell is parsed strictly against conv instead of inferring a locale, so a malformed string is rejected. 
proc getMoney(row: Row; col: int; scale: int = 2): PgMoney {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
Get a column value as PgMoney. Handles binary money (8-byte int64) and locale-formatted text (see parsePgMoney for accepted forms). scale is the server's frac_digits (default 2 for C / en_US; pass 0 for ja_JP etc.). The wire protocol does not expose this, so callers must specify it when it differs from the default. Raises PgTypeError on NULL or when scale is outside 0..18. In binary format the column OID must be money. The text path infers the locale conventions; prefer the PgMoneyConventions overload when they are known. 
proc getMoneyArray(row: Row; col: int; conv: PgMoneyConventions): seq[PgMoney] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
money[] under known lc_monetary conventions. See the PgMoneyConventions overload of getMoney. 
proc getMoneyArray(row: Row; col: int; scale: int = 2): seq[PgMoney] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
Get a column value as a seq of PgMoney. Handles binary array format and locale-formatted text arrays (see parsePgMoney). scale tags each element's frac_digits and is also used for text parsing. Raises PgTypeError when scale is outside 0..18. 
proc getMoneyArrayND(row: Row; col: int; conv: PgMoneyConventions): PgArray[
    PgMoney] {....raises: [PgTypeError, PgError], tags: [], forbids: [].}
money[] of any dimensionality under known lc_monetary conventions; conv.fracDigits supplies the scale. Binary format only, so the conventions add nothing beyond that — they are accepted so a caller holding one need not unpack it, and validated because this path never reaches the text parser. 
proc getMoneyArrayND(row: Row; col: int; scale: int = 2): PgArray[PgMoney] {.
    ...raises: [PgTypeError, PgError], tags: [], forbids: [].}
getArrayND-style accessor for money[] (any dimensionality). getArrayND[PgMoney] is intentionally {.error.}-gated because the binary money wire format does not carry the fractional-digit count, so the caller must supply scale (matching the server's lc_monetary frac_digits) — this accessor is the only way to read a money[] column. Defaults to scale = 2 for the common locale. Raises PgTypeError when scale is outside 0..18. 
proc getMoneyArrayNDOpt(row: Row; col: int; conv: PgMoneyConventions): Option[
    PgArray[PgMoney]] {....raises: [PgTypeError, PgError], tags: [], forbids: [].}
NULL-safe column-level variant of the conventions overload. 
proc getMoneyArrayNDOpt(row: Row; col: int; scale: int = 2): Option[
    PgArray[PgMoney]] {....raises: [PgTypeError, PgError], tags: [], forbids: [].}
NULL-safe column-level variant of getMoneyArrayND. 
proc getMoneyArrayOpt(row`gensym522: Row; col`gensym522: int;
                      conv`gensym522: PgMoneyConventions): Option[seq[PgMoney]] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getMoneyArrayOpt(row`gensym522: Row; col`gensym522: int;
                      scale`gensym522: int = 2): Option[seq[PgMoney]] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getMoneyOpt(row`gensym199: Row; col`gensym199: int;
                 conv`gensym199: PgMoneyConventions): Option[PgMoney] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getMoneyOpt(row`gensym199: Row; col`gensym199: int;
                 scale`gensym199: int = 2): Option[PgMoney] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getNumeric(row: Row; col: int): PgNumeric {.
    ...raises: [PgTypeError, PgError, CatchableError, PgProtocolError], tags: [],
    forbids: [].}
Get a column value as PgNumeric. Handles binary numeric format. In binary format the column OID must be numeric. 
proc getNumericArray(row: Row; col: int): seq[PgNumeric] {.
    ...raises: [PgTypeError, PgError, PgProtocolError, CatchableError], tags: [],
    forbids: [].}
proc getNumericArrayOpt(row`gensym521: Row; col`gensym521: int): Option[
    seq[PgNumeric]] {....raises: [PgTypeError, PgError, PgProtocolError,
                               CatchableError], tags: [], forbids: [].}
proc getNumericOpt(row`gensym198: Row; col`gensym198: int): Option[PgNumeric] {.
    ...raises: [PgTypeError, PgError, CatchableError, PgProtocolError], tags: [],
    forbids: [].}
proc getPath(row: Row; col: int): PgPath {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
Get a column value as PgPath. Handles binary format. In binary format the column OID must be path. 
proc getPathArray(row: Row; col: int): seq[PgPath] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getPathArrayOpt(row`gensym529: Row; col`gensym529: int): Option[seq[PgPath]] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getPathOpt(row`gensym225: Row; col`gensym225: int): Option[PgPath] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getPoint(row: Row; col: int): PgPoint {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
Get a column value as PgPoint. Handles binary format. In binary format the column OID must be point. 
proc getPointArray(row: Row; col: int): seq[PgPoint] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getPointArrayOpt(row`gensym525: Row; col`gensym525: int): Option[
    seq[PgPoint]] {....raises: [PgTypeError, PgError, PgProtocolError], tags: [],
                    forbids: [].}
proc getPointOpt(row`gensym221: Row; col`gensym221: int): Option[PgPoint] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getPolygon(row: Row; col: int): PgPolygon {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
Get a column value as PgPolygon. Handles binary format. In binary format the column OID must be polygon. 
proc getPolygonArray(row: Row; col: int): seq[PgPolygon] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getPolygonArrayOpt(row`gensym530: Row; col`gensym530: int): Option[
    seq[PgPolygon]] {....raises: [PgTypeError, PgError, PgProtocolError], tags: [],
                      forbids: [].}
proc getPolygonOpt(row`gensym226: Row; col`gensym226: int): Option[PgPolygon] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getStr(row: Row; col: int): string {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
Get a column value as a string. Handles binary-to-text conversion for common types (bool, int2/4/8, float4/8, numeric). Raises PgTypeError on NULL, or on a binary-safe OID this proc cannot stringify — use a typed accessor or resultFormat = rfText in that case. 
proc getStrArray(row: Row; col: int): seq[string] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getStrArrayElemOpt(row: Row; col: int): seq[Option[string]] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getStrArrayElemOptOpt(row`gensym542: Row; col`gensym542: int): Option[
    seq[Option[string]]] {....raises: [PgTypeError, PgError, PgProtocolError],
                           tags: [], forbids: [].}
proc getStrArrayOpt(row`gensym508: Row; col`gensym508: int): Option[seq[string]] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getStrOpt(row`gensym192: Row; col`gensym192: int): Option[string] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getTime(row: Row; col: int): PgTime {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
Get a column value as PgTime. Handles binary time format. In binary format the column OID must be time. 
proc getTimeArray(row: Row; col: int): seq[PgTime] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getTimeArrayOpt(row`gensym513: Row; col`gensym513: int): Option[seq[PgTime]] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getTimeOpt(row`gensym208: Row; col`gensym208: int): Option[PgTime] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getTimestamp(row: Row; col: int): DateTime {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [TimeEffect],
    forbids: [].}
Get a column value as DateTime. Handles binary timestamp format. In binary format the column OID must be timestamp. 
proc getTimestampArray(row: Row; col: int): seq[DateTime] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [TimeEffect],
    forbids: [].}
proc getTimestampArrayOpt(row`gensym510: Row; col`gensym510: int): Option[
    seq[DateTime]] {....raises: [PgTypeError, PgError, PgProtocolError],
                     tags: [TimeEffect], forbids: [].}
proc getTimestampOpt(row`gensym206: Row; col`gensym206: int): Option[DateTime] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [TimeEffect],
    forbids: [].}
proc getTimestampTz(row: Row; col: int): DateTime {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [TimeEffect],
    forbids: [].}
Get a column value as DateTime from a timestamptz column. In binary format the column OID must be timestamptz. 
proc getTimestampTzArray(row: Row; col: int): seq[DateTime] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [TimeEffect],
    forbids: [].}
proc getTimestampTzArrayOpt(row`gensym511: Row; col`gensym511: int): Option[
    seq[DateTime]] {....raises: [PgTypeError, PgError, PgProtocolError],
                     tags: [TimeEffect], forbids: [].}
proc getTimestampTzOpt(row`gensym210: Row; col`gensym210: int): Option[DateTime] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [TimeEffect],
    forbids: [].}
proc getTimeTz(row: Row; col: int): PgTimeTz {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
Get a column value as PgTimeTz. Handles binary timetz format. In binary format the column OID must be timetz. 
proc getTimeTzArray(row: Row; col: int): seq[PgTimeTz] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getTimeTzArrayOpt(row`gensym514: Row; col`gensym514: int): Option[
    seq[PgTimeTz]] {....raises: [PgTypeError, PgError, PgProtocolError], tags: [],
                     forbids: [].}
proc getTimeTzOpt(row`gensym209: Row; col`gensym209: int): Option[PgTimeTz] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getTsQuery(row: Row; col: int): PgTsQuery {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
Get a column value as PgTsQuery. Handles both text and binary format. In binary format the column OID must be tsquery. 
proc getTsQueryArray(row: Row; col: int): seq[PgTsQuery] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getTsQueryArrayOpt(row`gensym534: Row; col`gensym534: int): Option[
    seq[PgTsQuery]] {....raises: [PgTypeError, PgError, PgProtocolError], tags: [],
                      forbids: [].}
proc getTsQueryOpt(row`gensym217: Row; col`gensym217: int): Option[PgTsQuery] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getTsVector(row: Row; col: int): PgTsVector {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
Get a column value as PgTsVector. Handles both text and binary format. In binary format the column OID must be tsvector. 
proc getTsVectorArray(row: Row; col: int): seq[PgTsVector] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getTsVectorArrayOpt(row`gensym533: Row; col`gensym533: int): Option[
    seq[PgTsVector]] {....raises: [PgTypeError, PgError, PgProtocolError],
                       tags: [], forbids: [].}
proc getTsVectorOpt(row`gensym216: Row; col`gensym216: int): Option[PgTsVector] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getUuid(row: Row; col: int): PgUuid {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
Get a column value as PgUuid. Handles binary format (16 bytes). In binary format the column OID must be uuid. 
proc getUuidArray(row: Row; col: int): seq[PgUuid] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getUuidArrayOpt(row`gensym516: Row; col`gensym516: int): Option[seq[PgUuid]] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getUuidOpt(row`gensym200: Row; col`gensym200: int): Option[PgUuid] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getXml(row: Row; col: int): PgXml {.
    ...raises: [PgTypeError, PgProtocolError, PgError], tags: [], forbids: [].}
Get a column value as PgXml. Handles both text and binary format. In binary format the column OID must be xml. 
proc getXmlArray(row: Row; col: int): seq[PgXml] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getXmlArrayOpt(row`gensym532: Row; col`gensym532: int): Option[seq[PgXml]] {.
    ...raises: [PgTypeError, PgError, PgProtocolError], tags: [], forbids: [].}
proc getXmlOpt(row`gensym218: Row; col`gensym218: int): Option[PgXml] {.
    ...raises: [PgTypeError, PgProtocolError, PgError], tags: [], forbids: [].}
proc initCommandResult(tag: string): CommandResult {.inline, ...raises: [],
    tags: [], forbids: [].}
proc isBinaryCol(row: Row; col: int): bool {.inline, ...raises: [], tags: [],
    forbids: [].}
Check if column was received in binary format. 
proc isNull(row: Row; col: int): bool {....raises: [PgTypeError], tags: [],
                                        forbids: [].}
Check if the column value is NULL. Raises PgTypeError on out-of-range column index (see cellInfo for why not IndexDefect). 
proc len(row: Row): int {.inline, ...raises: [], tags: [], forbids: [].}
Return the number of columns in this row.

Converters

converter toRow(cells: seq[Option[seq[byte]]]): Row {....raises: [], tags: [],
    forbids: [].}
Backward-compatible converter: build a Row from seq[Option[seq[byte]]].

Templates

template nameAccessor(getProc: untyped; T: typedesc)
Generate getProc*(row, name): T that delegates to the index-based overload. Auto-detects a scale parameter on the index-based proc and forwards it — so a scaled accessor like getMoney cannot silently drop the kwarg when its index-based signature grows one. 
template optAccessor(getProc, optProc: untyped; T: typedesc)
Generate optProc*(row, col): Option[T] that delegates to getProc.

Made with Nim. Generated: 2026-09-11 08:44:50 UTC