async_postgres/pg_types/encoding

Search:
Group by:

Procs

proc addBind(buf: var seq[byte]; portalName: string; stmtName: string;
             params: openArray[PgParam]; resultFormats: openArray[int16] = []) {.
    ...raises: [ValueError, ProtocolError], tags: [], forbids: [].}
proc addParse(buf: var seq[byte]; stmtName: string; sql: string;
              params: openArray[PgParam]) {....raises: [ValueError, ProtocolError],
    tags: [], forbids: [].}
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 dimsFor1D(n: int): seq[int32] {.inline, ...raises: [PgTypeError], tags: [],
                                     forbids: [].}
Helper used by 1D toPgParam wrappers: returns @[] when n == 0 (so encodeBinaryArray emits the ndim=0 wire form) and @[int32(n)] otherwise. Exported because external array encoders (ranges.nim etc.) share the same single-dimension shortcut. Raises PgTypeError when n exceeds int32.high — without this guard the int32(n) cast on 64-bit platforms would silently wrap and the resulting dims[0] would disagree with elements.len. 
proc encodeBinaryArray(elemOid: int32; dims: openArray[int32];
                       elements: openArray[Option[seq[byte]]]): seq[byte] {.
    ...raises: [PgTypeError, PgError], tags: [], forbids: [].}
