Clean up.

Author: WaVEV

README.md

@@ -115,11 +115,6 @@ Migrations for 'admin':
   - `distinct()`
   - `extra()`
 
-- `Subquery`, `Exists`, and using a `QuerySet` in `QuerySet.annotate()` aren't
-  supported.
-
-- Queries with joins aren't supported.
-
 - `DateTimeField` doesn't support microsecond precision, and correspondingly,
   `DurationField` stores milliseconds rather than microseconds.
 

django_mongodb/__init__.py

@@ -6,14 +6,12 @@
 
 check_django_compatability()
 
-from .datastructures import register_datastructures  # noqa: E402
 from .expressions import register_expressions  # noqa: E402
 from .fields import register_fields  # noqa: E402
 from .functions import register_functions  # noqa: E402
 from .lookups import register_lookups  # noqa: E402
 from .query import register_nodes  # noqa: E402
 
-register_datastructures()
 register_expressions()
 register_fields()
 register_functions()

django_mongodb/compiler.py

@@ -5,6 +5,7 @@
 from django.db.models.constants import LOOKUP_SEP
 from django.db.models.sql import compiler
 from django.db.models.sql.constants import GET_ITERATOR_CHUNK_SIZE, MULTI
+from django.utils.functional import cached_property
 
 from .base import Cursor
 from .query import MongoQuery, wrap_database_errors
@@ -79,12 +80,6 @@ def _make_result(self, entity, columns, converters, tuple_expected=False):
         The entity is assumed to be a dict using field database column
         names as keys.
         """
-        result = self._apply_converters(entity, columns, converters)
-        if tuple_expected:
-            result = tuple(result)
-        return result
-
-    def _apply_converters(self, entity, columns, converters):
         result = []
         for name, col in columns:
             field = col.field
@@ -101,6 +96,8 @@ def _apply_converters(self, entity, columns, converters):
                 for converter in converters.get(name, ()):
                     value = converter(value, col, self.connection)
             result.append(value)
+        if tuple_expected:
+            result = tuple(result)
         return result
 
     def check_query(self):
@@ -150,8 +147,9 @@ def get_count(self, check_exists=False):
     def build_query(self, columns=None):
         """Check if the query is supported and prepare a MongoQuery."""
         self.check_query()
+        self.setup_query()
         query = self.query_class(self, columns)
-        query.mongo_lookups = self.get_lookup_clauses()
+        query.lookups_pipeline = self.get_lookup_clauses()
         try:
             query.mongo_query = {"$expr": self.query.where.as_mql(self, self.connection)}
         except FullResultSet:
@@ -230,7 +228,7 @@ def _get_ordering(self):
             field_ordering.append((opts.get_field(name), ascending))
         return field_ordering
 
-    @property
+    @cached_property
     def collection_name(self):
         return self.query.get_meta().db_table
 

django_mongodb/datastructures.py

@@ -39,6 +39,7 @@ class DatabaseFeatures(BaseDatabaseFeatures):
         "ordering.tests.OrderingTests.test_order_by_expression_ref",
         "ordering.tests.OrderingTests.test_order_by_f_expression",
         "ordering.tests.OrderingTests.test_order_by_f_expression_duplicates",
+        "ordering.tests.OrderingTests.test_ordering_select_related_collision",
         "ordering.tests.OrderingTests.test_reverse_ordering_pure",
         # 'ManyToOneRel' object has no attribute 'column'
         "m2m_through.tests.M2mThroughTests.test_order_by_relational_field_through_model",
@@ -61,8 +62,6 @@ class DatabaseFeatures(BaseDatabaseFeatures):
         "model_fields.test_jsonfield.TestQuerying.test_order_grouping_custom_decoder",
         "model_fields.test_jsonfield.TestQuerying.test_ordering_by_transform",
         "model_fields.test_jsonfield.TestQuerying.test_ordering_grouping_by_key_transform",
-        # Ordering 'OrderBy' is not iterable
-        "ordering.tests.OrderingTests.test_ordering_select_related_collision",
     }
     # $bitAnd, #bitOr, and $bitXor are new in MongoDB 6.3.
     _django_test_expected_failures_bitwise = {

django_mongodb/features.py

@@ -7,7 +7,7 @@
 from django.conf import settings
 from django.db import DataError
 from django.db.backends.base.operations import BaseDatabaseOperations
-from django.db.models.expressions import Col, Combinable
+from django.db.models.expressions import Combinable
 from django.utils import timezone
 from django.utils.regex_helper import _lazy_re_compile
 
@@ -159,12 +159,6 @@ def execute_sql_flush(self, tables):
             if not options.get("capped", False):
                 collection.drop()
 
-    def prepare_join_on_clause(self, lhs_table, lhs_field, rhs_table, rhs_field):
-        lhs_expr = Col(lhs_table, lhs_field)
-        rhs_expr = Col(rhs_table, rhs_field)
-
-        return lhs_expr, rhs_expr
-
     def prep_lookup_value(self, value, field, lookup):
         """
         Perform type-conversion on `value` before using as a filter parameter.

django_mongodb/operations.py

@@ -3,6 +3,8 @@
 from django.core.exceptions import EmptyResultSet, FullResultSet
 from django.db import DatabaseError, IntegrityError
 from django.db.models import Value
+from django.db.models.sql.constants import INNER
+from django.db.models.sql.datastructures import Join
 from django.db.models.sql.where import AND, XOR, WhereNode
 from pymongo import ASCENDING, DESCENDING
 from pymongo.errors import DuplicateKeyError, PyMongoError
@@ -43,10 +45,7 @@ def __init__(self, compiler, columns):
         self.collection_name = self.compiler.collection_name
         self.collection = self.compiler.get_collection()
         self.mongo_query = getattr(compiler.query, "raw_query", {})
-        # maybe I have to create a new object or named tuple.
-        # it will save lookups, some filters (in case of inner) and project to rename field
-        # don't know if the rename is needed
-        self.mongo_lookups = None
+        self.lookups_pipeline = None
 
     def __repr__(self):
         return f"<MongoQuery: {self.mongo_query!r} ORDER {self.ordering!r}>"
@@ -112,16 +111,15 @@ def get_cursor(self):
                 # another column.
                 fields[name] = 1 if name == column else f"${column}"
 
-        # Add the subquery results if fields is defined.
+        # Add the related results if fields is defined.
         if fields:
             for alias in self.query.alias_map:
                 if self.query.alias_refcount[alias] and self.collection_name != alias:
                     fields[alias] = 1
 
         pipeline = []
-        if self.mongo_lookups:
-            lookups = self.mongo_lookups
-            pipeline.extend(lookups)
+        if self.lookups_pipeline:
+            pipeline.extend(self.lookups_pipeline)
         if self.mongo_query:
             pipeline.append({"$match": self.mongo_query})
         if fields:
@@ -135,6 +133,75 @@ def get_cursor(self):
         return self.collection.aggregate(pipeline)
 
 
+def join(self, compiler, connection):
+    lookups_pipeline = []
+    join_fields = self.join_fields or self.join_cols
+    lhs_fields = []
+    rhs_fields = []
+    for lhs, rhs in join_fields:
+        if isinstance(lhs, str):
+            lhs_mql = lhs
+            rhs_mql = rhs
+        else:
+            lhs, rhs = connection.ops.prepare_join_on_clause(
+                self.parent_alias, lhs, self.table_name, rhs
+            )
+            lhs_mql = lhs.as_mql(compiler, connection)
+            rhs_mql = rhs.as_mql(compiler, connection)
+            # replace prefix, in lookup stages the reference
+            # to this column is without the collection name.
+            rhs_mql = rhs_mql.replace(f"{self.table_name}.", "", 1)
+        lhs_fields.append(lhs_mql)
+        rhs_fields.append(rhs_mql)
+
+    parent_template = "parent__field__"
+    lookups_pipeline = [
+        {
+            "$lookup": {
+                "from": self.table_name,
+                "let": {
+                    f"{parent_template}{i}": parent_field
+                    for i, parent_field in enumerate(lhs_fields)
+                },
+                "pipeline": [
+                    {
+                        "$match": {
+                            "$expr": {
+                                "$and": [
+                                    {"$eq": [f"$${parent_template}{i}", field]}
+                                    for i, field in enumerate(rhs_fields)
+                                ]
+                            }
+                        }
+                    }
+                ],
+                "as": self.table_alias,
+            }
+        },
+    ]
+    if self.join_type != INNER:
+        lookups_pipeline.append(
+            {
+                "$set": {
+                    self.table_alias: {
+                        "$cond": {
+                            "if": {
+                                "$or": [
+                                    {"$eq": [{"$type": f"${self.table_alias}"}, "missing"]},
+                                    {"$eq": [{"$size": f"${self.table_alias}"}, 0]},
+                                ]
+                            },
+                            "then": [{}],
+                            "else": f"${self.table_alias}",
+                        }
+                    }
+                }
+            }
+        )
+    lookups_pipeline.append({"$unwind": f"${self.table_alias}"})
+    return lookups_pipeline
+
+
 def where_node(self, compiler, connection):
     if self.connector == AND:
         full_needed, empty_needed = len(self.children), 1
@@ -185,4 +252,5 @@ def where_node(self, compiler, connection):
 
 
 def register_nodes():
+    Join.as_mql = join
     WhereNode.as_mql = where_node