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`gensym238: Row; col`gensym238: int): Option[
    seq[PgMultirange[DateTime]]] {....raises: [PgTypeError, CatchableError],
                                   tags: [RootEffect], forbids: [].}
proc getDateMultirangeOpt(row`gensym211: Row; col`gensym211: 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`gensym265: Row; col`gensym265: int): Option[
    seq[PgRange[DateTime]]] {....raises: [PgTypeError, CatchableError],
                              tags: [RootEffect], forbids: [].}
proc getDateRangeOpt(row`gensym115: Row; col`gensym115: 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`gensym233: Row; col`gensym233: int): Option[
    seq[PgMultirange[int32]]] {....raises: [PgTypeError, CatchableError],
                                tags: [RootEffect], forbids: [].}
proc getInt4MultirangeOpt(row`gensym206: Row; col`gensym206: 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`gensym260: Row; col`gensym260: int): Option[
    seq[PgRange[int32]]] {....raises: [PgTypeError, CatchableError],
                           tags: [RootEffect], forbids: [].}
proc getInt4RangeOpt(row`gensym110: Row; col`gensym110: 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`gensym234: Row; col`gensym234: int): Option[
    seq[PgMultirange[int64]]] {....raises: [PgTypeError, CatchableError],
                                tags: [RootEffect], forbids: [].}
proc getInt8MultirangeOpt(row`gensym207: Row; col`gensym207: 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`gensym261: Row; col`gensym261: int): Option[
    seq[PgRange[int64]]] {....raises: [PgTypeError, CatchableError],
                           tags: [RootEffect], forbids: [].}
proc getInt8RangeOpt(row`gensym111: Row; col`gensym111: 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`gensym235: Row; col`gensym235: int): Option[
    seq[PgMultirange[PgNumeric]]] {....raises: [PgTypeError, CatchableError],
                                    tags: [RootEffect], forbids: [].}
proc getNumMultirangeOpt(row`gensym208: Row; col`gensym208: 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`gensym262: Row; col`gensym262: int): Option[
    seq[PgRange[PgNumeric]]] {....raises: [PgTypeError, CatchableError],
                               tags: [RootEffect], forbids: [].}
proc getNumRangeOpt(row`gensym112: Row; col`gensym112: 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`gensym236: Row; col`gensym236: int): Option[
    seq[PgMultirange[DateTime]]] {....raises: [PgTypeError, CatchableError],
                                   tags: [RootEffect], forbids: [].}
proc getTsMultirangeOpt(row`gensym209: Row; col`gensym209: 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`gensym263: Row; col`gensym263: int): Option[
    seq[PgRange[DateTime]]] {....raises: [PgTypeError, CatchableError],
                              tags: [RootEffect], forbids: [].}
proc getTsRangeOpt(row`gensym113: Row; col`gensym113: 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`gensym237: Row; col`gensym237: int): Option[
    seq[PgMultirange[DateTime]]] {....raises: [PgTypeError, CatchableError],
                                   tags: [RootEffect], forbids: [].}
proc getTsTzMultirangeOpt(row`gensym210: Row; col`gensym210: 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`gensym264: Row; col`gensym264: int): Option[
    seq[PgRange[DateTime]]] {....raises: [PgTypeError, CatchableError],
                              tags: [RootEffect], forbids: [].}
