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`gensym295: Row; col`gensym295: int): PgMultirange[
    DateTime] {....raises: [PgTypeError, PgTypeError, PgError, PgTypeError,
                         PgProtocolError, PgError, PgTypeError], tags: [],
                forbids: [].}
proc getDateMultirangeArray(row`gensym351: Row; col`gensym351: int): seq[
    PgMultirange[DateTime]] {....raises: [PgTypeError, PgError, PgTypeError,
                                       PgError, PgTypeError, PgTypeError,
                                       PgError, PgTypeError, PgProtocolError,
                                       PgError, PgTypeError], tags: [],
                              forbids: [].}
proc getDateMultirangeArrayOpt(row`gensym365: Row; col`gensym365: int): Option[
    seq[PgMultirange[DateTime]]] {....raises: [PgTypeError, PgError,
    PgProtocolError], tags: [], forbids: [].}
proc getDateMultirangeOpt(row`gensym305: Row; col`gensym305: int): Option[
    PgMultirange[DateTime]] {....raises: [PgTypeError, PgError, PgProtocolError],
                              tags: [], forbids: [].}
proc getDateRange(row`gensym162: Row; col`gensym162: int): PgRange[DateTime] {....raises: [
    PgTypeError, PgError, PgTypeError, PgProtocolError, PgError, PgTypeError],
    tags: [], forbids: [].}
proc getDateRangeArray(row`gensym411: Row; col`gensym411: int): seq[
    PgRange[DateTime]] {....raises: [PgTypeError, PgError, PgTypeError, PgError,
                                  PgTypeError, PgTypeError, PgError,
                                  PgTypeError, PgProtocolError, PgError,
                                  PgTypeError], tags: [], forbids: [].}
proc getDateRangeArrayOpt(row`gensym425: Row; col`gensym425: int): Option[
    seq[PgRange[DateTime]]] {....raises: [PgTypeError, PgError, PgProtocolError],
                              tags: [], forbids: [].}
proc getDateRangeOpt(row`gensym171: Row; col`gensym171: int): Option[
    PgRange[DateTime]] {....raises: [PgTypeError, PgError, PgProtocolError],
                         tags: [], forbids: [].}
proc getInt4Multirange(row`gensym210: Row; col`gensym210: int): PgMultirange[
    int32] {....raises: [PgTypeError, PgTypeError, PgTypeError, PgError,
                      PgProtocolError, PgTypeError], tags: [], forbids: [].}
proc getInt4MultirangeArray(row`gensym306: Row; col`gensym306: int): seq[
    PgMultirange[int32]] {....raises: [PgTypeError, PgError, PgTypeError, PgError,
                                    PgTypeError, PgTypeError, PgTypeError,
                                    PgProtocolError, PgError, PgTypeError],
                           tags: [], forbids: [].}
proc getInt4MultirangeArrayOpt(row`gensym360: Row; col`gensym360: int): Option[
    seq[PgMultirange[int32]]] {....raises: [PgTypeError, PgError, PgProtocolError],
                                tags: [], forbids: [].}
proc getInt4MultirangeOpt(row`gensym300: Row; col`gensym300: int): Option[
    PgMultirange[int32]] {....raises: [PgTypeError, PgError, PgProtocolError],
                           tags: [], forbids: [].}
proc getInt4Range(row`gensym74: Row; col`gensym74: int): PgRange[int32] {.
    ...raises: [PgTypeError, PgTypeError, PgError, PgProtocolError, PgTypeError],
    tags: [], forbids: [].}
proc getInt4RangeArray(row`gensym366: Row; col`gensym366: int): seq[
    PgRange[int32]] {....raises: [PgTypeError, PgError, PgTypeError, PgError,
                               PgTypeError, PgTypeError, PgTypeError,
                               PgProtocolError, PgError, PgTypeError], tags: [],
                      forbids: [].}
