Included analyzer and search_analyzer as new fields; included more tests and documentation

Author: Jibola

django_mongodb_backend/indexes.py

@@ -109,13 +109,21 @@ class SearchIndex(Index):
     suffix = "six"
     _error_id_prefix = "django_mongodb_backend.indexes.SearchIndex"
 
-    def __init__(self, *, fields=(), field_mappings=None, name=None):
+    def __init__(
+        self, *, fields=(), field_mappings=None, name=None, analyzer=None, search_analyzer=None
+    ):
         if field_mappings and not isinstance(field_mappings, dict):
             raise ValueError(
                 "field_mappings must be a dictionary mapping field names to their "
                 "Atlas Search field mappings."
             )
+        if analyzer is not None and not isinstance(analyzer, str):
+            raise ValueError(f"Analyzer must be a string. got type: {type(analyzer)}")
+        if search_analyzer is not None and not isinstance(search_analyzer, str):
+            raise ValueError(f"search_analyzer must be a string. got type: {type(search_analyzer)}")
         self.field_mappings = field_mappings
+        self.analyzer = analyzer
+        self.search_analyzer = search_analyzer
         if field_mappings:
             if fields:
                 raise ValueError("Cannot provide fields and fields_mappings")
@@ -126,6 +134,10 @@ def deconstruct(self):
         path, args, kwargs = super().deconstruct()
         if self.field_mappings is not None:
             kwargs["field_mappings"] = self.field_mappings
+        if self.analyzer is not None:
+            kwargs["analyzer"] = self.analyzer
+        if self.search_analyzer is not None:
+            kwargs["search_analyzer"] = self.search_analyzer
         return path, args, kwargs
 
     def check(self, model, connection):
@@ -175,8 +187,14 @@ def get_pymongo_index_model(
                 field = model._meta.get_field(field_name)
                 type_ = self.search_index_data_types(field.db_type(schema_editor.connection))
                 fields[field_path] = {"type": type_}
+        analyzers = {}
+        if self.analyzer is not None:
+            analyzers["analyzer"] = self.analyzer
+        if self.search_analyzer is not None:
+            analyzers["searchAnalyzer"] = self.search_analyzer
         return SearchIndexModel(
-            definition={"mappings": {"dynamic": False, "fields": fields}}, name=self.name
+            definition={"mappings": {"dynamic": False, "fields": fields, **analyzers}},
+            name=self.name,
         )
 
 

docs/ref/models/indexes.rst

@@ -26,7 +26,7 @@ minutes, depending on the size of the collection.
 ``SearchIndex``
 ---------------
 
-.. class:: SearchIndex(fields=(), field_mappings=None, name=None)
+.. class:: SearchIndex(fields=(), field_mappings=None, name=None, analyzer=None, search_analyzer=None)
 
     Creates a basic :doc:`search index <atlas:atlas-search/index-definitions>`
     on the given field(s).
@@ -46,9 +46,17 @@ minutes, depending on the size of the collection.
     (substituting the name of your model as well as a different list index if
     your model has multiple indexes).
 
+    Use ``analyzer`` or ``search_analyzer`` to configure the
+    indexing and searching analyzer, respectively, for
+    the search index definition. If these fields are not provided,
+    they will default to ``lucene.standard`` at the server level.
+    (See ``definition["mappings"]["analyzer"]``
+    and ``definition["mappings"]["searchAnalyzer"]``
+    in the :ref:`atlas:fts-static-mapping-example`).
+
     .. versionchanged:: 5.2.2
 
-        The ``fields_mappings`` argument was added.
+        The ``fields_mappings``, ``analyzer``, and ``search_analyzer`` arguments were added.
 
 ``VectorSearchIndex``
 ---------------------

docs/releases/5.2.x.rst

@@ -10,8 +10,8 @@ Django MongoDB Backend 5.2.x
 New features
 ------------
 
-- Added the ``field_mappings`` argument to :class:`.SearchIndex` to allow
-  creating advanced indexes.
+- Added the ``field_mappings``, ``analyzer``, and ``search_analyzer``
+  arguments to :class:`.SearchIndex` to allow creating advanced indexes.
 
 Bug fixes
 ---------

tests/indexes_/test_search_indexes.py

@@ -66,6 +66,16 @@ def test_field_mappings_type(self):
         with self.assertRaisesMessage(ValueError, msg):
             SearchIndex(field_mappings={"foo"})
 
+    def test_analyzer_type(self):
+        msg = "analyzer must be a string. got type: <class 'int'>"
+        with self.assertRaisesMessage(ValueError, msg):
+            SearchIndex(analyzer=42)
+
+    def test_search_analyzer_type(self):
+        msg = "search_analyzer must be a string. got type: <class 'list'>"
+        with self.assertRaisesMessage(ValueError, msg):
+            SearchIndex(search_analyzer=["foo"])
+
 
 class VectorSearchIndexTests(SimpleTestCase):
     def test_no_init_args(self):
@@ -197,6 +207,39 @@ def test_valid_fields(self):
             with connection.schema_editor() as editor:
                 editor.remove_index(index=index, model=SearchIndexTestModel)
 
+    def test_analyzer_inclusion(self):
+        index = SearchIndex(
+            name="recent_test_idx",
+            fields=["char"],
+            analyzer="lucene.simple",
+            search_analyzer="lucene.simple",
+        )
+        with connection.schema_editor() as editor:
+            editor.add_index(index=index, model=SearchIndexTestModel)
+        try:
+            index_info = connection.introspection.get_constraints(
+                cursor=None,
+                table_name=SearchIndexTestModel._meta.db_table,
+            )
+            expected_options = {
+                "dynamic": False,
+                "analyzer": "lucene.simple",
+                "searchAnalyzer": "lucene.simple",
+                "fields": {
+                    "char": {
+                        "indexOptions": "offsets",
+                        "norms": "include",
+                        "store": True,
+                        "type": "string",
+                    }
+                },
+            }
+            self.assertCountEqual(index_info[index.name]["columns"], index.fields)
+            self.assertEqual(index_info[index.name]["options"], expected_options)
+        finally:
+            with connection.schema_editor() as editor:
+                editor.remove_index(index=index, model=SearchIndexTestModel)
+
 
 @skipUnlessDBFeature("supports_atlas_search")
 class VectorSearchIndexSchemaTests(SchemaAssertionMixin, TestCase):