feat: get labeler/feedgen stats

consumer/src/database_writer/workers.rs

···
                 tracing::info!(inserted = inserted.len(), "Bulk COPY feedgen_likes completed");
                 total_inserted += inserted.len();
 
-                // Generate deltas for feedgen likes (currently not tracked in aggregates)
-                // Future: Could add FeedGen aggregate target
+                // Update feedgen like_count aggregates
+                let feedgen_ids: Vec<i64> = inserted.iter().map(|like| like.feedgen_id).collect();
+                if let Err(e) = crate::db::operations::increment_feedgen_like_counts(&txn, &feedgen_ids).await {
+                    tracing::error!(error = ?e, "Failed to update feedgen like_count aggregates");
+                }
             }
             Err(e) => {
                 tracing::error!(error = ?e, "Failed to bulk COPY feedgen_likes");
···
                 tracing::info!(inserted = inserted.len(), "Bulk COPY labeler_likes completed");
                 total_inserted += inserted.len();
 
-                // Generate deltas for labeler likes (currently not tracked in aggregates)
-                // Future: Could add Labeler aggregate target
+                // Update labeler like_count aggregates
+                let labeler_actor_ids: Vec<i32> = inserted.iter().map(|like| like.labeler_actor_id).collect();
+                if let Err(e) = crate::db::operations::increment_labeler_like_counts(&txn, &labeler_actor_ids).await {
+                    tracing::error!(error = ?e, "Failed to update labeler like_count aggregates");
+                }
             }
             Err(e) => {
                 tracing::error!(error = ?e, "Failed to bulk COPY labeler_likes");

consumer/src/db/operations/feed.rs

···
 mod feedgen;
 
 // Re-export all public functions for external use
-pub use feedgen::{feedgen_delete, feedgen_upsert};
+pub use feedgen::{feedgen_delete, feedgen_upsert, increment_feedgen_like_counts, decrement_feedgen_like_count};
 pub use helpers::{ensure_list_id, get_actor_id};
 pub use like::{like_delete, like_insert};
 pub use post::{post_delete, post_insert};

consumer/src/db/operations/feed/feedgen.rs

···
     .await
     .wrap_err_with(|| format!("Failed to delete feedgen for actor_id:{} rkey:{}", actor_id, rkey))
 }
+
+/// Increment like_count for multiple feedgens (bulk operation)
+///
+/// This is called after bulk inserting feedgen_likes to update the aggregate counts.
+/// Uses a single UPDATE statement with unnest for efficiency.
+pub async fn increment_feedgen_like_counts<C: GenericClient>(
+    conn: &C,
+    feedgen_ids: &[i64],
+) -> Result<u64> {
+    if feedgen_ids.is_empty() {
+        return Ok(0);
+    }
+
+    conn.execute(
+        "UPDATE feedgens
+         SET like_count = like_count + counts.count
+         FROM (
+             SELECT unnest($1::bigint[]) as id, unnest($2::int[]) as count
+         ) AS counts
+         WHERE feedgens.id = counts.id",
+        &[&feedgen_ids, &vec![1i32; feedgen_ids.len()]],
+    )
+    .await
+    .wrap_err("Failed to increment feedgen like_count aggregates")
+}
+
+/// Decrement like_count for a single feedgen
+///
+/// This is called when deleting a feedgen_like record.
+pub async fn decrement_feedgen_like_count<C: GenericClient>(
+    conn: &C,
+    feedgen_id: i64,
+) -> Result<u64> {
+    conn.execute(
+        "UPDATE feedgens
+         SET like_count = GREATEST(like_count - 1, 0)
+         WHERE id = $1",
+        &[&feedgen_id],
+    )
+    .await
+    .wrap_err("Failed to decrement feedgen like_count")
+}

consumer/src/db/operations/labeler.rs

···
     .await
     .wrap_err_with(|| format!("Failed to delete labeler for actor_id:{}", actor_id))
 }
