Cast join condition when the types are differents.

Author: WaVEV

django_mongodb/operations.py

@@ -8,7 +8,9 @@
 from django.conf import settings
 from django.db import DataError
 from django.db.backends.base.operations import BaseDatabaseOperations
+from django.db.models import TextField
 from django.db.models.expressions import Combinable
+from django.db.models.functions import Cast
 from django.utils import timezone
 from django.utils.regex_helper import _lazy_re_compile
 
@@ -254,3 +256,17 @@ def format_for_duration_arithmetic(self, sql):
 
     def time_trunc_sql(self, lookup_type, sql, params, tzname=None):
         return f"DATE_TRUNC(%s, {sql})::time", (lookup_type, *params)
+
+    def prepare_join_on_clause(self, lhs_table, lhs_field, rhs_table, rhs_field):
+        lhs_expr, rhs_expr = super().prepare_join_on_clause(
+            lhs_table, lhs_field, rhs_table, rhs_field
+        )
+
+        # If the types are different, we cast both to string.
+        if lhs_field.db_type(self.connection) != rhs_field.db_type(self.connection):
+            if lhs_field.db_type(self.connection) != "string":
+                lhs_expr = Cast(lhs_expr, output_field=TextField())
+            if rhs_field.db_type(self.connection) != "string":
+                rhs_expr = Cast(rhs_expr, output_field=TextField())
+
+        return lhs_expr, rhs_expr

django_mongodb/query.py

@@ -99,12 +99,12 @@ def join(self, compiler, connection):
     # Add a join condition for each pair of joining fields.
     for lhs, rhs in self.join_fields:
         lhs, rhs = connection.ops.prepare_join_on_clause(
-            self.parent_alias, lhs, self.table_name, rhs
+            self.parent_alias, lhs, compiler.collection_name, rhs
         )
         lhs_fields.append(lhs.as_mql(compiler, connection))
         # In the lookup stage, the reference to this column doesn't include
         # the collection name.
-        rhs_fields.append(rhs.as_mql(compiler, connection).replace(f"{self.table_name}.", "", 1))
+        rhs_fields.append(rhs.as_mql(compiler, connection))
 
     parent_template = "parent__field__"
     lookup_pipeline = [
@@ -115,7 +115,7 @@ def join(self, compiler, connection):
                 # The pipeline variables to be matched in the pipeline's
                 # expression.
                 "let": {
-                    f"{parent_template}{i}": {"$toString": parent_field}
+                    f"{parent_template}{i}": parent_field
                     for i, parent_field in enumerate(lhs_fields)
                 },
                 "pipeline": [
@@ -129,7 +129,7 @@ def join(self, compiler, connection):
                         "$match": {
                             "$expr": {
                                 "$and": [
-                                    {"$eq": [f"$${parent_template}{i}", {"$toString": field}]}
+                                    {"$eq": [f"$${parent_template}{i}", field]}
                                     for i, field in enumerate(rhs_fields)
                                 ]
                             }