Ticket #5415: db_signal_r6702.2.patch

django/db/__init__.py

@@ -1 +1 @@
 import os
 from django.conf import settings
-from django.core import signals
+from django.core import signals as core_signals
 from django.core.exceptions import ImproperlyConfigured
 from django.dispatch import dispatcher
 from django.utils.functional import curry
@@ -54 +54 @@
 
 # Register an event that closes the database connection
 # when a Django request is finished.
-dispatcher.connect(connection.close, signal=signals.request_finished)
+dispatcher.connect(connection.close, signal=core_signals.request_finished)
 
-# Register an event that resets connection.queries
-# when a Django request is started.
-def reset_queries():
-    connection.queries = []
-dispatcher.connect(reset_queries, signal=signals.request_started)
-
 # Register an event that rolls back the connection
 # when a Django request has an exception.
 def _rollback_on_exception():
     from django.db import transaction
     transaction.rollback_unless_managed()
-dispatcher.connect(_rollback_on_exception, signal=signals.got_request_exception)
+dispatcher.connect(_rollback_on_exception, signal=core_signals.got_request_exception)

django/db/signals.py

@@ +1 @@
+query_execute = object()

django/db/backends/util.py

@@ -1 +1 @@
 import datetime
+from django.db import signals
+from django.dispatch import dispatcher
 import md5
 from time import time
 
@@ -7 +9 @@
 except ImportError:
     from django.utils import _decimal as decimal    # for Python 2.3
 
-class CursorDebugWrapper(object):
+class CursorSignalWrapper(object):
     def __init__(self, cursor, db):
         self.cursor = cursor
         self.db = db # Instance of a BaseDatabaseWrapper subclass
@@ -18 +20 @@
             return self.cursor.execute(sql, params)
         finally:
             stop = time()
-            sql = self.db.ops.last_executed_query(self.cursor, sql, params)
-            self.db.queries.append({
-                'sql': sql,
-                'time': "%.3f" % (stop - start),
-            })
+            dispatcher.send(signal=signals.query_execute, sender=self, sql=sql, params=params, time=stop-start)
 
     def executemany(self, sql, param_list):
         start = time()
@@ -30 +28 @@
             return self.cursor.executemany(sql, param_list)
         finally:
             stop = time()
-            self.db.queries.append({
-                'sql': '%s times: %s' % (len(param_list), sql),
-                'time': "%.3f" % (stop - start),
-            })
+            # XXX: Should this be a special signal that only gets called once for efficiency?
+            for params in param_list:
+                dispatcher.send(signal=signals.query_execute, sender=self, sql=sql, params=params, time=stop-start)
 
     def __getattr__(self, attr):
         if attr in self.__dict__:
@@ -41 +38 @@
         else:
             return getattr(self.cursor, attr)
 
+
 ###############################################
 # Converters from database (string) to Python #
 ###############################################

django/db/backends/__init__.py

@@ -12 +12 @@
     ops = None
     def __init__(self, **kwargs):
         self.connection = None
-        self.queries = []
         self.options = kwargs
 
     def _commit(self):
@@ -31 +30 @@
     def cursor(self):
         from django.conf import settings
         cursor = self._cursor(settings)
-        if settings.DEBUG:
-            return self.make_debug_cursor(cursor)
+        from django.db.backends import util
+        cursor = util.CursorSignalWrapper(cursor, self)
         return cursor
 
-    def make_debug_cursor(self, cursor):
-        from django.db.backends import util
-        return util.CursorDebugWrapper(cursor, self)
-
 class BaseDatabaseFeatures(object):
     allows_group_by_ordinal = True
     allows_unique_and_pk = True

django/core/context_processors.py

@@ -33 +33 @@
     context_extras = {}
     if settings.DEBUG and request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS:
         context_extras['debug'] = True
-        from django.db import connection
-        context_extras['sql_queries'] = connection.queries
     return context_extras
 
 def i18n(request):

tests/modeltests/select_related/models.py