+
+/// Increment like_count for multiple labelers (bulk operation)
+///
+/// This is called after bulk inserting labeler_likes to update the aggregate counts.
+/// Uses a single UPDATE statement with unnest for efficiency.
+pub async fn increment_labeler_like_counts<C: GenericClient>(
+    conn: &C,
+    labeler_actor_ids: &[i32],
+) -> Result<u64> {
+    if labeler_actor_ids.is_empty() {
+        return Ok(0);
+    }
+
+    conn.execute(
+        "UPDATE labelers
+         SET like_count = like_count + counts.count
+         FROM (
+             SELECT unnest($1::int[]) as actor_id, unnest($2::int[]) as count
+         ) AS counts
+         WHERE labelers.actor_id = counts.actor_id",
+        &[&labeler_actor_ids, &vec![1i32; labeler_actor_ids.len()]],
+    )
+    .await
+    .wrap_err("Failed to increment labeler like_count aggregates")
+}
+
+/// Decrement like_count for a single labeler
+///
+/// This is called when deleting a labeler_like record.
+pub async fn decrement_labeler_like_count<C: GenericClient>(
+    conn: &C,
+    labeler_actor_id: i32,
+) -> Result<u64> {
+    conn.execute(
+        "UPDATE labelers
+         SET like_count = GREATEST(like_count - 1, 0)
+         WHERE actor_id = $1",
+        &[&labeler_actor_id],
+    )
+    .await
+    .wrap_err("Failed to decrement labeler like_count")
+}

consumer/tests/feedgen_labeler_operations_test.rs

···
 //! Tests coverage for:
 //! - `feedgen_upsert` (insert and update paths)
 //! - `feedgen_delete`
+//! - `increment_feedgen_like_counts` (bulk increment aggregates)
+//! - `decrement_feedgen_like_count` (single decrement with GREATEST protection)
 //! - `labeler_upsert` (creates labeler and maintains label definitions)
 //! - `labeler_delete`
+//! - `increment_labeler_like_counts` (bulk increment aggregates)
+//! - `decrement_labeler_like_count` (single decrement with GREATEST protection)
 
 mod common;
 
···
     tx.rollback().await.wrap_err("Failed to rollback")?;
     Ok(())
 }
