Return-Funktion wie ein Feld, auf dem django-Modell

Einen Weg, dies zu tun ist, erstellen Sie einen Manager und eine Funktion definiert, mit der raw-SQL-Abfrage. Erstellen Sie das Modell-Objekt anfügen das neue berechnete Feld verweisen, auf die model-Klasse mit sich selbst.Modell

Class MyModel(models.Model):
    fieldA = models.FloatField() 
    fieldB = models.FloatField()
    objects = MyModelManager() #Binds the manager to the model


Class MyModelManager(models.Manager):
    def ReturnDelta(self):
        from django.db import connection
        cursor = connection.cursor()
        cursor.execute = """SELECT fieldA, fieldB, fieldA-fieldB as delta
                            from MyModel_table"""
        result_list = []

        for row in cursor.fetchall():
            p = self.model(fieldA=row[0], fieldB[1]) #access the model associated w/the manager
            p.delta = row[2] #adds the new field to the queryset
            result_list.append(p)
        return result_list 

Fast ein copy-paste aus Django-Dokumentation
Dann können wir den manager-Funktion in der extra-Kontext-Wörterbuch der Allgemeinen Sicht. und tun algebraische Operationen, ohne auf die Datenbank unnötig.

Eine bessere Lösung ist, erstellen Sie Ihre eigenen QuerySet-Klasse mit einem benutzerdefinierten Manager. Dies erlaubt eine Kette von filtern und zurück alle berechneten Wert als ein QuerySet-Attribut. Genommen wird fast direkt von dieser snippet

class CustomManager(models.Manager):
    '''
       An general purpose manager which allows to filter a queryset
       and chain filters
       "Constructor": CustomManager(CustomQuerySetClass)
    '''

    def __init__(self, qs_class=models.query.QuerySet):
        super(CustomManager,self).__init__()
        self.queryset_class = qs_class

    def get_query_set(self):
        return self.queryset_class(self.model)

    def __getattr__(self, attr, *args):
        try:
            return getattr(self.__class__, attr, *args)
        except AttributeError:
            return getattr(self.get_query_set(), attr, *args)


class MyModelQuerySet(models.query.QuerySet):
    '''
       A very specific queryset designed to return a computed value (this
       time a sum of all rows values)
    '''
    def filter(self, *args, **kwargs):
        qs = super(MyModelQuerySet, self).filter(*args,**kwargs)
        sum=0
        for row in qs:
            sum += row.delta    #use a callback to prevent from caching
        setattr(qs, 'sum',sum)
        return qs 


class MyModel(models.Model):
    objects = CustomManager()    #Binds the manager to the model
    fieldA = models.FloatField() 
    fieldB = models.FloatField()
    def delta(self):
        return self.fieldA - self.fieldB

Ok, erstmal dein code sollte sich beanspruchten, da Sie berechnen wollen, delta von jeder Zeile.

def delta(self):
    return self.fieldA - self.fieldB

Bezüglich Ihrer Frage, es ist nicht möglich, die Anhäufung von einer django-Funktion. Es gibt drei Möglichkeiten, das zu erreichen, was Sie wollen:

1. Tun die aggregation in Python. Nachteil: lädt alle Daten aus der Datenbank.

2. Umgehung des Django-ORM, und führen Sie die SQL-Abfrage manuell (dadurch wird der code-Datenbank-spezifisch).

3. Erstellen Sie ein weiteres Feld in der Datenbank für die delta-und update Sie auf speichern (oder mit einem trigger, wenn Sie wollen, um Datenbank-spezifische).