async_postgres/pg_types/ranges

Search:
Group by:

Types

RangeBinaryRaw = tuple[isEmpty: bool, hasLower: bool, hasUpper: bool,
                       lowerInc: bool, upperInc: bool, lowerOff: int,
                       lowerLen: int, upperOff: int, upperLen: int]

Procs

proc `$`[T](mr: PgMultirange[T]): string
proc `$`[T](r: PgRange[T]): string
proc `==`[T](a, b: PgMultirange[T]): bool
proc `==`[T](a, b: PgRange[T]): bool
proc `[]`[T](mr: PgMultirange[T]; i: int): PgRange[T]
proc decodeDateRangeBinary(data: openArray[byte]): PgRange[DateTime] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc decodeInt4RangeBinary(data: openArray[byte]): PgRange[int32] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc decodeInt8RangeBinary(data: openArray[byte]): PgRange[int64] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc decodeMultirangeBinaryRaw(data: openArray[byte]): seq[
    tuple[off: RelOff, len: int]] {....raises: [PgTypeError], tags: [], forbids: [].}
Decode the framing of a binary multirange into (off, len) pairs for each contained range. off is relative to data (typed as RelOff); recover the absolute parent-buffer offset with parentOff + p.off. 
proc decodeNumRangeBinary(data: openArray[byte]): PgRange[PgNumeric] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc decodeRangeBinaryRaw(data: openArray[byte]): RangeBinaryRaw {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc decodeTsRangeBinary(data: openArray[byte]): PgRange[DateTime] {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc emptyRange[T](): PgRange[T]
Create an empty range. 
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[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[seq[PgMultirange[int32]]]): seq[
    PgMultirange[int32]]
proc get(row: Row; col: int; T: typedesc[seq[PgMultirange[int64]]]): seq[
    PgMultirange[int64]]
proc get(row: Row; col: int; T: typedesc[seq[PgMultirange[PgNumeric]]]): seq[
    PgMultirange[PgNumeric]]
proc get(row: Row; col: int; T: typedesc[seq[PgRange[int32]]]): seq[
    PgRange[int32]]
proc get(row: Row; col: int; T: typedesc[seq[PgRange[int64]]]): seq[
    PgRange[int64]]
proc get(row: Row; col: int; T: typedesc[seq[PgRange[PgNumeric]]]): seq[
    PgRange[PgNumeric]]
proc getDateMultirange(row: Row; col: int): PgMultirange[DateTime] {.
    ...raises: [PgTypeError, CatchableError], tags: [RootEffect], forbids: [].}
Get a column value as a datemultirange. Handles binary format. 
proc getDateMultirangeArray(row: Row; col: int): seq[PgMultirange[DateTime]] {.
    ...raises: [PgTypeError, CatchableError], tags: [RootEffect], forbids: [].}
proc getDateMultirangeArrayOpt(row`gensym232: Row; col`gensym232: int): Option[
    seq[PgMultirange[DateTime]]] {....raises: [PgTypeError, CatchableError],
                                   tags: [RootEffect], forbids: [].}
proc getDateMultirangeOpt(row`gensym205: Row; col`gensym205: int): Option[
    PgMultirange[DateTime]] {....raises: [PgTypeError, CatchableError],
                              tags: [RootEffect], forbids: [].}
proc getDateRange(row: Row; col: int): PgRange[DateTime] {.
    ...raises: [PgTypeError, CatchableError], tags: [RootEffect], forbids: [].}
Get a column value as a daterange. Handles binary format. 
proc getDateRangeArray(row: Row; col: int): seq[PgRange[DateTime]] {.
    ...raises: [PgTypeError, CatchableError], tags: [RootEffect], forbids: [].}
Get a column value as a daterange[]. Handles binary format. 
proc getDateRangeArrayOpt(row`gensym259: Row; col`gensym259: int): Option[
    seq[PgRange[DateTime]]] {....raises: [PgTypeError, CatchableError],
                              tags: [RootEffect], forbids: [].}
proc getDateRangeOpt(row`gensym111: Row; col`gensym111: int): Option[
    PgRange[DateTime]] {....raises: [PgTypeError, CatchableError],
                         tags: [RootEffect], forbids: [].}
proc getInt4Multirange(row: Row; col: int): PgMultirange[int32] {.
    ...raises: [PgTypeError, CatchableError], tags: [RootEffect], forbids: [].}
Get a column value as an int4multirange. Handles binary format. 
proc getInt4MultirangeArray(row: Row; col: int): seq[PgMultirange[int32]] {.
    ...raises: [PgTypeError, CatchableError], tags: [RootEffect], forbids: [].}
proc getInt4MultirangeArrayOpt(row`gensym227: Row; col`gensym227: int): Option[
    seq[PgMultirange[int32]]] {....raises: [PgTypeError, CatchableError],
                                tags: [RootEffect], forbids: [].}
proc getInt4MultirangeOpt(row`gensym200: Row; col`gensym200: int): Option[
    PgMultirange[int32]] {....raises: [PgTypeError, CatchableError],
                           tags: [RootEffect], forbids: [].}
proc getInt4Range(row: Row; col: int): PgRange[int32] {.
    ...raises: [PgTypeError, CatchableError], tags: [RootEffect], forbids: [].}
Get a column value as an int4range. Handles binary format. 
proc getInt4RangeArray(row: Row; col: int): seq[PgRange[int32]] {.
    ...raises: [PgTypeError, CatchableError], tags: [RootEffect], forbids: [].}
Get a column value as an int4range[]. Handles binary format. 
proc getInt4RangeArrayOpt(row`gensym254: Row; col`gensym254: int): Option[
    seq[PgRange[int32]]] {....raises: [PgTypeError, CatchableError],
                           tags: [RootEffect], forbids: [].}
proc getInt4RangeOpt(row`gensym106: Row; col`gensym106: int): Option[
    PgRange[int32]] {....raises: [PgTypeError, CatchableError], tags: [RootEffect],
                      forbids: [].}
proc getInt8Multirange(row: Row; col: int): PgMultirange[int64] {.
    ...raises: [PgTypeError, CatchableError], tags: [RootEffect], forbids: [].}
Get a column value as an int8multirange. Handles binary format. 
proc getInt8MultirangeArray(row: Row; col: int): seq[PgMultirange[int64]] {.
    ...raises: [PgTypeError, CatchableError], tags: [RootEffect], forbids: [].}
proc getInt8MultirangeArrayOpt(row`gensym228: Row; col`gensym228: int): Option[
    seq[PgMultirange[int64]]] {....raises: [PgTypeError, CatchableError],
                                tags: [RootEffect], forbids: [].}
proc getInt8MultirangeOpt(row`gensym201: Row; col`gensym201: int): Option[
    PgMultirange[int64]] {....raises: [PgTypeError, CatchableError],
                           tags: [RootEffect], forbids: [].}
proc getInt8Range(row: Row; col: int): PgRange[int64] {.
    ...raises: [PgTypeError, CatchableError], tags: [RootEffect], forbids: [].}
Get a column value as an int8range. Handles binary format. 
proc getInt8RangeArray(row: Row; col: int): seq[PgRange[int64]] {.
    ...raises: [PgTypeError, CatchableError], tags: [RootEffect], forbids: [].}
Get a column value as an int8range[]. Handles binary format. 
proc getInt8RangeArrayOpt(row`gensym255: Row; col`gensym255: int): Option[
    seq[PgRange[int64]]] {....raises: [PgTypeError, CatchableError],
                           tags: [RootEffect], forbids: [].}
proc getInt8RangeOpt(row`gensym107: Row; col`gensym107: int): Option[
    PgRange[int64]] {....raises: [PgTypeError, CatchableError], tags: [RootEffect],
                      forbids: [].}
proc getNumMultirange(row: Row; col: int): PgMultirange[PgNumeric] {.
    ...raises: [PgTypeError, CatchableError], tags: [RootEffect], forbids: [].}
Get a column value as a nummultirange. Handles binary format. 
proc getNumMultirangeArray(row: Row; col: int): seq[PgMultirange[PgNumeric]] {.
    ...raises: [PgTypeError, CatchableError], tags: [RootEffect], forbids: [].}
proc getNumMultirangeArrayOpt(row`gensym229: Row; col`gensym229: int): Option[
    seq[PgMultirange[PgNumeric]]] {....raises: [PgTypeError, CatchableError],
                                    tags: [RootEffect], forbids: [].}
proc getNumMultirangeOpt(row`gensym202: Row; col`gensym202: int): Option[
    PgMultirange[PgNumeric]] {....raises: [PgTypeError, CatchableError],
                               tags: [RootEffect], forbids: [].}
proc getNumRange(row: Row; col: int): PgRange[PgNumeric] {.
    ...raises: [PgTypeError, CatchableError], tags: [RootEffect], forbids: [].}
Get a column value as a numrange. Handles binary format. 
proc getNumRangeArray(row: Row; col: int): seq[PgRange[PgNumeric]] {.
    ...raises: [PgTypeError, CatchableError], tags: [RootEffect], forbids: [].}
Get a column value as a numrange[]. Handles binary format. 
proc getNumRangeArrayOpt(row`gensym256: Row; col`gensym256: int): Option[
    seq[PgRange[PgNumeric]]] {....raises: [PgTypeError, CatchableError],
                               tags: [RootEffect], forbids: [].}
proc getNumRangeOpt(row`gensym108: Row; col`gensym108: int): Option[
    PgRange[PgNumeric]] {....raises: [PgTypeError, CatchableError],
                          tags: [RootEffect], forbids: [].}
proc getTsMultirange(row: Row; col: int): PgMultirange[DateTime] {.
    ...raises: [PgTypeError, CatchableError], tags: [RootEffect], forbids: [].}
Get a column value as a tsmultirange. Handles binary format. 
proc getTsMultirangeArray(row: Row; col: int): seq[PgMultirange[DateTime]] {.
    ...raises: [PgTypeError, CatchableError], tags: [RootEffect], forbids: [].}
proc getTsMultirangeArrayOpt(row`gensym230: Row; col`gensym230: int): Option[
    seq[PgMultirange[DateTime]]] {....raises: [PgTypeError, CatchableError],
                                   tags: [RootEffect], forbids: [].}
proc getTsMultirangeOpt(row`gensym203: Row; col`gensym203: int): Option[
    PgMultirange[DateTime]] {....raises: [PgTypeError, CatchableError],
                              tags: [RootEffect], forbids: [].}
proc getTsRange(row: Row; col: int): PgRange[DateTime] {.
    ...raises: [PgTypeError, CatchableError], tags: [RootEffect], forbids: [].}
Get a column value as a tsrange. Handles binary format. 
proc getTsRangeArray(row: Row; col: int): seq[PgRange[DateTime]] {.
    ...raises: [PgTypeError, CatchableError], tags: [RootEffect], forbids: [].}
Get a column value as a tsrange[]. Handles binary format. 
proc getTsRangeArrayOpt(row`gensym257: Row; col`gensym257: int): Option[
    seq[PgRange[DateTime]]] {....raises: [PgTypeError, CatchableError],
                              tags: [RootEffect], forbids: [].}
proc getTsRangeOpt(row`gensym109: Row; col`gensym109: int): Option[
    PgRange[DateTime]] {....raises: [PgTypeError, CatchableError],
                         tags: [RootEffect], forbids: [].}
proc getTsTzMultirange(row: Row; col: int): PgMultirange[DateTime] {.
    ...raises: [PgTypeError, CatchableError], tags: [RootEffect], forbids: [].}
Get a column value as a tstzmultirange. Handles binary format. 
proc getTsTzMultirangeArray(row: Row; col: int): seq[PgMultirange[DateTime]] {.
    ...raises: [PgTypeError, CatchableError], tags: [RootEffect], forbids: [].}
proc getTsTzMultirangeArrayOpt(row`gensym231: Row; col`gensym231: int): Option[
    seq[PgMultirange[DateTime]]] {....raises: [PgTypeError, CatchableError],
                                   tags: [RootEffect], forbids: [].}
proc getTsTzMultirangeOpt(row`gensym204: Row; col`gensym204: int): Option[
    PgMultirange[DateTime]] {....raises: [PgTypeError, CatchableError],
                              tags: [RootEffect], forbids: [].}
proc getTsTzRange(row: Row; col: int): PgRange[DateTime] {.
    ...raises: [PgTypeError, CatchableError], tags: [RootEffect], forbids: [].}
Get a column value as a tstzrange. Handles binary format. 
proc getTsTzRangeArray(row: Row; col: int): seq[PgRange[DateTime]] {.
    ...raises: [PgTypeError, CatchableError], tags: [RootEffect], forbids: [].}
Get a column value as a tstzrange[]. Handles binary format. 
proc getTsTzRangeArrayOpt(row`gensym258: Row; col`gensym258: int): Option[
    seq[PgRange[DateTime]]] {....raises: [PgTypeError, CatchableError],
                              tags: [RootEffect], forbids: [].}
proc getTsTzRangeOpt(row`gensym110: Row; col`gensym110: int): Option[
    PgRange[DateTime]] {....raises: [PgTypeError, CatchableError],
                         tags: [RootEffect], forbids: [].}
proc len[T](mr: PgMultirange[T]): int
Return the number of ranges in the multirange. 
proc parseMultirangeText[T](s: string; parseElem: proc (s: string): T {....gcsafe,
    raises: [CatchableError].}): PgMultirange[T]
proc parseRangeText[T](s: string; parseElem: proc (s: string): T {....gcsafe,
    raises: [CatchableError].}): PgRange[T]
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 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: 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: 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: 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 toPgBinaryTsTzRangeArrayParam(v: seq[PgRange[DateTime]]): PgParam {.
    ...raises: [Exception, PgError], tags: [RootEffect], forbids: [].}
proc toPgBinaryTsTzRangeParam(v: PgRange[DateTime]): PgParam {.
    ...raises: [Exception], tags: [RootEffect], forbids: [].}
proc toPgDateMultirangeArrayParam(v: seq[PgMultirange[DateTime]]): PgParam {.
    ...raises: [], tags: [], forbids: [].}
Encode date multirange array. DateTime values are formatted as date-only. 
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: 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: 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`gensym134: seq[PgMultirange[int32]]): PgParam {....raises: [],
    tags: [], forbids: [].}
proc toPgParam(v`gensym138: seq[PgMultirange[int64]]): PgParam {....raises: [],
    tags: [], forbids: [].}
proc toPgParam(v`gensym142: seq[PgMultirange[PgNumeric]]): PgParam {....raises: [],
    tags: [], forbids: [].}
proc toPgRangeParam[T](v: PgRange[T]; oid: int32): PgParam
proc toPgTsMultirangeArrayParam(v: seq[PgMultirange[DateTime]]): PgParam {.
    ...raises: [], tags: [], forbids: [].}
proc toPgTsTzMultirangeArrayParam(v: seq[PgMultirange[DateTime]]): PgParam {.
    ...raises: [], tags: [], forbids: [].}
proc toPgTsTzMultirangeParam(v: PgMultirange[DateTime]): PgParam {....raises: [],
    tags: [], forbids: [].}
proc toPgTsTzRangeParam(v: PgRange[DateTime]): PgParam {....raises: [], tags: [],
    forbids: [].}
proc unboundedRange[T](): PgRange[T]
Create a fully unbounded range (,).

Iterators

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

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