Nim → PostgreSQL parameter encoders. Caller-sized payloads raise PgTypeError (not ValueError) via checkPgBinLen/textParam.
Procs
proc addBind(buf: var seq[byte]; portalName: string; stmtName: string; params: openArray[PgParam]; resultFormats: openArray[int16] = []) {. ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}
- PgParam-aware Bind builder, sharing pg_protocol's pre-flight and atomicity.
proc addParse(buf: var seq[byte]; stmtName: string; sql: string; params: openArray[PgParam]) {. ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}
- PgParam-aware Parse builder, sharing pg_protocol's pre-flight and atomicity.
proc checkArrayLen(n: int) {.inline, ...raises: [PgTypeError], tags: [], forbids: [].}
- Validates a 1D array length without building the dimension seq, so callers can fail before allocating their element buffers.
proc checkPgBinLen(n: int; what: string) {.inline, ...raises: [PgTypeError], tags: [], forbids: [].}
- Guard payload against Int32 overflow. Raises PgTypeError.
proc checkPgBinPayload(size: int64; what: string) {.inline, ...raises: [PgTypeError], tags: [], forbids: [].}
- Cumulative payload guard. Raises PgTypeError if too large.
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 decodeByteaEscape(s: openArray[char]; errCtx: string): seq[byte] {. ...raises: [PgTypeError], tags: [], forbids: [].}
- Decode bytea text in the legacy bytea_output = escape format. Server output only ever produces \\ and \NNN (3 octal digits); other bytes pass through verbatim.
proc decodeHexPair(buf: openArray[byte]; i: int; errCtx: string): byte {. ...raises: [PgTypeError], tags: [], forbids: [].}
proc decodeHexPair(s: string; i: int; errCtx: string): byte {. ...raises: [PgTypeError], tags: [], forbids: [].}
proc dimsFor1D(n: int): seq[int32] {.inline, ...raises: [PgTypeError], tags: [], forbids: [].}
- 1D helper: @[] if n==0 else @[int32(n)]. Raises PgTypeError if n exceeds int32.high.
proc encodeBinaryArray(elemOid: int32; dims: openArray[int32]; elements: openArray[Option[seq[byte]]]): seq[byte] {. ...raises: [PgTypeError, PgProtocolError], 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, PgProtocolError], tags: [], forbids: [].}
- Encode N-dim binary array. dims.len==0 means empty array.
proc encodeHstoreBinary(v: PgHstore): seq[byte] {. ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}
- Encode hstore as PostgreSQL binary format. Format: numPairs(int32) + [keyLen(int32) + keyData + valLen(int32) + valData]...
proc encodeHstoreText(v: PgHstore): string {....raises: [PgTypeError], tags: [], forbids: [].}
- Encode hstore as PostgreSQL text format: "key1"=>"val1", "key2"=>NULL. Appended straight into result: joining a seq[string] would hold the whole literal twice, and the per-entry bound fails early on an oversized one.
proc encodeInetBinary(address: IpAddress; mask: uint8; isCidr: bool): seq[byte] {. ...raises: [], tags: [], forbids: [].}
- Encode PostgreSQL binary inet/cidr format: family(1) + bits(1) + is_cidr(1) + addrlen(1) + addr(4|16). Shared by inet and cidr (which differ only in the is_cidr byte and OID); mirrors decodeInetBinary on the decode side, which ignores is_cidr on the way back.
proc encodeJsonbBinary(node: JsonNode): seq[byte] {. ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}
- Encode JsonNode as jsonb binary (0x01 + JSON text). Raises PgTypeError if oversized.
proc encodeNumericBinary(v: PgNumeric): seq[byte] {....raises: [PgTypeError], 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: [PgTypeError, PgProtocolError], 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: [PgTypeError], tags: [], forbids: [].}
proc encodePgArrayElement(v: PgPath): seq[byte] {....raises: [PgTypeError], tags: [], forbids: [].}
proc encodePgArrayElement(v: PgPoint): seq[byte] {....raises: [], tags: [], forbids: [].}
proc encodePgArrayElement(v: PgPolygon): seq[byte] {....raises: [PgTypeError], tags: [], forbids: [].}
proc encodePgArrayElement(v: PgTime): seq[byte] {....raises: [], tags: [], forbids: [].}
proc encodePgArrayElement(v: PgTimeTz): seq[byte] {....raises: [PgTypeError], 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).
proc foldBindParam(payload: var int64; v: PgNumeric; rendered: var string) {. ...raises: [PgTypeError], tags: [], forbids: [].}
proc foldBindParam[T](payload: var int64; v: T; rendered: var string) {. ...raises: [PgTypeError].}
- Fold one addBindDirect argument into the Bind payload total, bounding it before anything is written. rendered is the write phase's scratch slot, left untouched by types that need none.
proc hexNibble(c: char): int {....raises: [], tags: [], forbids: [].}
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: [].}
func paramValueLen(v: bool): int {....raises: [], tags: [], forbids: [].}
func paramValueLen(v: float32): int {....raises: [], tags: [], forbids: [].}
func paramValueLen(v: float64): int {....raises: [], tags: [], forbids: [].}
func paramValueLen(v: int): int {....raises: [], tags: [], forbids: [].}
func paramValueLen(v: int16): int {....raises: [], tags: [], forbids: [].}
func paramValueLen(v: int32): int {....raises: [], tags: [], forbids: [].}
func paramValueLen(v: int64): int {....raises: [], tags: [], forbids: [].}
func paramValueLen(v: PgNumeric): int {....raises: [], tags: [], forbids: [].}
func paramValueLen(v: seq[byte]): int {....raises: [], tags: [], forbids: [].}
func paramValueLen(v: string): int {....raises: [], tags: [], forbids: [].}
func paramValueLenBound(v: PgNumeric): int {....raises: [], tags: [], forbids: [].}
func paramValueLenBound[T](v: T): int
- Upper bound on paramValueLen, for the direct macros' size pre-flight: measuring a PgNumeric exactly would render it a second time.
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 pgDateDays(v: DateTime): int32 {.inline, ...raises: [], tags: [], forbids: [].}
- Days since the PostgreSQL epoch (2000-01-01) for date binary format. Shared with ranges.nim.
proc pgTimestampMicros(t: Time): int64 {.inline, ...raises: [], tags: [], forbids: [].}
- Microseconds since the PostgreSQL epoch (2000-01-01 UTC) for a Time. Shared with the DateTime overload, ranges.nim, and pg_replication.currentPgTimestamp.
proc pgTimestampMicros(v: DateTime): int64 {.inline, ...raises: [], tags: [], forbids: [].}
- Microseconds since the PostgreSQL epoch (2000-01-01 UTC) for timestamp / timestamptz binary format. Shared with ranges.nim.
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: [PgTypeError, PgProtocolError], tags: [], forbids: [].}
proc toPgBinaryParam(v: Option[JsonNode]): PgParam {. ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}
proc toPgBinaryParam(v: Option[PgMoney]; scale: int = 2): PgParam {. ...raises: [PgTypeError], tags: [], forbids: [].}
- Money Option → binary with scale validation, like toPgParam.
proc toPgBinaryParam(v: PgBit): PgParam {....raises: [], tags: [], forbids: [].}
- Bit → binary (4-byte count + data). Cannot fail: initPgBit bounds nbits by PgBitMaxBits and ties data.len to it, so the payload is within checkPgBinLen by construction.
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: [PgTypeError, PgProtocolError], 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; scale: int = 2): PgParam {. ...raises: [PgTypeError], tags: [], forbids: [].}
- Money → binary with scale validation, like toPgParam.
proc toPgBinaryParam(v: PgNumeric): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgBinaryParam(v: PgPath): PgParam {....raises: [PgTypeError], 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: [PgTypeError], tags: [], forbids: [].}
- Binary format: npts(4) + points(npts * 16).
proc toPgBinaryParam(v: PgTime): PgParam {....raises: [], tags: [], forbids: [].}
proc toPgBinaryParam(v: PgTimeTz): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgBinaryParam(v: PgTsQuery): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
- Send as text format — PostgreSQL handles the parsing.
proc toPgBinaryParam(v: PgTsVector): PgParam {....raises: [PgTypeError], 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: [PgTypeError], tags: [], forbids: [].}
- Xml binary is text representation.
proc toPgBinaryParam(v: seq[byte]): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
- bytea → binary PgParam. Raises PgTypeError if oversized.
proc toPgBinaryParam(v: seq[PgBit]): PgParam {. ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}
proc toPgBinaryParam(v: seq[PgHstore]; elemOid: int32; arrayOid: int32): PgParam {. ...raises: [PgTypeError, PgProtocolError], 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: [PgTypeError], tags: [], forbids: [].}
- String → binary PgParam. Raises PgTypeError if oversized.
proc toPgBinaryParam[T](v: Option[T]): PgParam
proc toPgBinaryParam[T](v: seq[T]): PgParam {. ...raises: [PgTypeError, PgProtocolError].}
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, PgProtocolError], tags: [], forbids: [].}
proc toPgDateArrayParam(v: seq[DateTime]): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgDateParam(v: DateTime): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
- Encode a DateTime as a date parameter (OID 1082).
proc toPgMoneyArrayNDParam(v: PgArray[PgMoney]; scale: int = 2): PgParam {. ...raises: [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 PgTypeError when scale is outside 0..18 or when any element's scale differs from the parameter.
proc toPgMoneyArrayParam(v: seq[PgMoney]; scale: int = 2): PgParam {. ...raises: [PgTypeError], tags: [], forbids: [].}
- Encode seq[PgMoney] as money[]. scale must match every element's scale. Raises PgTypeError on mismatch.
proc toPgParam(v {.inject.}: seq[bool]): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v {.inject.}: seq[float32]): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v {.inject.}: seq[float64]): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v {.inject.}: seq[int16]): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v {.inject.}: seq[int32]): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v {.inject.}: seq[int64]): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v {.inject.}: seq[Option[bool]]): PgParam {. ...raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v {.inject.}: seq[Option[float32]]): PgParam {. ...raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v {.inject.}: seq[Option[float64]]): PgParam {. ...raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v {.inject.}: seq[Option[int16]]): PgParam {. ...raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v {.inject.}: seq[Option[int32]]): PgParam {. ...raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v {.inject.}: seq[Option[int64]]): PgParam {. ...raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v {.inject.}: seq[PgBox]): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v {.inject.}: seq[PgCircle]): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v {.inject.}: seq[PgInterval]): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v {.inject.}: seq[PgLine]): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v {.inject.}: seq[PgLseg]): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v {.inject.}: seq[PgMacAddr8]): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v {.inject.}: seq[PgMacAddr]): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v {.inject.}: seq[PgPoint]): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v {.inject.}: seq[PgTime]): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v {.inject.}: seq[PgTimeTz]): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v {.inject.}: seq[PgUuid]): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v: DateTime): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v: JsonNode): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v: Option[JsonNode]): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v: Option[PgMoney]; scale: int = 2): PgParam {. ...raises: [PgTypeError], tags: [], forbids: [].}
- Money Option → binary with scale validation. none encodes as NULL without touching scale; some requires v.get.scale == scale.
proc toPgParam(v: PgBit): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v: PgBox): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v: PgCidr): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v: PgCircle): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v: PgHstore): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
- Hstore → text with OID 0 (let server infer type).
proc toPgParam(v: PgInet): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v: PgInterval): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v: PgLine): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v: PgLseg): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v: PgMacAddr): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v: PgMacAddr8): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v: PgMoney; scale: int = 2): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
- Money → binary (raw int64). Text is locale-dependent. The wire carries only the raw amount, so v.scale must match the declared scale (server lc_monetary frac_digits). Defaults to 2 for the common locale.
proc toPgParam(v: PgNumeric): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v: PgPath): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v: PgPoint): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v: PgPolygon): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v: PgTime): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v: PgTimeTz): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v: PgTsQuery): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v: PgTsVector): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v: PgUuid): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v: PgXml): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v: seq[byte]): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
- bytea → binary PgParam. Raises PgTypeError if oversized.
proc toPgParam(v: seq[JsonNode]): PgParam {. ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}
proc toPgParam(v: seq[Option[int]]): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
- int has no plain seq[int] encoder (callers use seq[int64]), so it is the one Option numeric not generated by genFixedArray1D. Encoded as 8-byte int8 (OID 20), matching seq[int64].
proc toPgParam(v: seq[Option[string]]): PgParam {. ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}
proc toPgParam(v: seq[PgBit]): PgParam {....raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}
proc toPgParam(v: seq[PgHstore]): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
- Send hstore[] in text format with OID 0 (unknown) so PostgreSQL infers the parameter type from context. Works with both SELECT $1::hstore[] and INSERT INTO t(hstore_arr_col) VALUES($1). Prefer toPgBinaryParam when the hstore / hstore[] OIDs are available via lookupTypeOids (binary format, faster).
proc toPgParam(v: seq[PgMoney]): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
- seq[PgMoney] → money[] with scale=2. Use toPgMoneyArrayParam for other scales.
proc toPgParam(v: seq[PgTsQuery]): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
- Send tsquery[] in text format, for the same reason as seq[PgTsVector].
proc toPgParam(v: seq[PgTsVector]): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
- Send tsvector[] in text format. The binary wire format for tsvector is structured (not the text representation), so binary framing of text bytes would be rejected or misread by the server.
proc toPgParam(v: seq[string]): PgParam {. ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}
proc toPgParam(v: string): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
- String → text PgParam. Raises PgTypeError if oversized.
proc toPgParam(v`gensym314: seq[PgInet]): PgParam {. ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}
proc toPgParam(v`gensym317: seq[PgCidr]): PgParam {. ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}
proc toPgParam(v`gensym352: seq[PgNumeric]): PgParam {. ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}
proc toPgParam(v`gensym459: seq[PgPath]): PgParam {. ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}
proc toPgParam(v`gensym462: seq[PgPolygon]): PgParam {. ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}
proc toPgParam(v`gensym479: seq[PgXml]): PgParam {. ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}
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: Option[PgMoney]; scale: int = 2): PgParamInline {. ...raises: [PgTypeError], tags: [], forbids: [].}
- Money Option → binary with scale validation. none encodes as NULL without touching scale; some requires v.get.scale == scale.
proc toPgParamInline(v: PgMoney; scale: int = 2): PgParamInline {. ...raises: [PgTypeError], tags: [], forbids: [].}
- Money → binary with scale validation. The wire carries only the raw amount, so v.scale must match the declared scale (server lc_monetary frac_digits). Defaults to 2 for the common locale.
proc toPgParamInline(v: PgUuid): PgParamInline {. ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}
- Inline-encode uuid param. Raises PgTypeError if oversized.
proc toPgParamInline(v: seq[byte]): PgParamInline {. ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}
- Inline-encode bytea param. Raises PgTypeError if oversized.
proc toPgParamInline(v: string): PgParamInline {. ...raises: [PgTypeError, PgProtocolError], tags: [], forbids: [].}
- Inline-encode text param. Raises PgTypeError if oversized.
proc toPgParamInline[T](v: Option[T]): PgParamInline
proc toPgTimestampArrayParam(v: seq[DateTime]): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
proc toPgTimestampTzArrayParam(v: seq[DateTime]): PgParam {. ...raises: [PgTypeError], tags: [], forbids: [].}
proc toPgTimestampTzParam(v: DateTime): PgParam {....raises: [PgTypeError], tags: [], forbids: [].}
- Encode a DateTime as a timestamptz parameter (OID 1184).
proc writeBindParam(buf: var seq[byte]; v: PgNumeric; rendered: string) {. ...raises: [PgTypeError], tags: [], forbids: [].}
proc writeBindParam[T](buf: var seq[byte]; v: T; rendered: string)
- Write one pre-flighted addBindDirect parameter value.
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: [PgTypeError], tags: [], forbids: [].}
proc writeParamValue(buf: var seq[byte]; v: seq[byte]) {....raises: [PgTypeError], tags: [], forbids: [].}
proc writeParamValue(buf: var seq[byte]; v: string) {....raises: [PgTypeError], 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. Splices buf and the name operands more than once, like addParseDirect; parameters and the result-format list are bound to temporaries and evaluated once.
macro addParseDirect(buf: untyped; stmtName: string; sql: string; args: varargs[untyped]): untyped
- Compile-time macro: generates Parse message with OIDs from arg types. Splices every operand more than once, so callers must pass side-effect-free expressions (queryDirect/execDirect bind theirs to lets first).
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.
Exports
-
readString, decodeFloat32BE, writeBE32, toBE64, writeBE16, fromBE16, appendBytes, decodeFloat64BE, fromBE32, writeBE64, writeBytesAt, toBE16, readBytes, toBE32, fromBE64, $, expectedElemCount, validate, PgArrayMaxDim, pgArray, pgArray, isEmpty, pgArray, validatePgArrayShape, pgArray, ==, PgArray, pgArray, ndim