Ermitteln aller Abfragen, die Django auf Postgresql ausführt

Question

Ich arbeite an einem django-postgresql-Projekt, und ich muss jede Abfrage sehen, die django auf Datenbank ausführen (so kann ich Abfragen feinabstimmen). Gibt es eine Möglichkeit, diese Abfragen zu erhalten. Update: Meine Entwicklungsumgebung ist auf ubuntu linux

Answer 1

Schauen Sie sich diese Frage (und die beiden meistgestellten Antworten) an: django orm, wie man die ausgeführte Abfrage anzeigen (oder protokollieren)?

Sie können auch einen Blick in die Djando-Dokumentation werfen: https://docs.djangoproject.com/en/dev/faq/models/#how-can-i-see-the-raw-sql-queries-django-is-running

Ich hoffe, das hilft, Anton

Answer 2

Sie könnten den pgsql-Server so einstellen, dass er jede Abfrage protokolliert. Oder nur die langsamen Abfragen protokollieren. Schauen Sie in die Datei postgresql.conf, sie ist fast selbstdokumentierend.

Answer 3

Sie können einen Request Handler oder eine andere Funktion damit ausstatten und es wird die Sql schön formatiert mit Summen am Ende ausgeben.

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

Answer 4

Versuchen Sie die django debug toolbar . Es zeigt Ihnen alle über die Anfrage ausgeführten SQL-Daten an. Wenn etwas viel zu viele Abfragen ausführt, wird es allerdings sehr langsam. Deshalb wollte ich das hier ausprobieren Profiler . Ich habe diese Middleware jedoch bei einigen Projekten eingesetzt:

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

Gehen Sie einfach auf die entsprechende URL für die Anfrage, die Sie interessiert, und fügen Sie eine dbprof GET sehen Sie die Profiling-Ausgabe anstelle der normalen Antwort.