Django - 通过计算字段排序查询集

Question

我希望有一个能够应用排序的计算字段模型。例如，假设我有以下模型：

class Foo(models.Model):
    A = models.IntegerField(..)
    B = models.IntegerField(..)
    C = models.ForeignKey(..)

我想要有一个D和一个E字段，它们的计算公式如下:

1. D = A - B
2. E = A - X（其中X是模型C相关记录的字段）

如果不需要排序，实现这个很容易，我只需向模型类中添加属性。但是，我需要按这些字段排序。

一种解决方案是将所有记录加载到内存中并在那里进行排序，但这是最后的手段（它会破坏分页等内容）。

是否有方法可以实现我的目标？ 感谢任何指导。

编辑：反规范化是不可行的。 字段X的值经常更改，而许多Foo记录与模型C的一个记录相关联。 更新X将需要更新E的数千次。

- shanyu

---

只是想指出已经有类似的问题被问到了：https://dev59.com/e0fSa4cB1Zd3GeqPAM2j - cethegeek

Answer 1

请不要使用extra()，因为它将在未来被弃用。

自Django 1.7以来，您可以使用annotate（）和order_by（）的组合来实现此目的。

Foo.objects.annotate(ordering=F('A') - F('B')).order_by('ordering')

还在进行工作，允许表达式在ORM的各个地方使用，因此在未来的Django版本中应该会起作用：

Foo.objects.order_by(F('A') - F('B'))

- Simon Charette

Answer 2

如果您不介意有些逻辑重复，那么以下内容将可以工作：

Foo.objects.extra(select={'d_field': 'A - B'}).extra(order_by=['d_field'])

- Dmitry Risenberg

---

如果您需要传递参数，应该使用OrderedDict：https://docs.djangoproject.com/en/1.8/ref/models/querysets/#extra - fjsj

请不要依赖extra()来实现此功能，因为它已经被弃用了。 - Simon Charette

Foo.objects.extra(select={'d_field': 'A - B'}, order_by=['d_field']) 一次 extra 就足够了。 - WeizhongTu

Answer 3

我会看一下Queryset的extra方法，并指定order_by参数。

- John Paulett

---

除非 D 和 E 在数据库中被实例化，否则我不认为额外的(order_by)会有帮助。 - cethegeek

@celopes 的 SQL 中的 order by 可以与即时计算字段一起使用，因此在这里适合使用额外的方法。 - shanyu

请不要依赖extra()完成此操作，因为它已经被弃用。请使用其他方法来替代。 - Simon Charette

Answer 4

正如Simon所说，您现在可以在查询中使用表达式，并且这些值将在数据库中计算。以下是您要求的带有新排序技术的查询：

Foo.objects.order_by(F('a') - F('b'))
Foo.objects.order_by(F('a') - F('bar__x'))

这里是一个完整的可运行示例，可以演示这些表达式的使用：

# Tested with Django 1.9.2
import logging
import sys

import django
from django.apps import apps
from django.apps.config import AppConfig
from django.conf import settings
from django.db import connections, models, DEFAULT_DB_ALIAS
from django.db.models import F
from django.db.models.base import ModelBase
from django.db.models.functions import Concat, Value

from mock import patch, PropertyMock, MagicMock

NAME = 'udjango'


def main():

    setup()

    class Bar(models.Model):
        x = models.IntegerField()

    class Foo(models.Model):
        a = models.IntegerField()
        b = models.IntegerField()
        bar = models.ForeignKey(Bar)

    syncdb(Bar)
    syncdb(Foo)

    bar1 = Bar.objects.create(x=1)
    bar5 = Bar.objects.create(x=5)
    Foo.objects.create(a=10, b=3, bar=bar1)
    Foo.objects.create(a=13, b=3, bar=bar5)
    Foo.objects.create(a=15, b=9, bar=bar1)

    print(Foo.objects.annotate(ordering=F('a') - F('b'))
          .order_by('ordering').values_list('a', 'b', 'bar__x', 'ordering'))
    # >>> [(15, 9, 1, 6), (10, 3, 1, 7), (13, 3, 5, 10)]

    print(Foo.objects.annotate(ordering=F('a') - F('bar__x'))
          .order_by('ordering').values_list('a', 'b', 'bar__x', 'ordering'))
    # >>> [(13, 3, 5, 8), (10, 3, 1, 9), (15, 9, 1, 14)]

    print(Foo.objects.order_by(F('a') - F('b')).values_list('a', 'b', 'bar__x'))
    # >>> [(15, 9, 1), (10, 3, 1), (13, 3, 5)]

    print(Foo.objects.order_by(F('a') - F('bar__x')).values_list('a', 'b', 'bar__x'))
    # >>> [(13, 3, 5), (10, 3, 1), (15, 9, 1)]

    logging.info('Done.')


