⚡ Bolt: Optimized database aggregates and RAG retrieval efficiency

.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.
+
+## 2025-05-22 - Consolidated Aggregate Queries
+**Learning:** Executing multiple separate aggregate queries (e.g., `count(distinct)`, `avg`, and `group_by` counts) for the same entity causes multiple database round-trips and redundant table scans.
+**Action:** Consolidate multiple aggregates into a single SQLAlchemy query using `func.sum(case(...))` for categorical counts alongside other aggregates. This reduces network overhead and database load significantly in high-traffic statistics endpoints.

backend/rag_service.py

@@ -48,8 +48,6 @@ def _prepare_policies(self):
             content = f"{title} {text}"
             content_tokens = self._tokenize(content)
 
-            content_tokens = self._tokenize(content)
-
             self._prepared_policies.append({
                 'title_tokens': self._tokenize(title),
                 'content_tokens': content_tokens,
@@ -92,10 +90,7 @@ def retrieve(self, query: str, threshold: float = 0.05) -> Optional[str]:
             policy_tokens = prepared['content_tokens']
 
             # Optimization 1: Fast early-exit for zero overlap
-            if query_tokens.isdisjoint(policy_tokens):
-                continue
-
-            # Optimized: Early exit using isdisjoint which is faster than computing intersection
+            # isdisjoint() is O(K) where K is min(len(query), len(policy))
             if query_tokens.isdisjoint(policy_tokens):
                 continue
 

backend/routers/field_officer.py

@@ -437,38 +437,23 @@ def get_visit_statistics(db: Session = Depends(get_db)):
         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
-        agg_stats = db.query(
+        # Optimized: Use a single aggregate query to fetch all statistics in one database roundtrip
+        # This reduces database overhead and network latency by avoiding multiple roundtrips and table scans.
+        stats = db.query(
+            func.count(FieldOfficerVisit.id).label('total_visits'),
             func.count(func.distinct(FieldOfficerVisit.officer_email)).label('unique_officers'),
-            func.avg(FieldOfficerVisit.distance_from_site).label('avg_distance')
+            func.avg(FieldOfficerVisit.distance_from_site).label('avg_distance'),
+            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')
         ).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
+        total_visits = stats.total_visits or 0
+        verified_visits = int(stats.verified_visits or 0)
+        within_geofence_count = int(stats.within_geofence_count or 0)
+        outside_geofence_count = int(stats.outside_geofence_count or 0)
+        unique_officers = stats.unique_officers or 0
+        average_distance = stats.avg_distance
 
         # Round to 2 decimals if not None
         if average_distance is not None: