Rewrite to use a CTE to leverage speedups by using sqllite internal optimization to do a single query instead of a starter query to get distinct labels and a subsequent loop of querys per distinct event labels.

Frigate is currently shipping sqlite 3.46.1, which is above the minimum version 3.25 needed for CTEs.

frigate/api/event.py

@@ -389,100 +389,69 @@ def events_explore(
     limit: int = 10,
     allowed_cameras: List[str] = Depends(get_allowed_cameras_for_filter),
 ):
-    # get distinct labels for all events
+    if not allowed_cameras:
-    distinct_labels = (
+        return JSONResponse(content=[])
-        Event.select(Event.label)
-        .where(Event.camera << allowed_cameras)
-        .distinct()
-        .order_by(Event.label)
-    )
 
-    label_counts = {}
+    # Single query: per-label COUNT and top-N ranking by start_time computed
+    # via window functions in a CTE, then filtered to rn <= limit. Replaces
+    # the previous loop that issued 2 queries per distinct label.
+    camera_placeholders = ",".join(["?"] * len(allowed_cameras))
+    sql = f"""
+        WITH ranked AS (
+            SELECT
+                id, camera, label, sub_label, zones, start_time, end_time,
+                has_clip, has_snapshot, plus_id, retain_indefinitely,
+                top_score, false_positive, box, data,
+                COUNT(*) OVER (PARTITION BY label) AS event_count,
+                ROW_NUMBER() OVER (
+                    PARTITION BY label ORDER BY start_time DESC
+                ) AS rn
+            FROM event
+            WHERE camera IN ({camera_placeholders})
+        )
+        SELECT * FROM ranked
+        WHERE rn <= ?
+        ORDER BY event_count DESC, start_time DESC
+    """
 
-    explore_columns = (
+    allowed_data_keys = {
-        Event.id,
+        "type",
-        Event.camera,
+        "score",
-        Event.label,
+        "top_score",
-        Event.sub_label,
+        "description",
-        Event.zones,
+        "sub_label_score",
-        Event.start_time,
+        "average_estimated_speed",
-        Event.end_time,
+        "velocity_angle",
-        Event.has_clip,
+        "path_data",
-        Event.has_snapshot,
+        "recognized_license_plate",
-        Event.plus_id,
+        "recognized_license_plate_score",
-        Event.retain_indefinitely,
+    }
-        Event.top_score,
-        Event.false_positive,
-        Event.box,
-        Event.data,
-    )
 
-    def event_generator():
+    processed_events = [
-        for label_obj in distinct_labels.iterator():
+        {
-            label = label_obj.label
+            "id": event.id,
-
+            "camera": event.camera,
-            # get most recent events for this label
+            "label": event.label,
-            label_events = (
+            "zones": event.zones,
-                Event.select(*explore_columns)
+            "start_time": event.start_time,
-                .where((Event.label == label) & (Event.camera << allowed_cameras))
+            "end_time": event.end_time,
-                .order_by(Event.start_time.desc())
+            "has_clip": event.has_clip,
-                .limit(limit)
+            "has_snapshot": event.has_snapshot,
-                .iterator()
+            "plus_id": event.plus_id,
-            )
+            "retain_indefinitely": event.retain_indefinitely,
-
+            "sub_label": event.sub_label,
-            # count total events for this label
+            "top_score": event.top_score,
-            label_counts[label] = (
+            "false_positive": event.false_positive,
-                Event.select()
+            "box": event.box,
-                .where((Event.label == label) & (Event.camera << allowed_cameras))
+            "data": {
-                .count()
+                k: v
-            )
+                for k, v in (event.data or {}).items()
-
+                if k in allowed_data_keys
-            yield from label_events
+            },
-
+            "event_count": event.event_count,
-    def process_events():
+        }
-        for event in event_generator():
+        for event in Event.raw(sql, *allowed_cameras, limit)
-            processed_event = {
+    ]
-                "id": event.id,
-                "camera": event.camera,
-                "label": event.label,
-                "zones": event.zones,
-                "start_time": event.start_time,
-                "end_time": event.end_time,
-                "has_clip": event.has_clip,
-                "has_snapshot": event.has_snapshot,
-                "plus_id": event.plus_id,
-                "retain_indefinitely": event.retain_indefinitely,
-                "sub_label": event.sub_label,
-                "top_score": event.top_score,
-                "false_positive": event.false_positive,
-                "box": event.box,
-                "data": {
-                    k: v
-                    for k, v in event.data.items()
-                    if k
-                    in [
-                        "type",
-                        "score",
-                        "top_score",
-                        "description",
-                        "sub_label_score",
-                        "average_estimated_speed",
-                        "velocity_angle",
-                        "path_data",
-                        "recognized_license_plate",
-                        "recognized_license_plate_score",
-                    ]
-                },
-                "event_count": label_counts[event.label],
-            }
-            yield processed_event
-
-    # convert iterator to list and sort
-    processed_events = sorted(
-        process_events(),
-        key=lambda x: (x["event_count"], x["start_time"]),
-        reverse=True,
-    )
 
     return JSONResponse(content=processed_events)