Support for SQLite, MySQL, Postgres and Django up to 2.1

Author: Alex Hill

.travis.yml

@@ -6,29 +6,64 @@ language: python
 # List the versions of Python you'd like to test against
 services:
   - postgresql
+  - mysql
 env:
   global:
     - DJANGO_SETTINGS_MODULE=tests.settings
   matrix:
-    - DJANGO_VERSION=1.8.19
-    - DJANGO_VERSION=1.9.13
-    - DJANGO_VERSION=1.10.8
-    - DJANGO_VERSION=1.11.18
+    - DJANGO_VERSION=1.8.19 DB=mysql
+    - DJANGO_VERSION=1.8.19 DB=postgres
+    - DJANGO_VERSION=1.8.19 DB=sqlite
+    - DJANGO_VERSION=1.9.13 DB=mysql
+    - DJANGO_VERSION=1.9.13 DB=postgres
+    - DJANGO_VERSION=1.9.13 DB=sqlite
+    - DJANGO_VERSION=1.10.8 DB=mysql
+    - DJANGO_VERSION=1.10.8 DB=postgres
+    - DJANGO_VERSION=1.10.8 DB=sqlite
+    - DJANGO_VERSION=1.11.18 DB=mysql
+    - DJANGO_VERSION=1.11.18 DB=postgres
+    - DJANGO_VERSION=1.11.18 DB=sqlite
+    - DJANGO_VERSION=2.0.10 DB=mysql
+    - DJANGO_VERSION=2.0.10 DB=postgres
+    - DJANGO_VERSION=2.0.10 DB=sqlite
+    - DJANGO_VERSION=2.1.5 DB=mysql
+    - DJANGO_VERSION=2.1.5 DB=postgres
+    - DJANGO_VERSION=2.1.5 DB=sqlite
+matrix:
+  exclude:
+     - python: "2.7"
+       env: DJANGO_VERSION=2.0.10 DB=mysql
+     - python: "2.7"
+       env: DJANGO_VERSION=2.0.10 DB=sqlite
+     - python: "2.7"
+       env: DJANGO_VERSION=2.0.10 DB=postgres
+     - python: "2.7"
+       env: DJANGO_VERSION=2.1.5 DB=mysql
+     - python: "2.7"
+       env: DJANGO_VERSION=2.1.5 DB=sqlite
+     - python: "2.7"
+       env: DJANGO_VERSION=2.1.5 DB=postgres
+     - python: "3.4"
+       env: DJANGO_VERSION=2.1.5 DB=mysql
+     - python: "3.4"
+       env: DJANGO_VERSION=2.1.5 DB=sqlite
+     - python: "3.4"
+       env: DJANGO_VERSION=2.1.5 DB=postgres
 python:
   - "2.7"
   - "3.4"
   - "3.5"
   - "3.6"
 # Tell it the things it will need to install when it boots
 install:
- - pip install -q pytz coveralls flake8 psycopg2
- - pip install -q "Django==$DJANGO_VERSION"
- - pip install -e .
+  - pip install -q pytz coveralls flake8 psycopg2 mysqlclient
+  - pip install -q "Django==$DJANGO_VERSION"
+  - pip install -e .
 # Tell Travis how to run the test script itself
 before_script:
-  - psql -c 'create database naivedatetimefield;' -U postgres
+  - mysql_tzinfo_to_sql /usr/share/zoneinfo | mysql -u root mysql
 script:
   - flake8 naivedatetimefield/
   - coverage run --parallel-mode --source=naivedatetimefield runtests.py
   - coverage combine
-after_success: coveralls
+# after_success: coveralls

naivedatetimefield/__init__.py

@@ -1,31 +1,35 @@
 import datetime
+import sys
+import warnings
 
-from django import forms
+import django
+import pytz
 from django.core import exceptions, checks
-
-from django.db import models
-
+from django.db.models import DateTimeField
 from django.utils import timezone
 from django.utils.dateparse import parse_date, parse_datetime
 from django.utils.translation import gettext_lazy as _
 
+if django.VERSION >= (1, 11):
+    from django.db.models.functions.datetime import TruncBase, Extract, ExtractYear
+    from django.db.models.lookups import Exact, GreaterThan, GreaterThanOrEqual, \
+        LessThan, LessThanOrEqual
+
 
-class NaiveDateTimeField(models.DateField):
+class NaiveDateTimeField(DateTimeField):
     description = _("Naive Date (with time)")
 
+    default_error_messages = {
+        'tzaware': _("TZ-aware datetimes cannot be coerced to naive datetimes"),
+    }
+
     def get_internal_type(self):
-        return "NaiveDateTime"
+        return "DateTimeField"
 
     def db_type(self, connection):
-        if connection.settings_dict["ENGINE"] in [
-            "django_prometheus.db.backends.postgresql",
-            "django_prometheus.db.backends.postgresql_psycopg2",
-            "django.db.backends.postgresql",
-            "django.db.backends.postgresql_psycopg2",
-        ]:
+        if connection.vendor == "postgresql":
             return "timestamp without time zone"
