Add search index test

Author: WaVEV

django_mongodb_backend/compiler.py

@@ -17,7 +17,7 @@
 from django.utils.functional import cached_property
 from pymongo import ASCENDING, DESCENDING
 
-from .functions import SearchExpression
+from .expressions.builtins import SearchExpression
 from .query import MongoQuery, wrap_database_errors
 
 

django_mongodb_backend/expressions/builtins.py

@@ -209,8 +209,7 @@ def value(self, compiler, connection):  # noqa: ARG001
 
 
 class SearchExpression(Expression):
-    def __init__(self):
-        super().__init__(output_field=FloatField())
+    output_field = FloatField()
 
     def get_source_expressions(self):
         return []
@@ -235,34 +234,37 @@ def _get_query_index(self, fields, compiler):
 
 
 class SearchAutocomplete(SearchExpression):
-    def __init__(self, path, query, score=None):
-        self.path = F(path)
-        self.query = Value(query)
+    def __init__(self, path, query, fuzzy=None, score=None):
+        self.path = path
+        self.query = query
+        self.fuzzy = fuzzy
         self.score = score
         super().__init__()
 
     def as_mql(self, compiler, connection):
         params = {
-            "path": self.path.as_mql(compiler, connection)[1:],
-            "query": self.query.as_mql(compiler, connection),
+            "path": self.path,
+            "query": self.query,
         }
         if self.score is not None:
             params["score"] = self.score
+        if self.fuzzy is not None:
+            params["fuzzy"] = self.fuzzy
         index = self._get_query_index([self.path], compiler)
         return {"$search": {"autocomplete": params, "index": index}}
 
 
 class SearchEquals(SearchExpression):
     def __init__(self, path, value, score=None):
-        self.path = F(path)
-        self.value = Value(query)
+        self.path = path
+        self.value = value
         self.score = score
         super().__init__()
 
     def as_mql(self, compiler, connection):
         params = {
-            "path": self.path.as_mql(compiler, connection)[1:],
-            "value": self.value.as_mql(compiler, connection),
+            "path": self.path,
+            "value": self.value,
         }
         if self.score is not None:
             params["score"] = self.score
@@ -272,13 +274,13 @@ def as_mql(self, compiler, connection):
 
 class SearchExists(SearchExpression):
     def __init__(self, path, score=None):
-        self.path = F(path)
+        self.path = path
         self.score = score
         super().__init__()
 
     def as_mql(self, compiler, connection):
         params = {
-            "path": self.path.as_mql(compiler, connection)[1:],
+            "path": self.path,
         }
         if self.score is not None:
             params["score"] = self.score
@@ -288,15 +290,15 @@ def as_mql(self, compiler, connection):
 
 class SearchIn(SearchExpression):
     def __init__(self, path, value, score=None):
-        self.path = F(path)
-        self.value = Value(value)
+        self.path = path
+        self.value = value
         self.score = score
         super().__init__()
 
     def as_mql(self, compiler, connection):
         params = {
-            "path": self.path.as_mql(compiler, connection)[1:],
-            "value": self.value.as_mql(compiler, connection),
+            "path": self.path,
+            "value": self.value,
         }
         if self.score is not None:
             params["score"] = self.score
@@ -305,18 +307,18 @@ def as_mql(self, compiler, connection):
 
 
 class SearchPhrase(SearchExpression):
-    def __init__(self, path, value, slop=None, synonyms=None, score=None):
-        self.path = F(path)
-        self.value = Value(value)
+    def __init__(self, path, query, slop=None, synonyms=None, score=None):
+        self.path = path
+        self.query = query
         self.score = score
         self.slop = slop
         self.synonyms = synonyms
         super().__init__()
 
     def as_mql(self, compiler, connection):
         params = {
-            "path": self.path.as_mql(compiler, connection)[1:],
-            "value": self.value.as_mql(compiler, connection),
+            "path": self.path,
+            "query": self.query,
         }
         if self.score is not None:
             params["score"] = self.score
