标签: django-q

我正在尝试构建我正在构建的Django站点的搜索,并且在搜索中我正在搜索3种不同的模型.为了获得搜索结果列表的分页,我想使用通用的object_list视图来显示结果.但要做到这一点,我必须将3个查询集合并为一个.

我怎样才能做到这一点？我试过这个:

result_list = []            
page_list = Page.objects.filter(
    Q(title__icontains=cleaned_search_term) | 
    Q(body__icontains=cleaned_search_term))
article_list = Article.objects.filter(
    Q(title__icontains=cleaned_search_term) | 
    Q(body__icontains=cleaned_search_term) | 
    Q(tags__icontains=cleaned_search_term))
post_list = Post.objects.filter(
    Q(title__icontains=cleaned_search_term) | 
    Q(body__icontains=cleaned_search_term) | 
    Q(tags__icontains=cleaned_search_term))

for x in page_list:
    result_list.append(x)
for x in article_list:
    result_list.append(x)
for x in post_list:
    result_list.append(x)

return object_list(
    request, 
    queryset=result_list, 
    template_object_name='result',
    paginate_by=10, 
    extra_context={
        'search_term': search_term},
    template_name="search/result_list.html")

但这不起作用当我尝试在通用视图中使用该列表时,我收到错误.该列表缺少clone属性.

有人知道如何合并三个列表page_list,article_list和post_list？

从示例中,您可以看到多个OR查询过滤器:

Article.objects.filter(Q(pk=1) | Q(pk=2) | Q(pk=3))

例如,这会导致:

[<Article: Hello>, <Article: Goodbye>, <Article: Hello and goodbye>]

但是,我想从列表中创建此查询过滤器.怎么做？

例如 [1, 2, 3] -> Article.objects.filter(Q(pk=1) | Q(pk=2) | Q(pk=3))

我正在尝试根据用户输入标签查询数据库.标签的数量可以是0-5,因此我需要动态创建查询.

所以我有一个标签列表,tag_list,我想查询数据库:

design_list = Design.objects.filter(Q(tags__tag__contains = "tag1") and Q(tags__tag__contains = "tag2") and etc. etc. )

我该如何创建此功能？

我有一个基本的Django模型,如:

class Business(models.Model):
    name = models.CharField(max_length=200, unique=True)
    email = models.EmailField()
    phone = models.CharField(max_length=40, blank=True, null=True)
    description = models.TextField(max_length=500)

我需要在上面的模型上执行一个复杂的查询,如:

qset = (
    Q(name__icontains=query) |
    Q(description__icontains=query) |
    Q(email__icontains=query)
    )
results = Business.objects.filter(qset).distinct()

我尝试了以下使用tastypie没有运气:

def build_filters(self, filters=None):
    if filters is None:
        filters = {}
    orm_filters = super(BusinessResource, self).build_filters(filters)

    if('query' in filters):
        query = filters['query']
        print query
        qset = (
                Q(name__icontains=query) |
                Q(description__icontains=query) |
                Q(email__icontains=query)
                )
        results = Business.objects.filter(qset).distinct()
        orm_filters = {'query__icontains': results}

    return orm_filters

在课程Meta for tastypie我有过滤设置为:

filtering = { …

我尝试在使用Q对象的过滤器中组合AND和OR.它看起来像| 表现得像一个AND.这与先前的注释有关,该注释在同一查询中运行而不是在子查询中运行.

用Django处理这个问题的正确方法是什么？

models.py

class Type(models.Model):
    name = models.CharField(_('name'), max_length=100)
    stock = models.BooleanField(_('in stock'), default=True)
    hide = models.BooleanField(_('hide'), default=False)
    deleted = models.BooleanField(_('deleted'), default=False)

class Item(models.Model):
    barcode = models.CharField(_('barcode'), max_length=100, blank=True)
    quantity = models.IntegerField(_('quantity'), default=1)
    type = models.ForeignKey('Type', related_name='items', verbose_name=_('type'))

views.py

def hire(request):
    categories_list = Category.objects.all().order_by('sorting')
    types_list = Type.objects.annotate(quantity=Sum('items__quantity')).filter(
        Q(hide=False) & Q(deleted=False),
        Q(stock=False) | Q(quantity__gte=1))
    return render_to_response('equipment/hire.html', {
           'categories_list': categories_list,
           'types_list': types_list,
           }, context_instance=RequestContext(request))

产生SQL查询

SELECT "equipment_type"."id" [...] FROM "equipment_type" LEFT OUTER JOIN
    "equipment_subcategory" ON ("equipment_type"."subcategory_id" =
    "equipment_subcategory"."id") LEFT OUTER JOIN …

我有一个奇怪的问题.

我有3个物体.全都一样

class Articles(models.Model):
    owner = models.ForeignKey(Author)
    tags = models.ManyToManyField('Tag')


class Tag(models.Model):
     name = models.CharField(max_length=255)

所以我有3篇文章.使用所有相同的标签:'tag1'和'tag2'

我有疑问

actionsAll = Articles.objects.filter((Q(tags__name__exact="tag1") | Q(tags__name__exact="tag2"))).distinct()

这给了我所有的文章.它会返回6篇不同的文章(因为它们会收集每篇文章2x,因为它们都有两个标签).

但是使用此查询:

actionsAll = Articles.objects.filter((Q(tags__name__exact="tag1") & Q(tags__name__exact="tag2"))).distinct()

这给了我没有文章.由于文章包含两个标签,它应该返回它们所有的不应该吗？

我想创建一些Django ORM过滤器查询的一部分,现在我可以这样做:

if some:
   Obj.filter(
       some_f1=some_v1,
       f1=v1,
       f2=v2,
       f3=v3,
       f4=v4,
       ...
   )
else:
   Obj.filter(
       f1=v1,
       f2=v2,
       f3=v3,
       f4=v4,
       ...
   )

我希望没有代码重复的东西像这样:

Obj.filter(
    Q(some_f1=some_v1) if some else True,  # what to use instead of True?
    f1=v1,
    f2=v2,
    f3=v3,
    f4=v4,
    ...
)

我想在django.db.models.Q对象上执行逻辑异或(XOR),使用运算符模块将模型字段的选择限制为外键的子集.我在Django 1.4.3和Python 2.7.2中这样做.我有这样的事情:

import operator

from django.conf import settings
from django.db import models
from django.db.models import Q
from django.contrib.auth.models import User, Group

def query_group_lkup(group_name):
    return Q(user__user__groups__name__exact=group_name)

class Book(models.Model):
    author = models.ForeignKey(
                 User,
                 verbose_name=_("Author"),
                 null=False,
                 default='',
                 related_name="%(app_label)s_%(class)s_author",
                 # This would have provide an exclusive OR on the selected group name for User
                 limit_choices_to=reduce(
                     operator.xor,
                     map(query_group_lkup, getattr(settings, 'AUTHORIZED_AUTHORS', ''))
                 )

AUTHORIZED_AUTHORS 是现有组名称的列表.

但这不起作用,因为Q对象不支持^运算符(仅来自文档的 |和&运算符).来自stacktrace的消息(部分)如下:

File "/home/moi/.virtualenvs/venv/lib/python2.7/site-packages/django/db/models/loading.py", line 64, in _populate
    self.load_app(app_name, True)
  File "/home/moi/.virtualenvs/venv/lib/python2.7/site-packages/django/db/models/loading.py", line …

我有一个 Django 模型，其中每个实例都需要一个从三个字段派生的唯一标识符：

class Example(Model):
    type = CharField(blank=False, null=False)           # either 'A' or 'B'
    timestamp = DateTimeField(default=timezone.now)
    number = models.IntegerField(null=True)             # a sequential number

这会产生一个形式为 的标签，[type][timestamp YEAR][number]除非number为空，否则它必须是唯一的。

我想我可以使用几个注释：

uid_expr = Case(
    When(
        number=None,
        then=Value(None),
    ),
    default=Concat(
        'type', ExtractYear('timestamp'), 'number',
        output_field=models.CharField()
    ),
    output_field=models.CharField()
)

uid_count_expr = Count('uid', distinct=True)

get_queryset默认情况下，我覆盖了模型的管理器以应用注释，然后尝试使用CheckConstraint：

class Example(Model):
    ...

    class Meta:
        constraints = [
            models.CheckConstraint(check=Q(uid_cnt=1), name='unique_uid')
        ]

这失败了，因为它无法在名为 的实例上找到一个字段uid_cnt，但是我认为Q对象可以访问注释。它看起来像是CheckConstraint直接针对模型进行查询，而不是使用管理器返回的查询集：

class CheckConstraint(BaseConstraint):
    ...

    def _get_check_sql(self, model, …

我想知道构造一个Q(...)与查询集中没有对象匹配的对象的正确方法.看来,双方Q()并~Q()匹配所有的对象!