+
+// ========================================
+// Feed Generator Like Count Tests
+// ========================================
+
+#[tokio::test]
+async fn test_increment_feedgen_like_counts() -> eyre::Result<()> {
+    let pool = test_pool();
+    let mut conn = pool.get().await.wrap_err("Failed to get connection")?;
+    let tx = conn
+        .transaction()
+        .await
+        .wrap_err("Failed to start transaction")?;
+
+    // Create actors
+    consumer::db::operations::feed::get_actor_id(&tx, "did:plc:feedgenowner4")
+        .await
+        .wrap_err("Failed to ensure owner actor")?;
+    consumer::db::operations::feed::get_actor_id(&tx, "did:plc:feedservice4")
+        .await
+        .wrap_err("Failed to ensure service actor")?;
+
+    // Insert feedgen
+    let feedgen = AppBskyFeedGenerator {
+        did: "did:plc:feedservice4".to_string(),
+        display_name: "Test Feed".to_string(),
+        description: None,
+        description_facets: None,
+        avatar: None,
+        accepts_interactions: None,
+        labels: None,
+        content_mode: None,
+        created_at: Utc::now(),
+    };
+
+    let (service_actor_id, _, _) =
+        consumer::db::operations::feed::get_actor_id(&tx, "did:plc:feedservice4").await?;
+    let (owner_actor_id, _, _) =
+        consumer::db::operations::feed::get_actor_id(&tx, "did:plc:feedgenowner4").await?;
+    let rkey = "testfeed";
+    feed::feedgen_upsert(&tx, owner_actor_id, rkey, test_cid(), service_actor_id, feedgen)
+        .await
+        .wrap_err("Failed to insert feedgen")?;
+
+    // Get feedgen_id
+    let feedgen_id: i64 = tx
+        .query_one(
+            "SELECT id FROM feedgens WHERE actor_id = $1 AND rkey = $2",
+            &[&owner_actor_id, &rkey],
+        )
+        .await
+        .wrap_err("Failed to get feedgen_id")?
+        .get(0);
+
+    // Verify initial like_count is 0
+    let initial_count: i32 = tx
+        .query_one(
+            "SELECT like_count FROM feedgens WHERE id = $1",
+            &[&feedgen_id],
+        )
+        .await
+        .wrap_err("Failed to get initial like_count")?
+        .get(0);
+    assert_eq!(initial_count, 0, "Initial like_count should be 0");
+
+    // Increment like count (simulating 3 likes for the same feedgen)
+    let result = feed::increment_feedgen_like_counts(&tx, &[feedgen_id, feedgen_id, feedgen_id])
+        .await
+        .wrap_err("Failed to increment feedgen like_counts")?;
+    assert_eq!(result, 1, "Should update 1 row (the feedgen itself)");
+
+    // Verify like_count was incremented
+    let updated_count: i32 = tx
+        .query_one(
+            "SELECT like_count FROM feedgens WHERE id = $1",
+            &[&feedgen_id],
+        )
+        .await
+        .wrap_err("Failed to get updated like_count")?
+        .get(0);
+    assert_eq!(updated_count, 3, "like_count should be incremented to 3");
+
+    tx.rollback().await.wrap_err("Failed to rollback")?;
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_decrement_feedgen_like_count() -> eyre::Result<()> {
+    let pool = test_pool();
+    let mut conn = pool.get().await.wrap_err("Failed to get connection")?;
+    let tx = conn
+        .transaction()
+        .await
+        .wrap_err("Failed to start transaction")?;
+
+    // Create actors
+    consumer::db::operations::feed::get_actor_id(&tx, "did:plc:feedgenowner5")
+        .await
+        .wrap_err("Failed to ensure owner actor")?;
+    consumer::db::operations::feed::get_actor_id(&tx, "did:plc:feedservice5")
+        .await
+        .wrap_err("Failed to ensure service actor")?;
+
+    // Insert feedgen
+    let feedgen = AppBskyFeedGenerator {
+        did: "did:plc:feedservice5".to_string(),
+        display_name: "Test Feed".to_string(),
+        description: None,
+        description_facets: None,
+        avatar: None,
+        accepts_interactions: None,
+        labels: None,
+        content_mode: None,
+        created_at: Utc::now(),
+    };
+
+    let (service_actor_id, _, _) =
+        consumer::db::operations::feed::get_actor_id(&tx, "did:plc:feedservice5").await?;
+    let (owner_actor_id, _, _) =
+        consumer::db::operations::feed::get_actor_id(&tx, "did:plc:feedgenowner5").await?;
+    let rkey = "testfeed";
+    feed::feedgen_upsert(&tx, owner_actor_id, rkey, test_cid(), service_actor_id, feedgen)
+        .await
+        .wrap_err("Failed to insert feedgen")?;
+
+    // Get feedgen_id
+    let feedgen_id: i64 = tx
+        .query_one(
+            "SELECT id FROM feedgens WHERE actor_id = $1 AND rkey = $2",
+            &[&owner_actor_id, &rkey],
+        )
+        .await
+        .wrap_err("Failed to get feedgen_id")?
+        .get(0);
+
+    // Set like_count to 5 manually
+    tx.execute(
+        "UPDATE feedgens SET like_count = 5 WHERE id = $1",
+        &[&feedgen_id],
+    )
+    .await
+    .wrap_err("Failed to set initial like_count")?;
+
+    // Decrement like count
+    let result = feed::decrement_feedgen_like_count(&tx, feedgen_id)
+        .await
+        .wrap_err("Failed to decrement feedgen like_count")?;
+    assert_eq!(result, 1, "Should update 1 row");
+
+    // Verify like_count was decremented
+    let updated_count: i32 = tx
+        .query_one(
+            "SELECT like_count FROM feedgens WHERE id = $1",
+            &[&feedgen_id],
+        )
+        .await
+        .wrap_err("Failed to get updated like_count")?
+        .get(0);
+    assert_eq!(updated_count, 4, "like_count should be decremented to 4");
+
+    // Test that it doesn't go below 0
+    for _ in 0..10 {
+        feed::decrement_feedgen_like_count(&tx, feedgen_id)
+            .await
+            .wrap_err("Failed to decrement")?;
+    }
+
+    let final_count: i32 = tx
+        .query_one(
+            "SELECT like_count FROM feedgens WHERE id = $1",
+            &[&feedgen_id],
+        )
+        .await
+        .wrap_err("Failed to get final like_count")?
+        .get(0);
+    assert_eq!(
+        final_count, 0,
+        "like_count should not go below 0 (GREATEST protection)"
+    );
+
+    tx.rollback().await.wrap_err("Failed to rollback")?;
+    Ok(())
+}
+
+// ========================================
+// Labeler Like Count Tests
+// ========================================
+
+#[tokio::test]
+async fn test_increment_labeler_like_counts() -> eyre::Result<()> {
+    let pool = test_pool();
+    let mut conn = pool.get().await.wrap_err("Failed to get connection")?;
+    let tx = conn
+        .transaction()
+        .await
+        .wrap_err("Failed to start transaction")?;
+
+    // Create actor
+    consumer::db::operations::feed::get_actor_id(&tx, "did:plc:labeler4")
+        .await
+        .wrap_err("Failed to ensure labeler actor")?;
+
+    // Insert labeler
+    let labeler = AppBskyLabelerService {
+        policies: LabelerPolicy {
+            label_values: vec!["test".to_string()],
+            label_value_definitions: vec![LabelValueDefinition {
+                identifier: "test".to_string(),
+                severity: Severity::Inform,
+                blurs: Blurs::None,
+                default_setting: None,
+                adult_only: None,
+                locales: vec![],
+            }],
+        },
+        labels: None,
+        reason_types: None,
+        subject_types: None,
+        subject_collections: None,
+        created_at: Utc::now(),
+    };
+
+    let (actor_id, _, _) =
+        consumer::db::operations::feed::get_actor_id(&tx, "did:plc:labeler4").await?;
+    labeler::labeler_upsert(&tx, actor_id, "did:plc:labeler4", test_cid(), labeler)
+        .await
+        .wrap_err("Failed to insert labeler")?;
+
+    // Verify initial like_count is 0
+    let initial_count: i32 = tx
+        .query_one(
+            "SELECT like_count FROM labelers WHERE actor_id = $1",
+            &[&actor_id],
+        )
+        .await
+        .wrap_err("Failed to get initial like_count")?
+        .get(0);
+    assert_eq!(initial_count, 0, "Initial like_count should be 0");
+
+    // Increment like count (simulating 2 likes for the same labeler)
+    let result = labeler::increment_labeler_like_counts(&tx, &[actor_id, actor_id])
+        .await
+        .wrap_err("Failed to increment labeler like_counts")?;
+    assert_eq!(result, 1, "Should update 1 row (the labeler itself)");
+
+    // Verify like_count was incremented
+    let updated_count: i32 = tx
+        .query_one(
+            "SELECT like_count FROM labelers WHERE actor_id = $1",
+            &[&actor_id],
+        )
+        .await
+        .wrap_err("Failed to get updated like_count")?
+        .get(0);
+    assert_eq!(updated_count, 2, "like_count should be incremented to 2");
+
+    tx.rollback().await.wrap_err("Failed to rollback")?;
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_decrement_labeler_like_count() -> eyre::Result<()> {
+    let pool = test_pool();
+    let mut conn = pool.get().await.wrap_err("Failed to get connection")?;
+    let tx = conn
+        .transaction()
+        .await
+        .wrap_err("Failed to start transaction")?;
+
+    // Create actor
+    consumer::db::operations::feed::get_actor_id(&tx, "did:plc:labeler5")
+        .await
+        .wrap_err("Failed to ensure labeler actor")?;
+
+    // Insert labeler
+    let labeler = AppBskyLabelerService {
+        policies: LabelerPolicy {
+            label_values: vec!["test".to_string()],
+            label_value_definitions: vec![LabelValueDefinition {
+                identifier: "test".to_string(),
+                severity: Severity::Inform,
+                blurs: Blurs::None,
+                default_setting: None,
+                adult_only: None,
+                locales: vec![],
+            }],
+        },
+        labels: None,
+        reason_types: None,
+        subject_types: None,
+        subject_collections: None,
+        created_at: Utc::now(),
+    };
+
+    let (actor_id, _, _) =
+        consumer::db::operations::feed::get_actor_id(&tx, "did:plc:labeler5").await?;
+    labeler::labeler_upsert(&tx, actor_id, "did:plc:labeler5", test_cid(), labeler)
+        .await
+        .wrap_err("Failed to insert labeler")?;
+
+    // Set like_count to 3 manually
+    tx.execute(
+        "UPDATE labelers SET like_count = 3 WHERE actor_id = $1",
+        &[&actor_id],
+    )
+    .await
+    .wrap_err("Failed to set initial like_count")?;
+
+    // Decrement like count
+    let result = labeler::decrement_labeler_like_count(&tx, actor_id)
+        .await
+        .wrap_err("Failed to decrement labeler like_count")?;
+    assert_eq!(result, 1, "Should update 1 row");
+
+    // Verify like_count was decremented
+    let updated_count: i32 = tx
+        .query_one(
+            "SELECT like_count FROM labelers WHERE actor_id = $1",
+            &[&actor_id],
+        )
+        .await
+        .wrap_err("Failed to get updated like_count")?
+        .get(0);
+    assert_eq!(updated_count, 2, "like_count should be decremented to 2");
+
+    // Test that it doesn't go below 0
+    for _ in 0..10 {
+        labeler::decrement_labeler_like_count(&tx, actor_id)
+            .await
+            .wrap_err("Failed to decrement")?;
+    }
+
+    let final_count: i32 = tx
+        .query_one(
+            "SELECT like_count FROM labelers WHERE actor_id = $1",
+            &[&actor_id],
+        )
+        .await
+        .wrap_err("Failed to get final like_count")?
+        .get(0);
+    assert_eq!(
+        final_count, 0,
+        "like_count should not go below 0 (GREATEST protection)"
+    );
+
+    tx.rollback().await.wrap_err("Failed to rollback")?;
+    Ok(())
+}

migrations/2025-11-27-143034_add_like_counts_to_feedgens_labelers/down.sql

···
+-- Drop indexes
+DROP INDEX IF EXISTS idx_labelers_like_count_desc;
+DROP INDEX IF EXISTS idx_feedgens_like_count_desc;
+
+-- Drop columns
+ALTER TABLE labelers DROP COLUMN IF EXISTS like_count;
+ALTER TABLE feedgens DROP COLUMN IF EXISTS like_count;

migrations/2025-11-27-143034_add_like_counts_to_feedgens_labelers/up.sql

···
+-- Add like_count column to feedgens table
+ALTER TABLE feedgens ADD COLUMN like_count INTEGER NOT NULL DEFAULT 0;
+
+-- Add like_count column to labelers table
+ALTER TABLE labelers ADD COLUMN like_count INTEGER NOT NULL DEFAULT 0;
+
+-- Create index for ranking feedgens by likes (descending)
+CREATE INDEX idx_feedgens_like_count_desc ON feedgens(like_count DESC);
+
+-- Create index for ranking labelers by likes (descending)
+CREATE INDEX idx_labelers_like_count_desc ON labelers(like_count DESC);
+
+-- Backfill existing like counts for feedgens
+UPDATE feedgens f
+SET like_count = (
+    SELECT COUNT(*)::int
+    FROM feedgen_likes fl
+    WHERE fl.feedgen_id = f.id
+);
+
+-- Backfill existing like counts for labelers
+UPDATE labelers l
+SET like_count = (
+    SELECT COUNT(*)::int
+    FROM labeler_likes ll
+    WHERE ll.labeler_actor_id = l.actor_id
+);

parakeet-db/src/models.rs

···
     pub avatar_cid: Option<Vec<u8>>, // 32-byte CID
     pub accepts_interactions: bool,
     pub status: FeedgenStatus, // ENUM: complete | stub | deleted
+    pub like_count: i32, // Aggregated count of likes (maintained by database_writer)
 }
 
 // =============================================================================
···
     pub subject_types: Option<array_helpers::SubjectTypeArray>, // ENUM array: account | record | chat
     pub subject_collections: Option<array_helpers::TextArray>, // Collection names (as TEXT since generic)
     pub status: LabelerStatus,                                 // ENUM: complete | stub | deleted
+    pub like_count: i32, // Aggregated count of likes (maintained by database_writer)
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize, Queryable, Selectable)]

