Documentation

This type represents a PostgreSQL interval. Intervals can have month, day, and microsecond components. Each component is bounded, so they are not arbitrary precision. For more information about intervals, consult the PostgreSQL documentation: https://www.postgresql.org/docs/17/datatype-datetime.html#DATATYPE-INTERVAL-INPUT.

Note that the time library provides several duration types that are not appropriate to use as PostgreSQL intervals:

• NominalDiffTime: Does not handle days or months. Allows up to picosecond precision. Is not bounded.
• CalendarDiffTime: Does not handle days. Embeds a NominalDiffTime. Is not bounded.
• CalendarDiffDays: Does not handle seconds. Is not bounded.

WARNING: The PostgreSQL interval parser is broken in versions prior to 15. It is not possible to round trip all intervals through PostgreSQL on those versions. You should upgrade to at least PostgreSQL version 15. For more information, see this patch: https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=e39f99046

The empty interval, representing no time at all.

>>> zero
MkInterval {months = 0, days = 0, microseconds = 0}

Creates an interval from a number of microseconds.

>>> fromMicroseconds 1
MkInterval {months = 0, days = 0, microseconds = 1}

Creates an interval from a number of milliseconds. Returns Nothing if the interval would overflow.

>>> fromMilliseconds 1
Just (MkInterval {months = 0, days = 0, microseconds = 1000})
>>> fromMilliseconds 9223372036854776
Nothing

Creates an interval from a number of seconds. Returns Nothing if the interval would overflow.

>>> fromSeconds 1
Just (MkInterval {months = 0, days = 0, microseconds = 1000000})
>>> fromSeconds 9223372036855
Nothing

Creates an interval from a number of minutes. Returns Nothing if the interval would overflow.

>>> fromMinutes 1
Just (MkInterval {months = 0, days = 0, microseconds = 60000000})
>>> fromMinutes 153722867281
Nothing

Creates an interval from a number of hours. Returns Nothing if the interval would overflow.

>>> fromHours 1
Just (MkInterval {months = 0, days = 0, microseconds = 3600000000})
>>> fromHours 2562047789
Nothing

Creates an interval from a number of days.

>>> fromDays 1
MkInterval {months = 0, days = 1, microseconds = 0}

Creates an interval from a number of weeks. Returns Nothing if the interval would overflow.

>>> fromWeeks 1
Just (MkInterval {months = 0, days = 7, microseconds = 0})
>>> fromWeeks 306783379
Nothing

Creates an interval from a number of months.

>>> fromMonths 1
MkInterval {months = 1, days = 0, microseconds = 0}

Creates an interval from a number of years. Returns Nothing if the interval would overflow.

>>> fromYears 1
Just (MkInterval {months = 12, days = 0, microseconds = 0})
>>> fromYears 178956971
Nothing

Adds two intervals. Returns Nothing if the result would overflow.

>>> add (fromMonths 1) (fromDays 2)
Just (MkInterval {months = 1, days = 2, microseconds = 0})
>>> add (fromDays 2147483647) (fromDays 1)
Nothing

Renders an interval to a Builder. This always has the same format: "@ A mon B day C hour D min E sec F us", where A, B, C, D, E, and F are signed integers.

This is not the most compact format, but it is very easy to interpret and does not require dealing with decimals (which could introduce precision problems).

>>> render MkInterval { months = 0, days = -1, microseconds = 2 }
"@ 0 mon -1 day 0 hour 0 min 0 sec +2 us"

Parses an interval. This is not a general purpose parser. It only supports the formats that PostgreSQL generates. For example, it will fail to parse an interval like "1 week" because PostgreSQL never uses weeks when rendering intervals.

One component of an interval. This is used to retain arbitrary precision for as long as possible before converting. It also shows which components are accepted, like years and months.

Converts a Component to an Interval. Returns Nothing if the component would overflow.

Converts a list of Components to an Interval. Returns Nothing if any of the components would overflow, or if adding any of them together would overflow.