@@ -330,15 +332,15 @@ def as_mql(self, compiler, connection):
 
 class SearchQueryString(SearchExpression):
     def __init__(self, path, query, score=None):
-        self.path = F(path)
-        self.query = Value(query)
+        self.path = path
+        self.query = query
         self.score = score
         super().__init__()
 
     def as_mql(self, compiler, connection):
         params = {
-            "defaultPath": self.path.as_mql(compiler, connection)[1:],
-            "query": self.query.as_mql(compiler, connection),
+            "defaultPath": self.path,
+            "query": self.query,
         }
         if self.score is not None:
             params["score"] = self.score
@@ -348,132 +350,138 @@ def as_mql(self, compiler, connection):
 
 class SearchRange(SearchExpression):
     def __init__(self, path, lt=None, lte=None, gt=None, gte=None, score=None):
-        self.path = F(path)
-        self.lt = Value(lt)
-        self.lte = Value(lte)
-        self.gt = Value(gt)
-        self.gte = Value(gte)
+        self.path = path
+        self.lt = lt
+        self.lte = lte
+        self.gt = gt
+        self.gte = gte
         self.score = score
         super().__init__()
 
     def as_mql(self, compiler, connection):
         params = {
-            "path": self.path.as_mql(compiler, connection)[1:],
+            "path": self.path,
         }
         if self.score is not None:
             params["score"] = self.score
         if self.lt is not None:
-            params["lt"] = self.lt.as_mql(compiler, connection)
+            params["lt"] = self.lt
         if self.lte is not None:
-            params["lte"] = self.lte.as_mql(compiler, connection)
+            params["lte"] = self.lte
         if self.gt is not None:
-            params["gt"] = self.gt.as_mql(compiler, connection)
+            params["gt"] = self.gt
         if self.gte is not None:
-            params["gte"] = self.gte.as_mql(compiler, connection)
+            params["gte"] = self.gte
         index = self._get_query_index([self.path], compiler)
         return {"$search": {"range": params, "index": index}}
 
 
 class SearchRegex(SearchExpression):
     def __init__(self, path, query, allow_analyzed_field=None, score=None):
-        self.path = F(path)
-        self.allow_analyzed_field = Value(allow_analyzed_field)
+        self.path = path
+        self.query = query
+        self.allow_analyzed_field = allow_analyzed_field
         self.score = score
         super().__init__()
 
     def as_mql(self, compiler, connection):
         params = {
-            "path": self.path.as_mql(compiler, connection)[1:],
+            "path": self.path,
+            "query": self.query,
         }
         if self.score:
             params["score"] = self.score
         if self.allow_analyzed_field is not None:
-            params["allowAnalyzedField"] = self.allow_analyzed_field.as_mql(compiler, connection)
+            params["allowAnalyzedField"] = self.allow_analyzed_field
         index = self._get_query_index([self.path], compiler)
         return {"$search": {"regex": params, "index": index}}
 
 
 class SearchText(SearchExpression):
     def __init__(self, path, query, fuzzy=None, match_criteria=None, synonyms=None, score=None):
-        self.path = F(path)
-        self.fuzzy = Value(fuzzy)
-        self.match_criteria = Value(match_criteria)
-        self.synonyms = Value(synonyms)
+        self.path = path
+        self.query = query
+        self.fuzzy = fuzzy
+        self.match_criteria = match_criteria
+        self.synonyms = synonyms
         self.score = score
         super().__init__()
 
     def as_mql(self, compiler, connection):
         params = {
-            "path": self.path.as_mql(compiler, connection)[1:],
+            "path": self.path,
+            "query": self.query,
         }
         if self.score:
             params["score"] = self.score
         if self.fuzzy is not None:
-            params["fuzzy"] = self.fuzzy.as_mql(compiler, connection)
+            params["fuzzy"] = self.fuzzy
         if self.match_criteria is not None:
-            params["matchCriteria"] = self.match_criteria.as_mql(compiler, connection)
+            params["matchCriteria"] = self.match_criteria
         if self.synonyms is not None:
-            params["synonyms"] = self.synonyms.as_mql(compiler, connection)
+            params["synonyms"] = self.synonyms
         index = self._get_query_index([self.path], compiler)
         return {"$search": {"text": params, "index": index}}
 
 
 class SearchWildcard(SearchExpression):
     def __init__(self, path, query, allow_analyzed_field=None, score=None):
-        self.path = F(path)
-        self.allow_analyzed_field = Value(allow_analyzed_field)
+        self.path = path
+        self.query = query
+        self.allow_analyzed_field = allow_analyzed_field
         self.score = score
         super().__init__()
 
     def as_mql(self, compiler, connection):
         params = {
-            "path": self.path.as_mql(compiler, connection)[1:],
+            "path": self.path,
+            "query": self.query,
         }
         if self.score:
             params["score"] = self.score
         if self.allow_analyzed_field is not None:
-            params["allowAnalyzedField"] = self.allow_analyzed_field.as_mql(compiler, connection)
+            params["allowAnalyzedField"] = self.allow_analyzed_field
         index = self._get_query_index([self.path], compiler)
         return {"$search": {"wildcard": params, "index": index}}
 
 
 class SearchGeoShape(SearchExpression):
     def __init__(self, path, relation, geometry, score=None):
-        self.path = F(path)
+        self.path = path
         self.relation = relation
         self.geometry = geometry
         self.score = score
         super().__init__()
 
     def as_mql(self, compiler, connection):
         params = {
-            "path": self.path.as_mql(compiler, connection)[1:],
+            "path": self.path,
             "relation": self.relation,
             "geometry": self.geometry,
         }
         if self.score:
             params["score"] = self.score
         index = self._get_query_index([self.path], compiler)
-        return {"$search": {"wildcard": params, "index": index}}
+        return {"$search": {"geoShape": params, "index": index}}
 
 
 class SearchGeoWithin(SearchExpression):
-    def __init__(self, path, kind, geo_object, geometry, score=None):
-        self.path = F(path)
+    def __init__(self, path, kind, geo_object, score=None):
+        self.path = path
         self.kind = kind
         self.geo_object = geo_object
         self.score = score
         super().__init__()
 
     def as_mql(self, compiler, connection):
         params = {
-            "path": self.path.as_mql(compiler, connection)[1:],
+            "path": self.path,
             self.kind: self.geo_object,
         }
         if self.score:
             params["score"] = self.score
         index = self._get_query_index([self.path], compiler)
-        return {"$search": {"wildcard": params, "index": index}}
+        return {"$search": {"geoWithin": params, "index": index}}
 
 
 class SearchMoreLikeThis(SearchExpression):
@@ -492,7 +500,22 @@ def as_mql(self, compiler, connection):
         for doc in self.documents:
             needed_fields += list(doc.keys())
         index = self._get_query_index(needed_fields, compiler)
-        return {"$search": {"wildcard": params, "index": index}}
+        return {"$search": {"moreLikeThis": params, "index": index}}
+
+
+class SearchScoreOption:
+    """Class to mutate scoring on a search operation"""
+
+    def __init__(self, definitions=None):
+        self.definitions = definitions
+
+
+class CombinedSearchExpression(SearchExpression):
+    def __init__(self, lhs, connector, rhs, output_field=None):
+        super().__init__(output_field=output_field)
+        self.connector = connector
+        self.lhs = lhs
+        self.rhs = rhs
 
 
 def register_expressions():

tests/queries_/models.py

@@ -1,7 +1,6 @@
 from django.db import models
 
 from django_mongodb_backend.fields import ObjectIdAutoField, ObjectIdField
-from django_mongodb_backend.indexes import SearchIndex
 
 
 class Author(models.Model):
@@ -60,6 +59,4 @@ class Article(models.Model):
     headline = models.CharField(max_length=100)
     number = models.IntegerField()
     body = models.TextField()
-
-    class Meta:
-        indexes = [SearchIndex(fields=["headline"])]
+    location = models.JSONField(null=True)