Support using L() inside complex expressions in predicate

Author: Alex Hill

relativity/fields.py

@@ -1,10 +1,11 @@
 from __future__ import unicode_literals, absolute_import
 
+import copy
 from collections import OrderedDict
 
 import django
 from django.db import models, connections
-from django.db.models import F, ForeignObject
+from django.db.models import F, ForeignObject, Value
 from django.db.models.fields.related_descriptors import (
     ReverseManyToOneDescriptor,
     ReverseOneToOneDescriptor,
@@ -237,19 +238,28 @@ def get_extra_restriction(self, where_class, alias, related_alias):
             where_class=where_class,
         )
 
+    @classmethod
+    def _resolve_expression_local_references(cls, expr, obj):
+        if isinstance(expr, L):
+            return expr._relativity_resolve_for_instance(obj)
+        else:
+            for source_expr in expr.get_source_expressions():
+                cls._resolve_expression_local_references(source_expr, obj)
+        return expr
+
     def get_forward_related_filter(self, obj):
         """
         Return the filter arguments which select the instances of self.model
         that are related to obj.
         """
         q = self.field.predicate
-        q = q() if callable(q) else q
+        q = q() if callable(q) else copy.deepcopy(q)
 
         # If this is a simple restriction that can be expressed as an AND of
         # two basic field lookups, we can return a dictionary of filters...
         if q.connector == Q.AND and all(type(c) == tuple for c in q.children):
             return {
-                lookup: getattr(obj, v.name) if isinstance(v, L) else v
+                lookup: self._resolve_expression_local_references(v, obj)
                 for lookup, v in q.children
             }
 
@@ -371,6 +381,11 @@ def relationship_related_query_name(self):
 
 
 class L(F):
+    def _relativity_resolve_for_instance(self, obj):
+        val = getattr(obj, self.name)
+        self._relativity_resolved_value = Value(val)
+        return val
+
     def resolve_expression(
         self,
         query=None,
@@ -380,7 +395,10 @@ def resolve_expression(
         for_save=False,
         simple_col=False,
     ):
-        # noinspection PyProtectedMember
-        return super(L, self).resolve_expression(
-            query._relationship_field_query, allow_joins, reuse, summarize, for_save
-        )
+        if hasattr(self, "_relativity_resolved_value"):
+            return self._relativity_resolved_value
+        else:
+            # noinspection PyProtectedMember
+            return super(L, self).resolve_expression(
+                query._relationship_field_query, allow_joins, reuse, summarize, for_save
+            )

tests/models.py

@@ -1,8 +1,9 @@
 from __future__ import absolute_import, unicode_literals
 
 from django.db import models
-from django.db.models import Lookup, Q
+from django.db.models import Lookup, Q, Value
 from django.db.models.fields import Field
+from django.db.models.functions import Concat
 from mptt.fields import TreeForeignKey
 from mptt.models import MPTTModel
 from six import python_2_unicode_compatible
@@ -186,3 +187,17 @@ class SavedFilter(models.Model):
     user = models.ForeignKey(User, on_delete=models.CASCADE)
     search_regex = models.TextField()
     chemicals = Relationship(Chemical, Q(formula__regex=L("search_regex")))
+
+
+class UserGenerator(models.Model):
+
+    user = Relationship(
+        User,
+        Q(username=Concat(Value("generated_for_"), L("id"))),
+        multiple=False,
+        reverse_multiple=False,
+    )
+
+    def save(self, *args, **kwargs):
+        super(UserGenerator, self).save(*args, **kwargs)
+        User.objects.create(username="generated_for_%d" % self.id)

tests/settings.py

@@ -17,3 +17,5 @@
 TEST_NON_SERIALIZED_APPS = ["tests"]
 
 DEBUG = True
+
+DEFAULT_AUTO_FIELD = "django.db.models.AutoField"

tests/tests.py

@@ -17,6 +17,7 @@
     SavedFilter,
     User,
     LinkedNode,
+    UserGenerator,
 )
 
 
@@ -354,3 +355,7 @@ def test_single_reverse(self):
         )
         self.assertEqual(node_3.prev, node_2)
         self.assertEqual(node_1.next, node_2)
+
+    def test_complex_expression(self):
+        ug = UserGenerator.objects.create()
+        self.assertEqual(ug.user, User.objects.get(username="generated_for_%d" % ug.id))