fix(spp_aggregation,spp_metrics_services): eliminate N+1 queries and optimize fairness analysis

- Replace per-area child lookup loops with a single OR-chained domain search in
  aggregation_access.py and service_scope_resolver.py to avoid N+1 queries
- Refactor _analyze_many2one_dimension, _analyze_selection_dimension, and
  _analyze_boolean_dimension in fairness_service.py to use read_group instead of
  loading entire partner recordsets into memory

Author: jeremi

spp_aggregation/models/aggregation_access.py

@@ -290,12 +290,15 @@ def _check_explicit_scope_area_compliance(self, partner_ids):
 
         # If include_child_areas is True, expand to include all child areas
         if self.include_child_areas:
-            # Use parent_path for efficient child lookup
-            for area in self.allowed_area_ids:
-                if area.parent_path:
-                    # Find all child areas using parent_path prefix
-                    children = self.env["spp.area"].sudo().search([("parent_path", "like", f"{area.parent_path}%")])
-                    allowed_area_ids.update(children.ids)
+            # Collect all parent_path values first, then do a single search using
+            # OR-chained domain conditions to avoid N+1 queries inside a loop.
+            parent_paths = [area.parent_path for area in self.allowed_area_ids if area.parent_path]
+            if parent_paths:
+                domain = ["|"] * (len(parent_paths) - 1)
+                for path in parent_paths:
+                    domain.append(("parent_path", "like", f"{path}%"))
+                child_areas = self.env["spp.area"].sudo().search(domain)
+                allowed_area_ids.update(child_areas.ids)
 
         # Get area_ids for the partners
         partners = self.env["res.partner"].sudo().browse(partner_ids)

spp_aggregation/models/service_scope_resolver.py

@@ -145,14 +145,17 @@ def _resolve_area_ids(self, area_ids, include_children=True):
 
         # Build area domain (sudo for model reads - callers may be unprivileged)
         if include_children:
-            # Use parent_path for efficient child lookup
+            # Collect all parent_path values first, then do a single search using
+            # OR-chained domain conditions to avoid N+1 queries inside a loop.
             areas = self.env["spp.area"].sudo().browse(area_ids)
             all_area_ids = set(area_ids)
-            for area in areas:
-                if area.parent_path:
-                    # Find all child areas using parent_path prefix
-                    children = self.env["spp.area"].sudo().search([("parent_path", "like", f"{area.parent_path}%")])
-                    all_area_ids.update(children.ids)
+            parent_paths = [area.parent_path for area in areas if area.parent_path]
+            if parent_paths:
+                domain = ["|"] * (len(parent_paths) - 1)
+                for path in parent_paths:
+                    domain.append(("parent_path", "like", f"{path}%"))
+                child_areas = self.env["spp.area"].sudo().search(domain)
+                all_area_ids.update(child_areas.ids)
             area_ids = list(all_area_ids)
 
         # Find registrants directly in these areas
@@ -241,7 +244,7 @@ def _resolve_spatial_polygon_geometry(self, geojson_str):
             return spatial_resolver.resolve_polygon(geojson_str)
 
         # Fallback: no spatial support
-        _logger.warning("Spatial polygon scope requires spp_aggregation_spatial module. " "Returning empty result.")
+        _logger.warning("Spatial polygon scope requires spp_aggregation_spatial module. Returning empty result.")
         return []
 
     def _resolve_spatial_buffer(self, scope):
@@ -276,7 +279,7 @@ def _resolve_spatial_buffer_params(self, latitude, longitude, radius_km):
             return spatial_resolver.resolve_buffer(latitude, longitude, radius_km)
 
         # Fallback: no spatial support
-        _logger.warning("Spatial buffer scope requires spp_aggregation_spatial module. " "Returning empty result.")
+        _logger.warning("Spatial buffer scope requires spp_aggregation_spatial module. Returning empty result.")
         return []
 
     # -------------------------------------------------------------------------

spp_metrics_services/models/fairness_service.py

@@ -206,27 +206,39 @@ def _analyze_many2one_dimension(
         overall_coverage,
         partner_model,
     ):
-        """Analyze a Many2one field dimension."""
+        """Analyze a Many2one field dimension.
+
+        Uses read_group to count population and beneficiaries per group in two
+        database queries rather than loading all records into memory.
+        """
         group_results = []
         worst_ratio = 1.0
 
-        # Get distinct values from population using mapped() to avoid N+1
-        population = partner_model.search(base_domain)
-        values = set(population.mapped(f"{field_name}.id"))
-        values.discard(False)
-
-        for value_id in values:
-            related_record = self.env[partner_model._fields[field_name].comodel_name].browse(value_id)
-
-            group_domain = base_domain + [(field_name, "=", value_id)]
-            group_total = partner_model.search_count(group_domain)
+        # Population counts per group - one query
+        population_groups = partner_model.read_group(base_domain, [field_name], [field_name])
+        # Beneficiary counts per group - one query
+        beneficiary_domain = base_domain + [("id", "in", list(beneficiary_set))]
+        beneficiary_groups = partner_model.read_group(beneficiary_domain, [field_name], [field_name])
+
+        # Build lookup dict from group value -> beneficiary count
+        # read_group returns the Many2one field as (id, display_name) tuple or False
+        beneficiary_counts = {}
+        for row in beneficiary_groups:
+            value = row[field_name]
+            value_id = value[0] if value else False
+            beneficiary_counts[value_id] = row[f"{field_name}_count"]
+
+        for row in population_groups:
+            value = row[field_name]
+            if not value:
+                continue
+            value_id, display_name = value
+            group_total = row[f"{field_name}_count"]
 
             if group_total == 0:
                 continue
 