parakeet-db/src/schema.rs

···
         avatar_cid -> Nullable<Bytea>,
         accepts_interactions -> Bool,
         status -> FeedgenStatus,
+        like_count -> Int4,
     }
 }
 
···
         subject_types -> Nullable<Array<Nullable<SubjectType>>>,
         subject_collections -> Nullable<Array<Nullable<Text>>>,
         status -> LabelerStatus,
+        like_count -> Int4,
     }
 }
 

parakeet/src/loaders/feed.rs

···
             f.avatar_cid,
             f.accepts_interactions,
             f.status,
+            f.like_count,
             'at://' || owner.did || '/app.bsky.feed.generator/' || f.rkey::text as at_uri,
             owner.did as owner_did,
             service.did as service_did
···
             accepts_interactions: bool,
             #[diesel(sql_type = parakeet_db::schema::sql_types::FeedgenStatus)]
             status: parakeet_db::types::FeedgenStatus,
+            #[diesel(sql_type = diesel::sql_types::Integer)]
+            like_count: i32,
             #[diesel(sql_type = diesel::sql_types::Text)]
             at_uri: String,
             #[diesel(sql_type = diesel::sql_types::Text)]
···
             tracing::error!("feedgen load failed: {e}");
             vec![]
         });
-
-        // Query like counts for all feedgens
-        let feedgen_ids: Vec<i64> = res.iter().map(|r| r.id).collect();
-        let like_counts: HashMap<i64, i32> = if !feedgen_ids.is_empty() {
-            #[derive(diesel::QueryableByName)]
-            struct LikeCountRow {
-                #[diesel(sql_type = diesel::sql_types::BigInt)]
-                feedgen_id: i64,
-                #[diesel(sql_type = diesel::sql_types::BigInt)]
-                like_count: i64,
-            }
-
-            let count_query = "SELECT feedgen_id, COUNT(*)::bigint as like_count
-                               FROM feedgen_likes
-                               WHERE feedgen_id = ANY($1)
-                               GROUP BY feedgen_id";
-
-            diesel_async::RunQueryDsl::load::<LikeCountRow>(
-                diesel::sql_query(count_query)
-                    .bind::<diesel::sql_types::Array<diesel::sql_types::BigInt>, _>(&feedgen_ids),
-                &mut conn,
-            )
-            .await
-            .unwrap_or_else(|e| {
-                tracing::error!("feedgen like count query failed: {e}");
-                vec![]
-            })
-            .into_iter()
-            .map(|row| (row.feedgen_id, row.like_count as i32))
-            .collect()
-        } else {
-            HashMap::new()
-        };
 
         HashMap::from_iter(res.into_iter().map(|row| {
             let enriched = EnrichedFeedGen {
···
                     avatar_cid: row.avatar_cid,
                     accepts_interactions: row.accepts_interactions,
                     status: row.status,
+                    like_count: row.like_count,
                 },
                 at_uri: row.at_uri.clone(),
                 owner: row.owner_did,
                 service_did: row.service_did,
                 cid: row.cid,
                 created_at: row.created_at,
-                like_count: like_counts.get(&row.id).copied().unwrap_or(0),
+                like_count: row.like_count,
             };
             (row.at_uri, enriched)
         }))
···
 ///
 /// This loader is specifically for loading JUST like counts for feedgens and labelers
 /// when we need to rank them by likes before hydrating the full data.
+///
+/// Like counts are stored as aggregated columns (feedgens.like_count, labelers.like_count)
+/// and are maintained by the database_writer when likes are inserted/deleted.
+///
 /// For posts, use the parakeet-index stats service via LikeRecordLoader.
 pub struct LikeLoader(pub(super) Pool<AsyncPgConnection>);
 impl BatchFn<String, i32> for LikeLoader {
···
 
         let mut result = HashMap::new();
 
-        // Query feedgen like counts
+        // Query feedgen like counts from aggregated column
         if !feedgen_uris.is_empty() {
             #[derive(diesel::QueryableByName)]
             struct FeedgenLikeCount {
                 #[diesel(sql_type = diesel::sql_types::Text)]
                 uri: String,
-                #[diesel(sql_type = diesel::sql_types::BigInt)]
-                like_count: i64,
+                #[diesel(sql_type = diesel::sql_types::Integer)]
+                like_count: i32,
             }
 
             let feedgen_query = "SELECT
                     'at://' || a.did || '/app.bsky.feed.generator/' || f.rkey::text as uri,
-                    COUNT(*)::bigint as like_count
+                    f.like_count
                 FROM feedgens f
                 INNER JOIN actors a ON f.owner_actor_id = a.id
-                INNER JOIN feedgen_likes fl ON fl.feedgen_id = f.id
-                WHERE 'at://' || a.did || '/app.bsky.feed.generator/' || f.rkey::text = ANY($1)
-                GROUP BY a.did, f.rkey";
+                WHERE 'at://' || a.did || '/app.bsky.feed.generator/' || f.rkey::text = ANY($1)";
 
             let feedgen_counts: Vec<FeedgenLikeCount> = diesel_async::RunQueryDsl::load(
                 diesel::sql_query(feedgen_query)
···
             });
 
             for row in feedgen_counts {
-                result.insert(row.uri, row.like_count as i32);
+                result.insert(row.uri, row.like_count);
             }
         }
 