Convenience overload: lowerBounds defaults to 1 for each dimension (PostgreSQL's default). 
proc encodeBinaryArray(elemOid: int32; dims: openArray[int32];
                       lowerBounds: openArray[int32];
                       elements: openArray[Option[seq[byte]]]): seq[byte] {.
    ...raises: [PgTypeError, PgError], tags: [], forbids: [].}

Encode an N-dimensional PostgreSQL binary array.

Header: ndim(4) + has_null(4) + elem_oid(4) + per-dim (dim_len(4) + lower_bound(4)). Each element is encoded as len(4) + data in row-major order; a NULL element is encoded with len = -1 and no payload. has_null is set to 1 iff any element is none.

When dims.len == 0 an empty array is emitted (ndim=0, 12-byte header, no elements); elements must be empty in that case. Otherwise elements.len must equal product(dims). See validatePgArrayShape in array.nim for the validation rules.

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 encodePgArrayElement(v: bool): seq[byte] {....raises: [], tags: [],
    forbids: [].}
proc encodePgArrayElement(v: float32): seq[byte] {....raises: [], tags: [],
    forbids: [].}
proc encodePgArrayElement(v: float64): seq[byte] {....raises: [], tags: [],
    forbids: [].}
proc encodePgArrayElement(v: int16): seq[byte] {....raises: [], tags: [],
    forbids: [].}
proc encodePgArrayElement(v: int32): seq[byte] {....raises: [], tags: [],
    forbids: [].}
proc encodePgArrayElement(v: int64): seq[byte] {....raises: [], tags: [],
    forbids: [].}
proc encodePgArrayElement(v: JsonNode): seq[byte] {....raises: [], tags: [],
    forbids: [].}
proc encodePgArrayElement(v: PgBit): seq[byte] {....raises: [], tags: [],
    forbids: [].}
proc encodePgArrayElement(v: PgBox): seq[byte] {....raises: [], tags: [],
    forbids: [].}
proc encodePgArrayElement(v: PgCidr): seq[byte] {....raises: [], tags: [],
    forbids: [].}
proc encodePgArrayElement(v: PgCircle): seq[byte] {....raises: [], tags: [],
    forbids: [].}
proc encodePgArrayElement(v: PgInet): seq[byte] {....raises: [], tags: [],
    forbids: [].}
proc encodePgArrayElement(v: PgInterval): seq[byte] {....raises: [], tags: [],
    forbids: [].}
proc encodePgArrayElement(v: PgLine): seq[byte] {....raises: [], tags: [],
    forbids: [].}
proc encodePgArrayElement(v: PgLseg): seq[byte] {....raises: [], tags: [],
    forbids: [].}
proc encodePgArrayElement(v: PgMacAddr): seq[byte] {....raises: [PgTypeError],
    tags: [], forbids: [].}
proc encodePgArrayElement(v: PgMacAddr8): seq[byte] {....raises: [PgTypeError],
    tags: [], forbids: [].}
proc encodePgArrayElement(v: PgNumeric): seq[byte] {....raises: [], tags: [],
    forbids: [].}
proc encodePgArrayElement(v: PgPath): seq[byte] {....raises: [], tags: [],
    forbids: [].}
proc encodePgArrayElement(v: PgPoint): seq[byte] {....raises: [], tags: [],
    forbids: [].}
proc encodePgArrayElement(v: PgPolygon): seq[byte] {....raises: [], tags: [],
    forbids: [].}
proc encodePgArrayElement(v: PgTime): seq[byte] {....raises: [], tags: [],
    forbids: [].}
proc encodePgArrayElement(v: PgTimeTz): seq[byte] {....raises: [], tags: [],
    forbids: [].}
proc encodePgArrayElement(v: PgUuid): seq[byte] {....raises: [PgTypeError],
    tags: [], forbids: [].}
proc encodePgArrayElement(v: PgXml): seq[byte] {....raises: [], tags: [],
    forbids: [].}
proc encodePgArrayElement(v: string): seq[byte] {....raises: [], tags: [],
    forbids: [].}
proc encodePointBinary(p: PgPoint): seq[byte] {....raises: [], tags: [],
    forbids: [].}
Encode a point as 16 bytes (two float64 big-endian). 
func paramOidOf(v: bool): int32 {....raises: [], tags: [], forbids: [].}
func paramOidOf(v: float32): int32 {....raises: [], tags: [], forbids: [].}
func paramOidOf(v: float64): int32 {....raises: [], tags: [], forbids: [].}
func paramOidOf(v: int): int32 {....raises: [], tags: [], forbids: [].}
func paramOidOf(v: int16): int32 {....raises: [], tags: [], forbids: [].}
func paramOidOf(v: int32): int32 {....raises: [], tags: [], forbids: [].}
func paramOidOf(v: int64): int32 {....raises: [], tags: [], forbids: [].}
func paramOidOf(v: PgNumeric): int32 {....raises: [], tags: [], forbids: [].}
func paramOidOf(v: seq[byte]): int32 {....raises: [], tags: [], forbids: [].}
func paramOidOf(v: string): int32 {....raises: [], tags: [], forbids: [].}
proc pgArrayArrayOid(_: typedesc[bool]): int32
proc pgArrayArrayOid(_: typedesc[float32]): int32
proc pgArrayArrayOid(_: typedesc[float64]): int32
proc pgArrayArrayOid(_: typedesc[int16]): int32
proc pgArrayArrayOid(_: typedesc[int32]): int32
proc pgArrayArrayOid(_: typedesc[int64]): int32
proc pgArrayArrayOid(_: typedesc[JsonNode]): int32
proc pgArrayArrayOid(_: typedesc[PgBit]): int32
proc pgArrayArrayOid(_: typedesc[PgBox]): int32
proc pgArrayArrayOid(_: typedesc[PgCidr]): int32
proc pgArrayArrayOid(_: typedesc[PgCircle]): int32
proc pgArrayArrayOid(_: typedesc[PgInet]): int32
proc pgArrayArrayOid(_: typedesc[PgInterval]): int32
proc pgArrayArrayOid(_: typedesc[PgLine]): int32
proc pgArrayArrayOid(_: typedesc[PgLseg]): int32
proc pgArrayArrayOid(_: typedesc[PgMacAddr8]): int32
proc pgArrayArrayOid(_: typedesc[PgMacAddr]): int32
proc pgArrayArrayOid(_: typedesc[PgNumeric]): int32
proc pgArrayArrayOid(_: typedesc[PgPath]): int32
proc pgArrayArrayOid(_: typedesc[PgPoint]): int32
proc pgArrayArrayOid(_: typedesc[PgPolygon]): int32
proc pgArrayArrayOid(_: typedesc[PgTime]): int32
proc pgArrayArrayOid(_: typedesc[PgTimeTz]): int32
proc pgArrayArrayOid(_: typedesc[PgUuid]): int32
proc pgArrayArrayOid(_: typedesc[PgXml]): int32
proc pgArrayArrayOid(_: typedesc[string]): int32
proc pgArrayElemOid(_: typedesc[bool]): int32
proc pgArrayElemOid(_: typedesc[float32]): int32
proc pgArrayElemOid(_: typedesc[float64]): int32
proc pgArrayElemOid(_: typedesc[int16]): int32
proc pgArrayElemOid(_: typedesc[int32]): int32
proc pgArrayElemOid(_: typedesc[int64]): int32
proc pgArrayElemOid(_: typedesc[JsonNode]): int32
proc pgArrayElemOid(_: typedesc[PgBit]): int32
proc pgArrayElemOid(_: typedesc[PgBox]): int32
proc pgArrayElemOid(_: typedesc[PgCidr]): int32
proc pgArrayElemOid(_: typedesc[PgCircle]): int32
proc pgArrayElemOid(_: typedesc[PgInet]): int32
proc pgArrayElemOid(_: typedesc[PgInterval]): int32
proc pgArrayElemOid(_: typedesc[PgLine]): int32
proc pgArrayElemOid(_: typedesc[PgLseg]): int32
proc pgArrayElemOid(_: typedesc[PgMacAddr8]): int32
proc pgArrayElemOid(_: typedesc[PgMacAddr]): int32
proc pgArrayElemOid(_: typedesc[PgMoney]): int32
Used by getMoneyArrayND to verify the wire elemOid. pgArrayArrayOid(PgMoney) and encodePgArrayElement(PgMoney) are intentionally not provided: money's binary wire format does not carry the scale, so callers must go through toPgMoneyArrayNDParam(v, scale = ...) (which validates every element's scale against the server's frac_digits), and the generic toPgParam(PgArray[PgMoney]) is {.error.}-gated. 
proc pgArrayElemOid(_: typedesc[PgNumeric]): int32
proc pgArrayElemOid(_: typedesc[PgPath]): int32
proc pgArrayElemOid(_: typedesc[PgPoint]): int32
proc pgArrayElemOid(_: typedesc[PgPolygon]): int32
proc pgArrayElemOid(_: typedesc[PgTime]): int32
proc pgArrayElemOid(_: typedesc[PgTimeTz]): int32
proc pgArrayElemOid(_: typedesc[PgUuid]): int32
proc pgArrayElemOid(_: typedesc[PgXml]): int32
proc pgArrayElemOid(_: typedesc[string]): int32
proc toPgBinaryDateParam(v: DateTime): PgParam {....raises: [], tags: [],
    forbids: [].}
Encode a DateTime as a binary date parameter (OID 1082). 
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, obtained via lookupTypeOids(conn, @["hstore"]). 
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: [PgTypeError], tags: [],
    forbids: [].}
