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`gensym268: Row; col`gensym268: int): PgMultirange[
    DateTime] {....raises: [PgTypeError, PgError, PgProtocolError, CatchableError],
                tags: [RootEffect], forbids: [].}
proc getDateMultirangeArray(row`gensym298: Row; col`gensym298: int): seq[
    PgMultirange[DateTime]] {....raises: [PgTypeError, PgError, PgProtocolError,
                                       CatchableError], tags: [RootEffect],
                              forbids: [].}
proc getDateMultirangeArrayOpt(row`gensym307: Row; col`gensym307: int): Option[
    seq[PgMultirange[DateTime]]] {....raises: [PgTypeError, PgError,
    PgProtocolError, CatchableError], tags: [RootEffect], forbids: [].}
proc getDateMultirangeOpt(row`gensym275: Row; col`gensym275: int): Option[
    PgMultirange[DateTime]] {....raises: [PgTypeError, PgError, PgProtocolError,
                                       CatchableError], tags: [RootEffect],
                              forbids: [].}
proc getDateRange(row`gensym152: Row; col`gensym152: int): PgRange[DateTime] {.
    ...raises: [PgTypeError, PgError, PgProtocolError, CatchableError],
    tags: [RootEffect], forbids: [].}
proc getDateRangeArray(row`gensym328: Row; col`gensym328: int): seq[
    PgRange[DateTime]] {....raises: [PgTypeError, PgError, PgProtocolError,
                                  CatchableError], tags: [RootEffect],
                         forbids: [].}
proc getDateRangeArrayOpt(row`gensym337: Row; col`gensym337: int): Option[
    seq[PgRange[DateTime]]] {....raises: [PgTypeError, PgError, PgProtocolError,
                                       CatchableError], tags: [RootEffect],
                              forbids: [].}
proc getDateRangeOpt(row`gensym159: Row; col`gensym159: int): Option[
    PgRange[DateTime]] {....raises: [PgTypeError, PgError, PgProtocolError,
                                  CatchableError], tags: [RootEffect],
                         forbids: [].}
proc getInt4Multirange(row`gensym198: Row; col`gensym198: int): PgMultirange[
    int32] {....raises: [PgTypeError, PgError, PgProtocolError, CatchableError],
             tags: [RootEffect], forbids: [].}
proc getInt4MultirangeArray(row`gensym278: Row; col`gensym278: int): seq[
    PgMultirange[int32]] {....raises: [PgTypeError, PgError, PgProtocolError,
                                    CatchableError], tags: [RootEffect],
                           forbids: [].}
proc getInt4MultirangeArrayOpt(row`gensym302: Row; col`gensym302: int): Option[
    seq[PgMultirange[int32]]] {....raises: [PgTypeError, PgError, PgProtocolError,
    CatchableError], tags: [RootEffect], forbids: [].}
proc getInt4MultirangeOpt(row`gensym270: Row; col`gensym270: int): Option[
    PgMultirange[int32]] {....raises: [PgTypeError, PgError, PgProtocolError,
                                    CatchableError], tags: [RootEffect],
                           forbids: [].}
proc getInt4Range(row`gensym74: Row; col`gensym74: int): PgRange[int32] {.
    ...raises: [PgTypeError, PgError, PgProtocolError, CatchableError],
    tags: [RootEffect], forbids: [].}
proc getInt4RangeArray(row`gensym308: Row; col`gensym308: int): seq[
    PgRange[int32]] {....raises: [PgTypeError, PgError, PgProtocolError,
                               CatchableError], tags: [RootEffect], forbids: [].}
proc getInt4RangeArrayOpt(row`gensym332: Row; col`gensym332: int): Option[
    seq[PgRange[int32]]] {....raises: [PgTypeError, PgError, PgProtocolError,
                                    CatchableError], tags: [RootEffect],
                           forbids: [].}
proc getInt4RangeOpt(row`gensym154: Row; col`gensym154: int): Option[
    PgRange[int32]] {....raises: [PgTypeError, PgError, PgProtocolError,
                               CatchableError], tags: [RootEffect], forbids: [].}
proc getInt8Multirange(row`gensym215: Row; col`gensym215: int): PgMultirange[
    int64] {....raises: [PgTypeError, PgError, PgProtocolError, CatchableError],
             tags: [RootEffect], forbids: [].}
