⚡ Bolt: Consolidated aggregate queries for visit statistics

.jules/bolt.md

@@ -93,3 +93,7 @@
 ## 2026-05-20 - Joined Queries for Integrity Verification
 **Learning:** Performing multiple sequential database queries to verify cryptographically chained records (e.g., fetching a record and then its associated token/metadata from another table) introduces unnecessary latency and increases database load.
 **Action:** Consolidate associated data retrieval into a single SQL `JOIN` query within the verification hot-path. This reduces database round-trips and improves end-to-end latency for blockchain-style integrity checks.
+
+## 2026-06-15 - Consolidated Aggregate Queries for Dashboard Stats
+**Learning:** Performing multiple separate aggregate queries in a single dashboard endpoint causes redundant table scans and increases latency. Using `func.sum(case(...))` allows calculating all category counts and summary metrics in a single SQL pass, significantly reducing database load.
+**Action:** Consolidate multiple aggregate queries into a single `db.query()` using conditional sums for categorical counts in dashboard-style endpoints.

backend/routers/field_officer.py

@@ -428,60 +428,38 @@ def get_issue_visit_history(
 @router.get("/field-officer/visit-stats", response_model=VisitStatsResponse)
 def get_visit_statistics(db: Session = Depends(get_db)):
     """
-    Get aggregate statistics for all field officer visits using optimized SQL queries.
-    Optimized: Uses serialization caching to bypass Pydantic overhead.
+    Get aggregate statistics for all field officer visits using a single optimized SQL query.
+    Consolidates multiple aggregate calls into a single pass using conditional sums.
     """
     try:
         cache_key = "global_visit_stats"
         cached_json = visit_stats_cache.get(cache_key)
         if cached_json:
             return Response(content=cached_json, media_type="application/json")
 
-        # Optimized: Use a single aggregate query to fetch multiple statistics in one database roundtrip
+        # Optimized: Use a single aggregate query to fetch ALL statistics in one database roundtrip
+        # Using func.sum(case(...)) for categorical counts reduces table scans and network roundtrips.
         agg_stats = db.query(
+            func.count(FieldOfficerVisit.id).label('total_visits'),
+            func.sum(case((FieldOfficerVisit.verified_at.isnot(None), 1), else_=0)).label('verified_visits'),
+            func.sum(case((FieldOfficerVisit.within_geofence == True, 1), else_=0)).label('within_geofence_count'),
+            func.sum(case((FieldOfficerVisit.within_geofence == False, 1), else_=0)).label('outside_geofence_count'),
             func.count(func.distinct(FieldOfficerVisit.officer_email)).label('unique_officers'),
             func.avg(FieldOfficerVisit.distance_from_site).label('avg_distance')
         ).first()
 
-        counts = db.query(
-            FieldOfficerVisit.verified_at.isnot(None).label("is_verified"),
-            FieldOfficerVisit.within_geofence,
-            func.count(FieldOfficerVisit.id)
-        ).group_by(
-            FieldOfficerVisit.verified_at.isnot(None),
-            FieldOfficerVisit.within_geofence
-        ).all()
-
-        total_visits = 0
-        verified_visits = 0
-        within_geofence_count = 0
-        outside_geofence_count = 0
-
-        for is_verified, within_geofence, count in counts:
-            c = count or 0
-            total_visits += c
-            if is_verified:
-                verified_visits += c
-            if within_geofence is True:
-                within_geofence_count += c
-            elif within_geofence is False:
-                outside_geofence_count += c
-
-        unique_officers = agg_stats.unique_officers or 0
         average_distance = agg_stats.avg_distance
-
-        # Round to 2 decimals if not None
         if average_distance is not None:
             average_distance = round(float(average_distance), 2)
         else:
             average_distance = 0.0
-        
+
         result_data = {
-            "total_visits": total_visits,
-            "verified_visits": verified_visits,
-            "within_geofence_count": within_geofence_count,
-            "outside_geofence_count": outside_geofence_count,
-            "unique_officers": unique_officers,
+            "total_visits": int(agg_stats.total_visits or 0),
+            "verified_visits": int(agg_stats.verified_visits or 0),
+            "within_geofence_count": int(agg_stats.within_geofence_count or 0),
+            "outside_geofence_count": int(agg_stats.outside_geofence_count or 0),
+            "unique_officers": int(agg_stats.unique_officers or 0),
             "average_distance_from_site": average_distance
         }