标签: django-queryset

由于get_queryset()仅返回一个查询集，我需要将查询集的长度添加search_store到模板文件中。因此，我尝试通过 将该值发送到模板get_context_data。

我知道我可以通过 获取查询集的长度{{ queryset|length }}，但由于某种原因，它只返回由分页分隔的查询集的长度，所以我只得到部分长度。

正如您所看到的代码，我正在尝试打印，并且我需要从search_stores.count()中获取它。谁能让我知道我该怎么做？get_context_dataget_queryset

class SearchListView(ListView):
    model = Store
    template_name = 'boutique/search.html'
    paginate_by = 2
    context_object_name = 'search_stores'

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['search_text'] = self.request.GET.get('search_text')
        context['sorter'] = self.request.GET.get('sorter')
        if not context['sorter']:
            context['sorter'] = 'popularity'
        return context

    def get_queryset(self):

        search_text = self.request.GET.get('search_text')
        sorter = self.request.GET.get('sorter')

        if not sorter:
            sorter = 'popularity'

        if search_text:
            search_stores = Store.objects.filter(Q(businessName__icontains=search_text) | Q(mKey__icontains=search_text))
            if sorter == 'businessName':
                search_stores = …

我在 Django 中有一个查询集：

    models.User:
       id = pk
       username = text

    models.Offer
       id = pk
       user = Fk(User)
       description = text

    my serializer is:

    class UserOfferSerializer(ModelSerializer):
        offers = OfferSerializerAll(many=True, read_only=True)
        class Meta:
            model = User
            fields = ('id', 'username', 'offers')

我试图通过描述文本中出现的一段文本来过滤它，这很简单（过滤第一级对象，即用户），但随后我想过滤每个用户的报价并返回具有所需的用户优惠。我在尝试：

queryset.filter(offers__description__icontains = sometext)

但我向用户提供了他拥有的所有优惠。

任何帮助，谢谢！

我试图找出两个查询集之间的差异，对我来说重要的是这个差异的答案是一个查询集。因此，自然的解决方案是使用 Django 查询集的差异方法。但是，当尝试这样做时，我收到以下错误：

NotSupportedError: difference is not supported on this database backend.

这是我想做的：

In [4]: type(small_qs)
Out[4]: django.db.models.query.QuerySet

In [5]: type(bigger_qs)
Out[5]: django.db.models.query.QuerySet

In [6]: bigger_qs.difference(small_qs)

重要提示：两个查询集来自同一模型。

其他有用的信息：

• 使用 docker（数据库和 django）
• 数据库后端是MariaDB（MySQL）
• Django版本是2.0.6
• MariaDB版本是10.3.8

这里是完整的输出：

Out[6]: ---------------------------------------------------------------- 
NotSupportedError                         Traceback (most recent call 
last)
/usr/local/lib/python3.6/site-packages/IPython/core/formatters.py in 
__call__(self, obj)
700                 type_pprinters=self.type_printers,
701                 deferred_pprinters=self.deferred_printers)
702             printer.pretty(obj)
703             printer.flush()
704             return stream.getvalue()

/usr/local/lib/python3.6/site-packages/IPython/lib/pretty.py in 
pretty(self, obj)
398                         if cls is not object \
399                                 and 
callable(cls.__dict__.get('__repr__')):
400                             return _repr_pprint(obj, self, cycle)
401
402 …

如何使用 django 的查询集从 MyUser 表中获取用户列表，其中 UserBankTransaction 表中 transaction_paid 为 False？

class UserBankTransaction(models.Model):
    user = models.ForeignKey(MyUser)
    plaid_transaction_id = models.CharField(max_length=300, unique=True)
    charge_amount = models.DecimalField(max_digits=10, decimal_places=2)
    account_id = models.CharField(max_length=300)
    location_name = models.CharField(blank=True, max_length=300)
    roundup_amount = models.DecimalField(max_digits=10, decimal_places=2, null=True)
    transaction_date = models.DateField()
    transaction_paid = models.BooleanField(default=False)
    created_date = models.DateTimeField(auto_now=False, auto_now_add=True)


class MyUser(AbstractBaseUser):
    username = models.CharField(max_length=255,unique=True,)
    email = models.EmailField(verbose_name='email address',max_length=255,unique=True)
    first_name = models.CharField(max_length=120,null=True,blank=True,)
    last_name = models.CharField(max_length=120,null=True, blank=True,)
    created = models.DateTimeField(auto_now_add=True, null=True, blank=True)
    updated = models.DateTimeField(auto_now=True, null=True, blank=True)

我有 and object，QuerySet其中包含这个对象。我需要获取下一个和上 object一个QuerySet。

我怎样才能做到这一点？

我可以这样进行下一步：

next = False
for o in QuerySet:
    if next:
        return o
    if o==object:
       next = True

但我认为在巨大的QuerySets 上这是非常缓慢且低效的方法。

您知道更好的解决方案吗？

我正在创建一个允许创建事件的网站，这些事件将显示在主页和事件列表上，以便人们可以单击事件来查看它们的描述以及在活动中签到。我在添加新事件时获取类中的查询集进行更新时遇到问题。

所以这个功能是针对我们的主页的。每次返回页面时，query_set都会更新，因此当添加新事件时，它会显示在该页面上。

def index(request):
    num_future_events = Event.objects.filter(date__gte=today).filter(approved=True).count()
    query_set = Event.objects.filter(date__gte=today).filter(approved=True).order_by('date', 'time')[:3]

    context = {
        'num_future_events': num_future_events,
        'query_set': query_set
    }

    return render(request, 'index.html', context=context)

