Ticket #13835: django-trunk-rev13294-for-johnny-cache.patch

django/contrib/gis/db/models/sql/where.py

@@ -44 +44 @@
         lvalue, lookup_type, value_annot, params_or_value = child
         if isinstance(lvalue, GeoConstraint):
             data, params = lvalue.process(lookup_type, params_or_value, connection)
+            tables = []
+            if hasattr(params, 'tables'):
+                tables.extend(params.tables)
             spatial_sql = connection.ops.spatial_lookup_sql(data, lookup_type, params_or_value, lvalue.field, qn)
-            return spatial_sql, params
+            return spatial_sql, params, tables
         else:
             return super(GeoWhereNode, self).make_atom(child, qn, connection)
 

django/db/models/query_utils.py

@@ -133 +133 @@
     A type that indicates the contents are an SQL fragment and the associate
     parameters. Can be used to pass opaque data to a where-clause, for example.
     """
-    def __init__(self, sql, params):
+    def __init__(self, sql, params, tables):
         self.data = sql, params
+        self.tables = tables
 
     def as_sql(self, qn=None, connection=None):
         return self.data

django/db/models/fields/__init__.py

@@ -315 +315 @@
                 sql, params = value.as_sql()
             else:
                 sql, params = value._as_sql(connection=connection)
-            return QueryWrapper(('(%s)' % sql), params)
+            tables = []
+            if hasattr(value, 'query'):
+                tables = value.query.tables
+            return QueryWrapper(('(%s)' % sql), params, tables)
 
         if lookup_type in ('regex', 'iregex', 'month', 'day', 'week_day', 'search'):
             return [value]

django/db/models/fields/related.py

@@ -152 +152 @@
                 sql, params = value.as_sql()
             else:
                 sql, params = value._as_sql(connection=connection)
-            return QueryWrapper(('(%s)' % sql), params)
+            tables = []
+            if hasattr(value, 'query'):
+                tables = value.query.tables
+            return QueryWrapper(('(%s)' % sql), params, tables)
 
         # FIXME: lt and gt are explicitly allowed to make
         # get_(next/prev)_by_date work; other lookups are not allowed since that

django/db/models/sql/where.py

@@ -84 +84 @@
             return None, []
         result = []
         result_params = []
+        result_tables = []
         empty = True
         for child in self.children:
             try:
+                # child can be 'WhereNode' (or Nothing/Everything Node) or tuple
+                # tuples do not have as_sql method, and theirs tables are
+                # processed in make_atom
+                # WhereNode provides tables in result_tables parameter
+                # constructed in the 'as_sql' method call
+                # NothingNode and EverythingNode do not provide result_tables
                 if hasattr(child, 'as_sql'):
                     sql, params = child.as_sql(qn=qn, connection=connection)
+                    if hasattr(child, 'result_tables'):
+                        tables = child.result_tables
                 else:
                     # A leaf node in the tree.
-                    sql, params = self.make_atom(child, qn, connection)
+                    sql, params, tables = self.make_atom(child, qn, connection)
 
             except EmptyResultSet:
                 if self.connector == AND and not self.negated:
@@ -115 +124 @@
             if sql:
                 result.append(sql)
                 result_params.extend(params)
+                result_tables.extend(tables)
         if empty:
             raise EmptyResultSet
 
@@ -125 +135 @@
                 sql_string = 'NOT (%s)' % sql_string
             elif len(self.children) != 1:
                 sql_string = '(%s)' % sql_string
+        self.result_tables = result_tables
         return sql_string, result_params
 
     def make_atom(self, child, qn, connection):
@@ -136 +147 @@
         it.
         """
         lvalue, lookup_type, value_annot, params_or_value = child
+        tables = []
         if hasattr(lvalue, 'process'):
             try:
                 lvalue, params = lvalue.process(lookup_type, params_or_value, connection)
@@ -150 +162 @@
         else:
             # A smart object with an as_sql() method.
             field_sql = lvalue.as_sql(qn, connection)
+            # lvalue with as_sql() method is an aggregate object
+            # (django.db.models.sql.aggregates.*)
+            # its join tables should appear in query.tables
 
         if value_annot is datetime.datetime:
             cast_sql = connection.ops.datetime_cast_sql()
@@ -157 +172 @@
             cast_sql = '%s'
 
         if hasattr(params, 'as_sql'):
+            # params with an as_sql method is a QueryWrapper or SQLEvaluator instance
+            # join tables of SQLEvaluator should appear in query.tables
+            # join tables of QueryWrapper are stored as tables instance variable
+            if hasattr(params, 'tables'):
+                tables.extend(params.tables)
             extra, params = params.as_sql(qn, connection)
             cast_sql = ''
         else:
@@ -171 +191 @@
             format = "%s %%s %%s" % (connection.ops.lookup_cast(lookup_type),)
             return (format % (field_sql,
                               connection.operators[lookup_type] % cast_sql,
-                              extra), params)
+                              extra), params, tables)
 
         if lookup_type == 'in':
             if not value_annot:
                 raise EmptyResultSet
             if extra:
-                return ('%s IN %s' % (field_sql, extra), params)
+                return ('%s IN %s' % (field_sql, extra), params, tables)
             return ('%s IN (%s)' % (field_sql, ', '.join(['%s'] * len(params))),
-                    params)
+                    params, tables)
         elif lookup_type in ('range', 'year'):
-            return ('%s BETWEEN %%s and %%s' % field_sql, params)
+            return ('%s BETWEEN %%s and %%s' % field_sql, params, tables)
         elif lookup_type in ('month', 'day', 'week_day'):
             return ('%s = %%s' % connection.ops.date_extract_sql(lookup_type, field_sql),
-                    params)
+                    params, tables)
         elif lookup_type == 'isnull':
             return ('%s IS %sNULL' % (field_sql,
-                (not value_annot and 'NOT ' or '')), ())
+                (not value_annot and 'NOT ' or '')), (), tables)
         elif lookup_type == 'search':
-            return (connection.ops.fulltext_search_sql(field_sql), params)
+            return (connection.ops.fulltext_search_sql(field_sql), params, tables)
         elif lookup_type in ('regex', 'iregex'):
-            return connection.ops.regex_lookup(lookup_type) % (field_sql, cast_sql), params
+            return connection.ops.regex_lookup(lookup_type) % (field_sql, cast_sql), params, tables
 
         raise TypeError('Invalid lookup_type: %r' % lookup_type)