async_postgres/pg_types/ranges

Search:
Group by:

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 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`gensym272: Row; col`gensym272: int): PgMultirange[
    DateTime] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                tags: [RootEffect], forbids: [].}
proc getDateMultirangeArray(row`gensym300: Row; col`gensym300: int): seq[
    PgMultirange[DateTime]] {....raises: [PgTypeError, PgProtocolError,
                                       CatchableError], tags: [RootEffect],
                              forbids: [].}
proc getDateMultirangeArrayOpt(row`gensym309: Row; col`gensym309: int): Option[
    seq[PgMultirange[DateTime]]] {....raises: [PgTypeError, PgProtocolError,
    CatchableError], tags: [RootEffect], forbids: [].}
proc getDateMultirangeOpt(row`gensym279: Row; col`gensym279: int): Option[
    PgMultirange[DateTime]] {....raises: [PgTypeError, PgProtocolError,
                                       CatchableError], tags: [RootEffect],
                              forbids: [].}
proc getDateRange(row`gensym154: Row; col`gensym154: int): PgRange[DateTime] {.
    ...raises: [PgTypeError, PgProtocolError, CatchableError], tags: [RootEffect],
    forbids: [].}
proc getDateRangeArray(row`gensym330: Row; col`gensym330: int): seq[
    PgRange[DateTime]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                         tags: [RootEffect], forbids: [].}
proc getDateRangeArrayOpt(row`gensym339: Row; col`gensym339: int): Option[
    seq[PgRange[DateTime]]] {....raises: [PgTypeError, PgProtocolError,
                                       CatchableError], tags: [RootEffect],
                              forbids: [].}
proc getDateRangeOpt(row`gensym161: Row; col`gensym161: int): Option[
    PgRange[DateTime]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                         tags: [RootEffect], forbids: [].}
proc getInt4Multirange(row`gensym202: Row; col`gensym202: int): PgMultirange[
    int32] {....raises: [PgTypeError, PgProtocolError, CatchableError],
             tags: [RootEffect], forbids: [].}
proc getInt4MultirangeArray(row`gensym280: Row; col`gensym280: int): seq[
    PgMultirange[int32]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                           tags: [RootEffect], forbids: [].}
proc getInt4MultirangeArrayOpt(row`gensym304: Row; col`gensym304: int): Option[
    seq[PgMultirange[int32]]] {....raises: [PgTypeError, PgProtocolError,
    CatchableError], tags: [RootEffect], forbids: [].}
proc getInt4MultirangeOpt(row`gensym274: Row; col`gensym274: int): Option[
    PgMultirange[int32]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                           tags: [RootEffect], forbids: [].}
proc getInt4Range(row`gensym76: Row; col`gensym76: int): PgRange[int32] {.
    ...raises: [PgTypeError, PgProtocolError, CatchableError], tags: [RootEffect],
    forbids: [].}
proc getInt4RangeArray(row`gensym310: Row; col`gensym310: int): seq[
    PgRange[int32]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                      tags: [RootEffect], forbids: [].}
proc getInt4RangeArrayOpt(row`gensym334: Row; col`gensym334: int): Option[
    seq[PgRange[int32]]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                           tags: [RootEffect], forbids: [].}
proc getInt4RangeOpt(row`gensym156: Row; col`gensym156: int): Option[
    PgRange[int32]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                      tags: [RootEffect], forbids: [].}
proc getInt8Multirange(row`gensym219: Row; col`gensym219: int): PgMultirange[
    int64] {....raises: [PgTypeError, PgProtocolError, CatchableError],
             tags: [RootEffect], forbids: [].}
proc getInt8MultirangeArray(row`gensym284: Row; col`gensym284: int): seq[
    PgMultirange[int64]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                           tags: [RootEffect], forbids: [].}
proc getInt8MultirangeArrayOpt(row`gensym305: Row; col`gensym305: int): Option[
    seq[PgMultirange[int64]]] {....raises: [PgTypeError, PgProtocolError,
    CatchableError], tags: [RootEffect], forbids: [].}
proc getInt8MultirangeOpt(row`gensym275: Row; col`gensym275: int): Option[
    PgMultirange[int64]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                           tags: [RootEffect], forbids: [].}
proc getInt8Range(row`gensym95: Row; col`gensym95: int): PgRange[int64] {.
    ...raises: [PgTypeError, PgProtocolError, CatchableError], tags: [RootEffect],
    forbids: [].}
