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: [], 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 cellInfo(row: Row; col: int): tuple[off: int, len: int] {.inline,
    ...raises: [], tags: [], forbids: [].}
proc colTypeOid(row: Row; col: int): int32 {.inline, ...raises: [], tags: [],
    forbids: [].}
Get the type OID for a column, or 0 if not available. 
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]): PgMoney
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]]): seq[PgMoney]
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[T](row: Row; name: string; _: typedesc[T]): T
Generic typed accessor by column name. Usage: row.get("id", int32) 
proc getBit(row: Row; col: int): PgBit {....raises: [PgTypeError], tags: [],
    forbids: [].}
Get a column value as PgBit. Handles both text and binary format. 
proc getBitArray(row: Row; col: int): seq[PgBit] {....raises: [PgTypeError],
    tags: [], forbids: [].}
Get a column value as a seq of PgBit. Handles both text and binary format. 
proc getBitArrayOpt(row`gensym406: Row; col`gensym406: int): Option[seq[PgBit]] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getBitOpt(row`gensym190: Row; col`gensym190: int): Option[PgBit] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getBool(row: Row; col: int): bool {....raises: [PgTypeError], tags: [],
    forbids: [].}
Get a column value as bool. Handles binary format directly. Raises PgTypeError on NULL. 
proc getBoolArray(row: Row; col: int): seq[bool] {....raises: [PgTypeError],
    tags: [], forbids: [].}
Get a column value as a seq of bool. Handles binary array format. 
proc getBoolArrayElemOpt(row: Row; col: int): seq[Option[bool]] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getBoolArrayElemOptOpt(row`gensym438: Row; col`gensym438: int): Option[
    seq[Option[bool]]] {....raises: [PgTypeError], tags: [], forbids: [].}
proc getBoolArrayOpt(row`gensym404: Row; col`gensym404: int): Option[seq[bool]] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getBoolOpt(row`gensym172: Row; col`gensym172: int): Option[bool] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getBox(row: Row; col: int): PgBox {....raises: [PgTypeError, ValueError],
    tags: [], forbids: [].}
