Introduction

In Django, you should calculate column totals in the database instead of pulling rows into Python and summing them manually. The ORM supports this cleanly through Sum, aggregate, annotate, and related functions, which keeps the query efficient and the code readable.

The Basic Sum Query

For a single total across all matching rows, use aggregate with Sum.

1from django.db.models import Sum
2from shop.models import Order
3
4result = Order.objects.aggregate(total_amount=Sum("amount"))
5print(result["total_amount"])

The result is a dictionary. If no rows match, the value may be None, so you should account for that in real code.

Filtering Before Summing

Usually you do not want the total of every row in the table. You want the total for a subset such as paid orders, one month, or one customer.

1from django.db.models import Sum
2from shop.models import Order
3
4paid_total = (
5    Order.objects
6    .filter(status="PAID", customer_id=42)
7    .aggregate(total=Sum("amount"))
8)["total"]
9
10print(paid_total)

The important point is that the filtering happens in SQL before the aggregation. That keeps the query efficient.

Returning Zero Instead of None

If no rows match, Sum returns None. That is correct database behavior, but application code often wants zero instead.

1from django.db.models import DecimalField, Sum, Value
2from django.db.models.functions import Coalesce
3
4result = Order.objects.aggregate(
5    total_amount=Coalesce(
6        Sum("amount"),
7        Value(0),
8        output_field=DecimalField(max_digits=12, decimal_places=2),
9    )
10)
11
12print(result["total_amount"])

Coalesce makes the fallback explicit at the query level.

Grouped Sums with annotate

If you want totals per group, use values() together with annotate().

1from django.db.models import Sum
2from shop.models import Order
3
4rows = (
5    Order.objects
6    .values("customer_id")
7    .annotate(total=Sum("amount"))
8    .order_by("-total")
9)
10
11for row in rows:
12    print(row["customer_id"], row["total"])

This translates to a grouped SQL query, which is much better than looping in Python and building totals manually.

Conditional Aggregation

Django also supports filtered aggregates, which is useful for dashboard-style summaries.

1from django.db.models import Q, Sum
2from shop.models import Order
3
4summary = Order.objects.aggregate(
5    paid_total=Sum("amount", filter=Q(status="PAID")),
6    refunded_total=Sum("amount", filter=Q(status="REFUNDED")),
7)
8
9print(summary)

That lets one query produce several totals for different conditions.

Aggregating by Date

Reporting queries often need totals grouped by day or month. Django provides date truncation helpers for that.

1from django.db.models import Sum
2from django.db.models.functions import TruncMonth
3from shop.models import Order
4
5monthly_totals = (
6    Order.objects
7    .filter(status="PAID")
8    .annotate(month=TruncMonth("created_at"))
9    .values("month")
10    .annotate(total=Sum("amount"))
11    .order_by("month")
12)
13
14for row in monthly_totals:
15    print(row["month"], row["total"])

This is a typical pattern for reports and dashboards.

Why Database Aggregation Is Better

The ORM aggregation methods are not just shorter. They also push the work to the database, which is optimized for filtering, grouping, and aggregation.

Bad pattern:

total = sum(order.amount for order in Order.objects.all())

That loads all rows into Python. It is slower, uses more memory, and scales badly compared with a database-side SUM.

Common Pitfalls

One common mistake is forgetting that Sum may return None when there are no matching rows. Handle that with Coalesce or in Python.

Another issue is using floating-point fields for money totals. Financial amounts should usually use decimal-based fields so aggregation stays precise.

A third pitfall is grouping by dates without thinking about timezone behavior. If your application uses time zones, make sure the reporting logic matches the business definition of a day or month.

Summary

• Use aggregate(Sum(...)) for a single total.
• Use values(...).annotate(Sum(...)) for grouped totals.
• Apply filters before aggregation so the database does the right work.
• Use Coalesce when you want zero instead of None.
• Prefer database-side sums over Python loops for correctness and performance.