async_postgres/pg_types

Search:
Group by:

Types

CommandResult = object
  commandTag*: string        ## Raw command tag string (e.g. "INSERT 0 1", "UPDATE 3", "DELETE 5").
Result of a command execution, wrapping the PostgreSQL command tag. 
PgBit = object
  nbits*: int32              ## number of bits
  data*: seq[byte]           ## packed bit data (MSB first)
PostgreSQL bit / bit varying type. 
PgBox = object
  high*: PgPoint
  low*: PgPoint
PostgreSQL box type: (upper-right),(lower-left). 
PgCidr = object
  address*: IpAddress
  mask*: uint8
PostgreSQL cidr type: a network address with a subnet mask. 
PgCircle = object
  center*: PgPoint
  radius*: float64
PostgreSQL circle type: <(x,y),r>. 
PgError = object of CatchableError
General PostgreSQL error. Base type for all pg-specific errors. 
PgHstore = Table[string, Option[string]]
PostgreSQL hstore type: a set of key/value pairs where values may be NULL. 
PgInet = object
  address*: IpAddress
  mask*: uint8
PostgreSQL inet type: an IP address with a subnet mask. 
PgInterval = object
  months*: int32
  days*: int32
  microseconds*: int64
PostgreSQL interval value decomposed into months, days, and microseconds. 
PgLine = object
  a*: float64
  b*: float64
  c*: float64
PostgreSQL line type: {A, B, C} representing Ax + By + C = 0. 
PgLseg = object
  p1*: PgPoint
  p2*: PgPoint
PostgreSQL lseg (line segment) type: [(x1,y1),(x2,y2)]. 
PgMacAddr = distinct string
MAC address as "08:00:2b:01:02:03" 
PgMacAddr8 = distinct string
EUI-64 MAC address as "08:00:2b:01:02:03:04:05" 
PgMultirange[T] = distinct seq[PgRange[T]]
PostgreSQL multirange value (PostgreSQL 14+). A sorted set of non-overlapping ranges. 
PgNumeric = object
  weight*: int16             ## exponent of first digit group (value = digit * 10000^weight)
  sign*: PgNumericSign       ## positive, negative, or NaN
  dscale*: int16             ## number of digits after decimal point (display scale)
  digits*: seq[int16]        ## base-10000 digit groups, each 0..9999
Arbitrary-precision numeric value using PostgreSQL's internal base-10000 representation. Supports comparison operators but not arithmetic. Use this instead of float64 to avoid precision loss with PostgreSQL numeric/decimal. 
PgNumericSign = enum
  pgPositive = 0, pgNegative = 16384, pgNaN = 49152
PgParam = object
  oid*: int32
  format*: int16
  value*: Option[seq[byte]]
A single query parameter in binary wire format, ready to send to PostgreSQL. 
PgPath = object
  closed*: bool
  points*: seq[PgPoint]
PostgreSQL path type: open or closed sequence of points. 
PgPoint = object
  x*: float64
  y*: float64
PostgreSQL point type: (x, y). 
PgPolygon = object
  points*: seq[PgPoint]
PostgreSQL polygon type: closed sequence of points. 
PgRange[T] = object
  isEmpty*: bool
  hasLower*: bool
  hasUpper*: bool
  lower*: PgRangeBound[T]
  upper*: PgRangeBound[T]
PostgreSQL range value (e.g. int4range, tsrange). 
PgRangeBound[T] = object
  value*: T
  inclusive*: bool
One endpoint of a PostgreSQL range value. 
PgTsQuery = distinct string
PostgreSQL tsquery (full-text search query). 
PgTsVector = distinct string
PostgreSQL tsvector (full-text search document). 
PgTypeError = object of PgError
Raised when a PostgreSQL value cannot be converted to the requested Nim type. 
PgUuid = distinct string
UUID value stored as its string representation (e.g. "550e8400-e29b-41d4-a716-446655440000"). 
PgXml = distinct string
PostgreSQL xml type. 
ResultFormat = enum
  rfAuto,                   ## Per-column binary-safe detection via statement cache (default).
  rfText,                   ## All columns in text format.
  rfBinary                   ## All columns in binary format.
How result columns should be encoded by the server.

Consts

OidBit = 1560'i32
OidBitArray = 1561'i32
OidBool = 16'i32
OidBoolArray = 1000'i32
OidBox = 603'i32
OidBytea = 17'i32
OidCidr = 650'i32
OidCircle = 718'i32
OidDate = 1082'i32
OidDateMultirange = 4535'i32
OidDateRange = 3912'i32
OidDateRangeArray = 3913'i32
OidFloat4 = 700'i32
OidFloat4Array = 1021'i32
OidFloat8 = 701'i32
OidFloat8Array = 1022'i32
OidInet = 869'i32
OidInt2 = 21'i32
OidInt2Array = 1005'i32
OidInt4 = 23'i32
OidInt4Array = 1007'i32
OidInt4Multirange = 4451'i32
OidInt4Range = 3904'i32
OidInt4RangeArray = 3905'i32
OidInt8 = 20'i32
OidInt8Array = 1016'i32
OidInt8Multirange = 4536'i32
OidInt8Range = 3926'i32
OidInt8RangeArray = 3927'i32
OidInterval = 1186'i32
OidJson = 114'i32
OidJsonb = 3802'i32
OidLine = 628'i32
OidLseg = 601'i32
OidMacAddr = 829'i32
OidMacAddr8 = 774'i32
OidNumeric = 1700'i32
OidNumMultirange = 4532'i32
OidNumRange = 3906'i32
OidNumRangeArray = 3907'i32
OidPath = 602'i32
OidPoint = 600'i32
OidPolygon = 604'i32
OidRecord = 2249'i32
Composite / anonymous record type OID. 
OidText = 25'i32
OidTextArray = 1009'i32
OidTime = 1083'i32
OidTimestamp = 1114'i32
OidTimestampTz = 1184'i32
OidTsMultirange = 4533'i32
OidTsQuery = 3615'i32
OidTsRange = 3908'i32
OidTsRangeArray = 3909'i32
OidTsTzMultirange = 4534'i32
OidTsTzRange = 3910'i32
OidTsTzRangeArray = 3911'i32
OidTsVector = 3614'i32
OidUuid = 2950'i32
OidVarbit = 1562'i32
OidVarbitArray = 1563'i32
OidVarchar = 1043'i32
OidVarcharArray = 1015'i32
OidXml = 142'i32
pgEpochDaysOffset = 10957'i32
Days from 1970-01-01 to 2000-01-01 
pgEpochUnix = 946684800'i64
2000-01-01 00:00:00 UTC in Unix seconds 
rangeEmpty = 0x01'u8
Range flag: range is empty. 
rangeHasLower = 0x02'u8
Range flag: lower bound present. 
rangeHasUpper = 0x04'u8
Range flag: upper bound present. 
rangeLowerInc = 0x08'u8
Range flag: lower bound is inclusive. 
rangeUpperInc = 0x10'u8
Range flag: upper bound is inclusive.

Procs