proc getInt8RangeArray(row`gensym314: Row; col`gensym314: int): seq[
    PgRange[int64]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                      tags: [RootEffect], forbids: [].}
proc getInt8RangeArrayOpt(row`gensym335: Row; col`gensym335: int): Option[
    seq[PgRange[int64]]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                           tags: [RootEffect], forbids: [].}
proc getInt8RangeOpt(row`gensym157: Row; col`gensym157: int): Option[
    PgRange[int64]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                      tags: [RootEffect], forbids: [].}
proc getNumMultirange(row`gensym236: Row; col`gensym236: int): PgMultirange[
    PgNumeric] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                 tags: [RootEffect], forbids: [].}
proc getNumMultirangeArray(row`gensym288: Row; col`gensym288: int): seq[
    PgMultirange[PgNumeric]] {....raises: [PgTypeError, PgProtocolError,
                                        CatchableError], tags: [RootEffect],
                               forbids: [].}
proc getNumMultirangeArrayOpt(row`gensym306: Row; col`gensym306: int): Option[
    seq[PgMultirange[PgNumeric]]] {....raises: [PgTypeError, PgProtocolError,
    CatchableError], tags: [RootEffect], forbids: [].}
proc getNumMultirangeOpt(row`gensym276: Row; col`gensym276: int): Option[
    PgMultirange[PgNumeric]] {....raises: [PgTypeError, PgProtocolError,
                                        CatchableError], tags: [RootEffect],
                               forbids: [].}
proc getNumRange(row`gensym114: Row; col`gensym114: int): PgRange[PgNumeric] {.
    ...raises: [PgTypeError, PgProtocolError, CatchableError], tags: [RootEffect],
    forbids: [].}
proc getNumRangeArray(row`gensym318: Row; col`gensym318: int): seq[
    PgRange[PgNumeric]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                          tags: [RootEffect], forbids: [].}
proc getNumRangeArrayOpt(row`gensym336: Row; col`gensym336: int): Option[
    seq[PgRange[PgNumeric]]] {....raises: [PgTypeError, PgProtocolError,
                                        CatchableError], tags: [RootEffect],
                               forbids: [].}
proc getNumRangeOpt(row`gensym158: Row; col`gensym158: int): Option[
    PgRange[PgNumeric]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                          tags: [RootEffect], forbids: [].}
proc getTsMultirange(row`gensym253: Row; col`gensym253: int): PgMultirange[
    DateTime] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                tags: [RootEffect], forbids: [].}
proc getTsMultirangeArray(row`gensym292: Row; col`gensym292: int): seq[
    PgMultirange[DateTime]] {....raises: [PgTypeError, PgProtocolError,
                                       CatchableError], tags: [RootEffect],
                              forbids: [].}
proc getTsMultirangeArrayOpt(row`gensym307: Row; col`gensym307: int): Option[
    seq[PgMultirange[DateTime]]] {....raises: [PgTypeError, PgProtocolError,
    CatchableError], tags: [RootEffect], forbids: [].}
proc getTsMultirangeOpt(row`gensym277: Row; col`gensym277: int): Option[
    PgMultirange[DateTime]] {....raises: [PgTypeError, PgProtocolError,
                                       CatchableError], tags: [RootEffect],
                              forbids: [].}
proc getTsRange(row`gensym133: Row; col`gensym133: int): PgRange[DateTime] {.
    ...raises: [PgTypeError, PgProtocolError, CatchableError], tags: [RootEffect],
    forbids: [].}
proc getTsRangeArray(row`gensym322: Row; col`gensym322: int): seq[
    PgRange[DateTime]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                         tags: [RootEffect], forbids: [].}
proc getTsRangeArrayOpt(row`gensym337: Row; col`gensym337: int): Option[
    seq[PgRange[DateTime]]] {....raises: [PgTypeError, PgProtocolError,
                                       CatchableError], tags: [RootEffect],
                              forbids: [].}
proc getTsRangeOpt(row`gensym159: Row; col`gensym159: int): Option[
    PgRange[DateTime]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                         tags: [RootEffect], forbids: [].}
proc getTsTzMultirange(row`gensym270: Row; col`gensym270: int): PgMultirange[
    DateTime] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                tags: [RootEffect], forbids: [].}
proc getTsTzMultirangeArray(row`gensym296: Row; col`gensym296: int): seq[
    PgMultirange[DateTime]] {....raises: [PgTypeError, PgProtocolError,
                                       CatchableError], tags: [RootEffect],
                              forbids: [].}