proc getInt4RangeArrayOpt(row`gensym420: Row; col`gensym420: int): Option[
    seq[PgRange[int32]]] {....raises: [PgTypeError, PgError, PgProtocolError],
                           tags: [], forbids: [].}
proc getInt4RangeOpt(row`gensym166: Row; col`gensym166: int): Option[
    PgRange[int32]] {....raises: [PgTypeError, PgError, PgProtocolError], tags: [],
                      forbids: [].}
proc getInt8Multirange(row`gensym230: Row; col`gensym230: int): PgMultirange[
    int64] {....raises: [PgTypeError, PgTypeError, PgTypeError, PgError,
                      PgProtocolError, PgTypeError], tags: [], forbids: [].}
proc getInt8MultirangeArray(row`gensym315: Row; col`gensym315: int): seq[
    PgMultirange[int64]] {....raises: [PgTypeError, PgError, PgTypeError, PgError,
                                    PgTypeError, PgTypeError, PgTypeError,
                                    PgProtocolError, PgError, PgTypeError],
                           tags: [], forbids: [].}
proc getInt8MultirangeArrayOpt(row`gensym361: Row; col`gensym361: int): Option[
    seq[PgMultirange[int64]]] {....raises: [PgTypeError, PgError, PgProtocolError],
                                tags: [], forbids: [].}
proc getInt8MultirangeOpt(row`gensym301: Row; col`gensym301: int): Option[
    PgMultirange[int64]] {....raises: [PgTypeError, PgError, PgProtocolError],
                           tags: [], forbids: [].}
proc getInt8Range(row`gensym95: Row; col`gensym95: int): PgRange[int64] {.
    ...raises: [PgTypeError, PgTypeError, PgError, PgProtocolError, PgTypeError],
    tags: [], forbids: [].}
proc getInt8RangeArray(row`gensym375: Row; col`gensym375: int): seq[
    PgRange[int64]] {....raises: [PgTypeError, PgError, PgTypeError, PgError,
                               PgTypeError, PgTypeError, PgTypeError,
                               PgProtocolError, PgError, PgTypeError], tags: [],
                      forbids: [].}
proc getInt8RangeArrayOpt(row`gensym421: Row; col`gensym421: int): Option[
    seq[PgRange[int64]]] {....raises: [PgTypeError, PgError, PgProtocolError],
                           tags: [], forbids: [].}
proc getInt8RangeOpt(row`gensym167: Row; col`gensym167: int): Option[
    PgRange[int64]] {....raises: [PgTypeError, PgError, PgProtocolError], tags: [],
                      forbids: [].}
proc getNumMultirange(row`gensym250: Row; col`gensym250: int): PgMultirange[
    PgNumeric] {....raises: [PgTypeError, PgTypeError, PgError, PgTypeError,
                          PgProtocolError, PgTypeError], tags: [], forbids: [].}
proc getNumMultirangeArray(row`gensym324: Row; col`gensym324: int): seq[
    PgMultirange[PgNumeric]] {....raises: [PgTypeError, PgError, PgTypeError,
                                        PgError, PgTypeError, PgTypeError,
                                        PgError, PgTypeError, PgProtocolError,
                                        PgError, PgTypeError], tags: [],
                               forbids: [].}
proc getNumMultirangeArrayOpt(row`gensym362: Row; col`gensym362: int): Option[
    seq[PgMultirange[PgNumeric]]] {....raises: [PgTypeError, PgError,
    PgProtocolError], tags: [], forbids: [].}
proc getNumMultirangeOpt(row`gensym302: Row; col`gensym302: int): Option[
    PgMultirange[PgNumeric]] {....raises: [PgTypeError, PgError, PgProtocolError],
                               tags: [], forbids: [].}
proc getNumRange(row`gensym116: Row; col`gensym116: int): PgRange[PgNumeric] {.
    ...raises: [PgTypeError, PgError, PgTypeError, PgProtocolError, PgTypeError],
    tags: [], forbids: [].}
