def get_by_model(self, queryset_or_model, tags):
        """
        Create a ``QuerySet`` containing instances of the specified
        model associated with a given tag or list of tags.
        """
        tags = get_tag_list(tags)
        tag_count = len(tags)
        queryset, model = get_queryset_and_model(queryset_or_model)

        if tag_count == 0:
            return model._default_manager.none()
        elif tag_count == 1:
            # Optimisation for single tag - fall through to the simpler
            # query below.
            tag = tags[0]
        else:
            return self.get_intersection_by_model(queryset_or_model, tags)
        
        content_type = ContentType.objects.get_for_model(model)
        opts = self.model._meta
        tagged_item_table = qn(opts.db_table)
        
        return queryset.active().extra(
            tables=[opts.db_table],
            where=[
                '%s.content_type_id = %%s' % tagged_item_table,
                '%s.tag_id = %%s' % tagged_item_table,
                '%s.%s = %s.object_id' % (qn(model._meta.db_table),
                                          qn(model._meta.pk.column),
                                          tagged_item_table)
            ],
            params=[content_type.pk, tag.pk],
        )
 def get_intersection_by_model(self, queryset_or_model, tags):
     """
     Create a ``QuerySet`` containing instances of the specified
     model associated with *all* of the given list of tags.
     """
     tags = get_tag_list(tags)
     tag_count = len(tags)
     queryset, model = get_queryset_and_model(queryset_or_model)
     
     if not tag_count:
         return model._default_manager.none()
     
     model_table = qn(model._meta.db_table)
     # This query selects the ids of all objects which have all the
     # given tags.
     query = """
     SELECT %(model_pk)s
     FROM %(model)s, %(tagged_item)s
     WHERE %(tagged_item)s.content_type_id = %(content_type_id)s
       AND %(tagged_item)s.tag_id IN (%(tag_id_placeholders)s)
       AND %(model_pk)s = %(tagged_item)s.object_id
     GROUP BY %(model_pk)s
     HAVING COUNT(%(model_pk)s) = %(tag_count)s""" % {
         'model_pk': '%s.%s' % (model_table, qn(model._meta.pk.column)),
         'model': model_table,
         'tagged_item': qn(self.model._meta.db_table),
         'content_type_id': ContentType.objects.get_for_model(model).pk,
         'tag_id_placeholders': ','.join(['%s'] * tag_count),
         'tag_count': tag_count,
     }
     
     cursor = connection.cursor()
     cursor.execute(query, [tag.pk for tag in tags])
     object_ids = [row[0] for row in cursor.fetchall()]
     if len(object_ids) > 0:
         return queryset.filter(pk__in=object_ids)
     else:
         return model._default_manager.none()