+# -*- coding: utf-8 -*-
"""
Models and managers for generic tagging.
"""
+
# Python 2.3 compatibility
-if not hasattr(__builtins__, 'set'):
+try:
+ set
+except NameError:
from sets import Set as set
from django.contrib.contenttypes import generic
from django.db import connection, models
from django.utils.translation import ugettext_lazy as _
from django.db.models.base import ModelBase
+from django.core.exceptions import ObjectDoesNotExist
qn = connection.ops.quote_name
if tag not in current_tags:
self.intermediary_table_model._default_manager.create(tag=tag, content_object=obj)
+ def remove_tag(self, obj, tag):
+ """
+ Remove tag from an object.
+ """
+ content_type = ContentType.objects.get_for_model(obj)
+ self.intermediary_table_model._default_manager.filter(content_type__pk=content_type.pk,
+ object_id=obj.pk, tag=tag).delete()
+
def get_for_object(self, obj):
"""
Create a queryset matching all tags associated with the given
return self.filter(items__content_type__pk=ctype.pk,
items__object_id=obj.pk)
- def _get_usage(self, model, counts=False, min_count=None, extra_joins=None, extra_criteria=None, params=None, extra=None):
+ def _get_usage(self, model, counts=False, min_count=None, extra_joins=None, extra_criteria=None, params=None, extra=None, extra_tables=None):
"""
Perform the custom SQL query for ``usage_for_model`` and
``usage_for_queryset``.
SELECT DISTINCT %(tag_columns)s%(count_sql)s
FROM
%(tag)s
- INNER JOIN %(tagged_item)s
- ON %(tag)s.id = %(tagged_item)s.tag_id
+ INNER JOIN %(tagged_item)s AS %(tagged_item_alias)s
+ ON %(tag)s.id = %(tagged_item_alias)s.tag_id
INNER JOIN %(model)s
- ON %(tagged_item)s.object_id = %(model_pk)s
+ ON %(tagged_item_alias)s.object_id = %(model_pk)s
%%s
- WHERE %(tagged_item)s.content_type_id = %(content_type_id)s
+ WHERE %(tagged_item_alias)s.content_type_id = %(content_type_id)s
%%s
%(extra_where)s
- GROUP BY %(tag)s.id, %(tag)s.name
+ GROUP BY %(tag_columns)s, %(tag)s.id, %(tag)s.name%(extra_tables)s
%%s
ORDER BY %(tag)s.%(ordering)s ASC""" % {
'tag': qn(self.model._meta.db_table),
'tag_columns': tag_columns,
'count_sql': counts and (', COUNT(%s)' % model_pk) or '',
'tagged_item': qn(self.intermediary_table_model._meta.db_table),
+ 'tagged_item_alias': qn('_newtagging_' + self.intermediary_table_model._meta.db_table),
'model': model_table,
'model_pk': model_pk,
'extra_where': extra_where,
+ 'extra_tables': ''.join((', %s.id' % qn(table)) for table in extra_tables),
'content_type_id': ContentType.objects.get_for_model(model).pk,
}
extra_joins = ' '.join(queryset.query.get_from_clause()[0][1:])
where, params = queryset.query.where.as_sql()
+ extra_tables = queryset.query.extra_tables
if where:
extra_criteria = 'AND %s' % where
else:
extra_criteria = ''
- return self._get_usage(queryset.model, counts, min_count, extra_joins, extra_criteria, params, extra)
+ return self._get_usage(queryset.model, counts, min_count, extra_joins, extra_criteria, params, extra, extra_tables=extra_tables)
def related_for_model(self, tags, model, counts=False, min_count=None, extra=None):
"""
if 'where' in extra:
extra_where = 'AND ' + ' AND '.join(extra['where'])
+ # Temporary table in this query is a hack to prevent MySQL from executing
+ # inner query as dependant query (which could result in severe performance loss)
query = """
SELECT %(tag_columns)s%(count_sql)s
FROM %(tagged_item)s INNER JOIN %(tag)s ON %(tagged_item)s.tag_id = %(tag)s.id
WHERE %(tagged_item)s.content_type_id = %(content_type_id)s
- AND %(tagged_item)s.object_id IN
- (
- SELECT %(tagged_item)s.object_id
- FROM %(tagged_item)s, %(tag)s
- WHERE %(tagged_item)s.content_type_id = %(content_type_id)s
- AND %(tag)s.id = %(tagged_item)s.tag_id
- AND %(tag)s.id IN (%(tag_id_placeholders)s)
- GROUP BY %(tagged_item)s.object_id
- HAVING COUNT(%(tagged_item)s.object_id) = %(tag_count)s
- )
- AND %(tag)s.id NOT IN (%(tag_id_placeholders)s)
- %(extra_where)s
+ AND %(tagged_item)s.object_id IN
+ (
+ SELECT *
+ FROM (
+ SELECT %(tagged_item)s.object_id
+ FROM %(tagged_item)s, %(tag)s
+ WHERE %(tagged_item)s.content_type_id = %(content_type_id)s
+ AND %(tag)s.id = %(tagged_item)s.tag_id
+ AND %(tag)s.id IN (%(tag_id_placeholders)s)
+ GROUP BY %(tagged_item)s.object_id
+ HAVING COUNT(%(tagged_item)s.object_id) = %(tag_count)s
+ ) AS temporary
+ )
+ AND %(tag)s.id NOT IN (%(tag_id_placeholders)s)
+ %(extra_where)s
GROUP BY %(tag_columns)s
%(min_count_sql)s
ORDER BY %(tag)s.%(ordering)s ASC""" % {
unique_together = (('tag', 'content_type', 'object_id'),)
def obj_unicode(self):
- return u'%s [%s]' % (self.content_type.get_object_for_this_type(pk=self.object_id), self.tag)
-
+ try:
+ return u'%s [%s]' % (self.content_type.get_object_for_this_type(pk=self.object_id), self.tag)
+ except ObjectDoesNotExist:
+ return u'<deleted> [%s]' % self.tag
+
# Set up a dictionary to simulate declarations within a class
attrs = {
'__module__': model.__module__,
fnp / wolnelektury.git / blobdiff