-
-        raise NotImplementedError("Only postgresql is supported at this time.")
+        return super(NaiveDateTimeField, self).db_type(connection)
 
     def _check_fix_default_value(self):
         """
@@ -81,13 +85,17 @@ def to_python(self, value):
         if value is None:
             return value
         if isinstance(value, datetime.datetime):
-            return value.replace(tzinfo=None)
+            if timezone.is_aware(value):
+                raise exceptions.ValidationError(self.error_messages['tzaware'])
+            return value
         if isinstance(value, datetime.date):
             return datetime.datetime(value.year, value.month, value.day)
 
         try:
             parsed = parse_datetime(value)
             if parsed is not None:
+                if timezone.is_aware(parsed):
+                    raise exceptions.ValidationError(self.error_messages['tzaware'])
                 return parsed
         except ValueError:
             raise exceptions.ValidationError(
@@ -112,104 +120,91 @@ def to_python(self, value):
         )
 
     def get_prep_value(self, value):
-        """
-        Ensure we have a naive datetime ready for insertion
-        """
-        value = super(NaiveDateTimeField, self).get_prep_value(value)
-        value = self.to_python(value)
-
-        if value is not None and timezone.is_aware(value):
-            # We were given an aware datetime, strip off tzinfo
-            value = value.replace(tzinfo=None)
-
-        return value
-
-    def get_db_prep_value(self, value, connection, prepared=False):
-        if not prepared:
-            value = self.get_prep_value(value)
-
-        if value is None:
-            return None
-
-        if hasattr(value, "resolve_expression"):
+        return super(DateTimeField, self).get_prep_value(value)
+
+    def from_db_value(self, value, expression, connection, context):
+        is_truncbase = django.VERSION >= (1, 11) and isinstance(expression, TruncBase)
+        if is_truncbase and not isinstance(expression, NaiveAsSQLMixin):
+            raise TypeError(
+                "Django's %s cannot be used with a NaiveDateTimeField"
+                % expression.__class__.__name__
+            )
+        if connection.vendor == "postgresql":
+            if is_truncbase:
+                return timezone.make_naive(value, pytz.utc)
             return value
-
-        if connection.settings_dict["ENGINE"] == "django.db.backends.mysql":
-            return str(value)
-
-        elif connection.settings_dict["ENGINE"] == "django.db.backends.sqlite3":
-            return str(value)
-
-        elif connection.settings_dict["ENGINE"] == "django.db.backends.oracle":
-            from django.db.backends.oracle.utils import Oracle_datetime
-
-            return Oracle_datetime.from_datetime(value)
-
+        if timezone.is_aware(value):
+            if django.VERSION < (1, 9):
+                return timezone.make_naive(value, pytz.utc)
+            return timezone.make_naive(value, connection.timezone)
         return value
 
     def pre_save(self, model_instance, add):
         if self.auto_now or (self.auto_now_add and add):
-            value = timezone.now().replace(tzinfo=None)
+            value = timezone.make_naive(timezone.now())
             setattr(model_instance, self.attname, value)
             return value
         else:
             return super(NaiveDateTimeField, self).pre_save(model_instance, add)
 
-    def value_to_string(self, obj):
-        val = self.value_from_object(obj)
-        return "" if val is None else val.isoformat()
 
-    def formfield(self, **kwargs):
-        defaults = {"form_class": forms.DateTimeField}
-        defaults.update(kwargs)
-        return super(NaiveDateTimeField, self).formfield(**defaults)
+class NaiveTimezoneMixin(object):
+    def get_tzname(self):
+        if isinstance(self.output_field, NaiveDateTimeField):
+            if self.tzinfo is not None:
+                warnings.warn(
+                    "tzinfo argument provided when truncating a NaiveDateTimeField. "
+                    "This argument will have no effect."
+                )
+            return 'UTC'
+        return super(NaiveTimezoneMixin, self).get_tzname()
 
 
-# try to register our field for the __time and __date lookups
-try:
-    from django.db.models import TimeField
-    from django.db.models.functions.datetime import TruncBase
+class NaiveConvertValueMixin(object):
+    def convert_value(self, value, *args, **kwargs):
+        if isinstance(self.output_field, NaiveDateTimeField):
+            return value
+        return super(NaiveConvertValueMixin, self).convert_value(value, *args, **kwargs)
 
-    class TruncTimeNaive(TruncBase):
-        kind = "time"
-        lookup_name = "time"
-        output_field = TimeField()
 
-        def as_sql(self, compiler, connection):
-            # Cast to date rather than truncate to date.
-            lhs, lhs_params = compiler.compile(self.lhs)
+class NaiveAsSQLMixin(object):
+    def as_sql(self, compiler, connection):
+        if isinstance(self.lhs.output_field, NaiveDateTimeField):
+            with timezone.override(pytz.utc):
+                return super(NaiveAsSQLMixin, self).as_sql(compiler, connection)
+        return super(NaiveAsSQLMixin, self).as_sql(compiler, connection)
 
-            # this is a postgresql only compatible cast, replacing
-            # a call to connection.ops.datetime_cast_time_sql that
-            # wouldn't work with None tzinfo
-            sql = "(%s)::time" % lhs
 
-            return sql, lhs_params
+_monkeypatching = False
 
-    NaiveDateTimeField.register_lookup(TruncTimeNaive)
-except ImportError:
-    pass
 
-try:
-    from django.db.models import DateField
-    from django.db.models.functions.datetime import TruncBase
+if django.VERSION >= (1, 11):
+    _this_module = sys.modules[__name__]
+    _db_functions = sys.modules['django.db.models.functions']
+    _lookups = set(DateTimeField.get_lookups().values())
+    _patch_classes = [
+        (Extract, [NaiveAsSQLMixin, NaiveTimezoneMixin]),
+        (TruncBase, [NaiveAsSQLMixin, NaiveTimezoneMixin, NaiveConvertValueMixin]),
+    ]
+    for original, mixins in _patch_classes:
+        for cls in original.__subclasses__():
 
-    class TruncDateNaive(TruncBase):
-        kind = "date"
-        lookup_name = "date"
-        output_field = DateField()
+            bases = tuple(mixins) + (cls,)
+            naive_cls = type(cls.__name__, bases, {})
 
-        def as_sql(self, compiler, connection):
-            # Cast to date rather than truncate to date.
-            lhs, lhs_params = compiler.compile(self.lhs)
+            if _monkeypatching:
+                setattr(_db_functions, cls.__name__, naive_cls)
 
-            # this is a postgresql only compatible cast, replacing
-            # a call to connection.ops.datetime_cast_date_sql that
-            # wouldn't work with None tzinfo
-            sql = "(%s)::date" % lhs
+            if cls in _lookups:
+                NaiveDateTimeField.register_lookup(naive_cls)
 
-            return sql, lhs_params
+                # Year lookups don't need special handling with naive fields
+                if cls is ExtractYear:
+                    naive_cls.register_lookup(Exact)
+                    naive_cls.register_lookup(GreaterThan)
+                    naive_cls.register_lookup(GreaterThanOrEqual)
+                    naive_cls.register_lookup(LessThan)
+                    naive_cls.register_lookup(LessThanOrEqual)
 
-    NaiveDateTimeField.register_lookup(TruncDateNaive)
-except ImportError:
-    pass
+            # Add an attribute to this module so these functions can be imported
+            setattr(_this_module, cls.__name__, naive_cls)

tests/settings.py

@@ -26,16 +26,29 @@
 
 MIDDLEWARE = MIDDLEWARE_CLASSES
 
-DATABASES = {
-    'default': {
-        'ENGINE': 'django.db.backends.postgresql_psycopg2',
+AVAILABLE_DATABASES = {
+    "sqlite": {
+        "ENGINE": "django.db.backends.sqlite3",
+        "NAME": ":memory:",
+    },
+    "postgres": {
+        "ENGINE": "django.db.backends.postgresql_psycopg2",
         "NAME": os.environ.get("DJANGO_DATABASE_NAME_POSTGRES", "naivedatetimefield"),
         "USER": os.environ.get("DJANGO_DATABASE_USER_POSTGRES", 'postgres'),
         "PASSWORD": os.environ.get("DJANGO_DATABASE_PASSWORD_POSTGRES", ""),
         "HOST": os.environ.get("DJANGO_DATABASE_HOST_POSTGRES", ""),
-    }
+    },
+    "mysql": {
+        "ENGINE": "django.db.backends.mysql",
+        "NAME": os.environ.get("DJANGO_DATABASE_NAME_MYSQL", "naivedatetimefield"),
+        "USER": os.environ.get("DJANGO_DATABASE_USER_MYSQL", 'root'),
+        "PASSWORD": os.environ.get("DJANGO_DATABASE_PASSWORD_MYSQL", ""),
+        "HOST": os.environ.get("DJANGO_DATABASE_HOST_MYSQL", ""),
+    },
 }
 
+DATABASES = {"default": AVAILABLE_DATABASES[os.environ.get("DB", "postgres")]}
+
 CACHES = {
     'default': {
         'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
@@ -68,3 +81,29 @@
         },
     },
 ]
+
+LOGGING = {
+    'disable_existing_loggers': False,
+    'version': 1,
+    'handlers': {
+        'console': {
+            # logging handler that outputs log messages to terminal
+            'class': 'logging.StreamHandler',
+            'level': 'DEBUG', # message level to be written to console
+        },
+    },
+    'loggers': {
+        '': {
+            # this sets root level logger to log debug and higher level
+            # logs to console. All other loggers inherit settings from
+            # root level logger.
+            'handlers': ['console'],
+            'level': 'DEBUG',
+            'propagate': False, # this tells logger to send logging message
+                                # to its parent (will send if set to True)
+        },
+        'django.db': {
+            # django also has database level logging
+        },
+    },
+}