Split datetime into three UI types

db/functions/hints.py

@@ -110,6 +110,15 @@ def _is_hint_applicable_to_types(hint):
 email = _make_hint("email")
 
 
+duration = _make_hint("duration")
+
+
+time = _make_hint("time")
+
+
+date = _make_hint("date")
+
+
 literal = _make_hint("literal")
 
 

db/types/base.py

@@ -183,23 +183,46 @@ def _add_to_db_type_hintsets(db_types, hints):
     hints_for_numeric_db_types = (hints.comparable,)
     _add_to_db_type_hintsets(numeric_db_types, hints_for_numeric_db_types)
 
-    # point in time db types get the "point_in_time" hint
-    point_in_time_db_types = (
-        PostgresType.DATE,
+    # time of day db types get the "time" hint
+    time_of_day_db_types = (
         PostgresType.TIME,
         PostgresType.TIME_WITH_TIME_ZONE,
         PostgresType.TIME_WITHOUT_TIME_ZONE,
+    )
+    _add_to_db_type_hintsets(time_of_day_db_types, (hints.time,))
+
+    # point in time db types get the "point_in_time" hint
+    point_in_time_db_types = (
+        *time_of_day_db_types,
+        PostgresType.DATE,
+    )
+    hints_for_point_in_time_types = (hints.point_in_time,)
+    _add_to_db_type_hintsets(point_in_time_db_types, hints_for_point_in_time_types)
+
+    # date db types get the "date" hint
+    date_db_types = (
+        PostgresType.DATE,
+    )
+    _add_to_db_type_hintsets(date_db_types, (hints.date,))
+
+    # datetime db types get the "date" and "time" hints
+    datetime_db_types = (
         PostgresType.TIMESTAMP,
         PostgresType.TIMESTAMP_WITH_TIME_ZONE,
         PostgresType.TIMESTAMP_WITHOUT_TIME_ZONE,
     )
-    hints_for_point_in_time_types = (hints.point_in_time,)
-    _add_to_db_type_hintsets(point_in_time_db_types, hints_for_point_in_time_types)
+    _add_to_db_type_hintsets(datetime_db_types, (hints.date, hints.time,))
+
+    # duration db types get the "duration" hints
+    duration_db_types = (
+        PostgresType.INTERVAL,
+    )
+    _add_to_db_type_hintsets(duration_db_types, (hints.duration,))
 
     # time related types get the "comparable" hint
     time_related_db_types = (
         *point_in_time_db_types,
-        PostgresType.INTERVAL,
+        *duration_db_types,
     )
     hints_for_time_related_types = (hints.comparable,)
     _add_to_db_type_hintsets(time_related_db_types, hints_for_time_related_types)

mathesar/api/display_options.py

@@ -17,6 +17,17 @@
         },
     MathesarTypeIdentifier.DATETIME.value:
         {
-            "options": [{"name": "format", "type": "string"}]
-        }
+            "options": [
+                {"name": "time_format", "type": "string"},
+                {"name": "date_format", "type": "string"},
+            ]
+        },
+    MathesarTypeIdentifier.TIME.value:
+        {
+            "options": [{"name": "time_format", "type": "string"}]
+        },
+    MathesarTypeIdentifier.DATE.value:
+        {
+            "options": [{"name": "date_format", "type": "string"}]
+        },
 }

mathesar/api/serializers/shared_serializers.py

@@ -1,6 +1,3 @@
-from abc import ABC, abstractmethod
-
-import arrow
 from django.core.exceptions import ImproperlyConfigured
 from rest_framework import serializers
 