Binary format: 6 raw bytes 
proc toPgBinaryParam(v: PgMacAddr8): PgParam {....raises: [PgTypeError], tags: [],
    forbids: [].}
Binary format: 8 raw bytes 
proc toPgBinaryParam(v: PgMoney): PgParam {....raises: [], tags: [], 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: PgTime): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgBinaryParam(v: PgTimeTz): PgParam {....raises: [], tags: [], 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: [PgTypeError], 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: [PgTypeError, PgError],
    tags: [], forbids: [].}
proc toPgBinaryParam(v: seq[PgHstore]; elemOid: int32; arrayOid: int32): PgParam {.
    ...raises: [PgTypeError, PgError], tags: [], forbids: [].}
Encode hstore[] in binary format. Requires the dynamic hstore and hstore[] OIDs, obtained in a single call via lookupTypeOids(conn, @["hstore"]) (the result entry exposes oid and arrayOid). 
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 toPgBinaryTimestampTzParam(v: DateTime): PgParam {....raises: [], tags: [],
    forbids: [].}
Encode a DateTime as a binary timestamptz parameter (OID 1184). 
proc toPgByteaArrayParam(v: seq[seq[byte]]): PgParam {.
    ...raises: [PgTypeError, PgError], tags: [], forbids: [].}
proc toPgDateArrayParam(v: seq[DateTime]): PgParam {.
    ...raises: [PgTypeError, PgError], tags: [], forbids: [].}
proc toPgDateParam(v: DateTime): PgParam {....raises: [], tags: [], forbids: [].}
Encode a DateTime as a date parameter (OID 1082). 
proc toPgMoneyArrayNDParam(v: PgArray[PgMoney]; scale: int = 2): PgParam {.
    ...raises: [PgError, PgTypeError], tags: [], forbids: [].}

Encoder counterpart to getMoneyArrayND. PostgreSQL's binary money wire format only carries the raw amount; the fractional-digit count is determined by the server's lc_monetary. scale declares the frac_digits the caller's PgMoney.amount values are scaled for, and every non-NULL element's scale field must match it — otherwise a silent value mismatch on the server is likely.