proc `$`(cr: CommandResult): string {.inline, ...raises: [], tags: [], forbids: [].}
proc `$`(v: PgBit): string {....raises: [], tags: [], forbids: [].}
Convert PgBit to a bit string like "10110011". 
proc `$`(v: PgBox): string {....raises: [], tags: [], forbids: [].}
proc `$`(v: PgCidr): string {....raises: [], tags: [], forbids: [].}
proc `$`(v: PgCircle): string {....raises: [], tags: [], forbids: [].}
proc `$`(v: PgInet): string {....raises: [], tags: [], forbids: [].}
proc `$`(v: PgInterval): string {....raises: [], tags: [], forbids: [].}
proc `$`(v: PgLine): string {....raises: [], tags: [], forbids: [].}
proc `$`(v: PgLseg): string {....raises: [], tags: [], forbids: [].}
proc `$`(v: PgMacAddr): string {.borrow, ...raises: [], tags: [], forbids: [].}
proc `$`(v: PgMacAddr8): string {.borrow, ...raises: [], tags: [], forbids: [].}
proc `$`(v: PgNumeric): string {....raises: [], tags: [], forbids: [].}
Convert PgNumeric to its decimal string representation. 
proc `$`(v: PgPath): string {....raises: [], tags: [], forbids: [].}
proc `$`(v: PgPoint): string {....raises: [], tags: [], forbids: [].}
proc `$`(v: PgPolygon): string {....raises: [], tags: [], forbids: [].}
proc `$`(v: PgTsQuery): string {.borrow, ...raises: [], tags: [], forbids: [].}
proc `$`(v: PgTsVector): string {.borrow, ...raises: [], tags: [], forbids: [].}
proc `$`(v: PgUuid): string {.borrow, ...raises: [], tags: [], forbids: [].}
proc `$`(v: PgXml): string {.borrow, ...raises: [], tags: [], forbids: [].}
proc `$`[T](mr: PgMultirange[T]): string
proc `$`[T](r: PgRange[T]): string
proc `<`(a, b: PgNumeric): bool {....raises: [], tags: [], forbids: [].}
proc `<=`(a, b: PgNumeric): bool {....raises: [], tags: [], forbids: [].}
proc `==`(a, b: PgBit): bool {....raises: [], tags: [], forbids: [].}
proc `==`(a, b: PgBox): bool {....raises: [], tags: [], forbids: [].}
proc `==`(a, b: PgCidr): bool {....raises: [], tags: [], forbids: [].}
proc `==`(a, b: PgCircle): bool {....raises: [], tags: [], forbids: [].}
proc `==`(a, b: PgInet): bool {....raises: [], tags: [], forbids: [].}
proc `==`(a, b: PgInterval): bool {....raises: [], tags: [], forbids: [].}
proc `==`(a, b: PgLine): bool {....raises: [], tags: [], forbids: [].}
proc `==`(a, b: PgLseg): bool {....raises: [], tags: [], forbids: [].}
proc `==`(a, b: PgMacAddr): bool {.borrow, ...raises: [], tags: [], forbids: [].}
proc `==`(a, b: PgMacAddr8): bool {.borrow, ...raises: [], tags: [], forbids: [].}
proc `==`(a, b: PgNumeric): bool {....raises: [], tags: [], forbids: [].}
Value-based equality. 1.0 == 1.00 is true. 
proc `==`(a, b: PgPath): bool {....raises: [], tags: [], forbids: [].}
proc `==`(a, b: PgPoint): bool {....raises: [], tags: [], forbids: [].}
proc `==`(a, b: PgPolygon): bool {....raises: [], tags: [], forbids: [].}
proc `==`(a, b: PgTsQuery): bool {.borrow, ...raises: [], tags: [], forbids: [].}
proc `==`(a, b: PgTsVector): bool {.borrow, ...raises: [], tags: [], forbids: [].}
proc `==`(a, b: PgUuid): bool {.borrow, ...raises: [], tags: [], forbids: [].}
proc `==`(a, b: PgXml): bool {.borrow, ...raises: [], tags: [], forbids: [].}
proc `==`(cr: CommandResult; s: string): bool {.inline, ...raises: [], tags: [],
    forbids: [].}
