added Interval column type

Author: dantownsend

docs/src/piccolo/schema/column_types.rst

@@ -117,6 +117,12 @@ Date
 
 .. autoclass:: Date
 
+========
+Interval
+========
+
+.. autoclass:: Interval
+
 ====
 Time
 ====

piccolo/columns/column_types.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 import copy
-from datetime import datetime, date, time
+from datetime import datetime, date, time, timedelta
 import decimal
 import typing as t
 import uuid
@@ -9,6 +9,7 @@
 from piccolo.columns.operators.string import ConcatPostgres, ConcatSQLite
 from piccolo.columns.defaults.date import DateArg, DateNow, DateCustom
 from piccolo.columns.defaults.time import TimeArg, TimeNow, TimeCustom
+from piccolo.columns.defaults.interval import IntervalArg, IntervalCustom
 from piccolo.columns.defaults.timestamp import (
     TimestampArg,
     TimestampNow,
@@ -612,6 +613,45 @@ def __init__(self, default: TimeArg = TimeNow(), **kwargs) -> None:
         super().__init__(**kwargs)
 
 
+class Interval(Column):
+    """
+    Used for storing timedeltas. Uses the ``timedelta`` type for values.
+
+    **Example**
+
+    .. code-block:: python
+
+        from datetime import timedelta
+
+        class Concert(Table):
+            duration = Interval()
+
+        # Create
+        >>> Concert(
+        >>>    duration=timedelta(hours=2)
+        >>> ).save().run_sync()
+
+        # Query
+        >>> Concert.select(Concert.duration).run_sync()
+        {'duration': datetime.timedelta(seconds=7200)}
+
+    """
+
+    value_type = timedelta
+
+    def __init__(
+        self, default: IntervalArg = IntervalCustom(), **kwargs
+    ) -> None:
+        self._validate_default(default, IntervalArg.__args__)  # type: ignore
+
+        if isinstance(default, timedelta):
+            default = IntervalCustom.from_timedelta(default)
+
+        self.default = default
+        kwargs.update({"default": default})
+        super().__init__(**kwargs)
+
+
 ###############################################################################
 
 

piccolo/columns/defaults/interval.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+import datetime
+import typing as t
+
+from .base import Default
+
+
+class IntervalCustom(Default):
+    def __init__(
+        self,
+        weeks: int = 0,
+        days: int = 0,
+        hours: int = 0,
+        minutes: int = 0,
+        seconds: int = 0,
+        milliseconds: int = 0,
+        microseconds: int = 0,
+    ):
+        self.weeks = weeks
+        self.days = days
+        self.hours = hours
+        self.minutes = minutes
+        self.seconds = seconds
+        self.milliseconds = milliseconds
+        self.microseconds = microseconds
+
+    @property
+    def timedelta(self):
+        return datetime.timedelta(
+            weeks=self.weeks,
+            days=self.days,
+            hours=self.hours,
+            minutes=self.minutes,
+            seconds=self.seconds,
+            milliseconds=self.milliseconds,
+            microseconds=self.microseconds,
+        )
+
+    @property
+    def postgres(self):
+        value = self.get_postgres_interval_string(
+            attributes=[
+                "weeks",
+                "days",
+                "hours",
+                "minutes",
+                "seconds",
+                "milliseconds",
+                "microseconds",
+            ]
+        )
+        return f"'{value}'"
+
+    @property
+    def sqlite(self):
+        value = self.get_sqlite_interval_string(
+            attributes=[
+                "weeks",
+                "days",
+                "hours",
+                "minutes",
+                "seconds",
+                "milliseconds",
+                "microseconds",
+            ]
+        ).replace("'", "")
+        return f"'{value}'"
+
+    def python(self):
+        return self.timedelta
+
+    @classmethod
+    def from_timedelta(cls, instance: datetime.timedelta):
+        return cls(
+            days=instance.days,
+            seconds=instance.seconds,
+            microseconds=instance.microseconds,
+        )
+
+
+###############################################################################
+
+IntervalArg = t.Union[
+    IntervalCustom, None, datetime.timedelta,
+]
+
+
+__all__ = [
+    "IntervalArg",
+    "IntervalCustom",
+]

piccolo/engine/sqlite.py

@@ -11,6 +11,7 @@
 import aiosqlite
 from aiosqlite import Cursor, Connection
 
+from piccolo.columns.defaults.interval import IntervalCustom
 from piccolo.engine.base import Batch, Engine
 from piccolo.engine.exceptions import TransactionError
 from piccolo.query.base import Query
@@ -51,6 +52,15 @@ def convert_date_in(value):
     return value.isoformat()
 
 
+def convert_timedelta_in(value):
+    """
+    Converts the timedelta value being passed into sqlite.
+    """
+    return IntervalCustom.from_timedelta(instance=value).sqlite.replace(
+        "'", ""
+    )
+
+
 def convert_numeric_out(value: bytes) -> Decimal:
     """
     Convert float values into Decimals.
@@ -78,21 +88,37 @@ def convert_date_out(value: bytes) -> datetime.date:
 
 def convert_time_out(value: bytes) -> datetime.time:
     """
-    If the value is a uuid, convert it to a UUID instance.
+    If the value is a time, convert it to a UUID instance.
     """
     return datetime.time.fromisoformat(value.decode("utf8"))
 
 
+def convert_interval_out(value: bytes) -> datetime.timedelta:
+    """
+    If the value is an interval, convert it to a timedelta instance.
+    """
+    unit_value_strings = [i.strip() for i in value.decode("utf8").split(",")]
+    kwargs = {}
+
+    for unit_value_string in unit_value_strings:
+        value, key = unit_value_string.split(" ")
+        kwargs[key] = int(value)
+
+    return datetime.timedelta(**kwargs)
+
+
 sqlite3.register_converter("Numeric", convert_numeric_out)
 sqlite3.register_converter("Integer", convert_int_out)
 sqlite3.register_converter("UUID", convert_uuid_out)
 sqlite3.register_converter("Date", convert_date_out)
 sqlite3.register_converter("Time", convert_time_out)
+sqlite3.register_converter("Interval", convert_interval_out)
 
 sqlite3.register_adapter(Decimal, convert_numeric_in)
 sqlite3.register_adapter(uuid.UUID, convert_uuid_in)
 sqlite3.register_adapter(datetime.time, convert_time_in)
 sqlite3.register_adapter(datetime.date, convert_date_in)
+sqlite3.register_adapter(datetime.timedelta, convert_timedelta_in)
 
 ###############################################################################
 

tests/columns/test_interval.py

@@ -0,0 +1,45 @@
+import datetime
+from unittest import TestCase
+
+from piccolo.table import Table
+from piccolo.columns.column_types import Interval
+from piccolo.columns.defaults.interval import IntervalCustom
+
+
+class MyTable(Table):
+    interval = Interval()
+
+
+class MyTableDefault(Table):
+    interval = Interval(default=IntervalCustom(days=1))
+
+
+class TestInterval(TestCase):
+    def setUp(self):
+        MyTable.create_table().run_sync()
+
+    def tearDown(self):
+        MyTable.alter().drop_table().run_sync()
+
+    def test_interval(self):
+        interval = datetime.timedelta(hours=2)
+        row = MyTable(interval=interval)
+        row.save().run_sync()
+
+        result = MyTable.objects().first().run_sync()
+        self.assertEqual(result.interval, interval)
+
+
+class TestIntervalDefault(TestCase):
+    def setUp(self):
+        MyTableDefault.create_table().run_sync()
+
+    def tearDown(self):
+        MyTableDefault.alter().drop_table().run_sync()
+
+    def test_interval(self):
+        row = MyTableDefault()
+        row.save().run_sync()
+
+        result = MyTableDefault.objects().first().run_sync()
+        self.assertTrue(result.interval.days == 1)