-            # Count beneficiaries in this group
-            beneficiary_domain = group_domain + [("id", "in", list(beneficiary_set))]
-            group_beneficiaries = partner_model.search_count(beneficiary_domain)
+            group_beneficiaries = beneficiary_counts.get(value_id, 0)
             group_coverage = group_beneficiaries / group_total
 
             disparity_ratio = self._compute_disparity_ratio(group_coverage, overall_coverage)
@@ -235,7 +247,7 @@ def _analyze_many2one_dimension(
             status = self._get_disparity_status(disparity_ratio)
             # For Many2one fields, prefer display_name over dimension label mapping
             # since label mappings may use codes rather than database IDs
-            label = related_record.display_name or dimension.get_label_for_value(str(value_id))
+            label = display_name or dimension.get_label_for_value(str(value_id))
 
             group_results.append(
                 {
@@ -269,31 +281,47 @@ def _analyze_selection_dimension(
         overall_coverage,
         partner_model,
     ):
-        """Analyze a Selection field dimension."""
+        """Analyze a Selection field dimension.
+
+        Uses read_group to count population and beneficiaries per group in two
+        database queries rather than one search_count pair per selection value.
+        """
         group_results = []
         worst_ratio = 1.0
 
         field = partner_model._fields[field_name]
         selection = field.selection
         if callable(selection):
             selection = selection(partner_model)
+        # Build label lookup from the field's selection values
+        label_by_key = dict(selection)
 
-        for key, label in selection:
-            group_domain = base_domain + [(field_name, "=", key)]
-            group_total = partner_model.search_count(group_domain)
+        # Population counts per group - one query
+        population_groups = partner_model.read_group(base_domain, [field_name], [field_name])
+        # Beneficiary counts per group - one query
+        beneficiary_domain = base_domain + [("id", "in", list(beneficiary_set))]
+        beneficiary_groups = partner_model.read_group(beneficiary_domain, [field_name], [field_name])
+
+        # Build lookup dict from selection key -> beneficiary count
+        beneficiary_counts = {row[field_name]: row[f"{field_name}_count"] for row in beneficiary_groups}
+
+        for row in population_groups:
+            key = row[field_name]
+            if key is False:
+                continue
+            group_total = row[f"{field_name}_count"]
 
             if group_total == 0:
                 continue
 
-            beneficiary_domain = group_domain + [("id", "in", list(beneficiary_set))]
-            group_beneficiaries = partner_model.search_count(beneficiary_domain)
+            group_beneficiaries = beneficiary_counts.get(key, 0)
             group_coverage = group_beneficiaries / group_total
 
             disparity_ratio = self._compute_disparity_ratio(group_coverage, overall_coverage)
             worst_ratio = min(worst_ratio, disparity_ratio)
 
             status = self._get_disparity_status(disparity_ratio)
-            display_label = dimension.get_label_for_value(key) or label
+            display_label = dimension.get_label_for_value(key) or label_by_key.get(key, key)
 
             group_results.append(
                 {
@@ -327,19 +355,31 @@ def _analyze_boolean_dimension(
         overall_coverage,
         partner_model,
     ):
-        """Analyze a Boolean field dimension."""
+        """Analyze a Boolean field dimension.
+
+        Uses read_group to count population and beneficiaries per group in two
+        database queries rather than one search_count pair per boolean value.
+        """
         group_results = []
         worst_ratio = 1.0
 
-        for value in [True, False]:
-            group_domain = base_domain + [(field_name, "=", value)]
-            group_total = partner_model.search_count(group_domain)
+        # Population counts per group - one query
+        population_groups = partner_model.read_group(base_domain, [field_name], [field_name])
+        # Beneficiary counts per group - one query
+        beneficiary_domain = base_domain + [("id", "in", list(beneficiary_set))]
+        beneficiary_groups = partner_model.read_group(beneficiary_domain, [field_name], [field_name])
+
+        # Build lookup dict from boolean value -> beneficiary count
+        beneficiary_counts = {row[field_name]: row[f"{field_name}_count"] for row in beneficiary_groups}
+
+        for row in population_groups:
+            value = row[field_name]
+            group_total = row[f"{field_name}_count"]
 
             if group_total == 0:
                 continue
 
-            beneficiary_domain = group_domain + [("id", "in", list(beneficiary_set))]
-            group_beneficiaries = partner_model.search_count(beneficiary_domain)
+            group_beneficiaries = beneficiary_counts.get(value, 0)
             group_coverage = group_beneficiaries / group_total
 
             disparity_ratio = self._compute_disparity_ratio(group_coverage, overall_coverage)