这是我网站上的事件列表页面的类。它使用查询集，但由于该类仅被调用一次，因此查询集只会随着类的初始化而更新。

class EventListView(generic.ListView):
    model = Event
    query_set = Event.objects.filter(date__gte=today).exclude(approved=False).order_by('date', 'time')[:21]
    template_name = 'listPage.html'

    def get_queryset(self):
        return self.query_set

我希望获得一些帮助，以便在添加新事件时，EventListView 类中设置的查询会自动更新，以便将其显示在此页面上。

任何帮助将不胜感激。

class Forecast(Model):
    id = UUID()
    type = StringField()
    approved = BooleanField()

type我想通过在批准的字段上应用“逻辑与”来对该字段进行分组。假设带注释的字段是all_approved. all_approved如果该类型的所有项目都为 True，则应为 True；如果至少有一项为 False，则应为 false。

所以最后在我的查询集中我想要有两个字段type, all_approved。

我怎样才能做到这一点？

我根据这个答案尝试了一些东西，但什么也没得到。

编辑：

当我尝试该答案中给出的内容时，它没有执行“逻辑与”。相反，对于每个type项目，它只给出两项，一项为all_approvedTrue，另一项all_approved为 False。我想要每个项目一个type。

我也不明白为什么这个答案应该有效。在哪里指定分组时是否应该执行“逻辑与”或“逻辑或”。

我有一个 Django 应用程序，具有以下模型：

class Person(models.Model):
    first_name = models.CharField(max_length=100)
    last_name = models.CharField(max_length=100)

class Job(models.Model):
    title = models.CharField(max_length=100)

class PersonJob(models.Model):
    person = models.ForeignKey(Person, related_name='person_jobs')
    job = models.ForeignKey(Job, related_name='person_jobs')
    is_active = models.BooleanField()

多个Person实例可以同时承担相同的工作。我有一个Job查询集，并尝试注释或通过其他方法将从事该工作的每个人的姓名附加到查询集中的每个项目上。我希望能够循环查询集并获取这些名称，而无需对每个项目进行额外的查询。我得到的最接近的是：

 qs = Job.objects.all().annotate(first_names='person_jobs__person__first_name')
.annotate(last_names='person_jobs__person__last_name') 

这将按照我的意愿将名称存储在 Job 实例上；但是，如果一个作业中有多个人员，则查询集中将包含同一作业的多个副本，每个副本都有一个人的姓名。相反，我只需要查询集中给定作业的一个实例，该实例包含其中所有人员的姓名。我不关心这些值是如何组合和存储的；列表、分隔字符字段或任何其他标准数据类型都可以。

我正在使用 Django 2.1 和 Postgres 10.3。我强烈希望不使用任何 Postgres 特定功能。

我的问题如下。有一个请求

Thread.objects.all().annotate(is_marked=Count('mark', Q(mark__username='gou')))

在 SQL 中它看起来像这样

SELECT "api_thread"."id",
       "api_thread"."conference_id",
       "api_thread"."title",
       "api_thread"."description",
       "api_thread"."is_closed",
       "api_thread"."is_hidden",
       "api_thread"."is_pinned",
       "api_thread"."has_voting",
       "api_thread"."creator_uid",
       "api_thread"."created_at",
       "api_thread"."expired",
       COUNT("api_thread_mark"."user_id") FILTER (WHERE "auth_user"."username" = 'gou') AS "is_marked"
FROM "api_thread"
         LEFT OUTER JOIN "api_thread_mark" ON ("api_thread"."id" = "api_thread_mark"."thread_id")
         LEFT OUTER JOIN "auth_user" ON ("api_thread_mark"."user_id" = "auth_user"."id")
GROUP BY "api_thread"."id"

我需要做什么才能将数字转换为布尔值。在 SQL 中它看起来像

COUNT("api_thread_mark"."user_id") FILTER (WHERE "auth_user"."username" = 'gou') > 0 AS "is_marked"

我看到很多类似的查询，但似乎没有一个能满足我的需求，

我有一个这样的表：

class BGPData(models.Model):
    subnet = models.ForeignKey(Subnet, verbose_name="Subnet", on_delete=models.CASCADE, blank=True, null=True)
    bgp_peer_as = models.CharField(max_length=20, verbose_name='BGP Peer AS', blank=True, null=True)
    bgp_session = models.CharField(max_length=10, verbose_name='BGP Session', blank=True, null=True)
    bgp_routes = models.CharField(max_length=10, verbose_name='BGP Routes Received', blank=True, null=True)
    timestamp = models.DateTimeField(auto_now=True, blank=True, null=True)  

目标： 我只想获取子网上每个外键的最新记录。

迄今为止的尝试如下：-

bgp_data_query = BGPData.objects.filter(subnet__get_bgp=True,subnet__wb_bgp=True) \
                                .annotate(last_updated=Cast(TruncSecond('timestamp', DateTimeField()), CharField()))

d = BGPData.objects.annotate(max_timestamp=Max('timestamp')).filter(timestamp=F('max_timestamp'))

有一些东西我不太明白，但我不确定它是什么......

谢谢

所以如果我的表包含：

subnet_id | routes | timestamp
    1     |   10   | 01-01-20 17:30
    1     |   10   | 01-01-20 17:20
    1     |   10   | 01-01-20 17:10
    2     | …