-        // Query labeler like counts
+        // Query labeler like counts from aggregated column
         if !labeler_uris.is_empty() {
             #[derive(diesel::QueryableByName)]
             struct LabelerLikeCount {
                 #[diesel(sql_type = diesel::sql_types::Text)]
                 uri: String,
-                #[diesel(sql_type = diesel::sql_types::BigInt)]
-                like_count: i64,
+                #[diesel(sql_type = diesel::sql_types::Integer)]
+                like_count: i32,
             }
 
             let labeler_query = "SELECT
                     'at://' || a.did || '/app.bsky.labeler.service/self' as uri,
-                    COUNT(*)::bigint as like_count
+                    l.like_count
                 FROM labelers l
                 INNER JOIN actors a ON l.actor_id = a.id
-                INNER JOIN labeler_likes ll ON ll.labeler_actor_id = l.actor_id
-                WHERE 'at://' || a.did || '/app.bsky.labeler.service/self' = ANY($1)
-                GROUP BY a.did, l.actor_id";
+                WHERE 'at://' || a.did || '/app.bsky.labeler.service/self' = ANY($1)";
 
             let labeler_counts: Vec<LabelerLikeCount> = diesel_async::RunQueryDsl::load(
                 diesel::sql_query(labeler_query)
···
             });
 
             for row in labeler_counts {
-                result.insert(row.uri, row.like_count as i32);
+                result.insert(row.uri, row.like_count);
             }
         }
 