proc getInt8MultirangeArray(row`gensym282: Row; col`gensym282: int): seq[
    PgMultirange[int64]] {....raises: [PgTypeError, PgError, PgProtocolError,
                                    CatchableError], tags: [RootEffect],
                           forbids: [].}
proc getInt8MultirangeArrayOpt(row`gensym303: Row; col`gensym303: int): Option[
    seq[PgMultirange[int64]]] {....raises: [PgTypeError, PgError, PgProtocolError,
    CatchableError], tags: [RootEffect], forbids: [].}
proc getInt8MultirangeOpt(row`gensym271: Row; col`gensym271: int): Option[
    PgMultirange[int64]] {....raises: [PgTypeError, PgError, PgProtocolError,
                                    CatchableError], tags: [RootEffect],
                           forbids: [].}
proc getInt8Range(row`gensym93: Row; col`gensym93: int): PgRange[int64] {.
    ...raises: [PgTypeError, PgError, PgProtocolError, CatchableError],
    tags: [RootEffect], forbids: [].}
proc getInt8RangeArray(row`gensym312: Row; col`gensym312: int): seq[
    PgRange[int64]] {....raises: [PgTypeError, PgError, PgProtocolError,
                               CatchableError], tags: [RootEffect], forbids: [].}
proc getInt8RangeArrayOpt(row`gensym333: Row; col`gensym333: int): Option[
    seq[PgRange[int64]]] {....raises: [PgTypeError, PgError, PgProtocolError,
                                    CatchableError], tags: [RootEffect],
                           forbids: [].}
proc getInt8RangeOpt(row`gensym155: Row; col`gensym155: int): Option[
    PgRange[int64]] {....raises: [PgTypeError, PgError, PgProtocolError,
                               CatchableError], tags: [RootEffect], forbids: [].}
proc getNumMultirange(row`gensym232: Row; col`gensym232: int): PgMultirange[
    PgNumeric] {....raises: [PgTypeError, PgError, PgProtocolError, CatchableError],
                 tags: [RootEffect], forbids: [].}
proc getNumMultirangeArray(row`gensym286: Row; col`gensym286: int): seq[
    PgMultirange[PgNumeric]] {....raises: [PgTypeError, PgError, PgProtocolError,
                                        CatchableError], tags: [RootEffect],
                               forbids: [].}
proc getNumMultirangeArrayOpt(row`gensym304: Row; col`gensym304: int): Option[
    seq[PgMultirange[PgNumeric]]] {....raises: [PgTypeError, PgError,
    PgProtocolError, CatchableError], tags: [RootEffect], forbids: [].}
proc getNumMultirangeOpt(row`gensym272: Row; col`gensym272: int): Option[
    PgMultirange[PgNumeric]] {....raises: [PgTypeError, PgError, PgProtocolError,
                                        CatchableError], tags: [RootEffect],
                               forbids: [].}
proc getNumRange(row`gensym112: Row; col`gensym112: int): PgRange[PgNumeric] {.
    ...raises: [PgTypeError, PgError, PgProtocolError, CatchableError],
    tags: [RootEffect], forbids: [].}
proc getNumRangeArray(row`gensym316: Row; col`gensym316: int): seq[
    PgRange[PgNumeric]] {....raises: [PgTypeError, PgError, PgProtocolError,
                                   CatchableError], tags: [RootEffect],
                          forbids: [].}
proc getNumRangeArrayOpt(row`gensym334: Row; col`gensym334: int): Option[
    seq[PgRange[PgNumeric]]] {....raises: [PgTypeError, PgError, PgProtocolError,
                                        CatchableError], tags: [RootEffect],
                               forbids: [].}
proc getNumRangeOpt(row`gensym156: Row; col`gensym156: int): Option[
    PgRange[PgNumeric]] {....raises: [PgTypeError, PgError, PgProtocolError,
                                   CatchableError], tags: [RootEffect],
                          forbids: [].}
proc getTsMultirange(row`gensym249: Row; col`gensym249: int): PgMultirange[
    DateTime] {....raises: [PgTypeError, PgError, PgProtocolError, CatchableError],
                tags: [RootEffect], forbids: [].}
proc getTsMultirangeArray(row`gensym290: Row; col`gensym290: int): seq[
    PgMultirange[DateTime]] {....raises: [PgTypeError, PgError, PgProtocolError,
                                       CatchableError], tags: [RootEffect],
                              forbids: [].}
