Fix DurationField, IntegerField unique constraints for values < or > 32 bits

Whether values less than or greater than 32 bits were problematic
depends on the field.

Author: timgraham

.github/workflows/test-python-atlas.yml

@@ -33,7 +33,7 @@ jobs:
         uses: actions/checkout@v4
         with:
           repository: 'mongodb-forks/django'
-          ref: 'mongodb-5.2.x'
+          ref: 'ints-as-long'
           path: 'django_repo'
           persist-credentials: false
       - name: Install system packages for Django's Python test dependencies

.github/workflows/test-python.yml

@@ -33,7 +33,7 @@ jobs:
         uses: actions/checkout@v4
         with:
           repository: 'mongodb-forks/django'
-          ref: 'mongodb-5.2.x'
+          ref: 'ints-as-long'
           path: 'django_repo'
           persist-credentials: false
       - name: Install system packages for Django's Python test dependencies

django_mongodb_backend/base.py

@@ -46,11 +46,11 @@ class DatabaseWrapper(BaseDatabaseWrapper):
         "FileField": "string",
         "FilePathField": "string",
         "FloatField": "double",
-        "IntegerField": "int",
+        "IntegerField": "long",
         "BigIntegerField": "long",
         "GenericIPAddressField": "string",
         "JSONField": "object",
-        "PositiveBigIntegerField": "int",
+        "PositiveBigIntegerField": "long",
         "PositiveIntegerField": "long",
         "PositiveSmallIntegerField": "int",
         "SlugField": "string",

django_mongodb_backend/fields/duration.py

@@ -1,3 +1,4 @@
+from bson import Int64
 from django.db.models.fields import DurationField
 
 _get_db_prep_value = DurationField.get_db_prep_value
@@ -8,6 +9,8 @@ def get_db_prep_value(self, value, connection, prepared=False):
     value = _get_db_prep_value(self, value, connection, prepared)
     if connection.vendor == "mongodb" and value is not None:
         value //= 1000
+        # Store value as Int64 (long).
+        value = Int64(value)
     return value
 
 

django_mongodb_backend/operations.py

@@ -4,7 +4,7 @@
 import uuid
 from decimal import Decimal
 
-from bson.decimal128 import Decimal128
+from bson import Decimal128, Int64
 from django.conf import settings
 from django.db import DataError
 from django.db.backends.base.operations import BaseDatabaseOperations
@@ -58,6 +58,14 @@ def adapt_decimalfield_value(self, value, max_digits=None, decimal_places=None):
             return None
         return Decimal128(value)
 
+    def adapt_integerfield_value(self, value, internal_type):
+        """Store all IntegerField variants as Int64 (long)."""
+        if value is None:
+            return None
+        if "Small" not in internal_type:
+            return Int64(value)
+        return value
+
     def adapt_json_value(self, value, encoder):
         if encoder is None:
             return value
@@ -123,8 +131,16 @@ def get_db_converters(self, expression):
                 converters.append(self.convert_timefield_value)
         elif internal_type == "UUIDField":
             converters.append(self.convert_uuidfield_value)
+        elif "IntegerField" in internal_type and "Small" not in internal_type:
+            converters.append(self.convert_integerfield_value)
         return converters
 
+    def convert_integerfield_value(self, value, expression, connection):
+        if value is not None:
+            # from Int64 to int
+            value = int(value)
+        return value
+
     def convert_datefield_value(self, value, expression, connection):
         if value is not None:
             value = value.date()

docs/source/releases/5.2.x.rst

@@ -32,6 +32,17 @@ Bug fixes
   databases.
 - :meth:`QuerySet.explain() <django.db.models.query.QuerySet.explain>` now
   :ref:`returns a string that can be parsed as JSON <queryset-explain>`.
+- Fixed unique constraint generation for :class:`~django.db.models.IntegerField`
+  and :class:`~django.db.models.PositiveBigIntegerField`, which incorrectly
+  allowed duplicate values larger than 32 bits. Existing unique constraints
+  must be recreated to use ``$type: long`` instead of ``int``.
+- :class:`~django.db.models.IntegerField`,
+  :class:`~django.db.models.BigIntegerField` (as well as the
+  ``Positive`` versions of these fields), and
+  :class:`~django.db.models.DurationField` values are now sent to MongoDB as
+  :class:`bson.int64.Int64`, which fixes unique constraints on values less than
+  32 bits for ``BigIntegerField``, ``PositiveIntegerField``, and
+  ``DurationField``. Existing data must be converted to ``Int64``.
 
 Performance improvements
 ------------------------

