refactor(integer-datetime): remove datatype conversion functions for when server option integer_datetime is disabled

Author: Brooke-white

redshift_connector/core.py

@@ -63,14 +63,6 @@
     pg_types,
     py_types,
     q_pack,
-    timestamp_recv_float,
-    timestamp_recv_integer,
-    timestamp_send_float,
-    timestamp_send_integer,
-    timestamptz_recv_float,
-    timestamptz_recv_integer,
-    timestamptz_send_float,
-    timestamptz_send_integer,
     walk_array,
 )
 
@@ -1186,33 +1178,6 @@ def handle_PARAMETER_STATUS(self: "Connection", data: bytes, ps) -> None:
         if key == b"client_encoding":
             encoding = value.decode("ascii").lower()
             _client_encoding = pg_to_py_encodings.get(encoding, encoding)
-
-        elif key == b"integer_datetimes":
-            if value == b"on":
-
-                py_types[1114] = (1114, FC_BINARY, timestamp_send_integer)
-                pg_types[1114] = (FC_BINARY, timestamp_recv_integer)
-
-                py_types[1184] = (1184, FC_BINARY, timestamptz_send_integer)
-                pg_types[1184] = (FC_BINARY, timestamptz_recv_integer)
-
-                # py_types[Interval] = (
-                #     1186, FC_BINARY, interval_send_integer)
-                # py_types[Timedelta] = (
-                #     1186, FC_BINARY, interval_send_integer)
-                # pg_types[1186] = (FC_BINARY, interval_recv_integer)
-            else:
-                py_types[1114] = (1114, FC_BINARY, timestamp_send_float)
-                pg_types[1114] = (FC_BINARY, timestamp_recv_float)
-                py_types[1184] = (1184, FC_BINARY, timestamptz_send_float)
-                pg_types[1184] = (FC_BINARY, timestamptz_recv_float)
-
-                # py_types[Interval] = (
-                #     1186, FC_BINARY, interval_send_float)
-                # py_types[Timedelta] = (
-                #     1186, FC_BINARY, interval_send_float)
-                # pg_types[1186] = (FC_BINARY, interval_recv_float)
-
         elif key == b"server_version":
             self._server_version: LooseVersion = LooseVersion(value.decode("ascii"))
             if self._server_version < LooseVersion("8.2.0"):

redshift_connector/utils/__init__.py

@@ -23,12 +23,8 @@
     pg_types,
     py_types,
     q_pack,
-    timestamp_recv_float,
     timestamp_recv_integer,
-    timestamp_send_float,
     timestamp_send_integer,
-    timestamptz_recv_float,
     timestamptz_recv_integer,
-    timestamptz_send_float,
     timestamptz_send_integer,
 )

redshift_connector/utils/type_utils.py

@@ -116,15 +116,6 @@ def null_send(v) -> bytes:
     return NULL
 
 
-# data is double-precision float representing seconds since 2000-01-01
-def timestamp_recv_float(data: bytes, offset: int, length: int) -> Datetime:
-    return Datetime.utcfromtimestamp(EPOCH_SECONDS + d_unpack(data, offset)[0])
-
-
-def timestamptz_recv_float(data: bytes, offset: int, length: int) -> Datetime:
-    return timestamp_recv_float(data, offset, length).replace(tzinfo=Timezone.utc)
-
-
 # data is 64-bit integer representing microseconds since 2000-01-01
 def timestamp_recv_integer(data: bytes, offset: int, length: int) -> typing.Union[Datetime, str, float]:
     micros: float = q_unpack(data, offset)[0]
@@ -144,23 +135,12 @@ def timestamp_send_integer(v: Datetime) -> bytes:
     return q_pack(int((timegm(v.timetuple()) - EPOCH_SECONDS) * 1e6) + v.microsecond)
 
 
-# data is double-precision float representing seconds since 2000-01-01
-def timestamp_send_float(v: Datetime) -> bytes:
-    return d_pack(timegm(v.timetuple()) + v.microsecond / 1e6 - EPOCH_SECONDS)
-
-
 def timestamptz_send_integer(v: Datetime) -> bytes:
     # timestamps should be sent as UTC.  If they have zone info,
     # convert them.
     return timestamp_send_integer(v.astimezone(Timezone.utc).replace(tzinfo=None))
 
 
