feat(datatype, interval): support interval, timedelta

Author: Brooke-white

redshift_connector/interval.py

@@ -1,85 +1,89 @@
-# from redshift_connector.config import max_int4, max_int8, min_int4, min_int8
-#
-#
-# class Interval:
-#     """An Interval represents a measurement of time.  In PostgreSQL, an
-#     interval is defined in the measure of months, days, and microseconds; as
-#     such, the interval type represents the same information.
-#
-#     Note that values of the :attr:`microseconds`, :attr:`days` and
-#     :attr:`months` properties are independently measured and cannot be
-#     converted to each other.  A month may be 28, 29, 30, or 31 days, and a day
-#     may occasionally be lengthened slightly by a leap second.
-#
-#     .. attribute:: microseconds
-#
-#         Measure of microseconds in the interval.
-#
-#         The microseconds value is constrained to fit into a signed 64-bit
-#         integer.  Any attempt to set a value too large or too small will result
-#         in an OverflowError being raised.
-#
-#     .. attribute:: days
-#
-#         Measure of days in the interval.
-#
-#         The days value is constrained to fit into a signed 32-bit integer.
-#         Any attempt to set a value too large or too small will result in an
-#         OverflowError being raised.
-#
-#     .. attribute:: months
-#
-#         Measure of months in the interval.
-#
-#         The months value is constrained to fit into a signed 32-bit integer.
-#         Any attempt to set a value too large or too small will result in an
-#         OverflowError being raised.
-#     """
-#
-#     def __init__(self: 'Interval', microseconds: int = 0, days: int = 0, months: int = 0) -> None:
-#         self.microseconds = microseconds
-#         self.days = days
-#         self.months = months
-#
-#     def _setMicroseconds(self: 'Interval', value: int) -> None:
-#         if not isinstance(value, int):
-#             raise TypeError("microseconds must be an integer type")
-#         elif not (min_int8 < value < max_int8):
-#             raise OverflowError(
-#                 "microseconds must be representable as a 64-bit integer")
-#         else:
-#             self._microseconds = value
-#
-#     def _setDays(self: 'Interval', value: int) -> None:
-#         if not isinstance(value, int):
-#             raise TypeError("days must be an integer type")
-#         elif not (min_int4 < value < max_int4):
-#             raise OverflowError(
-#                 "days must be representable as a 32-bit integer")
-#         else:
-#             self._days = value
-#
-#     def _setMonths(self: 'Interval', value: int) -> None:
-#         if not isinstance(value, int):
-#             raise TypeError("months must be an integer type")
-#         elif not (min_int4 < value < max_int4):
-#             raise OverflowError(
-#                 "months must be representable as a 32-bit integer")
-#         else:
-#             self._months = value
-#
-#     microseconds = property(lambda self: self._microseconds, _setMicroseconds)
-#     days = property(lambda self: self._days, _setDays)
-#     months = property(lambda self: self._months, _setMonths)
-#
-#     def __repr__(self: 'Interval') -> str:
-#         return "<Interval %s months %s days %s microseconds>" % (
-#             self.months, self.days, self.microseconds)
-#
-#     def __eq__(self: 'Interval', other: object) -> bool:
-#         return other is not None and isinstance(other, Interval) and \
-#             self.months == other.months and self.days == other.days and \
-#             self.microseconds == other.microseconds
-#
-#     def __neq__(self: 'Interval', other: 'Interval') -> bool:
-#         return not self.__eq__(other)
+from redshift_connector.config import max_int4, max_int8, min_int4, min_int8
+
+
+class Interval:
+    """An Interval represents a measurement of time.  In PostgreSQL, an
+    interval is defined in the measure of months, days, and microseconds; as
+    such, the interval type represents the same information.
+
+    Note that values of the :attr:`microseconds`, :attr:`days` and
+    :attr:`months` properties are independently measured and cannot be
+    converted to each other.  A month may be 28, 29, 30, or 31 days, and a day
+    may occasionally be lengthened slightly by a leap second.
+
+    .. attribute:: microseconds
+
+        Measure of microseconds in the interval.
+
+        The microseconds value is constrained to fit into a signed 64-bit
+        integer.  Any attempt to set a value too large or too small will result
+        in an OverflowError being raised.
+
+    .. attribute:: days
+
+        Measure of days in the interval.
+
+        The days value is constrained to fit into a signed 32-bit integer.
+        Any attempt to set a value too large or too small will result in an
+        OverflowError being raised.
+
+    .. attribute:: months
+
+        Measure of months in the interval.
+
+        The months value is constrained to fit into a signed 32-bit integer.
+        Any attempt to set a value too large or too small will result in an
+        OverflowError being raised.
+    """
+
+    def __init__(self: "Interval", microseconds: int = 0, days: int = 0, months: int = 0) -> None:
+        self.microseconds = microseconds
+        self.days = days
+        self.months = months
+
+    def _setMicroseconds(self: "Interval", value: int) -> None:
+        if not isinstance(value, int):
+            raise TypeError("microseconds must be an integer type")
+        elif not (min_int8 < value < max_int8):
+            raise OverflowError("microseconds must be representable as a 64-bit integer")
+        else:
+            self._microseconds = value
+
+    def _setDays(self: "Interval", value: int) -> None:
+        if not isinstance(value, int):
+            raise TypeError("days must be an integer type")
+        elif not (min_int4 < value < max_int4):
+            raise OverflowError("days must be representable as a 32-bit integer")
+        else:
+            self._days = value
+
+    def _setMonths(self: "Interval", value: int) -> None:
+        if not isinstance(value, int):
+            raise TypeError("months must be an integer type")
+        elif not (min_int4 < value < max_int4):
+            raise OverflowError("months must be representable as a 32-bit integer")
+        else:
+            self._months = value
+
+    microseconds = property(lambda self: self._microseconds, _setMicroseconds)
+    days = property(lambda self: self._days, _setDays)
+    months = property(lambda self: self._months, _setMonths)
+
+    def __repr__(self: "Interval") -> str:
+        return "<Interval %s months %s days %s microseconds>" % (self.months, self.days, self.microseconds)
+
+    def __eq__(self: "Interval", other: object) -> bool:
+        return (
+            other is not None
+            and isinstance(other, Interval)
+            and self.months == other.months
+            and self.days == other.days
+            and self.microseconds == other.microseconds
+        )
+
+    def __neq__(self: "Interval", other: "Interval") -> bool:
+        return not self.__eq__(other)
+
+    def total_seconds(self: "Interval") -> float:
+        """Total seconds in the Interval, excluding month field."""
+        return ((self.days * 86400) * 10 ** 6 + self.microseconds) / 10 ** 6