def setup():
    db_file = NAME + '.db'
    with open(db_file, 'w'):
        pass  # wipe the database
    settings.configure(
        DEBUG=True,
        DATABASES={
            DEFAULT_DB_ALIAS: {
                'ENGINE': 'django.db.backends.sqlite3',
                'NAME': db_file}},
        LOGGING={'version': 1,
                 'disable_existing_loggers': False,
                 'formatters': {
                    'debug': {
                        'format': '%(asctime)s[%(levelname)s]'
                                  '%(name)s.%(funcName)s(): %(message)s',
                        'datefmt': '%Y-%m-%d %H:%M:%S'}},
                 'handlers': {
                    'console': {
                        'level': 'DEBUG',
                        'class': 'logging.StreamHandler',
                        'formatter': 'debug'}},
                 'root': {
                    'handlers': ['console'],
                    'level': 'INFO'},
                 'loggers': {
                    "django.db": {"level": "DEBUG"}}})
    app_config = AppConfig(NAME, sys.modules['__main__'])
    apps.populate([app_config])
    django.setup()
    original_new_func = ModelBase.__new__

    # noinspection PyDecorator
    @staticmethod
    def patched_new(cls, name, bases, attrs):
        if 'Meta' not in attrs:
            class Meta:
                app_label = NAME
            attrs['Meta'] = Meta
        return original_new_func(cls, name, bases, attrs)
    ModelBase.__new__ = patched_new


def syncdb(model):
    """ Standard syncdb expects models to be in reliable locations.

    Based on https://github.com/django/django/blob/1.9.3
    /django/core/management/commands/migrate.py#L285
    """
    connection = connections[DEFAULT_DB_ALIAS]
    with connection.schema_editor() as editor:
        editor.create_model(model)

main()

- Don Kirkby

Answer 5

我目前没有运行Django安装程序，但我认为你想问的是如何进行自定义保存，以便自动生成D和E。我不知道你的ForeignKey返回的unicode是什么，所以我假设它不是字符串，并将"valueName"分配为你想要使用的整数的令牌值。

无论如何，应该像这样进行：

class Foo(models.Model):
    A = models.IntegerField(..)
    B = models.IntegerField(..)
    C = models.ForeignKey(..)
    D = models.IntegerField(..)
    E = models.IntegerField(..)
    def save(self):
        self.D = self.A - self.B
        self.E = self.A - self.C.valueName
        super(Foo, self).save()

在(super())的最后一行之前的任何内容都将是PRE保存，之后的任何内容都是POST。那确实是最重要的点。

- user199973

---

如果shanyu不介意在数据库中实现计算字段，那么这是可以的。 - cethegeek

请查看我的编辑，去规范化不是一个选项。感谢您的帮助。 - shanyu

Answer 6

我发现在save方法中没有*args和**kwargs会返回一个错误。正如celopes所说，这只是一个解决方案，如果你不介意在数据库中实现计算字段。

class Foo(models.Model):
    A = models.IntegerField(..)
    B = models.IntegerField(..)
    C = models.ForeignKey(..)
    D = models.IntegerField(..)
    E = models.IntegerField(..)

    def save(self, *args, **kwargs):
        self.D = self.A - self.B
        self.E = self.A - self.C.X
        super(Foo, self).save(*args, **kwargs)

    class Meta:
        ordering = ["E", "D"]

- Carlo Chum