Django - упорядочение запроса по вычисленному полю

Я хочу иметь модель с вычисленными полями, которые я могу применить для сортировки. Например, допустим, что у меня есть следующая модель:

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

Я хочу иметь поле D и E, которые вычисляются по следующим формулам:

  • D = A - B
  • E = A - X (где X - поле соответствующей записи модели C)

Реализация этого будет тривиальной, если мне не нужно применять сортировку; Я бы просто добавил свойства к классу модели. Тем не менее, мне нужно упорядочить по этим полям.

Решение состоит в том, чтобы извлекать все записи в память и выполнять сортировку там, которую я представляю в крайнем случае (это нарушит положение в отношении разбивки на страницы).

Есть ли способ достичь того, что я пытаюсь сделать? Любые рекомендации приветствуются.

РЕДАКТИРОВАТЬ: Денормализация - это не-go. Значение поля X изменяется очень часто, и многие записи Foo связаны с одной записью модели C. Обновление X потребует тысяч обновлений E.

Ответы

Ответ 2

Если вы не возражаете против логического дубликата, тогда будет работать следующее:

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

Ответ 3

Пожалуйста, воздержитесь от использования 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'))

Ответ 4

Как Саймон говорит, теперь вы можете использовать выражения в запросах, и эти значения будут вычисляться в базе данных. Ниже приведены запросы, которые вы задали с помощью новой техники сортировки:

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()

Ответ 5

В настоящее время я не запускал установку Django, но я думаю, что вы спрашиваете, как выполнить пользовательское сохранение, так что автоматически создаются D и E. Я не знаю, что возвращает ваш ForeignKey в unicode, поэтому я предполагаю, что это не строка и присвоение значения valueName как токена vlaue для целого числа, которое вы хотите использовать.

В любом случае, это должно выглядеть примерно так:

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 save, что-нибудь после POST. Это действительно самый важный момент.

Ответ 6

Я нахожу, что без * 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"]