Trace db queries in Django shell

import logging
l = logging.getLogger('django.db.backends')
l.setLevel(logging.DEBUG)
l.addHandler(logging.StreamHandler())

or use this command (requires Django Debug Toolbar installed):

$ python manage.py debugsqlshell

or add this to your settings:

#
# LOGGING
#

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'verbose': {
            'format': '%(levelname)s %(asctime)s %(module)s %(process)d %(thread)d %(message)s'
        },
        'simple': {
            'format': '%(levelname)s %(message)s'
        },
    },
    'handlers': {
        # 'file': {
        #     'level': 'DEBUG',
        #     'class': 'logging.FileHandler',
        #     'filename': '/home/aecweb/logs/django.log',
        # },
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',
            'formatter': 'simple'
        },
        'mail_admins': {
            'level': 'ERROR',
            'class': 'django.utils.log.AdminEmailHandler',
        },
    },
    'loggers': {
        'django.db.backends': {
            'handlers': ['console', ],
            'level': 'DEBUG',
        },
    },
}

Build absolute url from relative url in Django

file myproject/utils.py

def build_absolute_url(request, relative_url):
    protocol = 'https' if request.is_secure() else 'http'
    domain = request.get_host()
    url = protocol + '://' + domain
    if not relative_url.startswith('/'):
        url += '/'
    return url + relative_url

Eventually, in templatetags.py

register = template.Library()

@register.filter
def build_absolute_url(request, relative_url):
    """ Sample usage:
        {{request|build_absolute_url:relative_url}}
    """
    from myproject.utils import build_absolute_url
    text = build_absolute_url(request, relative_url)
    return text

Accessing the model instance from within ModelAdmin?

Untested !
TODO: test this

    def get_object(self, request, model):
        object_id = request.META['PATH_INFO'].strip('/').split('/')[-1]
        # ?? object_id = resolve(request.path).args[0]
        try:
            object_id = int(object_id)
        except ValueError:
            return None
        return model.objects.get(pk=object_id)

Credits: http://stackoverflow.com/questions/949268/django-accessing-the-model-instance-from-within-modeladmin

Verify reverse() result

from django.core.urlresolvers import reverse
print reverse('grp_related_lookup')

manageex.py: Print all queries to console during Django debug session

file “manageex.py”

#!/usr/bin/env python
import os
import sys
from django.db.backends import util

#
# Purpose: act like 'manage.py', but display every query to the console
# to keep the coder depressed
#
# Mario Orlandi, adapted from http://gist.github.com/118990
#

sqlparse = None
try:
    import sqlparse
except ImportError:
    sqlparse = None


class PrintQueryWrapper(util.CursorDebugWrapper):
    def execute(self, sql, params=()):
        try:
            return self.cursor.execute(sql, params)
        finally:
            raw_sql = self.db.ops.last_executed_query(self.cursor, sql, params)
            print '\x1b[1;;43;30m',  # turn highlight on
            if sqlparse:
                print sqlparse.format(raw_sql, reindent=True),
            else:
                print raw_sql,
            print '\x1b[0m'  # turn highlight off
            print ''


if __name__ == "__main__":
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "myproject.settings")
    from django.core.management import execute_from_command_line

    try:
        util.CursorDebugWrapper = PrintQueryWrapper
    except:
        pass

    execute_from_command_line(sys.argv)

Previous implementation

Adapted from django-extensions to print queries during 'runserver';
may be used when tracing code via pdb.

Usage: call setup_print_queries() once after DJANGO_SETTINGS_MODULE has been set
(typically in manage.py; see also: http://eldarion.com/blog/2013/02/14/entry-point-hook-django-projects/)
 
from django.db.backends import util
from django.conf import settings


# Adapted by Mario Orlandi from http://gist.github.com/118990
sqlparse = None
try:
    import sqlparse
except ImportError:
    sqlparse = None


class PrintQueryWrapper(util.CursorDebugWrapper):
    def execute(self, sql, params=()):
        try:
            return self.cursor.execute(sql, params)
        finally:
            raw_sql = self.db.ops.last_executed_query(self.cursor, sql, params)
            print '\x1b[1;;43;30m',  # turn highlight on
            if sqlparse:
                print sqlparse.format(raw_sql, reindent=True),
            else:
                print raw_sql,
            print '\x1b[0m'  # turn highlight off


def setup_print_queries():
    if settings.DEBUG and settings.PRINT_QUERIES:
        util.CursorDebugWrapper = PrintQueryWrapper

Disable Django queries logging

from django.db import connection

connection.use_debug_cursor = False

Replicate Django database using fixtures

1) Dump source database

$ python manage.py dumpdata --indent=2 --format=json > AAAA-MM-DD_django_fulldump.json

2) Create empty structure for target database

$ python manage.py syncdb --noinput --no-initial-data --migrate
$ python mangate dbshell

DELETE FROM auth_permission;
DELETE FROM django_content_type;
DELETE FROM django_site;
DELETE FROM south_migrationhistory;

or:

$ python manage.py sqlflush

3) Load target database contents

$ python manage.py loaddata AAAA-MM-DD_django_fulldump.json

See also:
http://www.ofbrooklyn.com/2010/07/18/migrating-django-mysql-postgresql-easy-way/

Fix Django auth_permission name length limitation

$ python manage.py dbshell
> alter table auth_permission alter column "name" type varchar(255);
> alter table auth_permission alter column "codename" type varchar(255);
> \q

$ python manage.py syncdb --all

Redirect in urlconf

from django.shortcuts import redirect

urlpatterns = patterns('myapp.views',
    ...
    ('^pattern/$', lambda x: redirect('/redirect/url/'))
    ...
)

Decode Django session

file “views.py”:

from django.http import HttpResponse
from django.contrib.admin.views.decorators import staff_member_required
from django.contrib.sessions.models import Session
from django.contrib.auth.models import User

@staff_member_required
def decode_session(request):

    if not request.user.is_superuser:
        raise Exception('Reserved for superuser')

    key = request.REQUEST.get('key', '')
    text = u''
    if len(key) <= 0:
        text = u'[key] parameter required: es ".../?key=session_id"'
    else:
        try:
            text = key + '<br />'
            session_key = key
            session = Session.objects.get(session_key=session_key)
            text += str(session.get_decoded().items())
            uid = session.get_decoded().get('_auth_user_id')
            user = User.objects.get(pk=uid)
            text += u'<br />User: %s (mailto:%s)' % (user.username, user.email)
        except Exception, e:
            text = u'ERROR:' + e.message

    return HttpResponse(text)