获取帮助

1.8
1.10
1.11
2.0
2.1
2.2
3.0
3.1
3.2
4.0
4.1
4.2
5.0
开发人员
文档版本：5.1

条件表达式¶

条件表达式允许你在过滤器、注释、聚合和更新中使用if … elif … else逻辑。条件表达式会评估表中每一行的条件序列，并返回匹配的结果表达式。条件表达式还可以像其他表达式一样组合和嵌套。

条件表达式类¶

在后续示例中，我们将使用以下模型

from django.db import models


class Client(models.Model):
    REGULAR = "R"
    GOLD = "G"
    PLATINUM = "P"
    ACCOUNT_TYPE_CHOICES = {
        REGULAR: "Regular",
        GOLD: "Gold",
        PLATINUM: "Platinum",
    }
    name = models.CharField(max_length=50)
    registered_on = models.DateField()
    account_type = models.CharField(
        max_length=1,
        choices=ACCOUNT_TYPE_CHOICES,
        default=REGULAR,
    )

`When`¶

class When(condition=None, then=None, **lookups)[source]¶

When()对象用于封装条件表达式中使用的条件及其结果。使用When()对象类似于使用filter()方法。可以使用字段查找、Q对象或具有output_field（其为BooleanField）的Expression对象来指定条件。结果使用then关键字提供。

一些示例

>>> from django.db.models import F, Q, When
>>> # String arguments refer to fields; the following two examples are equivalent:
>>> When(account_type=Client.GOLD, then="name")
>>> When(account_type=Client.GOLD, then=F("name"))
>>> # You can use field lookups in the condition
>>> from datetime import date
>>> When(
...     registered_on__gt=date(2014, 1, 1),
...     registered_on__lt=date(2015, 1, 1),
...     then="account_type",
... )
>>> # Complex conditions can be created using Q objects
>>> When(Q(name__startswith="John") | Q(name__startswith="Paul"), then="name")
>>> # Condition can be created using boolean expressions.
>>> from django.db.models import Exists, OuterRef
>>> non_unique_account_type = (
...     Client.objects.filter(
...         account_type=OuterRef("account_type"),
...     )
...     .exclude(pk=OuterRef("pk"))
...     .values("pk")
... )
>>> When(Exists(non_unique_account_type), then=Value("non unique"))
>>> # Condition can be created using lookup expressions.
>>> from django.db.models.lookups import GreaterThan, LessThan
>>> When(
...     GreaterThan(F("registered_on"), date(2014, 1, 1))
...     & LessThan(F("registered_on"), date(2015, 1, 1)),
...     then="account_type",
... )

请记住，这些值中的每一个都可以是表达式。

注意

由于then关键字参数保留用于When()的结果，因此如果Model具有名为then的字段，则可能存在冲突。这可以通过两种方式解决

>>> When(then__exact=0, then=1)
>>> When(Q(then=0), then=1)

`Case`¶

class Case(*cases, **extra)[source]¶

Case()表达式类似于Python中的if … elif … else语句。提供的When()对象中的每个condition都会按顺序进行评估，直到一个评估结果为真值。然后返回匹配的When()对象的result表达式。

一个例子

>>>
>>> from datetime import date, timedelta
>>> from django.db.models import Case, Value, When
>>> Client.objects.create(
...     name="Jane Doe",
...     account_type=Client.REGULAR,
...     registered_on=date.today() - timedelta(days=36),
... )
>>> Client.objects.create(
...     name="James Smith",
...     account_type=Client.GOLD,
...     registered_on=date.today() - timedelta(days=5),
... )
>>> Client.objects.create(
...     name="Jack Black",
...     account_type=Client.PLATINUM,
...     registered_on=date.today() - timedelta(days=10 * 365),
... )
>>> # Get the discount for each Client based on the account type
>>> Client.objects.annotate(
...     discount=Case(
...         When(account_type=Client.GOLD, then=Value("5%")),
...         When(account_type=Client.PLATINUM, then=Value("10%")),
...         default=Value("0%"),
...     ),
... ).values_list("name", "discount")
<QuerySet [('Jane Doe', '0%'), ('James Smith', '5%'), ('Jack Black', '10%')]>

Case()接受任意数量的When()对象作为单个参数。其他选项使用关键字参数提供。如果没有任何条件评估结果为TRUE，则返回使用default关键字参数给出的表达式。如果没有提供default参数，则使用None。

如果我们想更改之前的查询以根据客户与我们合作的时间长短来获取折扣，则可以使用查找来做到这一点