Raises PgError when scale is outside 0..18 or when any element's scale differs from the parameter.

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: PgMoney): PgParam {....raises: [], tags: [], forbids: [].}
Uses binary format: money's text representation is lc_monetary-dependent, so a text round-trip is not reliable. Binary sends the raw int64 amount. 
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: PgTime): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: PgTimeTz): 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: [PgTypeError, PgError],
                                        tags: [], forbids: [].}
proc toPgParam(v: seq[byte]): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgParam(v: seq[float32]): PgParam {....raises: [PgTypeError, PgError],
    tags: [], forbids: [].}
proc toPgParam(v: seq[float64]): PgParam {....raises: [PgTypeError, PgError],
    tags: [], forbids: [].}
proc toPgParam(v: seq[int16]): PgParam {....raises: [PgTypeError, PgError],
    tags: [], forbids: [].}
proc toPgParam(v: seq[int32]): PgParam {....raises: [PgTypeError, PgError],
    tags: [], forbids: [].}
proc toPgParam(v: seq[int64]): PgParam {....raises: [PgTypeError, PgError],
    tags: [], forbids: [].}
proc toPgParam(v: seq[JsonNode]): PgParam {....raises: [PgTypeError, PgError],
    tags: [], forbids: [].}
proc toPgParam(v: seq[Option[bool]]): PgParam {....raises: [PgTypeError, PgError],
    tags: [], forbids: [].}
proc toPgParam(v: seq[Option[float32]]): PgParam {.
    ...raises: [PgTypeError, PgError], tags: [], forbids: [].}
proc toPgParam(v: seq[Option[float64]]): PgParam {.
    ...raises: [PgTypeError, PgError], tags: [], forbids: [].}
proc toPgParam(v: seq[Option[int16]]): PgParam {....raises: [PgTypeError, PgError],
    tags: [], forbids: [].}
proc toPgParam(v: seq[Option[int32]]): PgParam {....raises: [PgTypeError, PgError],
    tags: [], forbids: [].}
proc toPgParam(v: seq[Option[int64]]): PgParam {....raises: [PgTypeError, PgError],
    tags: [], forbids: [].}
proc toPgParam(v: seq[Option[int]]): PgParam {....raises: [PgTypeError, PgError],
    tags: [], forbids: [].}
proc toPgParam(v: seq[Option[string]]): PgParam {.
    ...raises: [PgTypeError, PgError], tags: [], forbids: [].}
proc toPgParam(v: seq[PgBit]): PgParam {....raises: [PgTypeError, PgError],
    tags: [], forbids: [].}
