Remove CBRS from db layer

mobile_verifier/migrations/45_drop_grandfathered_radio_threshold.sql

@@ -0,0 +1 @@
+DROP TABLE grandfathered_radio_threshold;

mobile_verifier/migrations/46_radio_threshold_rework_unique_idx.sql

@@ -0,0 +1,7 @@
+DELETE FROM radio_threshold WHERE cbsd_id IS NOT NULL;
+
+DROP INDEX radio_threshold_hotspot_pubkey_cbsd_id_idx;
+
+ALTER TABLE radio_threshold DROP COLUMN cbsd_id;
+
+CREATE UNIQUE INDEX radio_threshold_hotspot_pubkey_idx ON radio_threshold (hotspot_pubkey);

mobile_verifier/migrations/47_drop_cbrs_heartbeats.sql

@@ -0,0 +1 @@
+DROP TABLE cbrs_heartbeats;

mobile_verifier/migrations/48_drop_old_hex_coverage.sql

@@ -0,0 +1 @@
+DROP TABLE old_hex_coverage;

mobile_verifier/migrations/49_delete_cbrs_from_seniority.sql

@@ -0,0 +1 @@
+DELETE FROM seniority WHERE radio_type = 'cbrs';

mobile_verifier/migrations/50_delete_cbrs_from_coverage_objects.sql

@@ -0,0 +1 @@
+DELETE FROM coverage_objects WHERE radio_type = 'cbrs';

mobile_verifier/src/heartbeats/mod.rs