redshift_connector/utils/type_utils.py

@@ -21,6 +21,7 @@
     _client_encoding,
     timegm,
 )
+from redshift_connector.interval import Interval
 from redshift_connector.pg_types import (
     PGEnum,
     PGJson,
@@ -115,6 +116,7 @@ def pack_funcs(fmt: str) -> typing.Tuple[typing.Callable, typing.Callable]:
 f_pack, f_unpack = pack_funcs("f")
 iii_pack, iii_unpack = pack_funcs("iii")
 ii_pack, ii_unpack = pack_funcs("ii")
+qhh_pack, qhh_unpack = pack_funcs("qhh")
 qii_pack, qii_unpack = pack_funcs("qii")
 dii_pack, dii_unpack = pack_funcs("dii")
 ihihih_pack, ihihih_unpack = pack_funcs("ihihih")
@@ -235,19 +237,15 @@ def timestamptz_recv_integer(data: bytes, offset: int, length: int) -> typing.Un
             return Datetime.max
 
 
-# def interval_send_integer(v: typing.Union[Interval, Timedelta]) -> bytes:
-#     microseconds: int = v.microseconds
-#     try:
-#         microseconds += int(v.seconds * 1e6)  # type: ignore
-#     except AttributeError:
-#         pass
-#
-#     try:
-#         months = v.months  # type: ignore
-#     except AttributeError:
-#         months = 0
-#
-#     return typing.cast(bytes, qii_pack(microseconds, v.days, months))
+def interval_send_integer(v: typing.Union[Timedelta, Interval]) -> bytes:
+    microseconds: int = int(v.total_seconds() * 1e6)
+
+    try:
+        months = v.months  # type: ignore
+    except AttributeError:
+        months = 0
+
+    return typing.cast(bytes, qhh_pack(microseconds, 0, months))
 
 
 glbls: typing.Dict[str, type] = {"Decimal": Decimal}
@@ -292,15 +290,13 @@ def numeric_in(data: bytes, offset: int, length: int) -> Decimal:
 #     return UUID(bytes=data[offset:offset+length])
 
 
-# def interval_recv_integer(data: bytes, offset: int, length: int) -> typing.Union[Timedelta, Interval]:
-#     microseconds, days, months = typing.cast(
-#         typing.Tuple[int, ...], qii_unpack(data, offset)
-#     )
-#     if months == 0:
-#         seconds, micros = divmod(microseconds, 1e6)
-#         return Timedelta(days, seconds, micros)
-#     else:
-#         return Interval(microseconds, days, months)
+def interval_recv_integer(data: bytes, offset: int, length: int) -> typing.Union[Timedelta, Interval]:
+    microseconds, days, months = typing.cast(typing.Tuple[int, ...], qhh_unpack(data, offset))
+    seconds, micros = divmod(microseconds, 1e6)
+    if months != 0:
+        return Interval(microseconds, days, months)
+    else:
+        return Timedelta(days, seconds, micros)
 
 
 def timetz_recv_binary(data: bytes, offset: int, length: int) -> time:
@@ -630,7 +626,7 @@ def varbytehex_recv(data: bytes, idx: int, length: int) -> str:
         TIMESTAMP: (FC_BINARY, timestamp_recv_integer),  # timestamp
         TIMESTAMPTZ: (FC_BINARY, timestamptz_recv_integer),  # timestamptz
         TIMETZ: (FC_BINARY, timetz_recv_binary),  # timetz
-        # 1186: (FC_BINARY, interval_recv_integer),
+        INTERVAL: (FC_BINARY, interval_recv_integer),
         # 1231: (FC_TEXT, array_in),  # NUMERIC[]
         # 1263: (FC_BINARY, array_recv),  # cstring[]
         NUMERIC: (FC_BINARY, numeric_in_binary),  # NUMERIC
@@ -691,8 +687,8 @@ def numeric_out(d: Decimal) -> bytes:
     TIMESTAMPTZ: (TIMESTAMPTZ, FC_BINARY, timestamptz_send_integer),
     PGJson: (JSON, FC_TEXT, text_out),
     # PGJsonb: (3802, FC_TEXT, text_out),
-    # Timedelta: (1186, FC_BINARY, interval_send_integer),
-    # Interval: (1186, FC_BINARY, interval_send_integer),
+    Timedelta: (INTERVAL, FC_BINARY, interval_send_integer),  # interval
+    Interval: (1186, FC_BINARY, interval_send_integer),
     Decimal: (NUMERIC, FC_TEXT, numeric_out),  # Decimal
     PGTsvector: (3614, FC_TEXT, text_out),
     # UUID: (2950, FC_BINARY, uuid_send),  # uuid

test/integration/datatype/test_datatypes.py

@@ -94,7 +94,7 @@ def test_redshift_specific_recv_support(db_kwargs, _input, client_protocol):
             results: typing.Tuple = cursor.fetchall()
             assert len(results) == 1
             assert len(results[0]) == 1
-            assert results[0][0] == bytes(exp_val, encoding="utf-8").hex()
+            assert results[0][0] == exp_val
 
 
 @pytest.mark.skip(reason="manual")

test/integration/test_typeobjects.py

@@ -1,12 +1,13 @@
 import typing
-from datetime import date, datetime, time, timezone
+from datetime import date, datetime, time, timedelta, timezone
 from decimal import Decimal
 from enum import Enum, auto
 from math import isclose
 
 import pytest  # type: ignore
 
 import redshift_connector
+from redshift_connector.interval import Interval
 from redshift_connector.utils import type_utils
 
 
@@ -36,6 +37,7 @@ class Datatypes(Enum):
     text_array: typing.Callable = type_utils.array_recv_text
     text_array_binary: typing.Callable = type_utils.array_recv_binary
     geometry: typing.Callable = type_utils.text_recv
+    interval: typing.Callable = type_utils.interval_recv_integer
 
 
 test_data: typing.Dict[Datatypes, typing.List[typing.Tuple]] = {
@@ -329,6 +331,16 @@ class Datatypes(Enum):
             "0103000020E61000000100000005000000000000000000000000000000000000000000000000000000000000000000F03F000000000000F03F000000000000F03F000000000000F03F000000000000000000000000000000000000000000000000",
         ),
     ],
+    Datatypes.interval: [
+        (b"\x00\x01\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01", 6, 12, Interval(months=1)),
+        (
+            b"\x00\x01\x00\x00\x00\x0c\x00\x00\x00d\x954\xe0\x00\x00\x00\x00\x01",
+            6,
+            12,
+            Interval(months=1, microseconds=432000000000),
+        ),
+        (b"\x00\x01\x00\x00\x00\x0c\x00\x00\x00d\x954\xe0\x00\x00\x00\x00\x00", 6, 12, timedelta(days=5)),
+    ],
 }