@@ -7 +7 @@
 the select-related behavior will traverse.
 """
 
-from django.db import models
+from django.db import models, signals
+from django.dispatch import dispatcher
 
 # Who remembers high school biology?
 
@@ -75 +76 @@
         obj.save()
         parent = obj
 
+class QueryCounter(object):
+    counter = 0
+
+    @staticmethod
+    def add():
+        QueryCounter.counter += 1
+        
+    @staticmethod
+    def clear():
+        QueryCounter.counter = 0
+
+
+def track_query(sender, *args, **kwargs):
+    QueryCounter.add()
+dispatcher.connect(track_query, signal=signals.query_execute, weak=False)
+
 __test__ = {'API_TESTS':"""
 
-# Set up.
-# The test runner sets settings.DEBUG to False, but we want to gather queries
-# so we'll set it to True here and reset it at the end of the test suite.
->>> from django.conf import settings
->>> settings.DEBUG = True
-
 >>> create_tree("Eukaryota Animalia Anthropoda Insecta Diptera Drosophilidae Drosophila melanogaster")
 >>> create_tree("Eukaryota Animalia Chordata Mammalia Primates Hominidae Homo sapiens")
 >>> create_tree("Eukaryota Plantae Magnoliophyta Magnoliopsida Fabales Fabaceae Pisum sativum")
@@ -91 +102 @@
 >>> from django import db
 
 # Normally, accessing FKs doesn't fill in related objects:
->>> db.reset_queries()
+>>> QueryCounter.clear()
 >>> fly = Species.objects.get(name="melanogaster")
 >>> fly.genus.family.order.klass.phylum.kingdom.domain
 <Domain: Eukaryota>
->>> len(db.connection.queries)
+>>> QueryCounter.counter
 8
 
 # However, a select_related() call will fill in those related objects without any extra queries:
->>> db.reset_queries()
+>>> QueryCounter.clear()
 >>> person = Species.objects.select_related().get(name="sapiens")
 >>> person.genus.family.order.klass.phylum.kingdom.domain
 <Domain: Eukaryota>
->>> len(db.connection.queries)
+>>> QueryCounter.counter
 1
 
 # select_related() also of course applies to entire lists, not just items.
 # Without select_related()
->>> db.reset_queries()
+>>> QueryCounter.clear()
 >>> world = Species.objects.all()
 >>> [o.genus.family for o in world]
 [<Family: Drosophilidae>, <Family: Hominidae>, <Family: Fabaceae>, <Family: Amanitacae>]
->>> len(db.connection.queries)
+>>> QueryCounter.counter
 9
 
 # With select_related():
->>> db.reset_queries()
+>>> QueryCounter.clear()
 >>> world = Species.objects.all().select_related()
 >>> [o.genus.family for o in world]
 [<Family: Drosophilidae>, <Family: Hominidae>, <Family: Fabaceae>, <Family: Amanitacae>]
->>> len(db.connection.queries)
+>>> QueryCounter.counter
 1
 
 # The "depth" argument to select_related() will stop the descent at a particular level:
->>> db.reset_queries()
+>>> QueryCounter.clear()
 >>> pea = Species.objects.select_related(depth=1).get(name="sativum")
 >>> pea.genus.family.order.klass.phylum.kingdom.domain
 <Domain: Eukaryota>
 
 # Notice: one few query than above because of depth=1
->>> len(db.connection.queries)
+>>> QueryCounter.counter
 7
 
->>> db.reset_queries()
+>>> QueryCounter.clear()
 >>> pea = Species.objects.select_related(depth=5).get(name="sativum")
 >>> pea.genus.family.order.klass.phylum.kingdom.domain
 <Domain: Eukaryota>
->>> len(db.connection.queries)
+>>> QueryCounter.counter
 3
 
->>> db.reset_queries()
+>>> QueryCounter.clear()
 >>> world = Species.objects.all().select_related(depth=2)
 >>> [o.genus.family.order for o in world]
 [<Order: Diptera>, <Order: Primates>, <Order: Fabales>, <Order: Agaricales>]
->>> len(db.connection.queries)
+>>> QueryCounter.counter
 5
-
-# Reset DEBUG to where we found it.
->>> settings.DEBUG = False
 """}