proc `==`[T](a, b: PgMultirange[T]): bool
proc `==`[T](a, b: PgRange[T]): bool
proc `>`(a, b: PgNumeric): bool {....raises: [], tags: [], forbids: [].}
proc `>=`(a, b: PgNumeric): bool {....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 `[]`[T](mr: PgMultirange[T]; i: int): PgRange[T]
proc addBind(buf: var seq[byte]; portalName: string; stmtName: string;
             params: openArray[PgParam]; resultFormats: openArray[int16] = []) {.
    ...raises: [], tags: [], forbids: [].}
proc addParse(buf: var seq[byte]; stmtName: string; sql: string;
              params: openArray[PgParam]) {....raises: [], tags: [], forbids: [].}
proc affectedRows(cr: CommandResult): int64 {.inline, ...raises: [], tags: [],
    forbids: [].}
Extract the number of affected rows from the command result. 
proc cmp(a, b: PgNumeric): int {....raises: [], tags: [], forbids: [].}
Compare two PgNumeric values. NaN sorts highest (PostgreSQL convention). 
proc coerceBinaryParam(param: PgParam; serverOid: int32): PgParam {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
Return a copy of param whose binary payload matches serverOid. Text-format parameters (format == 0) and matching OIDs are returned unchanged. For binary-format parameters with a type mismatch, safe widening conversions are applied. 
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 decodeBinaryArray(data: openArray[byte]): tuple[elemOid: int32,
    elements: seq[tuple[off: int, len: int]]] {....raises: [PgTypeError], tags: [],
    forbids: [].}
Decode a PostgreSQL binary array, returning element OID and (offset, length) pairs. Offsets are relative to the start of data. 
proc decodeBinaryComposite(data: openArray[byte]): seq[
    tuple[oid: int32, off: int, len: int]] {....raises: [PgTypeError], tags: [],
    forbids: [].}
Decode a PostgreSQL binary composite value. Returns (typeOid, offset, length) tuples. offset is relative to data. length of -1 indicates NULL. 
proc decodeHstoreBinary(data: openArray[byte]): PgHstore {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
Decode PostgreSQL binary hstore format. 
proc emptyRange[T](): PgRange[T]
Create an empty range. 
proc encodeBinaryArray(elemOid: int32; elements: seq[seq[byte]]): seq[byte] {.
    ...raises: [PgError], tags: [], forbids: [].}
Encode a 1-dimensional PostgreSQL binary array. Header: ndim(4) + has_null(4) + elem_oid(4) + dim_len(4) + lower_bound(4) = 20 bytes Each element: len(4) + data 
proc encodeBinaryArrayEmpty(elemOid: int32): seq[byte] {....raises: [], tags: [],
    forbids: [].}
Encode an empty 1-dimensional PostgreSQL binary array. ndim=0, has_null=0, elem_oid 
proc encodeBinaryComposite(fields: seq[tuple[oid: int32, data: Option[seq[byte]]]]): seq[
    byte] {....raises: [], tags: [], forbids: [].}
Encode a PostgreSQL binary composite value. Format: numFields(4) + [oid(4) + len(4) + data]... 
proc encodeCompositeText(fields: seq[Option[string]]): string {....raises: [],
    tags: [], forbids: [].}
Encode fields as PostgreSQL composite text format: (val1,val2,...) 
proc encodeHstoreBinary(v: PgHstore): seq[byte] {....raises: [], tags: [],
    forbids: [].}
Encode hstore as PostgreSQL binary format. Format: numPairs(int32) + [keyLen(int32) + keyData + valLen(int32) + valData]... 
proc encodeHstoreText(v: PgHstore): string {....raises: [], tags: [], forbids: [].}
Encode hstore as PostgreSQL text format: "key1"=>"val1", "key2"=>NULL. 
proc encodeNumericBinary(v: PgNumeric): seq[byte] {....raises: [], tags: [],
    forbids: [].}
Encode PgNumeric as PostgreSQL binary numeric format. 
proc fromBE16(data: openArray[byte]): int16 {....raises: [], tags: [], forbids: [].}
Decode a 16-bit integer from big-endian bytes. 
proc fromBE32(data: openArray[byte]): int32 {....raises: [], tags: [], forbids: [].}
Decode a 32-bit integer from big-endian bytes. 
proc fromBE64(data: openArray[byte]): int64 {....raises: [], tags: [], forbids: [].}
Decode a 64-bit integer from big-endian bytes. 
proc fromPgText(data: seq[byte]; oid: int32): string {....raises: [], tags: [],
    forbids: [].}
Convert text-format bytes from PostgreSQL to a Nim string. 
proc get(row: Row; col: int; T: typedesc[bool]): bool
proc get(row: Row; col: int; T: typedesc[float64]): float64
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[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[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[PgMultirange[int32]]): PgMultirange[
    int32]
proc get(row: Row; col: int; T: typedesc[PgMultirange[int64]]): PgMultirange[
    int64]
proc get(row: Row; col: int; T: typedesc[PgMultirange[PgNumeric]]): PgMultirange[
    PgNumeric]
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[PgRange[int32]]): PgRange[int32]
proc get(row: Row; col: int; T: typedesc[PgRange[int64]]): PgRange[int64]
proc get(row: Row; col: int; T: typedesc[PgRange[PgNumeric]]): PgRange[PgNumeric]
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[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[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 getBit(row`gensym635: Row; name`gensym635: string): PgBit {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
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 getBitArray(row`gensym676: Row; name`gensym676: string): seq[PgBit] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getBitArrayOpt(row`gensym385: Row; col`gensym385: int): Option[seq[PgBit]] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getBitArrayOpt(row`gensym684: Row; name`gensym684: string): Option[
    seq[PgBit]] {....raises: [PgTypeError], tags: [], forbids: [].}
proc getBitOpt(row`gensym331: Row; col`gensym331: int): Option[PgBit] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getBitOpt(row`gensym660: Row; name`gensym660: string): 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 getBool(row`gensym620: Row; name`gensym620: string): bool {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
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 getBoolArray(row`gensym674: Row; name`gensym674: string): seq[bool] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getBoolArrayOpt(row`gensym383: Row; col`gensym383: int): Option[seq[bool]] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getBoolArrayOpt(row`gensym682: Row; name`gensym682: string): Option[
    seq[bool]] {....raises: [PgTypeError], tags: [], forbids: [].}
proc getBoolOpt(row`gensym319: Row; col`gensym319: int): Option[bool] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getBoolOpt(row`gensym650: Row; name`gensym650: string): 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 getBox(row`gensym640: Row; name`gensym640: string): PgBox {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getBoxOpt(row`gensym336: Row; col`gensym336: int): Option[PgBox] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getBoxOpt(row`gensym665: Row; name`gensym665: string): 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 getBytes(row`gensym621: Row; name`gensym621: string): 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 getCidr(row`gensym629: Row; name`gensym629: string): PgCidr {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getCidrOpt(row`gensym325: Row; col`gensym325: int): Option[PgCidr] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getCidrOpt(row`gensym654: Row; name`gensym654: string): 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 getCircle(row`gensym643: Row; name`gensym643: string): PgCircle {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getCircleOpt(row`gensym339: Row; col`gensym339: int): Option[PgCircle] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getCircleOpt(row`gensym668: Row; name`gensym668: string): Option[PgCircle] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getComposite[T: object](row: Row; col: int): T
Read a PostgreSQL composite column as a Nim object. Handles binary format. 
proc getCompositeOpt[T: object](row: Row; col: int): Option[T]
NULL-safe version of getComposite. 
proc getDate(row: Row; col: int): DateTime {....raises: [PgTypeError, PgTypeError],
    tags: [TimeEffect], forbids: [].}
Get a column value as DateTime. Handles binary date format. 
proc getDate(row`gensym625: Row; name`gensym625: string): DateTime {.
    ...raises: [PgTypeError], tags: [TimeEffect], forbids: [].}
proc getDateMultirange(row: Row; col: int): PgMultirange[DateTime] {.
    ...raises: [PgTypeError, Exception], tags: [RootEffect], forbids: [].}
Get a column value as a datemultirange. Handles binary format. 
proc getDateMultirange(row`gensym702: Row; name`gensym702: string): PgMultirange[
    DateTime] {....raises: [PgTypeError, Exception], tags: [RootEffect],
                forbids: [].}
proc getDateMultirangeOpt(row`gensym565: Row; col`gensym565: int): Option[
    PgMultirange[DateTime]] {....raises: [PgTypeError, Exception],
                              tags: [RootEffect], forbids: [].}
proc getDateMultirangeOpt(row`gensym708: Row; name`gensym708: string): Option[
    PgMultirange[DateTime]] {....raises: [PgTypeError, Exception],
                              tags: [RootEffect], forbids: [].}
proc getDateRange(row: Row; col: int): PgRange[DateTime] {.
    ...raises: [PgTypeError, Exception], tags: [RootEffect], forbids: [].}
Get a column value as a daterange. Handles binary format. 
proc getDateRange(row`gensym690: Row; name`gensym690: string): PgRange[DateTime] {.
    ...raises: [PgTypeError, Exception], tags: [RootEffect], forbids: [].}
proc getDateRangeArray(row: Row; col: int): seq[PgRange[DateTime]] {.
    ...raises: [PgTypeError, Exception], tags: [RootEffect], forbids: [].}
Get a column value as a daterange[]. Handles binary format. 
proc getDateRangeArrayOpt(row`gensym592: Row; col`gensym592: int): Option[
    seq[PgRange[DateTime]]] {....raises: [PgTypeError, Exception],
                              tags: [RootEffect], forbids: [].}
proc getDateRangeOpt(row`gensym491: Row; col`gensym491: int): Option[
    PgRange[DateTime]] {....raises: [PgTypeError, Exception], tags: [RootEffect],
                         forbids: [].}
proc getDateRangeOpt(row`gensym696: Row; name`gensym696: string): Option[
    PgRange[DateTime]] {....raises: [PgTypeError, Exception], tags: [RootEffect],
                         forbids: [].}
proc getDomain[T: distinct](row: Row; col: int): T
Read a PostgreSQL domain column as a Nim distinct type. The base type determines which row accessor is used. 
proc getDomainOpt[T: distinct](row: Row; col: int): Option[T]
NULL-safe version of getDomain. 
proc getEnum[T: enum](row: Row; col: int): T
Read a PostgreSQL enum column (text format) as a Nim enum. The column value must exactly match one of T's string representations. 
proc getEnumOpt[T: enum](row: Row; col: int): Option[T]
Read a PostgreSQL enum column as Option[T]. Returns none if NULL. NULL-safe version of getEnum. 
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 getFloat(row`gensym619: Row; name`gensym619: string): float64 {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
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 getFloat32Array(row`gensym673: Row; name`gensym673: string): seq[float32] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getFloat32ArrayOpt(row`gensym382: Row; col`gensym382: int): Option[
    seq[float32]] {....raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getFloat32ArrayOpt(row`gensym681: Row; name`gensym681: string): Option[
    seq[float32]] {....raises: [PgTypeError, ValueError], 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 getFloatArray(row`gensym672: Row; name`gensym672: string): seq[float64] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getFloatArrayOpt(row`gensym381: Row; col`gensym381: int): Option[
    seq[float64]] {....raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getFloatArrayOpt(row`gensym680: Row; name`gensym680: string): Option[
    seq[float64]] {....raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getFloatOpt(row`gensym316: Row; col`gensym316: int): Option[float64] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getFloatOpt(row`gensym647: Row; name`gensym647: string): 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 getHstore(row`gensym636: Row; name`gensym636: string): PgHstore {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getHstoreOpt(row`gensym332: Row; col`gensym332: int): Option[PgHstore] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getHstoreOpt(row`gensym661: Row; name`gensym661: string): 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 getInet(row`gensym628: Row; name`gensym628: string): PgInet {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getInetOpt(row`gensym324: Row; col`gensym324: int): Option[PgInet] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getInetOpt(row`gensym653: Row; name`gensym653: string): 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 getInt(row`gensym617: Row; name`gensym617: string): int32 {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getInt4Multirange(row: Row; col: int): PgMultirange[int32] {.
    ...raises: [PgTypeError, Exception], tags: [RootEffect], forbids: [].}
Get a column value as an int4multirange. Handles binary format. 
proc getInt4Multirange(row`gensym697: Row; name`gensym697: string): PgMultirange[
    int32] {....raises: [PgTypeError, Exception], tags: [RootEffect], forbids: [].}
proc getInt4MultirangeOpt(row`gensym560: Row; col`gensym560: int): Option[
    PgMultirange[int32]] {....raises: [PgTypeError, Exception], tags: [RootEffect],
                           forbids: [].}
proc getInt4MultirangeOpt(row`gensym703: Row; name`gensym703: string): Option[
    PgMultirange[int32]] {....raises: [PgTypeError, Exception], tags: [RootEffect],
                           forbids: [].}
proc getInt4Range(row: Row; col: int): PgRange[int32] {.
    ...raises: [PgTypeError, Exception], tags: [RootEffect], forbids: [].}
Get a column value as an int4range. Handles binary format. 
proc getInt4Range(row`gensym685: Row; name`gensym685: string): PgRange[int32] {.
    ...raises: [PgTypeError, Exception], tags: [RootEffect], forbids: [].}
proc getInt4RangeArray(row: Row; col: int): seq[PgRange[int32]] {.
    ...raises: [PgTypeError, Exception], tags: [RootEffect], forbids: [].}
Get a column value as an int4range[]. Handles binary format. 
proc getInt4RangeArrayOpt(row`gensym587: Row; col`gensym587: int): Option[
    seq[PgRange[int32]]] {....raises: [PgTypeError, Exception], tags: [RootEffect],
                           forbids: [].}
proc getInt4RangeOpt(row`gensym486: Row; col`gensym486: int): Option[
    PgRange[int32]] {....raises: [PgTypeError, Exception], tags: [RootEffect],
                      forbids: [].}
proc getInt4RangeOpt(row`gensym691: Row; name`gensym691: string): Option[
    PgRange[int32]] {....raises: [PgTypeError, Exception], tags: [RootEffect],
                      forbids: [].}
proc getInt8Multirange(row: Row; col: int): PgMultirange[int64] {.
    ...raises: [PgTypeError, Exception], tags: [RootEffect], forbids: [].}
Get a column value as an int8multirange. Handles binary format. 
proc getInt8Multirange(row`gensym698: Row; name`gensym698: string): PgMultirange[
    int64] {....raises: [PgTypeError, Exception], tags: [RootEffect], forbids: [].}
proc getInt8MultirangeOpt(row`gensym561: Row; col`gensym561: int): Option[
    PgMultirange[int64]] {....raises: [PgTypeError, Exception], tags: [RootEffect],
                           forbids: [].}
proc getInt8MultirangeOpt(row`gensym704: Row; name`gensym704: string): Option[
    PgMultirange[int64]] {....raises: [PgTypeError, Exception], tags: [RootEffect],
                           forbids: [].}
proc getInt8Range(row: Row; col: int): PgRange[int64] {.
    ...raises: [PgTypeError, Exception], tags: [RootEffect], forbids: [].}
Get a column value as an int8range. Handles binary format. 
proc getInt8Range(row`gensym686: Row; name`gensym686: string): PgRange[int64] {.
    ...raises: [PgTypeError, Exception], tags: [RootEffect], forbids: [].}
proc getInt8RangeArray(row: Row; col: int): seq[PgRange[int64]] {.
    ...raises: [PgTypeError, Exception], tags: [RootEffect], forbids: [].}
Get a column value as an int8range[]. Handles binary format. 
proc getInt8RangeArrayOpt(row`gensym588: Row; col`gensym588: int): Option[
    seq[PgRange[int64]]] {....raises: [PgTypeError, Exception], tags: [RootEffect],
                           forbids: [].}
proc getInt8RangeOpt(row`gensym487: Row; col`gensym487: int): Option[
    PgRange[int64]] {....raises: [PgTypeError, Exception], tags: [RootEffect],
                      forbids: [].}
proc getInt8RangeOpt(row`gensym692: Row; name`gensym692: string): Option[
    PgRange[int64]] {....raises: [PgTypeError, Exception], tags: [RootEffect],
                      forbids: [].}
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 getInt16Array(row`gensym670: Row; name`gensym670: string): seq[int16] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getInt16ArrayOpt(row`gensym379: Row; col`gensym379: int): Option[seq[int16]] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getInt16ArrayOpt(row`gensym678: Row; name`gensym678: string): Option[
    seq[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 getInt64(row`gensym618: Row; name`gensym618: string): int64 {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
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 getInt64Array(row`gensym671: Row; name`gensym671: string): seq[int64] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getInt64ArrayOpt(row`gensym380: Row; col`gensym380: int): Option[seq[int64]] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getInt64ArrayOpt(row`gensym679: Row; name`gensym679: string): Option[
    seq[int64]] {....raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getInt64Opt(row`gensym315: Row; col`gensym315: int): Option[int64] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getInt64Opt(row`gensym646: Row; name`gensym646: string): 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 getIntArray(row`gensym669: Row; name`gensym669: string): seq[int32] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getIntArrayOpt(row`gensym378: Row; col`gensym378: int): Option[seq[int32]] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getIntArrayOpt(row`gensym677: Row; name`gensym677: string): 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 getInterval(row`gensym627: Row; name`gensym627: string): PgInterval {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getIntervalOpt(row`gensym323: Row; col`gensym323: int): Option[PgInterval] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getIntervalOpt(row`gensym652: Row; name`gensym652: string): Option[
    PgInterval] {....raises: [PgTypeError], tags: [], forbids: [].}
proc getIntOpt(row`gensym314: Row; col`gensym314: int): Option[int32] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getIntOpt(row`gensym645: Row; name`gensym645: string): 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 getJson(row`gensym626: Row; name`gensym626: string): JsonNode {.
    ...raises: [PgTypeError, IOError, OSError, ValueError],
    tags: [ReadIOEffect, WriteIOEffect], forbids: [].}
proc getJsonOpt(row`gensym320: Row; col`gensym320: int): Option[JsonNode] {.
    ...raises: [PgTypeError, IOError, OSError, ValueError],
    tags: [ReadIOEffect, WriteIOEffect], forbids: [].}
proc getJsonOpt(row`gensym651: Row; name`gensym651: string): 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 getLine(row`gensym638: Row; name`gensym638: string): PgLine {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getLineOpt(row`gensym334: Row; col`gensym334: int): Option[PgLine] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getLineOpt(row`gensym663: Row; name`gensym663: string): 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 getLseg(row`gensym639: Row; name`gensym639: string): PgLseg {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getLsegOpt(row`gensym335: Row; col`gensym335: int): Option[PgLseg] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getLsegOpt(row`gensym664: Row; name`gensym664: string): 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 getMacAddr(row`gensym630: Row; name`gensym630: string): PgMacAddr {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getMacAddr8(row: Row; col: int): PgMacAddr8 {....raises: [PgTypeError],
    tags: [], forbids: [].}
Get a column value as PgMacAddr8 (EUI-64). Handles binary format. 
proc getMacAddr8(row`gensym631: Row; name`gensym631: string): PgMacAddr8 {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getMacAddr8Opt(row`gensym327: Row; col`gensym327: int): Option[PgMacAddr8] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getMacAddr8Opt(row`gensym656: Row; name`gensym656: string): Option[
    PgMacAddr8] {....raises: [PgTypeError], tags: [], forbids: [].}
proc getMacAddrOpt(row`gensym326: Row; col`gensym326: int): Option[PgMacAddr] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getMacAddrOpt(row`gensym655: Row; name`gensym655: string): Option[PgMacAddr] {.
    ...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 getNumeric(row`gensym622: Row; name`gensym622: string): PgNumeric {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getNumericOpt(row`gensym317: Row; col`gensym317: int): Option[PgNumeric] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getNumericOpt(row`gensym648: Row; name`gensym648: string): Option[PgNumeric] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getNumMultirange(row: Row; col: int): PgMultirange[PgNumeric] {.
    ...raises: [PgTypeError, Exception], tags: [RootEffect], forbids: [].}
Get a column value as a nummultirange. Handles binary format. 
proc getNumMultirange(row`gensym699: Row; name`gensym699: string): PgMultirange[
    PgNumeric] {....raises: [PgTypeError, Exception], tags: [RootEffect],
                 forbids: [].}
proc getNumMultirangeOpt(row`gensym562: Row; col`gensym562: int): Option[
    PgMultirange[PgNumeric]] {....raises: [PgTypeError, Exception],
                               tags: [RootEffect], forbids: [].}
proc getNumMultirangeOpt(row`gensym705: Row; name`gensym705: string): Option[
    PgMultirange[PgNumeric]] {....raises: [PgTypeError, Exception],
                               tags: [RootEffect], forbids: [].}
proc getNumRange(row: Row; col: int): PgRange[PgNumeric] {.
    ...raises: [PgTypeError, Exception], tags: [RootEffect], forbids: [].}
Get a column value as a numrange. Handles binary format. 
proc getNumRange(row`gensym687: Row; name`gensym687: string): PgRange[PgNumeric] {.
    ...raises: [PgTypeError, Exception], tags: [RootEffect], forbids: [].}
proc getNumRangeArray(row: Row; col: int): seq[PgRange[PgNumeric]] {.
    ...raises: [PgTypeError, Exception], tags: [RootEffect], forbids: [].}
Get a column value as a numrange[]. Handles binary format. 
proc getNumRangeArrayOpt(row`gensym589: Row; col`gensym589: int): Option[
    seq[PgRange[PgNumeric]]] {....raises: [PgTypeError, Exception],
                               tags: [RootEffect], forbids: [].}
proc getNumRangeOpt(row`gensym488: Row; col`gensym488: int): Option[
    PgRange[PgNumeric]] {....raises: [PgTypeError, Exception], tags: [RootEffect],
                          forbids: [].}
proc getNumRangeOpt(row`gensym693: Row; name`gensym693: string): Option[
    PgRange[PgNumeric]] {....raises: [PgTypeError, Exception], tags: [RootEffect],
                          forbids: [].}
proc getPath(row: Row; col: int): PgPath {....raises: [PgTypeError, ValueError],
    tags: [], forbids: [].}
Get a column value as PgPath. Handles binary format. 
proc getPath(row`gensym641: Row; name`gensym641: string): PgPath {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getPathOpt(row`gensym337: Row; col`gensym337: int): Option[PgPath] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getPathOpt(row`gensym666: Row; name`gensym666: string): 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 getPoint(row`gensym637: Row; name`gensym637: string): PgPoint {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getPointOpt(row`gensym333: Row; col`gensym333: int): Option[PgPoint] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getPointOpt(row`gensym662: Row; name`gensym662: string): 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 getPolygon(row`gensym642: Row; name`gensym642: string): PgPolygon {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getPolygonOpt(row`gensym338: Row; col`gensym338: int): Option[PgPolygon] {.
    ...raises: [PgTypeError, ValueError], tags: [], forbids: [].}
proc getPolygonOpt(row`gensym667: Row; name`gensym667: string): 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 getStr(row`gensym616: Row; name`gensym616: string): string {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
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 getStrArray(row`gensym675: Row; name`gensym675: string): seq[string] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getStrArrayOpt(row`gensym384: Row; col`gensym384: int): Option[seq[string]] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getStrArrayOpt(row`gensym683: Row; name`gensym683: string): Option[
    seq[string]] {....raises: [PgTypeError], tags: [], forbids: [].}
proc getStrOpt(row`gensym313: Row; col`gensym313: int): Option[string] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getStrOpt(row`gensym644: Row; name`gensym644: string): Option[string] {.
    ...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 getTimestamp(row`gensym624: Row; name`gensym624: string): DateTime {.
    ...raises: [PgTypeError, TimeFormatParseError], tags: [TimeEffect], forbids: [].}
proc getTsMultirange(row: Row; col: int): PgMultirange[DateTime] {.
    ...raises: [PgTypeError, Exception], tags: [RootEffect], forbids: [].}
Get a column value as a tsmultirange. Handles binary format. 
proc getTsMultirange(row`gensym700: Row; name`gensym700: string): PgMultirange[
    DateTime] {....raises: [PgTypeError, Exception], tags: [RootEffect],
                forbids: [].}
proc getTsMultirangeOpt(row`gensym563: Row; col`gensym563: int): Option[
    PgMultirange[DateTime]] {....raises: [PgTypeError, Exception],
                              tags: [RootEffect], forbids: [].}
proc getTsMultirangeOpt(row`gensym706: Row; name`gensym706: string): Option[
    PgMultirange[DateTime]] {....raises: [PgTypeError, Exception],
                              tags: [RootEffect], 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 getTsQuery(row`gensym633: Row; name`gensym633: string): PgTsQuery {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getTsQueryOpt(row`gensym329: Row; col`gensym329: int): Option[PgTsQuery] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getTsQueryOpt(row`gensym658: Row; name`gensym658: string): Option[PgTsQuery] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getTsRange(row: Row; col: int): PgRange[DateTime] {.
    ...raises: [PgTypeError, Exception], tags: [RootEffect], forbids: [].}
Get a column value as a tsrange. Handles binary format. 
proc getTsRange(row`gensym688: Row; name`gensym688: string): PgRange[DateTime] {.
    ...raises: [PgTypeError, Exception], tags: [RootEffect], forbids: [].}
proc getTsRangeArray(row: Row; col: int): seq[PgRange[DateTime]] {.
    ...raises: [PgTypeError, Exception], tags: [RootEffect], forbids: [].}
Get a column value as a tsrange[]. Handles binary format. 
proc getTsRangeArrayOpt(row`gensym590: Row; col`gensym590: int): Option[
    seq[PgRange[DateTime]]] {....raises: [PgTypeError, Exception],
                              tags: [RootEffect], forbids: [].}
proc getTsRangeOpt(row`gensym489: Row; col`gensym489: int): Option[
    PgRange[DateTime]] {....raises: [PgTypeError, Exception], tags: [RootEffect],
                         forbids: [].}
proc getTsRangeOpt(row`gensym694: Row; name`gensym694: string): Option[
    PgRange[DateTime]] {....raises: [PgTypeError, Exception], tags: [RootEffect],
                         forbids: [].}
proc getTsTzMultirange(row: Row; col: int): PgMultirange[DateTime] {.
    ...raises: [PgTypeError, Exception], tags: [RootEffect], forbids: [].}
Get a column value as a tstzmultirange. Handles binary format. 
proc getTsTzMultirange(row`gensym701: Row; name`gensym701: string): PgMultirange[
    DateTime] {....raises: [PgTypeError, Exception], tags: [RootEffect],
                forbids: [].}
proc getTsTzMultirangeOpt(row`gensym564: Row; col`gensym564: int): Option[
    PgMultirange[DateTime]] {....raises: [PgTypeError, Exception],
                              tags: [RootEffect], forbids: [].}
proc getTsTzMultirangeOpt(row`gensym707: Row; name`gensym707: string): Option[
    PgMultirange[DateTime]] {....raises: [PgTypeError, Exception],
                              tags: [RootEffect], forbids: [].}
proc getTsTzRange(row: Row; col: int): PgRange[DateTime] {.
    ...raises: [PgTypeError, Exception], tags: [RootEffect], forbids: [].}
Get a column value as a tstzrange. Handles binary format. 
proc getTsTzRange(row`gensym689: Row; name`gensym689: string): PgRange[DateTime] {.
    ...raises: [PgTypeError, Exception], tags: [RootEffect], forbids: [].}
proc getTsTzRangeArray(row: Row; col: int): seq[PgRange[DateTime]] {.
    ...raises: [PgTypeError, Exception], tags: [RootEffect], forbids: [].}
Get a column value as a tstzrange[]. Handles binary format. 
proc getTsTzRangeArrayOpt(row`gensym591: Row; col`gensym591: int): Option[
    seq[PgRange[DateTime]]] {....raises: [PgTypeError, Exception],
                              tags: [RootEffect], forbids: [].}
proc getTsTzRangeOpt(row`gensym490: Row; col`gensym490: int): Option[
    PgRange[DateTime]] {....raises: [PgTypeError, Exception], tags: [RootEffect],
                         forbids: [].}
proc getTsTzRangeOpt(row`gensym695: Row; name`gensym695: string): Option[
    PgRange[DateTime]] {....raises: [PgTypeError, Exception], tags: [RootEffect],
                         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 getTsVector(row`gensym632: Row; name`gensym632: string): PgTsVector {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getTsVectorOpt(row`gensym328: Row; col`gensym328: int): Option[PgTsVector] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getTsVectorOpt(row`gensym657: Row; name`gensym657: string): 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 getUuid(row`gensym623: Row; name`gensym623: string): PgUuid {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getUuidOpt(row`gensym318: Row; col`gensym318: int): Option[PgUuid] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getUuidOpt(row`gensym649: Row; name`gensym649: string): 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 getXml(row`gensym634: Row; name`gensym634: string): PgXml {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getXmlOpt(row`gensym330: Row; col`gensym330: int): Option[PgXml] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc getXmlOpt(row`gensym659: Row; name`gensym659: string): Option[PgXml] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc hash(v: PgNumeric): Hash {....raises: [], tags: [], forbids: [].}
Hash consistent with value-based ==. 
proc hash(v: PgUuid): Hash {.borrow, ...raises: [], 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 isNull(row`gensym615: Row; name`gensym615: string): bool {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc isZero(v: PgNumeric): bool {....raises: [], tags: [], forbids: [].}
Check if the numeric value is zero. 
proc len(row: Row): int {.inline, ...raises: [], tags: [], forbids: [].}
Return the number of columns in this row. 
proc len[T](mr: PgMultirange[T]): int
Return the number of ranges in the multirange. 
proc parseAffectedRows(tag: string): int64 {....raises: [], tags: [], forbids: [].}
Extract row count from command tag (e.g. "UPDATE 3" -> 3, "INSERT 0 1" -> 1). 
proc parseBitString(s: string): PgBit {....raises: [PgTypeError], tags: [],
                                        forbids: [].}
Parse a bit string like "10110011" into PgBit. 
proc parseCompositeText(s: string): seq[Option[string]] {....raises: [PgTypeError],
    tags: [], forbids: [].}
Parse PostgreSQL composite text format: (val1,val2,...) Returns fields as Option[string] (none for NULL). 
proc parseHstoreText(s: string): PgHstore {....raises: [PgTypeError], tags: [],
    forbids: [].}
Parse PostgreSQL hstore text format: "key1"=>"val1", "key2"=>NULL. 
proc parseMultirangeText[T](s: string; parseElem: proc (s: string): T): PgMultirange[
    T]
proc parsePgNumeric(s: string): PgNumeric {....raises: [PgTypeError, ValueError],
    tags: [], forbids: [].}
Parse a decimal string (e.g. "123.45", "-0.001", "NaN") into PgNumeric. 
proc parseRangeText[T](s: string; parseElem: proc (s: string): T): PgRange[T]
proc parseTextArray(s: string): seq[Option[string]] {....raises: [PgTypeError],
    tags: [], forbids: [].}
Parse PostgreSQL text-format array literal: {elem1,elem2,...} Returns elements as Option[string] (none for NULL). 
proc rangeFrom[T](lower: T; inclusive = true): PgRange[T]
Create a range with only a lower bound (upper unbounded). 
proc rangeOf[T](lower, upper: T; lowerInc = true; upperInc = false): PgRange[T]
Create a range with both bounds. Default: [lower, upper). 
proc rangeTo[T](upper: T; inclusive = false): PgRange[T]
Create a range with only an upper bound (lower unbounded). 
proc toBytes(s: string): seq[byte] {....raises: [], tags: [], forbids: [].}
Converts a string to a sequence of bytes. 
proc toMultirange[T](ranges: varargs[PgRange[T]]): PgMultirange[T]
Create a multirange from individual ranges. 
proc toPgBinaryDateRangeArrayParam(v: seq[PgRange[DateTime]]): PgParam {.
    ...raises: [Exception, PgError], tags: [RootEffect], forbids: [].}
proc toPgBinaryDateRangeParam(v: PgRange[DateTime]): PgParam {.
    ...raises: [Exception], tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: bool): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgBinaryParam(v: DateTime): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgBinaryParam(v: float32): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgBinaryParam(v: float64): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgBinaryParam(v: int): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgBinaryParam(v: int16): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgBinaryParam(v: int32): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgBinaryParam(v: int64): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgBinaryParam(v: JsonNode): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgBinaryParam(v: Option[JsonNode]): PgParam {....raises: [], tags: [],
    forbids: [].}
proc toPgBinaryParam(v: PgBit): PgParam {....raises: [], tags: [], forbids: [].}
Binary format: 4-byte bit count (big-endian) + packed bit data. 
proc toPgBinaryParam(v: PgBox): PgParam {....raises: [], tags: [], forbids: [].}
Binary format: 32 bytes (high point, low point). 
proc toPgBinaryParam(v: PgCidr): PgParam {....raises: [], tags: [], forbids: [].}
Binary format: family(1) + bits(1) + is_cidr(1) + addrlen(1) + addr(4|16) 
proc toPgBinaryParam(v: PgCircle): PgParam {....raises: [], tags: [], forbids: [].}
Binary format: 24 bytes (center point + radius float64). 
proc toPgBinaryParam(v: PgHstore; oid: int32): PgParam {....raises: [], tags: [],
    forbids: [].}
Encode hstore in binary format. Requires the dynamic hstore OID (available as conn.hstoreOid after connection). 
proc toPgBinaryParam(v: PgInet): PgParam {....raises: [], tags: [], forbids: [].}
Binary format: family(1) + bits(1) + is_cidr(1) + addrlen(1) + addr(4|16) 
proc toPgBinaryParam(v: PgInterval): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgBinaryParam(v: PgLine): PgParam {....raises: [], tags: [], forbids: [].}
Binary format: 24 bytes (three float64 big-endian: A, B, C). 
proc toPgBinaryParam(v: PgLseg): PgParam {....raises: [], tags: [], forbids: [].}
Binary format: 32 bytes (two points). 
proc toPgBinaryParam(v: PgMacAddr): PgParam {....raises: [ValueError], tags: [],
    forbids: [].}
Binary format: 6 raw bytes 
proc toPgBinaryParam(v: PgMacAddr8): PgParam {....raises: [ValueError], tags: [],
    forbids: [].}
Binary format: 8 raw bytes 
proc toPgBinaryParam(v: PgMultirange[DateTime]): PgParam {....raises: [Exception],
    tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: PgMultirange[int32]): PgParam {....raises: [Exception],
    tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: PgMultirange[int64]): PgParam {....raises: [Exception],
    tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: PgMultirange[PgNumeric]): PgParam {....raises: [Exception],
    tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: PgNumeric): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgBinaryParam(v: PgPath): PgParam {....raises: [], tags: [], forbids: [].}
Binary format: closed(1) + npts(4) + points(npts * 16). 
proc toPgBinaryParam(v: PgPoint): PgParam {....raises: [], tags: [], forbids: [].}
Binary format: 16 bytes (two float64 big-endian). 
proc toPgBinaryParam(v: PgPolygon): PgParam {....raises: [], tags: [], forbids: [].}
Binary format: npts(4) + points(npts * 16). 
proc toPgBinaryParam(v: PgRange[DateTime]): PgParam {....raises: [Exception],
    tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: PgRange[int32]): PgParam {....raises: [Exception],
    tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: PgRange[int64]): PgParam {....raises: [Exception],
    tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: PgRange[PgNumeric]): PgParam {....raises: [Exception],
    tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: PgTsQuery): PgParam {....raises: [], tags: [], forbids: [].}
Send as text format — PostgreSQL handles the parsing. 
proc toPgBinaryParam(v: PgTsVector): PgParam {....raises: [], tags: [], forbids: [].}
Send as text format — PostgreSQL handles the parsing. 
proc toPgBinaryParam(v: PgUuid): PgParam {....raises: [ValueError], tags: [],
    forbids: [].}
proc toPgBinaryParam(v: PgXml): PgParam {....raises: [], tags: [], forbids: [].}
Binary wire format for xml is the text representation itself. 
proc toPgBinaryParam(v: seq[byte]): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgBinaryParam(v: seq[PgBit]): PgParam {....raises: [PgError], tags: [],
    forbids: [].}
proc toPgBinaryParam(v: seq[PgRange[DateTime]]): PgParam {.
    ...raises: [Exception, PgError], tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: seq[PgRange[int32]]): PgParam {.
    ...raises: [Exception, PgError], tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: seq[PgRange[int64]]): PgParam {.
    ...raises: [Exception, PgError], tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: seq[PgRange[PgNumeric]]): PgParam {.
    ...raises: [Exception, PgError], tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: string): PgParam {....raises: [], tags: [], forbids: [].}
Convert a Nim value to a PgParam using binary format. Prefer this over toPgParam when binary format is needed for all types. 
proc toPgBinaryParam[T](v: Option[T]): PgParam
proc toPgBinaryParam[T](v: seq[T]): PgParam
proc toPgBinaryTsTzRangeArrayParam(v: seq[PgRange[DateTime]]): PgParam {.
    ...raises: [Exception, PgError], tags: [RootEffect], forbids: [].}
proc toPgBinaryTsTzRangeParam(v: PgRange[DateTime]): PgParam {.
    ...raises: [Exception], tags: [RootEffect], forbids: [].}
proc toPgDateMultirangeParam(v: PgMultirange[DateTime]): PgParam {....raises: [],
    tags: [], forbids: [].}
Encode a date multirange. DateTime values are formatted as date-only. 
proc toPgDateRangeParam(v: PgRange[DateTime]): PgParam {....raises: [], tags: [],
    forbids: [].}
Encode a date range. DateTime values are formatted as date-only. 
proc toPgMultirangeParam[T](v: PgMultirange[T]; oid: int32): PgParam
proc toPgParam(v: bool): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: DateTime): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: float32): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: float64): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: int): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: int16): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: int32): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: int64): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: JsonNode): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: Option[JsonNode]): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: PgBit): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: PgBox): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: PgCidr): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: PgCircle): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: PgHstore): PgParam {....raises: [], tags: [], forbids: [].}
Send hstore as text format. PostgreSQL casts text to hstore implicitly. 
proc toPgParam(v: PgInet): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: PgInterval): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: PgLine): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: PgLseg): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: PgMacAddr): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: PgMacAddr8): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: PgMultirange[DateTime]): PgParam {....raises: [], tags: [],
    forbids: [].}
proc toPgParam(v: PgMultirange[int32]): PgParam {....raises: [], tags: [],
    forbids: [].}
proc toPgParam(v: PgMultirange[int64]): PgParam {....raises: [], tags: [],
    forbids: [].}
proc toPgParam(v: PgMultirange[PgNumeric]): PgParam {....raises: [], tags: [],
    forbids: [].}
proc toPgParam(v: PgNumeric): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: PgPath): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: PgPoint): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: PgPolygon): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: PgRange[DateTime]): PgParam {....raises: [], tags: [],
    forbids: [].}
proc toPgParam(v: PgRange[int32]): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: PgRange[int64]): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: PgRange[PgNumeric]): PgParam {....raises: [], tags: [],
    forbids: [].}
proc toPgParam(v: PgTsQuery): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: PgTsVector): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: PgUuid): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: PgXml): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: seq[bool]): PgParam {....raises: [PgError], tags: [], forbids: [].}
proc toPgParam(v: seq[byte]): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: seq[float32]): PgParam {....raises: [PgError], tags: [],
    forbids: [].}
proc toPgParam(v: seq[float64]): PgParam {....raises: [PgError], tags: [],
    forbids: [].}
proc toPgParam(v: seq[int16]): PgParam {....raises: [PgError], tags: [],
    forbids: [].}
proc toPgParam(v: seq[int32]): PgParam {....raises: [PgError], tags: [],
    forbids: [].}
proc toPgParam(v: seq[int64]): PgParam {....raises: [PgError], tags: [],
    forbids: [].}
proc toPgParam(v: seq[PgBit]): PgParam {....raises: [PgError], tags: [],
    forbids: [].}
proc toPgParam(v: seq[string]): PgParam {....raises: [PgError], tags: [],
    forbids: [].}
proc toPgParam(v: string): PgParam {....raises: [], tags: [], forbids: [].}
Convert a Nim value to a PgParam for use as a query parameter. Uses text format for strings, binary for numeric types. 
proc toPgParam[T](v: Option[T]): PgParam
proc toPgRangeParam[T](v: PgRange[T]; oid: int32): PgParam
proc toPgTsTzMultirangeParam(v: PgMultirange[DateTime]): PgParam {....raises: [],
    tags: [], forbids: [].}
proc toPgTsTzRangeParam(v: PgRange[DateTime]): PgParam {....raises: [], tags: [],
    forbids: [].}
proc toString(s: seq[byte]): string {....raises: [], tags: [], forbids: [].}
Converts a sequence of bytes to a string. 
proc unboundedRange[T](): PgRange[T]
Create a fully unbounded range (,). 
proc writeParamFormat(buf: var seq[byte]; v: bool) {....raises: [], tags: [],
    forbids: [].}
proc writeParamFormat(buf: var seq[byte]; v: float32) {....raises: [], tags: [],
    forbids: [].}
proc writeParamFormat(buf: var seq[byte]; v: float64) {....raises: [], tags: [],
    forbids: [].}
proc writeParamFormat(buf: var seq[byte]; v: int) {....raises: [], tags: [],
    forbids: [].}
proc writeParamFormat(buf: var seq[byte]; v: int16) {....raises: [], tags: [],
    forbids: [].}
proc writeParamFormat(buf: var seq[byte]; v: int32) {....raises: [], tags: [],
    forbids: [].}
proc writeParamFormat(buf: var seq[byte]; v: int64) {....raises: [], tags: [],
    forbids: [].}
proc writeParamFormat(buf: var seq[byte]; v: PgNumeric) {....raises: [], tags: [],
    forbids: [].}
proc writeParamFormat(buf: var seq[byte]; v: seq[byte]) {....raises: [], tags: [],
    forbids: [].}
proc writeParamFormat(buf: var seq[byte]; v: string) {....raises: [], tags: [],
    forbids: [].}
proc writeParamOid(buf: var seq[byte]; v: bool) {....raises: [], tags: [],
    forbids: [].}
proc writeParamOid(buf: var seq[byte]; v: float32) {....raises: [], tags: [],
    forbids: [].}
proc writeParamOid(buf: var seq[byte]; v: float64) {....raises: [], tags: [],
    forbids: [].}
proc writeParamOid(buf: var seq[byte]; v: int) {....raises: [], tags: [],
    forbids: [].}
proc writeParamOid(buf: var seq[byte]; v: int16) {....raises: [], tags: [],
    forbids: [].}
proc writeParamOid(buf: var seq[byte]; v: int32) {....raises: [], tags: [],
    forbids: [].}
proc writeParamOid(buf: var seq[byte]; v: int64) {....raises: [], tags: [],
    forbids: [].}
proc writeParamOid(buf: var seq[byte]; v: PgNumeric) {....raises: [], tags: [],
    forbids: [].}
proc writeParamOid(buf: var seq[byte]; v: seq[byte]) {....raises: [], tags: [],
    forbids: [].}
proc writeParamOid(buf: var seq[byte]; v: string) {....raises: [], tags: [],
    forbids: [].}
proc writeParamValue(buf: var seq[byte]; v: bool) {....raises: [], tags: [],
    forbids: [].}
proc writeParamValue(buf: var seq[byte]; v: float32) {....raises: [], tags: [],
    forbids: [].}
proc writeParamValue(buf: var seq[byte]; v: float64) {....raises: [], tags: [],
    forbids: [].}
proc writeParamValue(buf: var seq[byte]; v: int) {....raises: [], tags: [],
    forbids: [].}
proc writeParamValue(buf: var seq[byte]; v: int16) {....raises: [], tags: [],
    forbids: [].}
proc writeParamValue(buf: var seq[byte]; v: int32) {....raises: [], tags: [],
    forbids: [].}
proc writeParamValue(buf: var seq[byte]; v: int64) {....raises: [], tags: [],
    forbids: [].}
proc writeParamValue(buf: var seq[byte]; v: PgNumeric) {....raises: [], tags: [],
    forbids: [].}
proc writeParamValue(buf: var seq[byte]; v: seq[byte]) {....raises: [], tags: [],
    forbids: [].}
proc writeParamValue(buf: var seq[byte]; v: string) {....raises: [], tags: [],
    forbids: [].}

Iterators

iterator items[T](mr: PgMultirange[T]): PgRange[T]

Converters

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

Macros

macro addBindDirect(buf: untyped; portalName: string; stmtName: string;
                    resultFormats: untyped; args: varargs[untyped]): untyped
Compile-time macro: generates Bind message writing params directly to buffer. Zero intermediate PgParam/seq[byte] allocations. 
macro addParseDirect(buf: untyped; stmtName: string; sql: string;
                     args: varargs[untyped]): untyped
Compile-time macro: generates Parse message with OIDs from arg types. 
macro pgComposite(T: typedesc; oid: int32 = 0'i32): untyped
Generate toPgParam for a Nim object as a PostgreSQL composite type. Each field is sent as text inside the composite text format. When OID is 0 (default), PostgreSQL infers the type from context. 
macro pgDomain(T: typedesc; Base: typedesc; oid: int32 = 0'i32): untyped
Generate toPgParam for a Nim distinct type as a PostgreSQL domain type. Encoding delegates to the base type's toPgParam. When OID is 0 (default), the base type's OID is used. 
macro pgEnum(T: untyped): untyped
Generate toPgParam for a Nim enum type. The parameter is sent as text with OID 0 (unspecified) so that PostgreSQL infers the enum type from context. 
macro pgEnum(T: untyped; oid: untyped): untyped
Generate toPgParam for a Nim enum type with an explicit OID. 
macro pgParams(args: varargs[typed]): untyped
Convert multiple values to a seq[PgParam] in one call. At least one argument is required; for parameterless queries omit the parameter argument entirely instead of calling pgParams().
await conn.query("SELECT * FROM users WHERE age > $1 AND name = $2",
  pgParams(25'i32, "Alice"))

Made with Nim. Generated: 2026-04-03 06:45:30 UTC