>>> a_month_ago = date.today() - timedelta(days=30)
>>> a_year_ago = date.today() - timedelta(days=365)
>>> # Get the discount for each Client based on the registration date
>>> Client.objects.annotate(
...     discount=Case(
...         When(registered_on__lte=a_year_ago, then=Value("10%")),
...         When(registered_on__lte=a_month_ago, then=Value("5%")),
...         default=Value("0%"),
...     )
... ).values_list("name", "discount")
<QuerySet [('Jane Doe', '5%'), ('James Smith', '0%'), ('Jack Black', '10%')]>

注意

请记住，条件是按顺序评估的，因此在上面的示例中，即使第二个条件与 Jane Doe 和 Jack Black 都匹配，我们也能得到正确的结果。这与Python中的if … elif … else语句的工作方式相同。

Case()也适用于filter()子句。例如，要查找一个月前注册的金牌客户和一年多前注册的白金客户

>>> a_month_ago = date.today() - timedelta(days=30)
>>> a_year_ago = date.today() - timedelta(days=365)
>>> Client.objects.filter(
...     registered_on__lte=Case(
...         When(account_type=Client.GOLD, then=a_month_ago),
...         When(account_type=Client.PLATINUM, then=a_year_ago),
...     ),
... ).values_list("name", "account_type")
<QuerySet [('Jack Black', 'P')]>

高级查询¶

条件表达式可用于注释、聚合、过滤器、查找和更新。它们还可以与其他表达式组合和嵌套。这使你可以进行强大的条件查询。

条件更新¶

假设我们希望更改客户的account_type以匹配其注册日期。我们可以使用条件表达式和update()方法来实现这一点

>>> a_month_ago = date.today() - timedelta(days=30)
>>> a_year_ago = date.today() - timedelta(days=365)
>>> # Update the account_type for each Client from the registration date
>>> Client.objects.update(
...     account_type=Case(
...         When(registered_on__lte=a_year_ago, then=Value(Client.PLATINUM)),
...         When(registered_on__lte=a_month_ago, then=Value(Client.GOLD)),
...         default=Value(Client.REGULAR),
...     ),
... )
>>> Client.objects.values_list("name", "account_type")
<QuerySet [('Jane Doe', 'G'), ('James Smith', 'R'), ('Jack Black', 'P')]>

条件聚合¶

如果我们想知道每种account_type有多少客户？我们可以使用聚合函数的filter参数来实现这一点

>>> # Create some more Clients first so we can have something to count
>>> Client.objects.create(
...     name="Jean Grey", account_type=Client.REGULAR, registered_on=date.today()
... )
>>> Client.objects.create(
...     name="James Bond", account_type=Client.PLATINUM, registered_on=date.today()
... )
>>> Client.objects.create(
...     name="Jane Porter", account_type=Client.PLATINUM, registered_on=date.today()
... )
>>> # Get counts for each value of account_type
>>> from django.db.models import Count
>>> Client.objects.aggregate(
...     regular=Count("pk", filter=Q(account_type=Client.REGULAR)),
...     gold=Count("pk", filter=Q(account_type=Client.GOLD)),
...     platinum=Count("pk", filter=Q(account_type=Client.PLATINUM)),
... )
{'regular': 2, 'gold': 1, 'platinum': 3}

此聚合会生成一个使用SQL 2003 FILTER WHERE语法的查询（在支持它的数据库上）

SELECT count('id') FILTER (WHERE account_type=1) as regular,
       count('id') FILTER (WHERE account_type=2) as gold,
       count('id') FILTER (WHERE account_type=3) as platinum
FROM clients;

在其他数据库上，这将使用CASE语句进行模拟

SELECT count(CASE WHEN account_type=1 THEN id ELSE null) as regular,
       count(CASE WHEN account_type=2 THEN id ELSE null) as gold,
       count(CASE WHEN account_type=3 THEN id ELSE null) as platinum
FROM clients;

这两个SQL语句在功能上是等效的，但更明确的FILTER可能会执行得更好。

条件过滤器¶

当条件表达式返回布尔值时，可以直接在过滤器中使用它。这意味着它不会添加到SELECT列中，但你仍然可以使用它来筛选结果

>>> non_unique_account_type = (
...     Client.objects.filter(
...         account_type=OuterRef("account_type"),
...     )
...     .exclude(pk=OuterRef("pk"))
...     .values("pk")
... )
>>> Client.objects.filter(~Exists(non_unique_account_type))

在SQL术语中，这将评估为

SELECT ...
FROM client c0
WHERE NOT EXISTS (
  SELECT c1.id
  FROM client c1
  WHERE c1.account_type = c0.account_type AND NOT c1.id = c0.id
)

查询表达式

数据库函数

返回顶部

文档

条件表达式¶