proc getTsTzRangeOpt(row`gensym114: Row; col`gensym114: 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 toPgBinaryDateMultirangeArrayParam(v: seq[PgMultirange[DateTime]]): PgParam {.
    ...raises: [Exception, PgTypeError, PgError], tags: [RootEffect], forbids: [].}
Encode a datemultirange[]. DateTime values are encoded as date-only. 
proc toPgBinaryDateMultirangeParam(v: PgMultirange[DateTime]): PgParam {.
    ...raises: [Exception], tags: [RootEffect], forbids: [].}
Encode a datemultirange. DateTime values are encoded as date-only. 
proc toPgBinaryDateRangeArrayParam(v: seq[PgRange[DateTime]]): PgParam {.
    ...raises: [Exception, PgTypeError, 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[PgMultirange[DateTime]]): PgParam {.
    ...raises: [Exception, PgTypeError, PgError], tags: [RootEffect], forbids: [].}
Encode a tsmultirange[] (timestamp without time zone). For tstzmultirange[] use toPgBinaryTsTzMultirangeArrayParam; for datemultirange[] use toPgBinaryDateMultirangeArrayParam. 
proc toPgBinaryParam(v: seq[PgMultirange[int32]]): PgParam {.
    ...raises: [Exception, PgTypeError, PgError], tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: seq[PgMultirange[int64]]): PgParam {.
    ...raises: [Exception, PgTypeError, PgError], tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: seq[PgMultirange[PgNumeric]]): PgParam {.
    ...raises: [Exception, PgTypeError, PgError], tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: seq[PgRange[DateTime]]): PgParam {.
    ...raises: [Exception, PgTypeError, PgError], tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: seq[PgRange[int32]]): PgParam {.
    ...raises: [Exception, PgTypeError, PgError], tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: seq[PgRange[int64]]): PgParam {.
    ...raises: [Exception, PgTypeError, PgError], tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: seq[PgRange[PgNumeric]]): PgParam {.
    ...raises: [Exception, PgTypeError, PgError], tags: [RootEffect], forbids: [].}
proc toPgBinaryTsTzMultirangeArrayParam(v: seq[PgMultirange[DateTime]]): PgParam {.
    ...raises: [Exception, PgTypeError, PgError], tags: [RootEffect], forbids: [].}
Encode a tstzmultirange[]. Disambiguates from toPgBinaryParam(seq[PgMultirange[DateTime]]) which produces tsmultirange[]. 
proc toPgBinaryTsTzMultirangeParam(v: PgMultirange[DateTime]): PgParam {.
    ...raises: [Exception], tags: [RootEffect], forbids: [].}
Encode a tstzmultirange. Disambiguates from toPgBinaryParam(PgMultirange[DateTime]) which produces tsmultirange. 
proc toPgBinaryTsTzRangeArrayParam(v: seq[PgRange[DateTime]]): PgParam {.
    ...raises: [Exception, PgTypeError, 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: [TimeFormatParseError], tags: [], forbids: [].}
Encode a date multirange. DateTime values are formatted as date-only. 
proc toPgDateRangeArrayParam(v: seq[PgRange[DateTime]]): PgParam {.
    ...raises: [TimeFormatParseError], tags: [], forbids: [].}
Encode a daterange[]. DateTime values are formatted as date-only. 
proc toPgDateRangeParam(v: PgRange[DateTime]): PgParam {.
    ...raises: [TimeFormatParseError], 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: [TimeFormatParseError],
    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: seq[PgRange[DateTime]]): PgParam {.
    ...raises: [TimeFormatParseError], tags: [], forbids: [].}
Encode a tsrange[] (timestamp without time zone, array). For tstzrange[] use toPgTsTzRangeArrayParam; for daterange[] use toPgDateRangeArrayParam. 
proc toPgParam(v: seq[PgRange[int32]]): PgParam {....raises: [], tags: [],
    forbids: [].}
proc toPgParam(v: seq[PgRange[int64]]): PgParam {....raises: [], tags: [],
    forbids: [].}
proc toPgParam(v: seq[PgRange[PgNumeric]]): PgParam {....raises: [], tags: [],
    forbids: [].}
proc toPgParam(v`gensym148: seq[PgMultirange[int32]]): PgParam {....raises: [],
    tags: [], forbids: [].}
proc toPgParam(v`gensym150: seq[PgMultirange[int64]]): PgParam {....raises: [],
    tags: [], forbids: [].}
proc toPgParam(v`gensym152: 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 toPgTsTzRangeArrayParam(v: seq[PgRange[DateTime]]): PgParam {.
    ...raises: [TimeFormatParseError], tags: [], forbids: [].}
Encode a tstzrange[] (timestamp with time zone, array). Disambiguates from toPgParam(seq[PgRange[DateTime]]) which produces tsrange[]. 
proc toPgTsTzRangeParam(v: PgRange[DateTime]): PgParam {.
    ...raises: [TimeFormatParseError], 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-29 11:06:37 UTC