proc getNumRangeArray(row`gensym384: Row; col`gensym384: int): seq[
    PgRange[PgNumeric]] {....raises: [PgTypeError, PgError, PgTypeError, PgError,
                                   PgTypeError, PgTypeError, PgError,
                                   PgTypeError, PgProtocolError, PgError,
                                   PgTypeError], tags: [], forbids: [].}
proc getNumRangeArrayOpt(row`gensym422: Row; col`gensym422: int): Option[
    seq[PgRange[PgNumeric]]] {....raises: [PgTypeError, PgError, PgProtocolError],
                               tags: [], forbids: [].}
proc getNumRangeOpt(row`gensym168: Row; col`gensym168: int): Option[
    PgRange[PgNumeric]] {....raises: [PgTypeError, PgError, PgProtocolError],
                          tags: [], forbids: [].}
proc getTsMultirange(row`gensym270: Row; col`gensym270: int): PgMultirange[
    DateTime] {....raises: [PgTypeError, PgTypeError, PgError, PgTypeError,
                         PgProtocolError, PgError, PgTypeError], tags: [],
                forbids: [].}
proc getTsMultirangeArray(row`gensym333: Row; col`gensym333: int): seq[
    PgMultirange[DateTime]] {....raises: [PgTypeError, PgError, PgTypeError,
                                       PgError, PgTypeError, PgTypeError,
                                       PgError, PgTypeError, PgProtocolError,
                                       PgError, PgTypeError], tags: [],
                              forbids: [].}
proc getTsMultirangeArrayOpt(row`gensym363: Row; col`gensym363: int): Option[
    seq[PgMultirange[DateTime]]] {....raises: [PgTypeError, PgError,
    PgProtocolError], tags: [], forbids: [].}
proc getTsMultirangeOpt(row`gensym303: Row; col`gensym303: int): Option[
    PgMultirange[DateTime]] {....raises: [PgTypeError, PgError, PgProtocolError],
                              tags: [], forbids: [].}
proc getTsRange(row`gensym137: Row; col`gensym137: int): PgRange[DateTime] {....raises: [
    PgTypeError, PgError, PgTypeError, PgProtocolError, PgError, PgTypeError],
    tags: [], forbids: [].}
proc getTsRangeArray(row`gensym393: Row; col`gensym393: int): seq[
    PgRange[DateTime]] {....raises: [PgTypeError, PgError, PgTypeError, PgError,
                                  PgTypeError, PgTypeError, PgError,
                                  PgTypeError, PgProtocolError, PgError,
                                  PgTypeError], tags: [], forbids: [].}
proc getTsRangeArrayOpt(row`gensym423: Row; col`gensym423: int): Option[
    seq[PgRange[DateTime]]] {....raises: [PgTypeError, PgError, PgProtocolError],
                              tags: [], forbids: [].}
proc getTsRangeOpt(row`gensym169: Row; col`gensym169: int): Option[
    PgRange[DateTime]] {....raises: [PgTypeError, PgError, PgProtocolError],
                         tags: [], forbids: [].}
proc getTsTzMultirange(row`gensym290: Row; col`gensym290: int): PgMultirange[
    DateTime] {....raises: [PgTypeError, PgTypeError, PgError, PgTypeError,
                         PgProtocolError, PgError, PgTypeError], tags: [],
                forbids: [].}
proc getTsTzMultirangeArray(row`gensym342: Row; col`gensym342: int): seq[
    PgMultirange[DateTime]] {....raises: [PgTypeError, PgError, PgTypeError,
                                       PgError, PgTypeError, PgTypeError,
                                       PgError, PgTypeError, PgProtocolError,
                                       PgError, PgTypeError], tags: [],
                              forbids: [].}
proc getTsTzMultirangeArrayOpt(row`gensym364: Row; col`gensym364: int): Option[
    seq[PgMultirange[DateTime]]] {....raises: [PgTypeError, PgError,
    PgProtocolError], tags: [], forbids: [].}