@@ -102,7 +99,7 @@ class CustomBooleanLabelSerializer(MathesarErrorMessageMixin, serializers.Serial
     FALSE = serializers.CharField()
 
 
-DISPLAY_OPTIONS_SERIALIZER_MAPPING_KEY = 'mathesar_type'
+DISPLAY_OPTIONS_SERIALIZER_MAPPING_KEY = 'db_type'
 
 
 class BooleanDisplayOptionSerializer(MathesarErrorMessageMixin, OverrideRootPartialMixin, serializers.Serializer):
@@ -115,105 +112,19 @@ class NumberDisplayOptionSerializer(MathesarErrorMessageMixin, OverrideRootParti
     locale = serializers.CharField(required=False)
 
 
-class AbstractDateTimeFormatValidator(ABC):
-    requires_context = True
-
-    def __init__(self):
-        pass
-
-    def __call__(self, value, serializer_field):
-        self.date_format_validator(value, serializer_field)
-
-    def date_format_validator(self, value, serializer_field):
-        try:
-            timestamp_with_tz_obj = arrow.get('2013-09-30T15:34:00.000-07:00')
-            parsed_datetime_str = timestamp_with_tz_obj.format(value)
-            datetime_object = arrow.get(parsed_datetime_str, value)
-        except ValueError:
-            raise serializers.ValidationError(f"{value} is not a valid format used for parsing a datetime.")
-        else:
-            self.validate(datetime_object, value, serializer_field)
-
-    @abstractmethod
-    def validate(self, datetime_obj, display_format, serializer_field):
-        pass
-
-
-class TimestampWithTimeZoneFormatValidator(AbstractDateTimeFormatValidator):
-
-    def validate(self, datetime_obj, display_format, serializer_field):
-        pass
-
-
-class TimestampWithoutTimeZoneFormatValidator(AbstractDateTimeFormatValidator):
-
-    def validate(self, datetime_obj, display_format, serializer_field):
-        if 'z' in display_format.lower():
-            raise serializers.ValidationError(
-                "Timestamp without timezone column cannot contain timezone display format"
-            )
-
-
-class DateFormatValidator(AbstractDateTimeFormatValidator):
-
-    def validate(self, datetime_obj, display_format, serializer_field):
-        date_obj = arrow.get('2013-09-30')
-        if datetime_obj.time() != date_obj.time():
-            raise serializers.ValidationError("Date column cannot contain time or timezone display format")
-
-
-class TimeWithTimeZoneFormatValidator(AbstractDateTimeFormatValidator):
-
-    def validate(self, datetime_obj, display_format, serializer_field):
-        time_only_format = 'HH:mm:ssZZ'
-        time_str = arrow.get('2013-09-30T15:34:00.000-07:00').format(time_only_format)
-        parsed_time_str = arrow.get(time_str, time_only_format)
-        if parsed_time_str.date() != datetime_obj.date():
-            raise serializers.ValidationError("Time column cannot contain date display format")
-
-
-class TimeWithoutTimeZoneFormatValidator(TimeWithTimeZoneFormatValidator):
-
-    def validate(self, datetime_obj, display_format, serializer_field):
-        if 'z' in display_format.lower():
-            raise serializers.ValidationError("Time without timezone column cannot contain timezone display format")
-        return super().validate(datetime_obj, display_format, serializer_field)
+def is_time_format_valid(format):
+    if isinstance(format, str) and len(format) <= 255:
+        return True
+    else:
+        raise serializers.ValidationError("Time format string not a string or longer than 255 characters.")
 
 
-class DateDisplayOptionSerializer(MathesarErrorMessageMixin, OverrideRootPartialMixin, serializers.Serializer):
-    format = serializers.CharField(validators=[DateFormatValidator()])
-
-
-class TimestampWithoutTimezoneDisplayOptionSerializer(
+class TimeFormatDisplayOptionSerializer(
     MathesarErrorMessageMixin,
     OverrideRootPartialMixin,
     serializers.Serializer
 ):
-    format = serializers.CharField(validators=[TimestampWithoutTimeZoneFormatValidator()])
-
-
-class TimestampWithTimezoneDisplayOptionSerializer(
-    MathesarErrorMessageMixin,
-    OverrideRootPartialMixin,
-    serializers.Serializer
-):
-    format = serializers.CharField(validators=[TimestampWithTimeZoneFormatValidator()])
-
-
-class TimeWithTimezoneDisplayOptionSerializer(
-    MathesarErrorMessageMixin,
-    OverrideRootPartialMixin,
-    serializers.Serializer
-):
-    format = serializers.CharField(validators=[TimeWithTimeZoneFormatValidator()])
-
-
-class TimeWithoutTimezoneDisplayOptionSerializer(
-    MathesarErrorMessageMixin,
-    OverrideRootPartialMixin,
-    serializers.Serializer
-):
-    format = serializers.CharField(validators=[TimeWithoutTimeZoneFormatValidator()])
+    format = serializers.CharField(validators=[is_time_format_valid])
 
 
 class DisplayOptionsMappingSerializer(
@@ -224,18 +135,12 @@ class DisplayOptionsMappingSerializer(
     serializers_mapping = {
         MathesarTypeIdentifier.BOOLEAN.value: BooleanDisplayOptionSerializer,
         MathesarTypeIdentifier.NUMBER.value: NumberDisplayOptionSerializer,
-        ('timestamp with time zone',
-         MathesarTypeIdentifier.DATETIME.value): TimestampWithTimezoneDisplayOptionSerializer,
-        ('timestamp without time zone',
-         MathesarTypeIdentifier.DATETIME.value): TimestampWithoutTimezoneDisplayOptionSerializer,
-        ('date', MathesarTypeIdentifier.DATETIME.value): DateDisplayOptionSerializer,
-        ('time with time zone', MathesarTypeIdentifier.DATETIME.value): TimeWithTimezoneDisplayOptionSerializer,
-        ('time without time zone', MathesarTypeIdentifier.DATETIME.value): TimeWithoutTimezoneDisplayOptionSerializer,
+        MathesarTypeIdentifier.DATETIME.value: TimeFormatDisplayOptionSerializer,
+        MathesarTypeIdentifier.DATE.value: TimeFormatDisplayOptionSerializer,
+        MathesarTypeIdentifier.TIME.value: TimeFormatDisplayOptionSerializer,
     }
 
     def get_mapping_field(self):
-        mathesar_type = get_mathesar_type_from_db_type(self.context[DISPLAY_OPTIONS_SERIALIZER_MAPPING_KEY])
-        if mathesar_type == MathesarTypeIdentifier.DATETIME.value:
-            return self.context[DISPLAY_OPTIONS_SERIALIZER_MAPPING_KEY].lower(), mathesar_type
-        else:
-            return mathesar_type
+        db_type = self.context[DISPLAY_OPTIONS_SERIALIZER_MAPPING_KEY]
+        mathesar_type = get_mathesar_type_from_db_type(db_type)
+        return mathesar_type

mathesar/database/types.py

@@ -13,6 +13,8 @@
 class MathesarTypeIdentifier(Enum):
     BOOLEAN = 'boolean'
     DATETIME = 'datetime'
+    TIME = 'time'
+    DATE = 'date'
     DURATION = 'duration'
     EMAIL = 'email'
     MONEY = 'money'
@@ -48,12 +50,22 @@ def _get_type_map():
         'name': 'Boolean',
         'sa_type_names': [PostgresType.BOOLEAN.value]
     }, {
-        'identifier': MathesarTypeIdentifier.DATETIME.value,
-        'name': 'Date & Time',
+        'identifier': MathesarTypeIdentifier.DATE.value,
+        'name': 'Date',
         'sa_type_names': [
             PostgresType.DATE.value,
+        ]
+    }, {
+        'identifier': MathesarTypeIdentifier.TIME.value,
+        'name': 'Time',
+        'sa_type_names': [
             PostgresType.TIME_WITH_TIME_ZONE.value,
             PostgresType.TIME_WITHOUT_TIME_ZONE.value,
+        ]
+    }, {
+        'identifier': MathesarTypeIdentifier.DATETIME.value,
+        'name': 'Date & Time',
+        'sa_type_names': [
             PostgresType.TIMESTAMP_WITH_TIME_ZONE.value,
             PostgresType.TIMESTAMP_WITHOUT_TIME_ZONE.value
         ]

mathesar/tests/api/test_column_api.py

@@ -265,18 +265,18 @@ def test_column_create_display_options(
     assert actual_new_col["display_options"] == display_options
 
 
+_too_long_string = "x" * 256
+
+
 create_display_options_invalid_test_list = [
     ("BOOLEAN", {"input": "invalid", "use_custom_columns": False}),
     ("BOOLEAN", {"input": "checkbox", "use_custom_columns": True, "custom_labels": {"yes": "yes", "1": "no"}}),
-    ("DATE", {'format': 'YYYY-MM-DD hh:mm Z'}),
-    ("DATE", {'format': 'hh:mm Z'}),
     ("NUMERIC", {"show_as_percentage": "wrong value type"}),
-    ("TIMESTAMP WITH TIME ZONE", {'format': 'xyz'}),
-    ("TIMESTAMP WITHOUT TIME ZONE", {'format': 'xyz'}),
-    ("TIMESTAMP WITHOUT TIME ZONE", {'format': 'YYYY-MM-DD hh:mm Z'}),
-    ("TIME WITH TIME ZONE", {'format': 'YYYY-MM-DD hh:mm Z'}),
-    ("TIME WITHOUT TIME ZONE", {'format': 'YYYY-MM-DD hh:mm'}),
-    ("TIME WITHOUT TIME ZONE", {'format': 'hh:mm Z'}),
+    ("DATE", {'format': _too_long_string}),
+    ("TIMESTAMP WITH TIME ZONE", {'format': []}),
+    ("TIMESTAMP WITHOUT TIME ZONE", {'format': _too_long_string}),
+    ("TIME WITH TIME ZONE", {'format': _too_long_string}),
+    ("TIME WITHOUT TIME ZONE", {'format': {}}),
 ]