Bug fixes.

Author: WaVEV

django_mongodb_backend/features.py

@@ -29,7 +29,7 @@ class DatabaseFeatures(GISFeatures, BaseDatabaseFeatures):
     supports_deferrable_unique_constraints = False
     supports_explaining_query_execution = True
     supports_expression_defaults = False
-    supports_expression_indexes = True
+    supports_expression_indexes = False
     supports_foreign_keys = False
     supports_ignore_conflicts = False
     supports_json_field_contains = False
@@ -102,6 +102,9 @@ class DatabaseFeatures(GISFeatures, BaseDatabaseFeatures):
         "model_fields.test_jsonfield.TestSaveLoad.test_bulk_update_custom_get_prep_value",
         # To debug: https://github.com/mongodb/django-mongodb-backend/issues/362
         "constraints.tests.UniqueConstraintTests.test_validate_case_when",
+        # Partially expression index support
+        "schema.tests.SchemaTests.test_func_unique_constraint_unsupported",
+        "schema.tests.SchemaTests.test_func_index_unsupported",
     }
     # $bitAnd, #bitOr, and $bitXor are new in MongoDB 6.3.
     _django_test_expected_failures_bitwise = {

django_mongodb_backend/indexes.py

@@ -4,7 +4,7 @@
 from django.core.checks import Error, Warning
 from django.db import NotSupportedError
 from django.db.models import FloatField, Index, IntegerField
-from django.db.models.expressions import F, OrderBy
+from django.db.models.expressions import OrderBy
 from django.db.models.lookups import BuiltinLookup
 from django.db.models.sql.query import Query
 from django.db.models.sql.where import AND, XOR, WhereNode
@@ -51,16 +51,14 @@ def get_pymongo_index_model(self, model, schema_editor, field=None, unique=False
     expressions_fields = []
     if self.contains_expressions:
         for expression in self.expressions:
-            if not isinstance(expression, F | OrderBy):
-                continue
             query = Query(model=model, alias_cols=False)
             field_ = expression.resolve_expression(query)
             compiler = query.get_compiler(connection=schema_editor.connection)
             column = field_.as_mql(compiler, schema_editor.connection, as_path=True)
             db_type = (
                 field_.expression.db_type(schema_editor.connection)
                 if isinstance(field_, OrderBy)
-                else field_.db_type(schema_editor.connection)
+                else field_.output_field.db_type(schema_editor.connection)
             )
             if unique:
                 filter_expression[column].update({"$type": db_type})

django_mongodb_backend/schema.py

@@ -1,5 +1,6 @@
 from django.db.backends.base.schema import BaseDatabaseSchemaEditor
 from django.db.models import Index, UniqueConstraint
+from django.db.models.expressions import F, OrderBy
 from pymongo.operations import SearchIndexModel
 
 from django_mongodb_backend.indexes import SearchIndex
@@ -345,6 +346,36 @@ def _remove_field_index(self, model, field, column_prefix=""):
             )
         collection.drop_index(index_names[0])
 
+    def _check_supported_expressions(self, expressions):
+        for expression in expressions:
+            expression = expression.expression if isinstance(expression, OrderBy) else expression
+            if not isinstance(expression, F):
+                return False
+        return True
+
+    def _unique_supported(
+        self,
+        condition=None,
+        deferrable=None,
+        include=None,
+        expressions=None,
+        nulls_distinct=None,
+    ):
+        return (
+            (not condition or self.connection.features.supports_partial_indexes)
+            and (not deferrable or self.connection.features.supports_deferrable_unique_constraints)
+            and (not include or self.connection.features.supports_covering_indexes)
+            and (
+                not expressions
+                or self._check_supported_expressions(expressions)
+                or self.connection.features.supports_expression_indexes
+            )
+            and (
+                nulls_distinct is None
+                or self.connection.features.supports_nulls_distinct_unique_constraints
+            )
+        )
+
     @ignore_embedded_models
     def add_constraint(self, model, constraint, field=None, column_prefix="", parent_model=None):
         if isinstance(constraint, UniqueConstraint) and self._unique_supported(
@@ -386,6 +417,7 @@ def remove_constraint(self, model, constraint):
             nulls_distinct=constraint.nulls_distinct,
         ):
             idx = Index(
+                *constraint.expressions,
                 fields=constraint.fields,
                 name=constraint.name,
                 condition=constraint.condition,