Obtenir toutes les requêtes exécutées par django sur postgresql

Question

Je travaille sur un projet django-postgresql et j'ai besoin de voir toutes les requêtes que django exécute sur la base de données (donc je peux affiner les requêtes). Existe-t-il un moyen d'obtenir ces requêtes? Mise à jour: Mon environnement de développement est sur Linux Ubuntu

Answer 1

Essayez le django debug toolbar. Il va vous montrer tout le SQL exécuté sur la demande. Quand quelque chose exécute beaucoup trop de requêtes, cela devient vraiment lent, cependant. Pour cela, je voulais essayer ce profiler. Cependant, j'ai roulé ce middleware sur deux projets:

try: 
    from cStringIO import StringIO 
except ImportError: 
    import StringIO 
from django.conf import settings 
from django.db import connection 

class DatabaseProfilerMiddleware(object): 
    def can(self, request): 
     return settings.DEBUG and 'dbprof' in request.GET 

    def process_response(self, request, response): 
     if self.can(request): 
      out = StringIO() 
      out.write('time  sql\n') 
      total_time = 0 
      for query in reversed(sorted(connection.queries, key=lambda x: x['time'])): 
       total_time += float(query['time'])*1000 
       out.write('%s %s\n' % (query['time'], query['sql'])) 
      response.content = '<pre style=&quot;white-space:pre-wrap&quot;>%d queries executed in %.3f seconds\n%s</pre>' \ 
       % (len(connection.queries), total_time/1000, out.getvalue()) 
     return response 

Il suffit d'aller à l'URL correspondant à la demande qui vous intéresse et ajouter un paramètre dbprofGET, vous verrez la sortie de profilage au lieu de la réponse normale.

Answer 2

Eh bien, vous pouvez simplement définir le serveur pgsql pour consigner chaque requête. Ou juste pour enregistrer les plus lents. Regardez dans le fichier postgresql.conf, c'est assez proche de l'auto-documentation.

Answer 3

Vérifiez cette question (et les deux les plus haut réponses): django orm, how to view (or log) the executed query?

Vous pouvez également jeter un oeil à la Documenation Djando: https://docs.djangoproject.com/en/dev/faq/models/#how-can-i-see-the-raw-sql-queries-django-is-running

Hope this helps, Anton

Answer 4

Vous pouvez décorer un gestionnaire de requête ou une autre fonction avec ceci et il imprimera le sql bien formé avec les totaux à la fin.

from functools import wraps 
from django.utils import termcolors 
format_ok = termcolors.make_style(opts=('bold',), fg='green') 
format_warning = termcolors.make_style(opts=('bold',), fg='yellow') 
format_error = termcolors.make_style(opts=('bold',), fg='red') 

try: 
    from pygments import highlight 
    from pygments.lexers import SqlLexer 
    from pygments.formatters import TerminalFormatter 
    pygments_sql_lexer = SqlLexer() 
    pygments_terminal_formatter = TerminalFormatter() 
    highlight_sql = lambda s: highlight(s, pygments_sql_lexer, 
           pygments_terminal_formatter) 
except ImportError: 
    highlight_sql = lambda s: s 


def debug_sql(f): 
    """ 
    Turn SQL statement debugging on for a test run. 
    """ 
    @wraps(f) 
    def wrapper(*a, **kw): 
     from django.conf import settings 
     from django.db import connection 
     try: 
      debug = settings.DEBUG 
      settings.DEBUG = True 
      connection.queries = [] 
      return f(*a, **kw) 
     finally: 
      total_time = 0 
      for q in connection.queries: 
       fmt = format_ok 
       t = float(q['time']) 
       total_time += t 
       if t > 1: 
        fmt = format_error 
       elif t > 0.3: 
        fmt = format_warning 
       print '[%s] %s' % (fmt(q['time']), highlight_sql(q['sql'])) 
      print "total time =", total_time 
      print "num queries =", len(connection.queries) 
      settings.DEBUG = debug 
    return wrapper