proc getTsTzMultirangeArrayOpt(row`gensym308: Row; col`gensym308: int): Option[
    seq[PgMultirange[DateTime]]] {....raises: [PgTypeError, PgProtocolError,
    CatchableError], tags: [RootEffect], forbids: [].}
proc getTsTzMultirangeOpt(row`gensym278: Row; col`gensym278: int): Option[
    PgMultirange[DateTime]] {....raises: [PgTypeError, PgProtocolError,
                                       CatchableError], tags: [RootEffect],
                              forbids: [].}
proc getTsTzRange(row`gensym152: Row; col`gensym152: int): PgRange[DateTime] {.
    ...raises: [PgTypeError, PgProtocolError, CatchableError], tags: [RootEffect],
    forbids: [].}
proc getTsTzRangeArray(row`gensym326: Row; col`gensym326: int): seq[
    PgRange[DateTime]] {....raises: [PgTypeError, PgProtocolError, CatchableError],
                         tags: [RootEffect], forbids: [].}
proc getTsTzRangeArrayOpt(row`gensym338: Row; col`gensym338: int): Option[
    seq[PgRange[DateTime]]] {....raises: [PgTypeError, PgProtocolError,
                                       CatchableError], tags: [RootEffect],
                              forbids: [].}
proc getTsTzRangeOpt(row`gensym160: Row; col`gensym160: int): Option[
    PgRange[DateTime]] {....raises: [PgTypeError, PgProtocolError, 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, PgError, PgProtocolError, PgTypeError],
    tags: [RootEffect], forbids: [].}
Encode a datemultirange[]. DateTime values are encoded as date-only. 
proc toPgBinaryDateMultirangeParam(v: PgMultirange[DateTime]): PgParam {.
    ...raises: [Exception, PgError, PgProtocolError], tags: [RootEffect],
    forbids: [].}
Encode a datemultirange. DateTime values are encoded as date-only. 
proc toPgBinaryDateRangeArrayParam(v: seq[PgRange[DateTime]]): PgParam {.
    ...raises: [Exception, PgError, PgProtocolError, PgTypeError],
    tags: [RootEffect], forbids: [].}
proc toPgBinaryDateRangeParam(v: PgRange[DateTime]): PgParam {.
    ...raises: [Exception, PgError, PgProtocolError], tags: [RootEffect],
    forbids: [].}
proc toPgBinaryParam(v: PgMultirange[DateTime]): PgParam {.
    ...raises: [Exception, PgError, PgProtocolError], tags: [RootEffect],
    forbids: [].}
proc toPgBinaryParam(v: PgMultirange[int32]): PgParam {.
    ...raises: [Exception, PgError, PgProtocolError], tags: [RootEffect],
    forbids: [].}
proc toPgBinaryParam(v: PgMultirange[int64]): PgParam {.
    ...raises: [Exception, PgError, PgProtocolError], tags: [RootEffect],
    forbids: [].}
proc toPgBinaryParam(v: PgMultirange[PgNumeric]): PgParam {.
    ...raises: [Exception, PgError, PgProtocolError], tags: [RootEffect],
    forbids: [].}
proc toPgBinaryParam(v: PgRange[DateTime]): PgParam {.
    ...raises: [Exception, PgError, PgProtocolError], tags: [RootEffect],
    forbids: [].}
proc toPgBinaryParam(v: PgRange[int32]): PgParam {.
    ...raises: [Exception, PgError, PgProtocolError], tags: [RootEffect],
    forbids: [].}
proc toPgBinaryParam(v: PgRange[int64]): PgParam {.
    ...raises: [Exception, PgError, PgProtocolError], tags: [RootEffect],
    forbids: [].}
proc toPgBinaryParam(v: PgRange[PgNumeric]): PgParam {.
    ...raises: [Exception, PgError, PgProtocolError], tags: [RootEffect],
    forbids: [].}
proc toPgBinaryParam(v: seq[PgMultirange[DateTime]]): PgParam {.
    ...raises: [Exception, PgError, PgProtocolError, PgTypeError],
    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, PgError, PgProtocolError, PgTypeError],
    tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: seq[PgMultirange[int64]]): PgParam {.
    ...raises: [Exception, PgError, PgProtocolError, PgTypeError],
    tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: seq[PgMultirange[PgNumeric]]): PgParam {.
    ...raises: [Exception, PgError, PgProtocolError, PgTypeError],
    tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: seq[PgRange[DateTime]]): PgParam {.
    ...raises: [Exception, PgError, PgProtocolError, PgTypeError],
    tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: seq[PgRange[int32]]): PgParam {.
    ...raises: [Exception, PgError, PgProtocolError, PgTypeError],
    tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: seq[PgRange[int64]]): PgParam {.
    ...raises: [Exception, PgError, PgProtocolError, PgTypeError],
    tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: seq[PgRange[PgNumeric]]): PgParam {.
    ...raises: [Exception, PgError, PgProtocolError, PgTypeError],
    tags: [RootEffect], forbids: [].}