tests/model_fields_/models.py

@@ -13,6 +13,16 @@
 from django_mongodb_backend.models import EmbeddedModel
 
 
+class Integers(models.Model):
+    small = models.SmallIntegerField(unique=True, null=True)
+    normal = models.IntegerField(unique=True, null=True)
+    big = models.BigIntegerField(unique=True, null=True)
+    positive_small = models.PositiveSmallIntegerField(unique=True, null=True)
+    positive = models.PositiveIntegerField(unique=True, null=True)
+    positive_big = models.PositiveBigIntegerField(unique=True, null=True)
+    duration = models.DurationField(unique=True, null=True)
+
+
 # ObjectIdField
 class ObjectIdModel(models.Model):
     field = ObjectIdField()

tests/model_fields_/test_durationfield.py

@@ -0,0 +1,27 @@
+from datetime import timedelta
+
+from django.db import IntegrityError
+from django.test import TestCase
+
+from .models import Integers
+
+
+class UniqueTests(TestCase):
+    def test_small_value(self):
+        """
+        Duplicate values < 32 bits are prohibited. This confirms DurationField values
+        are cast to Int64 so MongoDB stores them as long. Otherwise, the
+        partialFilterExpression: {$type: long} unique constraint doesn't work.
+        """
+        Integers.objects.create(duration=timedelta(1))
+        with self.assertRaises(IntegrityError):
+            Integers.objects.create(duration=timedelta(1))
+
+    def test_large_value(self):
+        """
+        Duplicate values > 32 bits are prohibited. This confirms DurationField uses the
+        long db_type() rather than the 32 bit int type.
+        """
+        Integers.objects.create(duration=timedelta(1000000))
+        with self.assertRaises(IntegrityError):
+            Integers.objects.create(duration=timedelta(1000000))

tests/model_fields_/test_integerfield.py

@@ -0,0 +1,59 @@
+from django.db import IntegrityError
+from django.test import TestCase
+
+from .models import Integers
+
+
+class SmallUniqueTests(TestCase):
+    """
+    Duplicate values < 32 bits are prohibited. This confirms integer field
+    values are cast to Int64 so MongoDB stores it as long. Otherwise, the
+    partialFilterExpression: {$type: long} unique constraint doesn't work.
+    """
+
+    def test_integerfield(self):
+        Integers.objects.create(normal=123)
+        with self.assertRaises(IntegrityError):
+            Integers.objects.create(normal=123)
+
+    def test_bigintegerfield(self):
+        Integers.objects.create(big=123)
+        with self.assertRaises(IntegrityError):
+            Integers.objects.create(big=123)
+
+    def test_positiveintegerfield(self):
+        Integers.objects.create(positive=123)
+        with self.assertRaises(IntegrityError):
+            Integers.objects.create(positive=123)
+
+    def test_positivebigintegerfield(self):
+        Integers.objects.create(positive_big=123)
+        with self.assertRaises(IntegrityError):
+            Integers.objects.create(positive_big=123)
+
+
+class LargeUniqueTests(TestCase):
+    """
+    Duplicate values > 32 bits are prohibited. This confirms each field uses
+    the long db_type() rather than the 32 bit int type.
+    """
+
+    def test_integerfield(self):
+        Integers.objects.create(normal=2**31)
+        with self.assertRaises(IntegrityError):
+            Integers.objects.create(normal=2**31)
+
+    def test_bigintegerfield(self):
+        Integers.objects.create(big=2**31)
+        with self.assertRaises(IntegrityError):
+            Integers.objects.create(big=2**31)
+
+    def test_positiveintegerfield(self):
+        Integers.objects.create(positive=2**31)
+        with self.assertRaises(IntegrityError):
+            Integers.objects.create(positive=2**31)
+
+    def test_positivebigintegerfield(self):
+        Integers.objects.create(positive_big=2**31)
+        with self.assertRaises(IntegrityError):
+            Integers.objects.create(positive_big=2**31)