Add combined expressions test.

Author: WaVEV

django_mongodb_backend/expressions/builtins.py

@@ -231,6 +231,12 @@ def negate(self):
     def __hash__(self):
         return hash(self.operator)
 
+    def __str__(self):
+        return self.operator
+
+    def __repr__(self):
+        return self.operator
+
 
 class SearchCombinable:
     def _combine(self, other, connector):
@@ -283,12 +289,12 @@ def _get_query_index(self, fields, compiler):
                 return search_indexes["name"]
         return "default"
 
-    def search_operator(self, compiler, connection):
+    def search_operator(self):
         raise NotImplementedError
 
     def as_mql(self, compiler, connection):
         index = self._get_query_index(self.get_search_fields(), compiler)
-        return {"$search": {**self.search_operator(compiler, connection), "index": index}}
+        return {"$search": {**self.search_operator(), "index": index}}
 
 
 class SearchAutocomplete(SearchExpression):
@@ -302,7 +308,7 @@ def __init__(self, path, query, fuzzy=None, score=None):
     def get_search_fields(self):
         return {self.path}
 
-    def search_operator(self, compiler, connection):
+    def search_operator(self):
         params = {
             "path": self.path,
             "query": self.query,
@@ -324,7 +330,7 @@ def __init__(self, path, value, score=None):
     def get_search_fields(self):
         return {self.path}
 
-    def search_operator(self, compiler, connection):
+    def search_operator(self):
         params = {
             "path": self.path,
             "value": self.value,
@@ -343,7 +349,7 @@ def __init__(self, path, score=None):
     def get_search_fields(self):
         return {self.path}
 
-    def search_operator(self, compiler, connection):
+    def search_operator(self):
         params = {
             "path": self.path,
         }
@@ -362,7 +368,7 @@ def __init__(self, path, value, score=None):
     def get_search_fields(self):
         return {self.path}
 
-    def search_operator(self, compiler, connection):
+    def search_operator(self):
         params = {
             "path": self.path,
             "value": self.value,
@@ -384,7 +390,7 @@ def __init__(self, path, query, slop=None, synonyms=None, score=None):
     def get_search_fields(self):
         return {self.path}
 
-    def search_operator(self, compiler, connection):
+    def search_operator(self):
         params = {
             "path": self.path,
             "query": self.query,
@@ -408,7 +414,7 @@ def __init__(self, path, query, score=None):
     def get_search_fields(self):
         return {self.path}
 
-    def search_operator(self, compiler, connection):
+    def search_operator(self):
         params = {
             "defaultPath": self.path,
             "query": self.query,
@@ -431,7 +437,7 @@ def __init__(self, path, lt=None, lte=None, gt=None, gte=None, score=None):
     def get_search_fields(self):
         return {self.path}
 
-    def search_operator(self, compiler, connection):
+    def search_operator(self):
         params = {
             "path": self.path,
         }
@@ -459,7 +465,7 @@ def __init__(self, path, query, allow_analyzed_field=None, score=None):
     def get_search_fields(self):
         return {self.path}
 
-    def search_operator(self, compiler, connection):
+    def search_operator(self):
         params = {
             "path": self.path,
             "query": self.query,
@@ -484,7 +490,7 @@ def __init__(self, path, query, fuzzy=None, match_criteria=None, synonyms=None,
     def get_search_fields(self):
         return {self.path}
 
-    def search_operator(self, compiler, connection):
+    def search_operator(self):
         params = {
             "path": self.path,
             "query": self.query,
@@ -511,7 +517,7 @@ def __init__(self, path, query, allow_analyzed_field=None, score=None):
     def get_search_fields(self):
         return {self.path}
 
-    def search_operator(self, compiler, connection):
+    def search_operator(self):
         params = {
             "path": self.path,
             "query": self.query,
@@ -534,7 +540,7 @@ def __init__(self, path, relation, geometry, score=None):
     def get_search_fields(self):
         return {self.path}
 
-    def search_operator(self, compiler, connection):
+    def search_operator(self):
         params = {
             "path": self.path,
             "relation": self.relation,
@@ -553,7 +559,7 @@ def __init__(self, path, kind, geo_object, score=None):
         self.score = score
         super().__init__()
 
-    def search_operator(self, compiler, connection):
+    def search_operator(self):
         params = {
             "path": self.path,
             self.kind: self.geo_object,
@@ -572,7 +578,7 @@ def __init__(self, documents, score=None):
         self.score = score
         super().__init__()
 
-    def search_operator(self, compiler, connection):
+    def search_operator(self):
         params = {
             "like": self.documents,
         }
@@ -665,29 +671,23 @@ def get_search_fields(self):
             fields.update(clause.get_search_fields())
         return fields
 
-    def search_operator(self, compiler, connection):
+    def search_operator(self):
         params = {}
         if self.must:
-            params["must"] = [clause.search_operator(compiler, connection) for clause in self.must]
+            params["must"] = [clause.search_operator() for clause in self.must]
         if self.must_not:
-            params["mustNot"] = [
-                clause.search_operator(compiler, connection) for clause in self.must_not
-            ]
+            params["mustNot"] = [clause.search_operator() for clause in self.must_not]
         if self.should:
-            params["should"] = [
-                clause.search_operator(compiler, connection) for clause in self.should
-            ]
+            params["should"] = [clause.search_operator() for clause in self.should]
         if self.filter:
-            params["filter"] = [
-                clause.search_operator(compiler, connection) for clause in self.filter
-            ]
+            params["filter"] = [clause.search_operator() for clause in self.filter]
         if self.minimum_should_match is not None:
             params["minimumShouldMatch"] = self.minimum_should_match
 
         return {"compound": params}
 
     def negate(self):
-        return CompoundExpression(must=self.must_not, must_not=self.must + self.filter)
+        return CompoundExpression(must_not=[self])
 
 
 class CombinedSearchExpression(SearchExpression):
@@ -697,7 +697,7 @@ def __init__(self, lhs, operator, rhs):
         self.rhs = rhs
 
     @staticmethod
-    def _flatten(node, negated=False):
+    def resolve(node, negated=False):
         if node is None:
             return None
         # Leaf, resolve the compoundExpression
@@ -706,25 +706,24 @@ def _flatten(node, negated=False):
         # Apply De Morgan's Laws.
         operator = node.operator.negate() if negated else node.operator
         negated = negated != (node.operator == Operator.NOT)
-        lhs_compound = node._flatten(node.lhs, negated)
-        rhs_compound = node._flatten(node.rhs, negated)
+        lhs_compound = node.resolve(node.lhs, negated)
+        rhs_compound = node.resolve(node.rhs, negated)
         if operator == Operator.OR:
             return CompoundExpression(should=[lhs_compound, rhs_compound], minimum_should_match=1)
-        if node.operator == Operator.AND:
-            return CompoundExpression(
-                must=lhs_compound.must + rhs_compound.must,
-                must_not=lhs_compound.must_not + rhs_compound.must_not,
-                should=lhs_compound.should + rhs_compound.should,
-                filter=lhs_compound.filter + rhs_compound.filter,
-            )
-            # it also can be written as:
-            # this way is more consistent with OR, but the above is shorter in the debug query.
-            # return CompoundExpression(must=[lhs_compound, rhs_compound])
+        if operator == Operator.AND:
+            # NOTE: we can't just do the code below, think about this case (A | B) & (C | D)
+            # return CompoundExpression(
+            #     must=lhs_compound.must + rhs_compound.must,
+            #     must_not=lhs_compound.must_not + rhs_compound.must_not,
+            #     should=lhs_compound.should + rhs_compound.should,
+            #     filter=lhs_compound.filter + rhs_compound.filter,
+            # )
+            return CompoundExpression(must=[lhs_compound, rhs_compound])
         # not operator
         return lhs_compound
 
     def as_mql(self, compiler, connection):
-        expression = self._flatten(self)
+        expression = self.resolve(self)
         return expression.as_mql(compiler, connection)