-def timestamptz_send_float(v: Datetime) -> bytes:
-    # timestamps should be sent as UTC.  If they have zone info,
-    # convert them.
-    return timestamp_send_float(v.astimezone(Timezone.utc).replace(tzinfo=None))
-
-
 # return a timezone-aware datetime instance if we're reading from a
 # "timestamp with timezone" type.  The timezone returned will always be
 # UTC, but providing that additional information can permit conversion
@@ -193,21 +173,6 @@ def timestamptz_recv_integer(data: bytes, offset: int, length: int) -> typing.Un
 #     return typing.cast(bytes, qii_pack(microseconds, v.days, months))
 
 
-# def interval_send_float(v: typing.Union[Interval, Timedelta]) -> bytes:
-#     seconds: float = v.microseconds / 1000.0 / 1000.0
-#     try:
-#         seconds += v.seconds  # type: ignore
-#     except AttributeError:
-#         pass
-#
-#     try:
-#         months: int = v.months  # type: ignore
-#     except AttributeError:
-#         months = 0
-#
-#     return typing.cast(bytes, dii_pack(seconds, v.days, months))
-
-
 glbls: typing.Dict[str, type] = {"Decimal": Decimal}
 trans_tab = dict(zip(map(ord, "{}"), "[]"))
 
@@ -236,15 +201,6 @@ def numeric_in(data: bytes, offset: int, length: int) -> Decimal:
 #     return UUID(bytes=data[offset:offset+length])
 
 
-# def interval_recv_float(data: bytes, offset: int, length: int) -> typing.Union[Timedelta, Interval]:
-#     seconds, days, months = typing.cast(typing.Tuple[int, ...], dii_unpack(data, offset))
-#     if months == 0:
-#         secs, microseconds = divmod(seconds, 1e6)
-#         return Timedelta(days, secs, microseconds)
-#     else:
-#         return Interval(int(seconds * 1000 * 1000), days, months)
-
-
 # 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)
@@ -346,8 +302,8 @@ def date_in(data: bytes, offset: int, length: int):
         1043: (FC_BINARY, text_recv),  # VARCHAR type
         1082: (FC_TEXT, date_in),  # date
         1083: (FC_TEXT, time_in),
-        1114: (FC_BINARY, timestamp_recv_float),  # timestamp w/ tz
-        1184: (FC_BINARY, timestamptz_recv_float),
+        1114: (FC_BINARY, timestamp_recv_integer),  # timestamp w/ tz
+        1184: (FC_BINARY, timestamptz_recv_integer),
         # 1186: (FC_BINARY, interval_recv_integer),
         # 1231: (FC_TEXT, array_in),  # NUMERIC[]
         # 1263: (FC_BINARY, array_recv),  # cstring[]

test/unit/test_type_utils.py

@@ -69,27 +69,15 @@ def test_numeric_out(_input):
     assert type_utils.numeric_out(in_val) == exp_val
 
 
-@pytest.mark.parametrize(
-    "_input",
-    [
-        (datetime(1999, 12, 12, 12, 12, 12, 342380), b"\xc19\xb2c\xa8Y\xc8\x00"),
-        (datetime(2017, 11, 28, 23, 55, 59, 342380), b"A\xc0\xd8Z\x07\xab\xd3\x1c"),
-    ],
-)
-def test_timestamp_send_float(_input):
-    in_val, exp_val = _input
-    assert type_utils.timestamp_send_float(in_val) == exp_val
-
-
-timestamp_send_float_data = [
+timestamp_send_integer_data = [
     (b"00000000", int.from_bytes(b"00000000", "big")),
     (b"12345678", int.from_bytes(b"12345678", "big")),
     (INFINITY_MICROSECONDS.to_bytes(length=8, byteorder="big"), "infinity"),
     (MINUS_INFINITY_MICROSECONDS.to_bytes(signed=True, length=8, byteorder="big"), "-infinity"),
 ]
 
 
-@pytest.mark.parametrize("_input", timestamp_send_float_data)
+@pytest.mark.parametrize("_input", timestamp_send_integer_data)
 def test_timestamp_recv_integer(_input):
     in_val, exp_val = _input
     print(type_utils.timestamp_recv_integer(in_val, 0, 0))