proc getTsTzMultirangeOpt(row`gensym304: Row; col`gensym304: int): Option[
    PgMultirange[DateTime]] {....raises: [PgTypeError, PgError, PgProtocolError],
                              tags: [], forbids: [].}
proc getTsTzRange(row`gensym158: Row; col`gensym158: int): PgRange[DateTime] {....raises: [
    PgTypeError, PgError, PgTypeError, PgProtocolError, PgError, PgTypeError],
    tags: [], forbids: [].}
proc getTsTzRangeArray(row`gensym402: Row; col`gensym402: int): seq[
    PgRange[DateTime]] {....raises: [PgTypeError, PgError, PgTypeError, PgError,
                                  PgTypeError, PgTypeError, PgError,
                                  PgTypeError, PgProtocolError, PgError,
                                  PgTypeError], tags: [], forbids: [].}
proc getTsTzRangeArrayOpt(row`gensym424: Row; col`gensym424: int): Option[
    seq[PgRange[DateTime]]] {....raises: [PgTypeError, PgError, PgProtocolError],
                              tags: [], forbids: [].}
proc getTsTzRangeOpt(row`gensym170: Row; col`gensym170: int): Option[
    PgRange[DateTime]] {....raises: [PgTypeError, PgError, PgProtocolError],
                         tags: [], 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.}): PgMultirange[
    T] {.effectsOf: parseElem.}
proc parseRangeText[T](s: string; parseElem: proc (s: string): T {....gcsafe.}): PgRange[
    T] {.effectsOf: parseElem.}
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: [PgTypeError, PgProtocolError], tags: [RootEffect], forbids: [].}
Encode a datemultirange[]. DateTime values are encoded as date-only. 
proc toPgBinaryDateMultirangeParam(v: PgMultirange[DateTime]): PgParam {.
    ...raises: [PgTypeError, PgProtocolError], tags: [RootEffect], forbids: [].}
Encode a datemultirange. DateTime values are encoded as date-only. 
proc toPgBinaryDateRangeArrayParam(v: seq[PgRange[DateTime]]): PgParam {.
    ...raises: [PgTypeError, PgProtocolError], tags: [RootEffect], forbids: [].}
proc toPgBinaryDateRangeParam(v: PgRange[DateTime]): PgParam {.
    ...raises: [PgTypeError, PgProtocolError], tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: PgMultirange[DateTime]): PgParam {.
    ...raises: [PgTypeError, PgProtocolError], tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: PgMultirange[int32]): PgParam {.
    ...raises: [PgTypeError, PgProtocolError], tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: PgMultirange[int64]): PgParam {.
    ...raises: [PgTypeError, PgProtocolError], tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: PgMultirange[PgNumeric]): PgParam {.
    ...raises: [PgTypeError, PgProtocolError], tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: PgRange[DateTime]): PgParam {.
    ...raises: [PgTypeError, PgProtocolError], tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: PgRange[int32]): PgParam {.
    ...raises: [PgTypeError, PgProtocolError], tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: PgRange[int64]): PgParam {.
    ...raises: [PgTypeError, PgProtocolError], tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: PgRange[PgNumeric]): PgParam {.
    ...raises: [PgTypeError, PgProtocolError], tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: seq[PgMultirange[DateTime]]): PgParam {.
    ...raises: [PgTypeError, PgProtocolError], 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: [PgTypeError, PgProtocolError], tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: seq[PgMultirange[int64]]): PgParam {.
    ...raises: [PgTypeError, PgProtocolError], tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: seq[PgMultirange[PgNumeric]]): PgParam {.
    ...raises: [PgTypeError, PgProtocolError], tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: seq[PgRange[DateTime]]): PgParam {.
    ...raises: [PgTypeError, PgProtocolError], tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: seq[PgRange[int32]]): PgParam {.
    ...raises: [PgTypeError, PgProtocolError], tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: seq[PgRange[int64]]): PgParam {.
    ...raises: [PgTypeError, PgProtocolError], tags: [RootEffect], forbids: [].}