parakeet/src/loaders/labeler.rs

···
 /// This function is public for testing purposes.
 pub fn build_labeler_records_query(actor_ids_str: &str) -> String {
     format!(
-        "SELECT actor_id, cid, created_at
+        "SELECT actor_id, cid, created_at, like_count
          FROM labelers
          WHERE actor_id IN ({})",
         actor_ids_str
···
             cid: Vec<u8>,
             #[diesel(sql_type = Timestamptz)]
             created_at: chrono::DateTime<chrono::Utc>,
+            #[diesel(sql_type = Integer)]
+            like_count: i32,
         }
 
         let records: Vec<RecordRow> = diesel_async::RunQueryDsl::load(
···
         )
         .await
         .unwrap_or_default();
-        let record_by_actor: HashMap<i32, (Vec<u8>, chrono::DateTime<chrono::Utc>)> =
-            records.into_iter().map(|row| (row.actor_id, (row.cid, row.created_at))).collect();
+        let record_by_actor: HashMap<i32, (Vec<u8>, chrono::DateTime<chrono::Utc>, i32)> =
+            records.into_iter().map(|row| (row.actor_id, (row.cid, row.created_at, row.like_count))).collect();
 
         // Load label definitions
         let defs: Vec<models::LabelerDef> = diesel_async::RunQueryDsl::load(
···
             defs_by_actor.entry(def.labeler_actor_id).or_default().push(def);
         }
 
-        // Load like counts for these labelers
-        let like_counts: HashMap<i32, i32> = if !labeler_actor_ids.is_empty() {
-            #[derive(diesel::QueryableByName)]
-            struct LikeCountRow {
-                #[diesel(sql_type = diesel::sql_types::Integer)]
-                labeler_actor_id: i32,
-                #[diesel(sql_type = diesel::sql_types::BigInt)]
-                like_count: i64,
-            }
-
-            let count_query = "SELECT labeler_actor_id, COUNT(*)::bigint as like_count
-                               FROM labeler_likes
-                               WHERE labeler_actor_id = ANY($1)
-                               GROUP BY labeler_actor_id";
-
-            diesel_async::RunQueryDsl::load::<LikeCountRow>(
-                diesel::sql_query(count_query)
-                    .bind::<diesel::sql_types::Array<diesel::sql_types::Integer>, _>(&labeler_actor_ids),
-                &mut conn,
-            )
-            .await
-            .unwrap_or_else(|e| {
-                tracing::error!("labeler like count query failed: {e}");
-                vec![]
-            })
-            .into_iter()
-            .map(|row| (row.labeler_actor_id, row.like_count as i32))
-            .collect()
-        } else {
-            HashMap::new()
-        };
-
         // Build result map: DID -> (EnrichedLabeler, Vec<LabelerDef>)
         labelers
             .into_iter()
             .filter_map(|labeler| {
                 let actor_id = labeler.actor_id;
                 let did = did_by_actor.get(&actor_id)?.clone();
-                let (cid, created_at) = record_by_actor.get(&actor_id)?;
+                let (cid, created_at, like_count) = record_by_actor.get(&actor_id)?;
                 let defs = defs_by_actor.remove(&actor_id).unwrap_or_default();
-                let like_count = like_counts.get(&actor_id).copied().unwrap_or(0);
 
                 let enriched = EnrichedLabeler {
                     labeler,
                     did: did.clone(),
                     cid: cid.clone(),
                     created_at: *created_at,
-                    like_count,
+                    like_count: *like_count,
                 };
                 Some((did, (enriched, defs)))
             })