proc getTsMultirangeArrayOpt(row`gensym305: Row; col`gensym305: int): Option[
    seq[PgMultirange[DateTime]]] {....raises: [PgTypeError, PgError,
    PgProtocolError, CatchableError], tags: [RootEffect], forbids: [].}
proc getTsMultirangeOpt(row`gensym273: Row; col`gensym273: int): Option[
    PgMultirange[DateTime]] {....raises: [PgTypeError, PgError, PgProtocolError,
                                       CatchableError], tags: [RootEffect],
                              forbids: [].}
proc getTsRange(row`gensym131: Row; col`gensym131: int): PgRange[DateTime] {.
    ...raises: [PgTypeError, PgError, PgProtocolError, CatchableError],
    tags: [RootEffect], forbids: [].}
proc getTsRangeArray(row`gensym320: Row; col`gensym320: int): seq[
    PgRange[DateTime]] {....raises: [PgTypeError, PgError, PgProtocolError,
                                  CatchableError], tags: [RootEffect],
                         forbids: [].}
proc getTsRangeArrayOpt(row`gensym335: Row; col`gensym335: int): Option[
    seq[PgRange[DateTime]]] {....raises: [PgTypeError, PgError, PgProtocolError,
                                       CatchableError], tags: [RootEffect],
                              forbids: [].}
proc getTsRangeOpt(row`gensym157: Row; col`gensym157: int): Option[
    PgRange[DateTime]] {....raises: [PgTypeError, PgError, PgProtocolError,
                                  CatchableError], tags: [RootEffect],
                         forbids: [].}
proc getTsTzMultirange(row`gensym266: Row; col`gensym266: int): PgMultirange[
    DateTime] {....raises: [PgTypeError, PgError, PgProtocolError, CatchableError],
                tags: [RootEffect], forbids: [].}
proc getTsTzMultirangeArray(row`gensym294: Row; col`gensym294: int): seq[
    PgMultirange[DateTime]] {....raises: [PgTypeError, PgError, PgProtocolError,
                                       CatchableError], tags: [RootEffect],
                              forbids: [].}
proc getTsTzMultirangeArrayOpt(row`gensym306: Row; col`gensym306: int): Option[
    seq[PgMultirange[DateTime]]] {....raises: [PgTypeError, PgError,
    PgProtocolError, CatchableError], tags: [RootEffect], forbids: [].}
proc getTsTzMultirangeOpt(row`gensym274: Row; col`gensym274: int): Option[
    PgMultirange[DateTime]] {....raises: [PgTypeError, PgError, PgProtocolError,
                                       CatchableError], tags: [RootEffect],
                              forbids: [].}
proc getTsTzRange(row`gensym150: Row; col`gensym150: int): PgRange[DateTime] {.
    ...raises: [PgTypeError, PgError, PgProtocolError, CatchableError],
    tags: [RootEffect], forbids: [].}
proc getTsTzRangeArray(row`gensym324: Row; col`gensym324: int): seq[
    PgRange[DateTime]] {....raises: [PgTypeError, PgError, PgProtocolError,
                                  CatchableError], tags: [RootEffect],
                         forbids: [].}
proc getTsTzRangeArrayOpt(row`gensym336: Row; col`gensym336: int): Option[
    seq[PgRange[DateTime]]] {....raises: [PgTypeError, PgError, PgProtocolError,
                                       CatchableError], tags: [RootEffect],
                              forbids: [].}
proc getTsTzRangeOpt(row`gensym158: Row; col`gensym158: int): Option[
    PgRange[DateTime]] {....raises: [PgTypeError, PgError, 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: [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: [], 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: [], 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: [], 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: [], 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 {.
    ...raises: [PgTypeError].}
proc toPgParam(v: PgMultirange[DateTime]): PgParam {....raises: [PgTypeError],
    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: [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: [], 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: [PgTypeError],
    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: [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`gensym193: seq[PgMultirange[int32]]): PgParam {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v`gensym194: seq[PgMultirange[int64]]): PgParam {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc toPgParam(v`gensym195: 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: [], 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: [], forbids: [].}
proc toPgTsTzMultirangeParam(v: PgMultirange[DateTime]): PgParam {.
    ...raises: [PgTypeError], tags: [], forbids: [].}
proc toPgTsTzRangeArrayParam(v: seq[PgRange[DateTime]]): PgParam {.
    ...raises: [PgTypeError], 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: [], 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-09-11 08:44:51 UTC