Get a column value as PgBox. Handles binary format. 
proc getBoxArray(row: Row; col: int): seq[PgBox] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getBoxArrayOpt(row`gensym425: Row; col`gensym425: int): Option[seq[PgBox]] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getBoxOpt(row`gensym195: Row; col`gensym195: int): Option[PgBox] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getBytes(row: Row; col: int): seq[byte] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
Get a column value as raw bytes. Decodes hex-encoded bytea in text format. Raises PgTypeError on NULL. 
proc getBytesArray(row: Row; col: int): seq[seq[byte]] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getBytesArrayOpt(row`gensym420: Row; col`gensym420: int): Option[
    seq[seq[byte]]] {....raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getBytesOpt(row`gensym173: Row; col`gensym173: int): Option[seq[byte]] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getCidr(row: Row; col: int): PgCidr {....raises: [PgTypeError, ValueError],
    tags: [], forbids: [].}
Get a column value as PgCidr (CIDR network address). Handles binary format. 
proc getCidrArray(row`gensym279: Row; col`gensym279: int): seq[PgCidr] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getCidrArrayOpt(row`gensym415: Row; col`gensym415: int): Option[seq[PgCidr]] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getCidrOpt(row`gensym184: Row; col`gensym184: int): Option[PgCidr] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getCircle(row: Row; col: int): PgCircle {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
Get a column value as PgCircle. Handles binary format. 
proc getCircleArray(row: Row; col: int): seq[PgCircle] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getCircleArrayOpt(row`gensym428: Row; col`gensym428: int): Option[
    seq[PgCircle]] {....raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getCircleOpt(row`gensym198: Row; col`gensym198: int): Option[PgCircle] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getDate(row: Row; col: int): DateTime {....raises: [PgTypeError, PgTypeError],
    tags: [TimeEffect], forbids: [].}
Get a column value as DateTime. Handles binary date format. 
proc getDateArray(row: Row; col: int): seq[DateTime] {.
    ...raises: [PgTypeError, PgTypeError], tags: [TimeEffect], forbids: [].}
proc getDateArrayOpt(row`gensym409: Row; col`gensym409: int): Option[
    seq[DateTime]] {....raises: [PgTypeError], tags: [TimeEffect], forbids: [].}
proc getDateOpt(row`gensym178: Row; col`gensym178: int): Option[DateTime] {.
    ...raises: [PgTypeError], 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. 
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. 
proc getFloat32Array(row: Row; col: int): seq[float32] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
Get a column value as a seq of float32. Handles binary array format. 
proc getFloat32ArrayElemOpt(row: Row; col: int): seq[Option[float32]] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getFloat32ArrayElemOptOpt(row`gensym437: Row; col`gensym437: int): Option[
    seq[Option[float32]]] {....raises: [PgTypeError, ValueError], tags: [],
                            forbids: [].}
proc getFloat32ArrayOpt(row`gensym403: Row; col`gensym403: int): Option[
    seq[float32]] {....raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getFloat32Opt(row`gensym168: Row; col`gensym168: int): Option[float32] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getFloatArray(row: Row; col: int): seq[float64] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
Get a column value as a seq of float64. Handles binary array format. 
proc getFloatArrayElemOpt(row: Row; col: int): seq[Option[float64]] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getFloatArrayElemOptOpt(row`gensym436: Row; col`gensym436: int): Option[
    seq[Option[float64]]] {....raises: [PgTypeError, ValueError], tags: [],
                            forbids: [].}
proc getFloatArrayOpt(row`gensym402: Row; col`gensym402: int): Option[
    seq[float64]] {....raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getFloatOpt(row`gensym167: Row; col`gensym167: int): Option[float64] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getHstore(row: Row; col: int): PgHstore {....raises: [PgTypeError], tags: [],
    forbids: [].}
Get a column value as PgHstore. Handles both text and binary format. 
proc getHstoreArray(row: Row; col: int): seq[PgHstore] {....raises: [PgTypeError],
    tags: [], forbids: [].}
Get a column value as seq[PgHstore]. Handles both text and binary format. 
proc getHstoreArrayOpt(row`gensym432: Row; col`gensym432: int): Option[
    seq[PgHstore]] {....raises: [PgTypeError], tags: [], forbids: [].}
proc getHstoreOpt(row`gensym191: Row; col`gensym191: int): Option[PgHstore] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getInet(row: Row; col: int): PgInet {....raises: [PgTypeError, ValueError],
    tags: [], forbids: [].}
Get a column value as PgInet (IP address with mask). Handles binary format. 
proc getInetArray(row`gensym275: Row; col`gensym275: int): seq[PgInet] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getInetArrayOpt(row`gensym414: Row; col`gensym414: int): Option[seq[PgInet]] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getInetOpt(row`gensym183: Row; col`gensym183: int): Option[PgInet] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getInt(row: Row; col: int): int32 {....raises: [PgTypeError, ValueError],
    tags: [], forbids: [].}
Get a column value as int32. Handles binary int2/int4 directly. Raises PgTypeError on NULL. 
proc getInt16(row: Row; col: int): int16 {....raises: [PgTypeError, ValueError],
    tags: [], forbids: [].}
Get a column value as int16. Handles binary int2 directly. Raises PgTypeError on NULL. 
proc getInt16Array(row: Row; col: int): seq[int16] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
Get a column value as a seq of int16. Handles binary array format. 
proc getInt16ArrayElemOpt(row: Row; col: int): seq[Option[int16]] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getInt16ArrayElemOptOpt(row`gensym434: Row; col`gensym434: int): Option[
    seq[Option[int16]]] {....raises: [PgTypeError, ValueError], tags: [],
                          forbids: [].}
proc getInt16ArrayOpt(row`gensym400: Row; col`gensym400: int): Option[seq[int16]] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getInt16Opt(row`gensym165: Row; col`gensym165: int): Option[int16] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getInt64(row: Row; col: int): int64 {....raises: [PgTypeError, ValueError],
    tags: [], forbids: [].}
Get a column value as int64. Handles binary int2/4/8 directly. Raises PgTypeError on NULL. 
proc getInt64Array(row: Row; col: int): seq[int64] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
Get a column value as a seq of int64. Handles binary array format. 
proc getInt64ArrayElemOpt(row: Row; col: int): seq[Option[int64]] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getInt64ArrayElemOptOpt(row`gensym435: Row; col`gensym435: int): Option[
    seq[Option[int64]]] {....raises: [PgTypeError, ValueError], tags: [],
                          forbids: [].}
proc getInt64ArrayOpt(row`gensym401: Row; col`gensym401: int): Option[seq[int64]] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getInt64Opt(row`gensym166: Row; col`gensym166: int): Option[int64] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getIntArray(row: Row; col: int): seq[int32] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
Get a column value as a seq of int32. Handles binary array format. 
proc getIntArrayElemOpt(row: Row; col: int): seq[Option[int32]] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getIntArrayElemOptOpt(row`gensym433: Row; col`gensym433: int): Option[
    seq[Option[int32]]] {....raises: [PgTypeError, ValueError], tags: [],
                          forbids: [].}
proc getIntArrayOpt(row`gensym399: Row; col`gensym399: int): Option[seq[int32]] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getInterval(row: Row; col: int): PgInterval {....raises: [PgTypeError],
    tags: [], forbids: [].}
Get a column value as PgInterval. Handles binary interval format. 
proc getIntervalArray(row: Row; col: int): seq[PgInterval] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getIntervalArrayOpt(row`gensym412: Row; col`gensym412: int): Option[
    seq[PgInterval]] {....raises: [PgTypeError], tags: [], forbids: [].}
proc getIntervalOpt(row`gensym182: Row; col`gensym182: int): Option[PgInterval] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getIntOpt(row`gensym164: Row; col`gensym164: int): Option[int32] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getJson(row: Row; col: int): JsonNode {....raises: [PgTypeError, IOError,
    OSError, ValueError, PgTypeError, IOError, OSError, ValueError, PgTypeError],
    tags: [ReadIOEffect, WriteIOEffect], forbids: [].}
Get a column value as a parsed JsonNode. Handles binary json/jsonb format. 
proc getJsonArray(row: Row; col: int): seq[JsonNode] {....raises: [PgTypeError,
    IOError, OSError, ValueError, PgTypeError, IOError, OSError, ValueError,
    PgTypeError], tags: [ReadIOEffect, WriteIOEffect], forbids: [].}
proc getJsonArrayOpt(row`gensym421: Row; col`gensym421: int): Option[
    seq[JsonNode]] {....raises: [PgTypeError, IOError, OSError, ValueError],
                     tags: [ReadIOEffect, WriteIOEffect], forbids: [].}
proc getJsonOpt(row`gensym174: Row; col`gensym174: int): Option[JsonNode] {.
    ...raises: [PgTypeError, IOError, OSError, ValueError],
    tags: [ReadIOEffect, WriteIOEffect], forbids: [].}
proc getLine(row: Row; col: int): PgLine {....raises: [PgTypeError, ValueError],
    tags: [], forbids: [].}
Get a column value as PgLine. Handles binary format. 
proc getLineArray(row: Row; col: int): seq[PgLine] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getLineArrayOpt(row`gensym423: Row; col`gensym423: int): Option[seq[PgLine]] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getLineOpt(row`gensym193: Row; col`gensym193: int): Option[PgLine] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getLseg(row: Row; col: int): PgLseg {....raises: [PgTypeError, ValueError],
    tags: [], forbids: [].}
Get a column value as PgLseg. Handles binary format. 
proc getLsegArray(row: Row; col: int): seq[PgLseg] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getLsegArrayOpt(row`gensym424: Row; col`gensym424: int): Option[seq[PgLseg]] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getLsegOpt(row`gensym194: Row; col`gensym194: int): Option[PgLseg] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getMacAddr(row: Row; col: int): PgMacAddr {....raises: [PgTypeError],
    tags: [], forbids: [].}
Get a column value as PgMacAddr. Handles binary format. 
proc getMacAddr8(row: Row; col: int): PgMacAddr8 {....raises: [PgTypeError],
    tags: [], forbids: [].}
Get a column value as PgMacAddr8 (EUI-64). Handles binary format. 
proc getMacAddr8Array(row`gensym289: Row; col`gensym289: int): seq[PgMacAddr8] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getMacAddr8ArrayOpt(row`gensym417: Row; col`gensym417: int): Option[
    seq[PgMacAddr8]] {....raises: [PgTypeError], tags: [], forbids: [].}
proc getMacAddr8Opt(row`gensym186: Row; col`gensym186: int): Option[PgMacAddr8] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getMacAddrArray(row`gensym283: Row; col`gensym283: int): seq[PgMacAddr] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getMacAddrArrayOpt(row`gensym416: Row; col`gensym416: int): Option[
    seq[PgMacAddr]] {....raises: [PgTypeError], tags: [], forbids: [].}
proc getMacAddrOpt(row`gensym185: Row; col`gensym185: int): Option[PgMacAddr] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getMoney(row: Row; col: int; scale: int = 2): PgMoney {.
    ...raises: [PgTypeError], 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. 
proc getMoneyArray(row: Row; col: int; scale: int = 2): seq[PgMoney] {.
    ...raises: [PgTypeError], 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 getMoneyArrayOpt(row`gensym419: Row; col`gensym419: int): Option[
    seq[PgMoney]] {....raises: [PgTypeError], tags: [], forbids: [].}
proc getMoneyOpt(row`gensym170: Row; col`gensym170: int): Option[PgMoney] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getNumeric(row: Row; col: int): PgNumeric {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
Get a column value as PgNumeric. Handles binary numeric format. 
proc getNumericArray(row: Row; col: int): seq[PgNumeric] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getNumericArrayOpt(row`gensym418: Row; col`gensym418: int): Option[
    seq[PgNumeric]] {....raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getNumericOpt(row`gensym169: Row; col`gensym169: int): Option[PgNumeric] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getPath(row: Row; col: int): PgPath {....raises: [PgTypeError, ValueError],
    tags: [], forbids: [].}
Get a column value as PgPath. Handles binary format. 
proc getPathArray(row: Row; col: int): seq[PgPath] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getPathArrayOpt(row`gensym426: Row; col`gensym426: int): Option[seq[PgPath]] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getPathOpt(row`gensym196: Row; col`gensym196: int): Option[PgPath] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getPoint(row: Row; col: int): PgPoint {....raises: [PgTypeError, ValueError],
    tags: [], forbids: [].}
Get a column value as PgPoint. Handles binary format. 
proc getPointArray(row: Row; col: int): seq[PgPoint] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getPointArrayOpt(row`gensym422: Row; col`gensym422: int): Option[
    seq[PgPoint]] {....raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getPointOpt(row`gensym192: Row; col`gensym192: int): Option[PgPoint] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getPolygon(row: Row; col: int): PgPolygon {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
Get a column value as PgPolygon. Handles binary format. 
proc getPolygonArray(row: Row; col: int): seq[PgPolygon] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getPolygonArrayOpt(row`gensym427: Row; col`gensym427: int): Option[
    seq[PgPolygon]] {....raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getPolygonOpt(row`gensym197: Row; col`gensym197: int): Option[PgPolygon] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getStr(row: Row; col: int): string {....raises: [PgTypeError], tags: [],
    forbids: [].}
Get a column value as a string. Handles binary-to-text conversion for common types (bool, int2/4/8, float4/8). Raises PgTypeError on NULL. 
proc getStrArray(row: Row; col: int): seq[string] {....raises: [PgTypeError],
    tags: [], forbids: [].}
Get a column value as a seq of strings. Handles binary array format. 
proc getStrArrayElemOpt(row: Row; col: int): seq[Option[string]] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getStrArrayElemOptOpt(row`gensym439: Row; col`gensym439: int): Option[
    seq[Option[string]]] {....raises: [PgTypeError], tags: [], forbids: [].}
proc getStrArrayOpt(row`gensym405: Row; col`gensym405: int): Option[seq[string]] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getStrOpt(row`gensym163: Row; col`gensym163: int): Option[string] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getTime(row: Row; col: int): PgTime {....raises: [PgTypeError], tags: [],
    forbids: [].}
Get a column value as PgTime. Handles binary time format. 
proc getTimeArray(row: Row; col: int): seq[PgTime] {....raises: [PgTypeError],
    tags: [], forbids: [].}
proc getTimeArrayOpt(row`gensym410: Row; col`gensym410: int): Option[seq[PgTime]] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getTimeOpt(row`gensym179: Row; col`gensym179: int): Option[PgTime] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getTimestamp(row: Row; col: int): DateTime {.
    ...raises: [PgTypeError, TimeFormatParseError], tags: [TimeEffect], forbids: [].}
Get a column value as DateTime. Handles binary timestamp format. 
proc getTimestampArray(row`gensym247: Row; col`gensym247: int): seq[DateTime] {.
    ...raises: [PgTypeError, TimeFormatParseError], tags: [TimeEffect], forbids: [].}
proc getTimestampArrayOpt(row`gensym407: Row; col`gensym407: int): Option[
    seq[DateTime]] {....raises: [PgTypeError, TimeFormatParseError],
                     tags: [TimeEffect], forbids: [].}
proc getTimestampOpt(row`gensym177: Row; col`gensym177: int): Option[DateTime] {.
    ...raises: [PgTypeError, TimeFormatParseError], tags: [TimeEffect], forbids: [].}
proc getTimestampTz(row: Row; col: int): DateTime {.
    ...raises: [PgTypeError, TimeFormatParseError], tags: [TimeEffect], forbids: [].}
Get a column value as DateTime from a timestamptz column. 
proc getTimestampTzArray(row`gensym251: Row; col`gensym251: int): seq[DateTime] {.
    ...raises: [PgTypeError, TimeFormatParseError], tags: [TimeEffect], forbids: [].}
proc getTimestampTzArrayOpt(row`gensym408: Row; col`gensym408: int): Option[
    seq[DateTime]] {....raises: [PgTypeError, TimeFormatParseError],
                     tags: [TimeEffect], forbids: [].}
proc getTimestampTzOpt(row`gensym181: Row; col`gensym181: int): Option[DateTime] {.
    ...raises: [PgTypeError, TimeFormatParseError], tags: [TimeEffect], forbids: [].}
proc getTimeTz(row: Row; col: int): PgTimeTz {....raises: [PgTypeError], tags: [],
    forbids: [].}
Get a column value as PgTimeTz. Handles binary timetz format. 
proc getTimeTzArray(row: Row; col: int): seq[PgTimeTz] {....raises: [PgTypeError],
    tags: [], forbids: [].}
proc getTimeTzArrayOpt(row`gensym411: Row; col`gensym411: int): Option[
    seq[PgTimeTz]] {....raises: [PgTypeError], tags: [], forbids: [].}
proc getTimeTzOpt(row`gensym180: Row; col`gensym180: int): Option[PgTimeTz] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getTsQuery(row: Row; col: int): PgTsQuery {....raises: [PgTypeError],
    tags: [], forbids: [].}
Get a column value as PgTsQuery. Handles both text and binary format. 
proc getTsQueryArray(row`gensym384: Row; col`gensym384: int): seq[PgTsQuery] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getTsQueryArrayOpt(row`gensym431: Row; col`gensym431: int): Option[
    seq[PgTsQuery]] {....raises: [PgTypeError], tags: [], forbids: [].}
proc getTsQueryOpt(row`gensym188: Row; col`gensym188: int): Option[PgTsQuery] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getTsVector(row: Row; col: int): PgTsVector {....raises: [PgTypeError],
    tags: [], forbids: [].}
Get a column value as PgTsVector. Handles both text and binary format. 
proc getTsVectorArray(row`gensym380: Row; col`gensym380: int): seq[PgTsVector] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getTsVectorArrayOpt(row`gensym430: Row; col`gensym430: int): Option[
    seq[PgTsVector]] {....raises: [PgTypeError], tags: [], forbids: [].}
proc getTsVectorOpt(row`gensym187: Row; col`gensym187: int): Option[PgTsVector] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getUuid(row: Row; col: int): PgUuid {....raises: [PgTypeError], tags: [],
    forbids: [].}
Get a column value as PgUuid. Handles binary format (16 bytes). 
proc getUuidArray(row: Row; col: int): seq[PgUuid] {....raises: [PgTypeError],
    tags: [], forbids: [].}
proc getUuidArrayOpt(row`gensym413: Row; col`gensym413: int): Option[seq[PgUuid]] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getUuidOpt(row`gensym171: Row; col`gensym171: int): Option[PgUuid] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getXml(row: Row; col: int): PgXml {....raises: [PgTypeError], tags: [],
    forbids: [].}
Get a column value as PgXml. Handles both text and binary format. 
proc getXmlArray(row`gensym376: Row; col`gensym376: int): seq[PgXml] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getXmlArrayOpt(row`gensym429: Row; col`gensym429: int): Option[seq[PgXml]] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getXmlOpt(row`gensym189: Row; col`gensym189: int): Option[PgXml] {.
    ...raises: [PgTypeError], 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: [], tags: [], forbids: [].}
Check if the column value is NULL. 
proc len(row: Row): int {.inline, ...raises: [], tags: [], forbids: [].}
Return the number of columns in this row. 
proc parseAffectedRows(tag: string): int64 {....raises: [], tags: [], forbids: [].}
Extract row count from command tag (e.g. "UPDATE 3" -> 3, "INSERT 0 1" -> 1). 
proc parseAffectedRowsRaw(tag: openArray[char]): int64 {....raises: [], tags: [],
    forbids: [].}

Extract row count from the raw bytes of a command tag (e.g. "UPDATE 3" -> 3, "INSERT 0 1" -> 1). Unlike parseAffectedRows(string) this performs zero heap allocation — useful for pipelines that process many CommandComplete messages.

Mirrors the legacy split(' ') semantics exactly: the last token (bytes after the final space) must parse as an integer; a trailing space or any non-numeric tail yields 0.

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 bufView(row: Row; off, clen: int): openArray[char]
Zero-copy char view into row.data.buf for parseutils. 
template nameAccessor(getProc: untyped; T: typedesc)
Generate getProc*(row, name): T that delegates to the index-based overload. 
template optAccessor(getProc, optProc: untyped; T: typedesc)
Generate optProc*(row, col): Option[T] that delegates to getProc.

Made with Nim. Generated: 2026-05-04 10:12:31 UTC