proc toPgBinaryTsTzMultirangeArrayParam(v: seq[PgMultirange[DateTime]]): PgParam {.
    ...raises: [Exception, PgError, PgProtocolError, PgTypeError],
    tags: [RootEffect], forbids: [].}
Encode a tstzmultirange[]. Disambiguates from toPgBinaryParam(seq[PgMultirange[DateTime]]) which produces tsmultirange[]. 
proc toPgBinaryTsTzMultirangeParam(v: PgMultirange[DateTime]): PgParam {.
    ...raises: [Exception, PgError, PgProtocolError], tags: [RootEffect],
    forbids: [].}
Encode a tstzmultirange. Disambiguates from toPgBinaryParam(PgMultirange[DateTime]) which produces tsmultirange. 
proc toPgBinaryTsTzRangeArrayParam(v: seq[PgRange[DateTime]]): PgParam {.
    ...raises: [Exception, PgError, PgProtocolError, PgTypeError],
    tags: [RootEffect], forbids: [].}
proc toPgBinaryTsTzRangeParam(v: PgRange[DateTime]): PgParam {.
    ...raises: [Exception, PgError, PgProtocolError], tags: [RootEffect],
    forbids: [].}
proc toPgDateMultirangeArrayParam(v: seq[PgMultirange[DateTime]]): PgParam {.
    ...raises: [TimeFormatParseError], tags: [], forbids: [].}
Encode date multirange array. DateTime values are formatted as date-only, taking the UTC calendar day so zoned bounds match the binary pgDateDays path. 
proc toPgDateMultirangeParam(v: PgMultirange[DateTime]): PgParam {.
    ...raises: [TimeFormatParseError], tags: [], forbids: [].}
Encode a date multirange. DateTime values are formatted as date-only, taking the UTC calendar day so zoned bounds match the binary pgDateDays path. 
proc toPgDateRangeArrayParam(v: seq[PgRange[DateTime]]): PgParam {.
    ...raises: [TimeFormatParseError], tags: [], forbids: [].}
Encode a daterange[]. DateTime values are formatted as date-only, taking the UTC calendar day so zoned bounds match the binary pgDateDays path. 
proc toPgDateRangeParam(v: PgRange[DateTime]): PgParam {.
    ...raises: [TimeFormatParseError], tags: [], forbids: [].}
Encode a date range. DateTime values are formatted as date-only, taking the UTC calendar day so zoned bounds match the binary pgDateDays path. 
proc toPgMultirangeParam[T](v: PgMultirange[T]; oid: int32): PgParam
proc toPgParam(v: PgMultirange[DateTime]): PgParam {.
    ...raises: [TimeFormatParseError], tags: [], forbids: [].}
Encode a ts multirange. DateTime bounds are formatted via UTC so that zoned values match the scalar toPgParam(DateTime) path. 
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`gensym197: seq[PgMultirange[int32]]): PgParam {....raises: [],
    tags: [], forbids: [].}
proc toPgParam(v`gensym198: seq[PgMultirange[int64]]): PgParam {....raises: [],
    tags: [], forbids: [].}
proc toPgParam(v`gensym199: seq[PgMultirange[PgNumeric]]): PgParam {....raises: [],
    tags: [], forbids: [].}
proc toPgRangeParam[T](v: PgRange[T]; oid: int32): PgParam
proc toPgTsMultirangeArrayParam(v: seq[PgMultirange[DateTime]]): PgParam {.
    ...raises: [TimeFormatParseError], tags: [], forbids: [].}
Encode a tsmultirange[]. DateTime bounds are formatted via UTC so that zoned values match the scalar toPgParam(DateTime) path. 
proc toPgTsTzMultirangeArrayParam(v: seq[PgMultirange[DateTime]]): PgParam {.
    ...raises: [TimeFormatParseError], tags: [], forbids: [].}
proc toPgTsTzMultirangeParam(v: PgMultirange[DateTime]): PgParam {.
    ...raises: [TimeFormatParseError], 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-08-22 10:47:27 UTC