proc toPgBinaryParam(v: seq[PgRange[PgNumeric]]): PgParam {.
    ...raises: [PgTypeError, PgProtocolError], tags: [RootEffect], forbids: [].}
proc toPgBinaryTsTzMultirangeArrayParam(v: seq[PgMultirange[DateTime]]): PgParam {.
    ...raises: [PgTypeError, PgProtocolError], tags: [RootEffect], forbids: [].}
Encode a tstzmultirange[]. Disambiguates from toPgBinaryParam(seq[PgMultirange[DateTime]]) which produces tsmultirange[]. 
proc toPgBinaryTsTzMultirangeParam(v: PgMultirange[DateTime]): PgParam {.
    ...raises: [PgTypeError, PgProtocolError], tags: [RootEffect], forbids: [].}
Encode a tstzmultirange. Disambiguates from toPgBinaryParam(PgMultirange[DateTime]) which produces tsmultirange. 
proc toPgBinaryTsTzRangeArrayParam(v: seq[PgRange[DateTime]]): PgParam {.
    ...raises: [PgTypeError, PgProtocolError], tags: [RootEffect], forbids: [].}
proc toPgBinaryTsTzRangeParam(v: PgRange[DateTime]): PgParam {.
    ...raises: [PgTypeError, PgProtocolError], tags: [RootEffect], forbids: [].}
proc toPgDateMultirangeArrayParam(v: seq[PgMultirange[DateTime]]): PgParam {.
    ...raises: [PgTypeError], tags: [RootEffect], 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: [PgTypeError], tags: [RootEffect], 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: [PgTypeError], tags: [RootEffect], 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: [PgTypeError],
    tags: [RootEffect], 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 {.
    ...raises: [PgTypeError].}
proc toPgParam(v: PgMultirange[DateTime]): PgParam {....raises: [PgTypeError],
    tags: [RootEffect], 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: [PgTypeError],
    tags: [], forbids: [].}
proc toPgParam(v: PgMultirange[int64]): PgParam {....raises: [PgTypeError],
    tags: [], forbids: [].}
proc toPgParam(v: PgMultirange[PgNumeric]): PgParam {....raises: [PgTypeError],
    tags: [], forbids: [].}
proc toPgParam(v: PgRange[DateTime]): PgParam {....raises: [PgTypeError],
    tags: [RootEffect], 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: [PgTypeError],
    tags: [RootEffect], 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: [PgTypeError],
    tags: [], forbids: [].}
proc toPgParam(v: seq[PgRange[int64]]): PgParam {....raises: [PgTypeError],
    tags: [], forbids: [].}
proc toPgParam(v: seq[PgRange[PgNumeric]]): PgParam {....raises: [PgTypeError],
    tags: [], forbids: [].}
proc toPgParam(v`gensym205: seq[PgMultirange[int32]]): PgParam {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v`gensym206: seq[PgMultirange[int64]]): PgParam {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v`gensym207: seq[PgMultirange[PgNumeric]]): PgParam {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc toPgRangeParam[T](v: PgRange[T]; oid: int32): PgParam
proc toPgTsMultirangeArrayParam(v: seq[PgMultirange[DateTime]]): PgParam {.
    ...raises: [PgTypeError], tags: [RootEffect], 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: [PgTypeError], tags: [RootEffect], forbids: [].}
proc toPgTsTzMultirangeParam(v: PgMultirange[DateTime]): PgParam {.
    ...raises: [PgTypeError], tags: [RootEffect], forbids: [].}
proc toPgTsTzRangeArrayParam(v: seq[PgRange[DateTime]]): PgParam {.
    ...raises: [PgTypeError], tags: [RootEffect], 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: [PgTypeError],
    tags: [RootEffect], 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-10-23 17:08:56 UTC