Add features.supports_in_index_operator flag.

Author: WaVEV

django_mongodb/features.py

@@ -1,3 +1,5 @@
+import operator
+
 from django.db.backends.base.features import BaseDatabaseFeatures
 from django.utils.functional import cached_property
 
@@ -21,6 +23,7 @@ class DatabaseFeatures(BaseDatabaseFeatures):
     supports_expression_indexes = False
     supports_foreign_keys = False
     supports_ignore_conflicts = False
+    supports_in_index_operator = property(operator.attrgetter("is_mongodb_6_0"))
     supports_json_field_contains = False
     # BSON Date type doesn't support microsecond precision.
     supports_microsecond_precision = False

django_mongodb/indexes.py

@@ -33,17 +33,18 @@ def builtin_lookup_idx(self, compiler, connection):
     lhs_mql = self.lhs.target.column
     value = process_rhs(self, compiler, connection)
     try:
-        return mongo_operators_idx[self.lookup_name](lhs_mql, value)
+        operator = mongo_operators_idx[self.lookup_name]
     except KeyError:
         raise NotSupportedError(
             f"MongoDB does not support the '{self.lookup_name}' lookup in indexes."
         ) from None
+    return {lhs_mql: {operator: value}}
 
 
 def in_idx(self, compiler, connection):
-    if not connection.features.is_mongodb_6_0:
+    if not connection.features.supports_in_index_operator:
         raise NotSupportedError(
-            f"MongoDB does not support the {self.lookup_name} lookup in indexes."
+            f"MongoDB < 6.0 does not support the {self.lookup_name} lookup in indexes."
         )
     return builtin_lookup_idx(self, compiler, connection)
 
@@ -56,13 +57,13 @@ def where_node_idx(self, compiler, connection):
     if self.connector == AND:
         operator = "$and"
     elif self.connector == XOR:
-        raise NotSupportedError("MongoDB does not support the 'Xor' lookup in indexes.")
+        raise NotSupportedError("MongoDB does not support the '^' operator lookup in indexes.")
     else:
-        if not connection.features.is_mongodb_6_0:
-            raise NotSupportedError("MongoDB does not support the 'Or' lookup in indexes.")
+        if not connection.features.supports_in_index_operator:
+            raise NotSupportedError("MongoDB < 6.0 does not support the '|' operator in indexes.")
         operator = "$or"
     if self.negated:
-        raise NotSupportedError("MongoDB does not support negated field in indexes.")
+        raise NotSupportedError("MongoDB does not support the '~' operator in indexes.")
     children_mql = []
     for child in self.children:
         try:

tests/indexes_/test_mql.py

@@ -18,7 +18,7 @@ def test_not_supported(self):
             )._get_condition_mql(Article, schema_editor=editor)
 
     def test_negated_not_supported(self):
-        msg = "MongoDB does not support negated field in indexes."
+        msg = "MongoDB does not support the '~' operator in indexes."
         with self.assertRaisesMessage(NotSupportedError, msg), connection.schema_editor() as editor:
             Index(
                 name="test",
@@ -27,15 +27,15 @@ def test_negated_not_supported(self):
             )._get_condition_mql(Article, schema_editor=editor)
 
     def test_xor_not_supported(self):
-        msg = "MongoDB does not support the 'Xor' lookup in indexes."
+        msg = "MongoDB does not support the '^' operator lookup in indexes."
         with self.assertRaisesMessage(NotSupportedError, msg), connection.schema_editor() as editor:
             Index(
                 name="test",
                 fields=["headline"],
                 condition=Q(pk=True) ^ Q(pk=False),
             )._get_condition_mql(Article, schema_editor=editor)
 
-    @skipIfDBFeature("is_mongodb_6_0")
+    @skipIfDBFeature("supports_in_index_operator")
     def test_or_not_supported(self):
         msg = "MongoDB does not support the 'Or' lookup in indexes."
         with self.assertRaisesMessage(NotSupportedError, msg), connection.schema_editor() as editor:
@@ -45,7 +45,7 @@ def test_or_not_supported(self):
                 condition=Q(pk=True) | Q(pk=False),
             )._get_condition_mql(Article, schema_editor=editor)
 
-    @skipIfDBFeature("is_mongodb_6_0")
+    @skipIfDBFeature("supports_in_index_operator")
     def test_in_not_supported(self):
         msg = "MongoDB does not support the 'in' lookup in indexes."
         with self.assertRaisesMessage(NotSupportedError, msg), connection.schema_editor() as editor:
@@ -55,21 +55,21 @@ def test_in_not_supported(self):
                 condition=Q(pk__in=[True]),
             )._get_condition_mql(Article, schema_editor=editor)
 
-    @skipUnlessDBFeature("is_mongodb_6_0")
+    @skipUnlessDBFeature("supports_in_index_operator")
     def test_composite_index(self):
         with connection.schema_editor() as editor:
             index = Index(
                 name="composite_proposition",
                 fields=["headline"],
-                condition=Q(number__gte=3) & (Q(text__gt="test1") | Q(text__in=["A", "B"])),
+                condition=Q(number__gte=3) & (Q(body__gt="test1") | Q(body__in=["A", "B"])),
             )
             index._get_condition_mql(Article, schema_editor=editor)
             self.assertEqual(
                 index._get_condition_mql(Article, schema_editor=editor),
                 {
                     "$and": [
                         {"number": {"$gte": 3}},
-                        {"$or": [{"text": {"$gt": "test1"}}, {"text": {"$in": ["A", "B"]}}]},
+                        {"$or": [{"body": {"$gt": "test1"}}, {"body": {"$in": ["A", "B"]}}]},
                     ]
                 },
             )
@@ -85,18 +85,23 @@ def test_composite_index(self):
             editor.remove_index(index=index, model=Article)
 
     def test_composite_op_index(self):
-        for op in (
-            [operator.or_, operator.and_] if connection.features.is_mongodb_6_0 else [operator.and_]
-        ):
+        operators = (
+            (
+                (operator.or_, "$or"),
+                (operator.and_, "$and"),
+            )
+            if connection.features.supports_in_index_operator
+            else ((operator.and_, "$and"),)
+        )
+        for op, mongo_operator in operators:
             with self.subTest(operator=op), connection.schema_editor() as editor:
                 index = Index(
                     name="composite_proposition",
                     fields=["headline"],
-                    condition=op(Q(number__gte=3), Q(text__gt="test1")),
+                    condition=op(Q(number__gte=3), Q(body__gt="test1")),
                 )
                 index._get_condition_mql(Article, schema_editor=editor)
-                mongo_operator = "$and" if op == operator.and_ else "$or"
-                target = {mongo_operator: [{"number": {"$gte": 3}}, {"text": {"$gt": "test1"}}]}
+                target = {mongo_operator: [{"number": {"$gte": 3}}, {"body": {"$gt": "test1"}}]}
                 self.assertEqual(
                     target,
                     index._get_condition_mql(Article, schema_editor=editor),