@@ -2,7 +2,7 @@ pub mod last_location;
 pub mod wifi;
 
 use crate::{
-    cell_type::{CellType, CellTypeLabel},
+    cell_type::CellType,
     coverage::{self, CoverageClaimTimeCache, CoverageObjectCache, CoverageObjectMeta},
     geofence::GeofenceValidator,
     seniority::{Seniority, SeniorityUpdate},
@@ -205,8 +205,7 @@ impl From<WifiHeartbeatIngestReport> for Heartbeat {
 #[derive(Debug, Clone, PartialEq, sqlx::FromRow)]
 pub struct HeartbeatReward {
     pub hotspot_key: PublicKeyBinary,
-    pub cell_type: CellType,
-    pub distances_to_asserted: Option<Vec<i64>>,
+    pub distances_to_asserted: Vec<i64>,
     pub trust_score_multipliers: Vec<Decimal>,
     pub coverage_object: Uuid,
 }
@@ -216,11 +215,8 @@ impl HeartbeatReward {
         KeyType::Wifi(&self.hotspot_key)
     }
 
-    pub fn id(&self) -> anyhow::Result<String> {
-        match self.cell_type.to_label() {
-            CellTypeLabel::Wifi => Ok(self.hotspot_key.to_string()),
-            _ => Err(anyhow!("failed to derive label from cell type")),
-        }
+    pub fn id(&self) -> String {
+        self.hotspot_key.to_string()
     }
 
     pub fn validated<'a>(
@@ -234,16 +230,21 @@ impl HeartbeatReward {
             .fetch(exec)
     }
 
-    pub fn iter_distances_and_scores(&self) -> impl Iterator<Item = (i64, Decimal)> {
-        let fallback: Vec<i64> = std::iter::repeat(0)
-            .take(self.trust_score_multipliers.len())
-            .collect();
+    pub fn iter_distances_and_scores(
+        &self,
+    ) -> anyhow::Result<impl Iterator<Item = (i64, Decimal)>> {
+        // This should never happen if valid_radio.sql is not touched
+        if self.trust_score_multipliers.len() != self.distances_to_asserted.len() {
+            return Err(anyhow!(
+                "Mismatched lengths between distances_to_asserted and trust_score_multipliers"
+            ));
+        }
 
-        self.distances_to_asserted
+        Ok(self
+            .distances_to_asserted
             .clone()
-            .unwrap_or(fallback)
             .into_iter()
-            .zip(self.trust_score_multipliers.clone())
+            .zip(self.trust_score_multipliers.clone()))
     }
 }
 
@@ -629,11 +630,6 @@ pub async fn clear_heartbeats(
     tx: &mut sqlx::Transaction<'_, sqlx::Postgres>,
     timestamp: &DateTime<Utc>,
 ) -> Result<(), sqlx::Error> {
-    sqlx::query("DELETE FROM cbrs_heartbeats WHERE truncated_timestamp < $1;")
-        .bind(timestamp)
-        .execute(&mut *tx)
-        .await?;
-
     sqlx::query("DELETE FROM wifi_heartbeats WHERE truncated_timestamp < $1;")
         .bind(timestamp)
         .execute(&mut *tx)
@@ -650,6 +646,38 @@ mod test {
     use file_store::wifi_heartbeat::WifiHeartbeat;
     use proto::SeniorityUpdateReason::*;
 
+    #[test]
+    fn test_iter_distances_and_scores_with_matching_lengths() {
+        let reward = HeartbeatReward {
+            hotspot_key: PublicKeyBinary::from(vec![1, 2, 3]),
+            distances_to_asserted: vec![10, 20, 30],
+            trust_score_multipliers: vec![dec!(0.25), dec!(0.5), dec!(1.0)],
+            coverage_object: uuid::Uuid::new_v4(),
+        };
+
+        let result = reward.iter_distances_and_scores();
+        assert!(result.is_ok(), "Expected successful iteration");
+
+        let pairs: Vec<(i64, Decimal)> = result.unwrap().collect();
+        assert_eq!(pairs.len(), 3, "Expected 3 pairs in the iterator");
+        assert_eq!(pairs[0], (10, dec!(0.25)));
+        assert_eq!(pairs[1], (20, dec!(0.5)));
+        assert_eq!(pairs[2], (30, dec!(1.0)));
+    }
+
+    #[test]
+    fn test_iter_distances_and_scores_with_mismatched_lengths() {
+        let reward = HeartbeatReward {
+            hotspot_key: PublicKeyBinary::from(vec![1, 2, 3]),
+            distances_to_asserted: vec![10, 20], // Only 2 elements
+            trust_score_multipliers: vec![dec!(0.25), dec!(0.5), dec!(1.0)], // 3 elements
+            coverage_object: uuid::Uuid::new_v4(),
+        };
+
+        let result = reward.iter_distances_and_scores();
+        assert!(result.is_err(), "Expected error due to mismatched lengths");
+    }
+
     fn heartbeat(timestamp: DateTime<Utc>, coverage_object: Uuid) -> ValidatedHeartbeat {
         ValidatedHeartbeat {
             cell_type: CellType::CellTypeNone,

mobile_verifier/src/heartbeats/valid_radios.sql

@@ -1,42 +1,6 @@
-WITH latest_cbrs_hotspot AS (
-    SELECT DISTINCT ON (cbsd_id)
-        cbsd_id,
-        hotspot_key
-    FROM
-        cbrs_heartbeats
-    WHERE
-        truncated_timestamp >= $1
-        AND truncated_timestamp < $2
-    ORDER BY
-        cbsd_id,
-        latest_timestamp DESC
-),
-heartbeats AS (
-    SELECT
-        lch.hotspot_key,
-        ch.cbsd_id,
-        ch.cell_type,
-        CASE WHEN count(*) >= $3 THEN
-            1.0
-        ELSE
-            0.0
-        END AS heartbeat_multiplier,
-	NULL as distances_to_asserted,
-	ARRAY_AGG(ch.location_trust_score_multiplier) as trust_score_multipliers
-    FROM
-        cbrs_heartbeats ch
-        INNER JOIN latest_cbrs_hotspot lch ON ch.cbsd_id = lch.cbsd_id
-    WHERE
-        ch.truncated_timestamp >= $1
-        AND ch.truncated_timestamp < $2
-    GROUP BY
-        ch.cbsd_id,
-        lch.hotspot_key,
-        ch.cell_type
-    UNION
+WITH heartbeats AS (
     SELECT
         hotspot_key,
-        NULL AS cbsd_id,
         cell_type,
         CASE WHEN count(*) >= $3 THEN
             1.0
@@ -54,44 +18,27 @@ heartbeats AS (
         hotspot_key,
         cell_type
 ),
-latest_uuids AS (( SELECT DISTINCT ON (hotspot_key,
-            cbsd_id)
-            hotspot_key,
-            cbsd_id,
-            coverage_object
-        FROM
-            cbrs_heartbeats ch
-        WHERE
-            truncated_timestamp >= $1
-            AND truncated_timestamp < $2
-        ORDER BY
-            hotspot_key,
-            cbsd_id,
-            truncated_timestamp DESC)
-    UNION ( SELECT DISTINCT ON (hotspot_key)
-            hotspot_key,
-            NULL AS cbsd_id,
-            coverage_object
-        FROM
-            wifi_heartbeats wh
-        WHERE
-            truncated_timestamp >= $1
-            AND truncated_timestamp < $2
-        ORDER BY
-            hotspot_key,
-            truncated_timestamp DESC))
+latest_uuids AS (
+    SELECT DISTINCT ON (hotspot_key)
+        hotspot_key,
+        coverage_object
+    FROM
+        wifi_heartbeats wh
+    WHERE
+        truncated_timestamp >= $1
+        AND truncated_timestamp < $2
+    ORDER BY
+        hotspot_key,
+        truncated_timestamp DESC
+)
 SELECT
     hb.hotspot_key,
-    hb.cbsd_id,
     hb.cell_type,
     hb.distances_to_asserted,
     hb.trust_score_multipliers,
     u.coverage_object
 FROM
     heartbeats hb
     INNER JOIN latest_uuids u ON hb.hotspot_key = u.hotspot_key
-        AND (hb.cbsd_id = u.cbsd_id
-            OR (hb.cbsd_id IS NULL
-                AND u.cbsd_id IS NULL))
 WHERE
     hb.heartbeat_multiplier = 1.0