proc toPgParam(v: seq[PgHstore]): PgParam {....raises: [], tags: [], forbids: [].}
Send hstore[] in text format using OidTextArray. Requires an explicit ::hstore[] cast in the SQL statement (e.g. SELECT $1::hstore[]), since the parameter is typed as text[]. No connection-specific OID is needed; prefer toPgBinaryParam when the hstore / hstore OIDs are available via lookupTypeOids (faster, no cast required). 
proc toPgParam(v: seq[string]): PgParam {....raises: [PgTypeError, 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(v`gensym92: seq[PgTime]): PgParam {.
    ...raises: [PgTypeError, PgError], tags: [], forbids: [].}
proc toPgParam(v`gensym95: seq[PgTimeTz]): PgParam {.
    ...raises: [PgTypeError, PgError], tags: [], forbids: [].}
proc toPgParam(v`gensym98: seq[PgInterval]): PgParam {.
    ...raises: [PgTypeError, PgError], tags: [], forbids: [].}
proc toPgParam(v`gensym101: seq[PgUuid]): PgParam {.
    ...raises: [PgTypeError, PgError], tags: [], forbids: [].}
proc toPgParam(v`gensym104: seq[PgInet]): PgParam {.
    ...raises: [PgTypeError, PgError], tags: [], forbids: [].}
proc toPgParam(v`gensym107: seq[PgCidr]): PgParam {.
    ...raises: [PgTypeError, PgError], tags: [], forbids: [].}
proc toPgParam(v`gensym110: seq[PgMacAddr]): PgParam {.
    ...raises: [PgTypeError, PgError], tags: [], forbids: [].}
proc toPgParam(v`gensym113: seq[PgMacAddr8]): PgParam {.
    ...raises: [PgTypeError, PgError], tags: [], forbids: [].}
proc toPgParam(v`gensym116: seq[PgMoney]): PgParam {.
    ...raises: [PgTypeError, PgError], tags: [], forbids: [].}
proc toPgParam(v`gensym119: seq[PgNumeric]): PgParam {.
    ...raises: [PgTypeError, PgError], tags: [], forbids: [].}
proc toPgParam(v`gensym158: seq[PgPoint]): PgParam {.
    ...raises: [PgTypeError, PgError], tags: [], forbids: [].}
proc toPgParam(v`gensym159: seq[PgLine]): PgParam {.
    ...raises: [PgTypeError, PgError], tags: [], forbids: [].}
proc toPgParam(v`gensym162: seq[PgLseg]): PgParam {.
    ...raises: [PgTypeError, PgError], tags: [], forbids: [].}
proc toPgParam(v`gensym165: seq[PgBox]): PgParam {.
    ...raises: [PgTypeError, PgError], tags: [], forbids: [].}
proc toPgParam(v`gensym168: seq[PgPath]): PgParam {.
    ...raises: [PgTypeError, PgError], tags: [], forbids: [].}
proc toPgParam(v`gensym171: seq[PgPolygon]): PgParam {.
    ...raises: [PgTypeError, PgError], tags: [], forbids: [].}
proc toPgParam(v`gensym174: seq[PgCircle]): PgParam {.
    ...raises: [PgTypeError, PgError], tags: [], forbids: [].}
proc toPgParam(v`gensym177: seq[PgXml]): PgParam {.
    ...raises: [PgTypeError, PgError], tags: [], forbids: [].}
proc toPgParam(v`gensym180: seq[PgTsVector]): PgParam {.
    ...raises: [PgTypeError, PgError], tags: [], forbids: [].}
proc toPgParam(v`gensym183: seq[PgTsQuery]): PgParam {.
    ...raises: [PgTypeError, PgError], tags: [], forbids: [].}
proc toPgParam[T](v: Option[T]): PgParam
proc toPgParam[T](v: PgArray[T]): PgParam

Encode an N-dimensional PgArray[T] as a PostgreSQL binary array parameter. T must be a registered scalar type — see the pgArrayElemOid / encodePgArrayElement overloads above.

For T == JsonNode the parameter is always tagged as jsonb[] (with the leading 0x01 version byte on every element). Binding such a value against a json[] column requires an explicit $1::json[] cast, otherwise PostgreSQL will reject the parameter.

proc toPgParamInline(v: bool): PgParamInline {....raises: [], tags: [], forbids: [].}
proc toPgParamInline(v: float32): PgParamInline {....raises: [], tags: [],
    forbids: [].}
proc toPgParamInline(v: float64): PgParamInline {....raises: [], tags: [],
    forbids: [].}
proc toPgParamInline(v: int): PgParamInline {....raises: [], tags: [], forbids: [].}
proc toPgParamInline(v: int16): PgParamInline {....raises: [], tags: [],
    forbids: [].}
proc toPgParamInline(v: int32): PgParamInline {....raises: [], tags: [],
    forbids: [].}
proc toPgParamInline(v: int64): PgParamInline {....raises: [], tags: [],
    forbids: [].}
proc toPgParamInline(v: PgMoney): PgParamInline {....raises: [], tags: [],
    forbids: [].}
proc toPgParamInline(v: PgUuid): PgParamInline {....raises: [], tags: [],
    forbids: [].}
proc toPgParamInline(v: seq[byte]): PgParamInline {....raises: [], tags: [],
    forbids: [].}
proc toPgParamInline(v: string): PgParamInline {....raises: [], tags: [],
    forbids: [].}
proc toPgParamInline[T](v: Option[T]): PgParamInline
proc toPgTimestampArrayParam(v: seq[DateTime]): PgParam {.
    ...raises: [PgTypeError, PgError], tags: [], forbids: [].}
proc toPgTimestampTzArrayParam(v: seq[DateTime]): PgParam {.
    ...raises: [PgTypeError, PgError], tags: [], forbids: [].}
proc toPgTimestampTzParam(v: DateTime): PgParam {....raises: [], tags: [],
    forbids: [].}
Encode a DateTime as a timestamptz parameter (OID 1184). 
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: [].}

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 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"))

Templates

template writePointAt(dst: var openArray[byte]; pos: int; p: PgPoint)
Write a point as 16 bytes (two float64 big-endian) into dst at pos.

Made with Nim. Generated: 2026-05-29 11:06:37 UTC