feat(data): complete portable SQL backend parity

Align MySQL and SQLite schemas, migrations, usage, stats, export, and backfill behavior with the shared data contracts. Extend gateway startup and maintenance support across all SQL drivers.
2026-10-08 02:17:46 +08:00 · 2026-07-25 21:28:21 +08:00
parent 764e9fd131
commit 778cfb1a5c
85 changed files with 32096 additions and 2328 deletions
@@ -14,11 +14,11 @@ impl MysqlBackend {
            let table_name = maintenance_identifier(table_name)?;
            summary.attempted += 1;
            let statement = format!("ANALYZE TABLE `{table_name}`");
-            if sqlx::raw_sql(&statement)
-                .execute(self.pool())
+            if sqlx::query_as::<_, (String, String, String, String)>(&statement)
+                .fetch_all(self.pool())
                .await
                .map_sql_err()
-                .is_ok()
+                .is_ok_and(|rows| mysql_analyze_succeeded(&rows))
            {
                summary.succeeded += 1;
            }
@@ -26,3 +26,42 @@ impl MysqlBackend {
        Ok(summary)
    }
 }
+
+fn mysql_analyze_succeeded(rows: &[(String, String, String, String)]) -> bool {
+    !rows.is_empty()
+        && rows.iter().any(|(_, _, message_type, message)| {
+            message_type.eq_ignore_ascii_case("status") && message.eq_ignore_ascii_case("ok")
+        })
+        && rows
+            .iter()
+            .all(|(_, _, message_type, _)| !message_type.eq_ignore_ascii_case("error"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::mysql_analyze_succeeded;
+
+    fn row(message_type: &str, message: &str) -> (String, String, String, String) {
+        (
+            "aether.usage".to_string(),
+            "analyze".to_string(),
+            message_type.to_string(),
+            message.to_string(),
+        )
+    }
+
+    #[test]
+    fn analyze_requires_an_explicit_ok_status() {
+        assert!(mysql_analyze_succeeded(&[row("status", "OK")]));
+        assert!(!mysql_analyze_succeeded(&[]));
+        assert!(!mysql_analyze_succeeded(&[row("note", "skipped")]));
+    }
+
+    #[test]
+    fn analyze_rejects_error_rows_even_when_an_ok_row_is_present() {
+        assert!(!mysql_analyze_succeeded(&[
+            row("Error", "Table does not exist"),
+            row("status", "OK"),
+        ]));
+    }
+}
@@ -538,6 +538,20 @@ WHERE wallet_id = ?
        for sql in [
            "DELETE FROM stats_daily WHERE `date` = 0",
            "DELETE FROM stats_hourly WHERE hour_utc = 3600",
+            "DELETE FROM stats_user_summary WHERE user_id LIKE 'user-%'",
+            "DELETE FROM stats_user_daily_model WHERE `date` = 0",
+            "DELETE FROM stats_user_daily_provider WHERE `date` = 0",
+            "DELETE FROM stats_user_daily_api_format WHERE `date` = 0",
+            "DELETE FROM stats_daily_model_provider WHERE `date` = 0",
+            "DELETE FROM stats_user_daily_model_provider WHERE `date` = 0",
+            "DELETE FROM stats_daily_cost_savings WHERE `date` = 0",
+            "DELETE FROM stats_daily_cost_savings_provider WHERE `date` = 0",
+            "DELETE FROM stats_daily_cost_savings_model WHERE `date` = 0",
+            "DELETE FROM stats_daily_cost_savings_model_provider WHERE `date` = 0",
+            "DELETE FROM stats_user_daily_cost_savings WHERE `date` = 0",
+            "DELETE FROM stats_user_daily_cost_savings_provider WHERE `date` = 0",
+            "DELETE FROM stats_user_daily_cost_savings_model WHERE `date` = 0",
+            "DELETE FROM stats_user_daily_cost_savings_model_provider WHERE `date` = 0",
            "DELETE FROM usage_settlement_snapshots WHERE request_id LIKE 'request-daily-%' OR request_id LIKE 'stats-%'",
            "DELETE FROM `usage` WHERE request_id LIKE 'request-%' OR request_id LIKE 'export-request-%' OR request_id LIKE 'stats-%'",
        ] {
@@ -550,19 +564,21 @@ WHERE wallet_id = ?
        sqlx::query(
            r#"
 INSERT INTO `usage` (
-  request_id, user_id, api_key_id, provider_name, model, status, billing_status,
+  request_id, user_id, api_key_id, provider_name, model, api_format, status, billing_status,
  status_code, error_category, input_tokens, output_tokens,
  cache_creation_input_tokens, cache_read_input_tokens, total_cost_usd,
-  actual_total_cost_usd, response_time_ms, created_at_unix_ms, updated_at_unix_secs
+  actual_total_cost_usd, cache_creation_cost_usd, cache_read_cost_usd,
+  input_price_per_1m, response_time_ms, first_byte_time_ms,
+  created_at_unix_ms, updated_at_unix_secs
 ) VALUES
-  ('stats-1', 'user-1', 'key-1', 'provider-a', 'model-a', 'completed', 'settled',
-   200, NULL, 10, 20, 1, 2, 0.30, 0.25, 100, 3600000, 3600),
-  ('stats-2', 'user-2', 'key-2', 'provider-b', 'model-b', 'failed', 'void',
-   500, 'upstream_error', 5, 7, 0, 1, 0.20, 0.20, 300, 3610000, 3610),
-  ('stats-pending', 'user-3', 'key-3', 'provider-a', 'model-a', 'pending', 'pending',
-   NULL, NULL, 100, 100, 0, 0, 9.99, 9.99, 50, 3620000, 3620),
-  ('stats-unknown-provider', 'user-4', 'key-4', 'unknown', 'model-a', 'completed', 'settled',
-   200, NULL, 100, 100, 0, 0, 9.99, 9.99, 50, 3630000, 3630)
+  ('stats-1', 'user-1', 'key-1', 'provider-a', 'model-a', 'openai', 'completed', 'settled',
+   200, NULL, 10, 20, 1, 2, 0.30, 0.25, 0.01, 0.02, 10.0, 100, 50, 3600, 3600),
+  ('stats-2', 'user-2', 'key-2', 'provider-b', 'model-b', 'claude', 'failed', 'void',
+   500, 'upstream_error', 5, 7, 0, 1, 0.20, 0.20, 0.00, 0.01, 20.0, 300, 200, 3610, 3610),
+  ('stats-pending', 'user-3', 'key-3', 'provider-a', 'model-a', 'openai', 'pending', 'pending',
+   NULL, NULL, 100, 100, 0, 0, 9.99, 9.99, 0.00, 0.00, 0.0, 50, 25, 3620, 3620),
+  ('stats-unknown-provider', 'user-4', 'key-4', 'unknown', 'model-a', 'openai', 'completed', 'settled',
+   200, NULL, 100, 100, 0, 0, 9.99, 9.99, 0.00, 0.00, 0.0, 50, 25, 3630, 3630)
 "#,
        )
        .execute(backend.pool())
@@ -627,7 +643,7 @@ WHERE hour_utc = 3600
        assert_eq!(daily.total_requests, 2);
        assert_eq!(daily.model_rows, 2);
        assert_eq!(daily.provider_rows, 2);
-        assert_eq!(daily.api_key_rows, 2);
+        assert_eq!(daily.api_key_rows, 4);
        assert_eq!(daily.error_rows, 1);
        assert_eq!(daily.user_rows, 2);

@@ -642,5 +658,46 @@ WHERE `date` = 0
        .await
        .expect("daily stats row should load");
        assert_eq!(daily_row, (2, 1, 1, 2));
+
+        let enriched_daily = sqlx::query_as::<_, (i64, i64, i64, i64, i64, Option<i64>)>(
+            r#"
+SELECT effective_input_tokens, total_input_context, cache_hit_total_requests,
+       completed_total_requests, settled_total_requests, p50_response_time_ms
+FROM stats_daily
+WHERE `date` = 0
+"#,
+        )
+        .fetch_one(backend.pool())
+        .await
+        .expect("mysql enriched daily stats row should load");
+        assert_eq!(enriched_daily, (13, 17, 4, 2, 2, None));
+
+        for table in [
+            "stats_user_summary",
+            "stats_user_daily_model",
+            "stats_user_daily_provider",
+            "stats_user_daily_api_format",
+            "stats_daily_model_provider",
+            "stats_user_daily_model_provider",
+            "stats_daily_cost_savings",
+            "stats_daily_cost_savings_provider",
+            "stats_daily_cost_savings_model",
+            "stats_daily_cost_savings_model_provider",
+            "stats_user_daily_cost_savings",
+            "stats_user_daily_cost_savings_provider",
+            "stats_user_daily_cost_savings_model",
+            "stats_user_daily_cost_savings_model_provider",
+        ] {
+            let sql = if table == "stats_user_summary" {
+                format!("SELECT COUNT(*) FROM {table} WHERE user_id IN ('user-1', 'user-2')")
+            } else {
+                format!("SELECT COUNT(*) FROM {table} WHERE `date` = 0")
+            };
+            let count: i64 = sqlx::query_scalar(&sql)
+                .fetch_one(backend.pool())
+                .await
+                .expect("mysql advanced stats count should load");
+            assert!(count > 0, "{table} should be populated");
+        }
    }
 }
@@ -586,22 +586,6 @@ VALUES ('target-key-1', 'target-user-1', 'hash-target-key', 'target key', 1, 1)
            .await
            .expect("sqlite migrations should run");

-        for (column, ty) in [
-            ("request_body", "TEXT"),
-            ("response_body", "TEXT"),
-            ("provider_request_body", "TEXT"),
-            ("client_response_body", "TEXT"),
-            ("request_body_compressed", "BLOB"),
-            ("response_body_compressed", "BLOB"),
-            ("provider_request_body_compressed", "BLOB"),
-            ("client_response_body_compressed", "BLOB"),
-        ] {
-            sqlx::query(&format!(r#"ALTER TABLE "usage" ADD COLUMN {column} {ty}"#))
-                .execute(backend.pool())
-                .await
-                .expect("legacy body column should be added");
-        }
-
        sqlx::query(
            r#"
 INSERT INTO "usage" (
@@ -842,25 +826,40 @@ WHERE billing_date = '2026-05-03'
        sqlx::query(
            r#"
 INSERT INTO "usage" (
-  request_id, user_id, api_key_id, provider_name, model, status, billing_status,
+  request_id, user_id, api_key_id, provider_name, model, api_format, status, billing_status,
  status_code, error_category, input_tokens, output_tokens,
  cache_creation_input_tokens, cache_read_input_tokens, total_cost_usd,
-  actual_total_cost_usd, response_time_ms, created_at_unix_ms, updated_at_unix_secs
+  actual_total_cost_usd, cache_creation_cost_usd, cache_read_cost_usd,
+  input_price_per_1m, response_time_ms, first_byte_time_ms,
+  created_at_unix_ms, updated_at_unix_secs
 ) VALUES
-  ('stats-1', 'user-1', 'key-1', 'provider-a', 'model-a', 'completed', 'settled',
-   200, NULL, 10, 20, 1, 2, 0.30, 0.25, 100, 3600000, 3600),
-  ('stats-2', 'user-2', 'key-2', 'provider-b', 'model-b', 'failed', 'void',
-   500, 'upstream_error', 5, 7, 0, 1, 0.20, 0.20, 300, 3610000, 3610),
-  ('stats-pending', 'user-3', 'key-3', 'provider-a', 'model-a', 'pending', 'pending',
-   NULL, NULL, 100, 100, 0, 0, 9.99, 9.99, 50, 3620000, 3620),
-  ('stats-unknown-provider', 'user-4', 'key-4', 'unknown', 'model-a', 'completed', 'settled',
-   200, NULL, 100, 100, 0, 0, 9.99, 9.99, 50, 3630000, 3630)
+  ('stats-1', 'user-1', 'key-1', 'provider-a', 'model-a', 'openai', 'completed', 'settled',
+   200, NULL, 10, 20, 1, 2, 0.30, 0.25, 0.01, 0.02, 10.0, 100, 50, 3600, 3600),
+  ('stats-2', 'user-2', 'key-2', 'provider-b', 'model-b', 'claude', 'failed', 'void',
+   500, 'upstream_error', 5, 7, 0, 1, 0.20, 0.20, 0.00, 0.01, 20.0, 300, 200, 3610, 3610),
+  ('stats-pending', 'user-3', 'key-3', 'provider-a', 'model-a', 'openai', 'pending', 'pending',
+   NULL, NULL, 100, 100, 0, 0, 9.99, 9.99, 0.00, 0.00, 0.0, 50, 25, 3620, 3620),
+  ('stats-unknown-provider', 'user-4', 'key-4', 'unknown', 'model-a', 'openai', 'completed', 'settled',
+   200, NULL, 100, 100, 0, 0, 9.99, 9.99, 0.00, 0.00, 0.0, 50, 25, 3630, 3630)
 "#,
        )
        .execute(backend.pool())
        .await
        .expect("usage stats rows should seed");

+        sqlx::query(
+            r#"
+INSERT INTO request_candidates (
+  id, request_id, candidate_index, retry_index, status, created_at
+) VALUES
+  ('stats-candidate-1', 'stats-fallback', 0, 0, 'failed', 3600000),
+  ('stats-candidate-2', 'stats-fallback', 1, 0, 'success', 3610000)
+"#,
+        )
+        .execute(backend.pool())
+        .await
+        .expect("fallback candidates should seed");
+
        let target_hour = chrono::DateTime::<chrono::Utc>::from_timestamp(3600, 0)
            .expect("target hour should be valid");
        let aggregated_at = chrono::DateTime::<chrono::Utc>::from_timestamp(7200, 0)
@@ -896,6 +895,66 @@ WHERE hour_utc = 3600
        assert_eq!(hourly_row.3, 15);
        assert!((hourly_row.4 - 0.50).abs() < f64::EPSILON);

+        let enriched_hourly: (f64, i64, i64, i64, i64, i64) = sqlx::query_as(
+            r#"
+SELECT response_time_sum_ms, response_time_samples, cache_hit_total_requests,
+       cache_hit_requests, completed_total_requests, settled_total_requests
+FROM stats_hourly
+WHERE hour_utc = 3600
+"#,
+        )
+        .fetch_one(backend.pool())
+        .await
+        .expect("enriched hourly stats row should load");
+        assert!((enriched_hourly.0 - 400.0).abs() < f64::EPSILON);
+        assert_eq!(enriched_hourly.1, 2);
+        assert_eq!(enriched_hourly.2, 4);
+        assert_eq!(enriched_hourly.3, 2);
+        assert_eq!(enriched_hourly.4, 2);
+        assert_eq!(enriched_hourly.5, 2);
+
+        assert_eq!(sqlite_count(backend.pool(), "stats_hourly_user").await, 2);
+        assert_eq!(
+            sqlite_count(backend.pool(), "stats_hourly_user_model").await,
+            2
+        );
+        assert_eq!(sqlite_count(backend.pool(), "stats_hourly_model").await, 2);
+        assert_eq!(
+            sqlite_count(backend.pool(), "stats_hourly_provider").await,
+            2
+        );
+        let hourly_user = sqlx::query_as::<_, (i64, i64, i64, i64, i64, f64)>(
+            r#"
+SELECT total_requests, success_requests, error_requests, input_tokens, output_tokens, total_cost
+FROM stats_hourly_user
+WHERE hour_utc = 3600 AND user_id = 'user-2'
+"#,
+        )
+        .fetch_one(backend.pool())
+        .await
+        .expect("hourly user stats row should load");
+        assert_eq!(hourly_user.0, 1);
+        assert_eq!(hourly_user.1, 0);
+        assert_eq!(hourly_user.2, 1);
+        assert_eq!(hourly_user.3, 5);
+        assert_eq!(hourly_user.4, 7);
+        assert!((hourly_user.5 - 0.20).abs() < f64::EPSILON);
+        let hourly_model = sqlx::query_as::<_, (i64, i64, i64, f64, f64)>(
+            r#"
+SELECT total_requests, input_tokens, output_tokens, total_cost, avg_response_time_ms
+FROM stats_hourly_model
+WHERE hour_utc = 3600 AND model = 'model-a'
+"#,
+        )
+        .fetch_one(backend.pool())
+        .await
+        .expect("hourly model stats row should load");
+        assert_eq!(hourly_model.0, 1);
+        assert_eq!(hourly_model.1, 10);
+        assert_eq!(hourly_model.2, 20);
+        assert!((hourly_model.3 - 0.30).abs() < f64::EPSILON);
+        assert!((hourly_model.4 - 100.0).abs() < f64::EPSILON);
+
        let second_hourly = backend
            .aggregate_stats_hourly(&StatsHourlyAggregationInput {
                target_hour_utc: target_hour,
@@ -919,13 +978,13 @@ WHERE hour_utc = 3600
        assert_eq!(daily.total_requests, 2);
        assert_eq!(daily.model_rows, 2);
        assert_eq!(daily.provider_rows, 2);
-        assert_eq!(daily.api_key_rows, 2);
+        assert_eq!(daily.api_key_rows, 4);
        assert_eq!(daily.error_rows, 1);
        assert_eq!(daily.user_rows, 2);

-        let daily_row = sqlx::query_as::<_, (i64, i64, i64, i64)>(
+        let daily_row = sqlx::query_as::<_, (i64, i64, i64, i64, i64)>(
            r#"
-SELECT total_requests, success_requests, error_requests, unique_models
+SELECT total_requests, success_requests, error_requests, unique_models, fallback_count
 FROM stats_daily
 WHERE "date" = 0
 "#,
@@ -933,6 +992,167 @@ WHERE "date" = 0
        .fetch_one(backend.pool())
        .await
        .expect("daily stats row should load");
-        assert_eq!(daily_row, (2, 1, 1, 2));
+        assert_eq!(daily_row, (2, 1, 1, 2, 1));
+
+        assert_eq!(sqlite_count(backend.pool(), "stats_daily_model").await, 2);
+        assert_eq!(
+            sqlite_count(backend.pool(), "stats_daily_provider").await,
+            2
+        );
+        assert_eq!(sqlite_count(backend.pool(), "stats_daily_api_key").await, 4);
+        assert_eq!(sqlite_count(backend.pool(), "stats_daily_error").await, 1);
+        assert_eq!(sqlite_count(backend.pool(), "stats_user_daily").await, 2);
+        let daily_model = sqlx::query_as::<_, (i64, i64, i64, i64, i64, f64, f64)>(
+            r#"
+SELECT total_requests, input_tokens, output_tokens, cache_creation_tokens,
+       cache_read_tokens, total_cost, avg_response_time_ms
+FROM stats_daily_model
+WHERE "date" = 0 AND model = 'model-a'
+"#,
+        )
+        .fetch_one(backend.pool())
+        .await
+        .expect("daily model stats row should load");
+        assert_eq!(daily_model.0, 1);
+        assert_eq!(daily_model.1, 10);
+        assert_eq!(daily_model.2, 20);
+        assert_eq!(daily_model.3, 1);
+        assert_eq!(daily_model.4, 2);
+        assert!((daily_model.5 - 0.30).abs() < f64::EPSILON);
+        assert!((daily_model.6 - 100.0).abs() < f64::EPSILON);
+        let daily_error = sqlx::query_as::<_, (String, Option<String>, Option<String>, i64)>(
+            r#"
+SELECT error_category, provider_name, model, count
+FROM stats_daily_error
+WHERE "date" = 0
+"#,
+        )
+        .fetch_one(backend.pool())
+        .await
+        .expect("daily error stats row should load");
+        assert_eq!(
+            daily_error,
+            (
+                "upstream_error".to_string(),
+                Some("provider-b".to_string()),
+                Some("model-b".to_string()),
+                1,
+            )
+        );
+        let daily_user = sqlx::query_as::<_, (i64, i64, i64, i64, i64, f64)>(
+            r#"
+SELECT total_requests, success_requests, error_requests, input_tokens, output_tokens, total_cost
+FROM stats_user_daily
+WHERE "date" = 0 AND user_id = 'user-2'
+"#,
+        )
+        .fetch_one(backend.pool())
+        .await
+        .expect("daily user stats row should load");
+        assert_eq!(daily_user.0, 1);
+        assert_eq!(daily_user.1, 0);
+        assert_eq!(daily_user.2, 1);
+        assert_eq!(daily_user.3, 5);
+        assert_eq!(daily_user.4, 7);
+        assert!((daily_user.5 - 0.20).abs() < f64::EPSILON);
+
+        let enriched_daily =
+            sqlx::query_as::<_, (i64, i64, f64, i64, i64, i64, i64, i64, i64, Option<i64>)>(
+                r#"
+SELECT effective_input_tokens, total_input_context, response_time_sum_ms,
+       response_time_samples, cache_hit_total_requests, cache_hit_requests,
+       completed_total_requests, completed_cache_hit_requests,
+       settled_total_requests, p50_response_time_ms
+FROM stats_daily
+WHERE "date" = 0
+"#,
+            )
+            .fetch_one(backend.pool())
+            .await
+            .expect("enriched daily stats row should load");
+        assert_eq!(enriched_daily.0, 13);
+        assert_eq!(enriched_daily.1, 17);
+        assert!((enriched_daily.2 - 400.0).abs() < f64::EPSILON);
+        assert_eq!(enriched_daily.3, 2);
+        assert_eq!(enriched_daily.4, 4);
+        assert_eq!(enriched_daily.5, 2);
+        assert_eq!(enriched_daily.6, 2);
+        assert_eq!(enriched_daily.7, 1);
+        assert_eq!(enriched_daily.8, 2);
+        assert_eq!(enriched_daily.9, None);
+
+        for (table, expected) in [
+            ("stats_user_summary", 2),
+            ("stats_user_daily_model", 2),
+            ("stats_user_daily_provider", 2),
+            ("stats_user_daily_api_format", 2),
+            ("stats_daily_model_provider", 2),
+            ("stats_user_daily_model_provider", 2),
+            ("stats_daily_cost_savings", 1),
+            ("stats_daily_cost_savings_provider", 3),
+            ("stats_daily_cost_savings_model", 2),
+            ("stats_daily_cost_savings_model_provider", 3),
+            ("stats_user_daily_cost_savings", 4),
+            ("stats_user_daily_cost_savings_provider", 4),
+            ("stats_user_daily_cost_savings_model", 4),
+            ("stats_user_daily_cost_savings_model_provider", 4),
+        ] {
+            assert_eq!(
+                sqlite_count(backend.pool(), table).await,
+                expected,
+                "{table}"
+            );
+        }
+
+        let model_rollup: (i64, i64, i64, f64, i64) = sqlx::query_as(
+            r#"
+SELECT total_requests, effective_input_tokens, total_tokens,
+       response_time_sum_ms, successful_response_time_samples
+FROM stats_user_daily_model
+WHERE user_id = 'user-1' AND "date" = 0 AND model = 'model-a'
+"#,
+        )
+        .fetch_one(backend.pool())
+        .await
+        .expect("advanced user model row should load");
+        assert_eq!(model_rollup.0, 1);
+        assert_eq!(model_rollup.1, 8);
+        assert_eq!(model_rollup.2, 31);
+        assert!((model_rollup.3 - 100.0).abs() < f64::EPSILON);
+        assert_eq!(model_rollup.4, 1);
+
+        let savings: (i64, f64, f64, f64) = sqlx::query_as(
+            r#"
+SELECT cache_read_tokens, cache_read_cost, cache_creation_cost, estimated_full_cost
+FROM stats_daily_cost_savings
+WHERE "date" = 0
+"#,
+        )
+        .fetch_one(backend.pool())
+        .await
+        .expect("daily cost savings row should load");
+        assert_eq!(savings.0, 3);
+        assert!((savings.1 - 0.03).abs() < 1e-12);
+        assert!((savings.2 - 0.01).abs() < 1e-12);
+        assert!((savings.3 - 0.00004).abs() < 1e-12);
+
+        let summary: (i64, i64, i64) = sqlx::query_as(
+            r#"
+SELECT all_time_requests, all_time_input_tokens, active_days
+FROM stats_user_summary
+WHERE user_id = 'user-1'
+"#,
+        )
+        .fetch_one(backend.pool())
+        .await
+        .expect("user summary row should load");
+        assert_eq!(summary, (1, 10, 1));
+
+        let global_summary: (i64, i64) =
+            sqlx::query_as("SELECT all_time_requests, all_time_input_tokens FROM stats_summary")
+                .fetch_one(backend.pool())
+                .await
+                .expect("global stats summary should load");
+        assert_eq!(global_summary, (2, 15));
    }
 }
@@ -1,7 +1,7 @@
 use chrono::{DateTime, Utc};
 use sqlx::Row;

-use crate::backend::stats_common::{stats_id, unix_ms, unix_secs, utc_from_unix_secs};
+use crate::backend::stats_common::{stats_id, unix_secs, utc_from_unix_secs};
 use crate::backend::MysqlBackend;
 use crate::driver::mysql::MysqlPool;
 use crate::error::SqlResultExt;
@@ -10,6 +10,8 @@ use crate::{
    StatsHourlyAggregationInput, StatsHourlyAggregationSummary,
 };

+mod advanced;
+
 impl MysqlBackend {
    pub async fn aggregate_stats_hourly(
        &self,
@@ -56,7 +58,7 @@ async fn next_mysql_stats_hourly_bucket(
    }
    let next_bucket: Option<i64> = sqlx::query_scalar(
        r#"
-SELECT CAST(MIN(FLOOR(created_at_unix_ms / 3600000) * 3600) AS SIGNED)
+SELECT CAST(MIN(FLOOR(created_at_unix_ms / 3600) * 3600) AS SIGNED)
 FROM `usage`
 WHERE created_at_unix_ms >= ?
  AND created_at_unix_ms < ?
@@ -64,8 +66,8 @@ WHERE created_at_unix_ms >= ?
  AND provider_name NOT IN ('unknown', 'pending')
 "#,
    )
-    .bind(unix_ms(search_from)?)
-    .bind(unix_ms(search_until)?)
+    .bind(search_from)
+    .bind(search_until)
    .fetch_one(pool)
    .await
    .map_sql_err()?;
@@ -88,7 +90,7 @@ async fn next_mysql_stats_daily_bucket(
    }
    let next_bucket: Option<i64> = sqlx::query_scalar(
        r#"
-SELECT CAST(MIN(FLOOR(created_at_unix_ms / 86400000) * 86400) AS SIGNED)
+SELECT CAST(MIN(FLOOR(created_at_unix_ms / 86400) * 86400) AS SIGNED)
 FROM `usage`
 WHERE created_at_unix_ms >= ?
  AND created_at_unix_ms < ?
@@ -96,8 +98,8 @@ WHERE created_at_unix_ms >= ?
  AND provider_name NOT IN ('unknown', 'pending')
 "#,
    )
-    .bind(unix_ms(search_from)?)
-    .bind(unix_ms(search_until)?)
+    .bind(search_from)
+    .bind(search_until)
    .fetch_one(pool)
    .await
    .map_sql_err()?;
@@ -110,7 +112,7 @@ SELECT
  CAST(COALESCE(SUM(CASE
    WHEN status = 'failed'
      OR status_code >= 400
-      OR (error_category IS NOT NULL AND error_category <> '')
+      OR error_message IS NOT NULL
    THEN 1 ELSE 0 END), 0) AS SIGNED) AS error_requests,
  CAST(COALESCE(SUM(input_tokens), 0) AS SIGNED) AS input_tokens,
  CAST(COALESCE(SUM(output_tokens), 0) AS SIGNED) AS output_tokens,
@@ -131,13 +133,13 @@ async fn perform_mysql_stats_hourly_aggregation(
    hour_utc_unix_secs: i64,
    aggregated_at: DateTime<Utc>,
 ) -> Result<StatsHourlyAggregationSummary, DataLayerError> {
-    let start_ms = unix_ms(hour_utc_unix_secs)?;
-    let end_ms = unix_ms(hour_utc_unix_secs + 3600)?;
+    let start_unix_secs = hour_utc_unix_secs;
+    let end_unix_secs = hour_utc_unix_secs + 3600;
    let aggregated_at_unix_secs = unix_secs(aggregated_at);
    let mut tx = pool.begin().await.map_sql_err()?;
    let row = sqlx::query(MYSQL_STATS_AGGREGATE_SQL)
-        .bind(start_ms)
-        .bind(end_ms)
+        .bind(start_unix_secs)
+        .bind(end_unix_secs)
        .fetch_one(&mut *tx)
        .await
        .map_sql_err()?;
@@ -193,10 +195,39 @@ ON DUPLICATE KEY UPDATE
    .await
    .map_sql_err()?;

-    let user_rows = mysql_group_count(&mut tx, "user_id", start_ms, end_ms).await?;
-    let user_model_rows = mysql_group_count(&mut tx, "user_id, model", start_ms, end_ms).await?;
-    let model_rows = mysql_group_count(&mut tx, "model", start_ms, end_ms).await?;
-    let provider_rows = mysql_group_count(&mut tx, "provider_name", start_ms, end_ms).await?;
+    let user_rows = upsert_mysql_stats_hourly_user_rows(
+        &mut tx,
+        hour_utc_unix_secs,
+        start_unix_secs,
+        end_unix_secs,
+        aggregated_at_unix_secs,
+    )
+    .await?;
+    let user_model_rows = upsert_mysql_stats_hourly_user_model_rows(
+        &mut tx,
+        hour_utc_unix_secs,
+        start_unix_secs,
+        end_unix_secs,
+        aggregated_at_unix_secs,
+    )
+    .await?;
+    let model_rows = upsert_mysql_stats_hourly_model_rows(
+        &mut tx,
+        hour_utc_unix_secs,
+        start_unix_secs,
+        end_unix_secs,
+        aggregated_at_unix_secs,
+    )
+    .await?;
+    let provider_rows = upsert_mysql_stats_hourly_provider_rows(
+        &mut tx,
+        hour_utc_unix_secs,
+        start_unix_secs,
+        end_unix_secs,
+        aggregated_at_unix_secs,
+    )
+    .await?;
+    advanced::refresh_hourly(&mut tx, hour_utc_unix_secs, start_unix_secs, end_unix_secs).await?;
    tx.commit().await.map_sql_err()?;

    Ok(StatsHourlyAggregationSummary {
@@ -214,21 +245,24 @@ async fn perform_mysql_stats_daily_aggregation(
    day_start_unix_secs: i64,
    aggregated_at: DateTime<Utc>,
 ) -> Result<StatsDailyAggregationSummary, DataLayerError> {
-    let start_ms = unix_ms(day_start_unix_secs)?;
-    let end_ms = unix_ms(day_start_unix_secs + 86_400)?;
+    let start_unix_secs = day_start_unix_secs;
+    let end_unix_secs = day_start_unix_secs + 86_400;
    let aggregated_at_unix_secs = unix_secs(aggregated_at);
    let mut tx = pool.begin().await.map_sql_err()?;
    let row = sqlx::query(MYSQL_STATS_AGGREGATE_SQL)
-        .bind(start_ms)
-        .bind(end_ms)
+        .bind(start_unix_secs)
+        .bind(end_unix_secs)
        .fetch_one(&mut *tx)
        .await
        .map_sql_err()?;
    let total_requests: i64 = row.try_get("total_requests").map_sql_err()?;
    let error_requests: i64 = row.try_get("error_requests").map_sql_err()?;
-    let unique_models = mysql_group_count(&mut tx, "model", start_ms, end_ms).await? as i64;
+    let unique_models =
+        mysql_group_count(&mut tx, "model", start_unix_secs, end_unix_secs).await? as i64;
    let unique_providers =
-        mysql_group_count(&mut tx, "provider_name", start_ms, end_ms).await? as i64;
+        mysql_group_count(&mut tx, "provider_name", start_unix_secs, end_unix_secs).await? as i64;
+    let fallback_count =
+        mysql_daily_fallback_count(&mut tx, start_unix_secs, end_unix_secs).await?;

    sqlx::query(
        r#"
@@ -237,7 +271,7 @@ INSERT INTO stats_daily (
  input_tokens, output_tokens, cache_creation_tokens, cache_read_tokens,
  total_cost, actual_total_cost, avg_response_time_ms, fallback_count,
  unique_models, unique_providers, is_complete, aggregated_at, created_at, updated_at
-) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?, TRUE, ?, ?, ?)
+) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, TRUE, ?, ?, ?)
 ON DUPLICATE KEY UPDATE
  total_requests = VALUES(total_requests),
  success_requests = VALUES(success_requests),
@@ -275,6 +309,7 @@ ON DUPLICATE KEY UPDATE
        row.try_get::<f64, _>("avg_response_time_ms")
            .map_sql_err()?,
    )
+    .bind(fallback_count)
    .bind(unique_models)
    .bind(unique_providers)
    .bind(aggregated_at_unix_secs)
@@ -284,11 +319,54 @@ ON DUPLICATE KEY UPDATE
    .await
    .map_sql_err()?;

-    let model_rows = usize::try_from(unique_models).unwrap_or(usize::MAX);
-    let provider_rows = usize::try_from(unique_providers).unwrap_or(usize::MAX);
-    let api_key_rows = mysql_group_count(&mut tx, "api_key_id", start_ms, end_ms).await?;
-    let error_rows = mysql_error_group_count(&mut tx, start_ms, end_ms).await?;
-    let user_rows = mysql_group_count(&mut tx, "user_id", start_ms, end_ms).await?;
+    let model_rows = upsert_mysql_stats_daily_model_rows(
+        &mut tx,
+        day_start_unix_secs,
+        start_unix_secs,
+        end_unix_secs,
+        aggregated_at_unix_secs,
+    )
+    .await?;
+    let provider_rows = upsert_mysql_stats_daily_provider_rows(
+        &mut tx,
+        day_start_unix_secs,
+        start_unix_secs,
+        end_unix_secs,
+        aggregated_at_unix_secs,
+    )
+    .await?;
+    let api_key_rows = upsert_mysql_stats_daily_api_key_rows(
+        &mut tx,
+        day_start_unix_secs,
+        start_unix_secs,
+        end_unix_secs,
+        aggregated_at_unix_secs,
+    )
+    .await?;
+    let error_rows = refresh_mysql_stats_daily_error_rows(
+        &mut tx,
+        day_start_unix_secs,
+        start_unix_secs,
+        end_unix_secs,
+        aggregated_at_unix_secs,
+    )
+    .await?;
+    let user_rows = upsert_mysql_stats_user_daily_rows(
+        &mut tx,
+        day_start_unix_secs,
+        start_unix_secs,
+        end_unix_secs,
+        aggregated_at_unix_secs,
+    )
+    .await?;
+    advanced::refresh_daily(
+        &mut tx,
+        day_start_unix_secs,
+        start_unix_secs,
+        end_unix_secs,
+        aggregated_at_unix_secs,
+    )
+    .await?;
    tx.commit().await.map_sql_err()?;

    Ok(StatsDailyAggregationSummary {
@@ -302,11 +380,425 @@ ON DUPLICATE KEY UPDATE
    })
 }

+async fn upsert_mysql_stats_hourly_user_rows(
+    tx: &mut sqlx::Transaction<'_, sqlx::MySql>,
+    hour_utc: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+    now_unix_secs: i64,
+) -> Result<usize, DataLayerError> {
+    let result = sqlx::query(
+        r#"
+INSERT INTO stats_hourly_user (
+  id, hour_utc, user_id, total_requests, success_requests, error_requests,
+  input_tokens, output_tokens, total_cost, created_at, updated_at
+)
+SELECT
+  SHA2(UUID(), 256), ?, user_id, COUNT(*),
+  COUNT(*) - COALESCE(SUM(CASE
+    WHEN status = 'failed' OR status_code >= 400 OR error_message IS NOT NULL
+    THEN 1 ELSE 0 END), 0),
+  COALESCE(SUM(CASE
+    WHEN status = 'failed' OR status_code >= 400 OR error_message IS NOT NULL
+    THEN 1 ELSE 0 END), 0),
+  COALESCE(SUM(input_tokens), 0), COALESCE(SUM(output_tokens), 0),
+  COALESCE(SUM(total_cost_usd), 0), ?, ?
+FROM `usage`
+WHERE created_at_unix_ms >= ? AND created_at_unix_ms < ?
+  AND user_id IS NOT NULL AND user_id <> ''
+  AND status NOT IN ('pending', 'streaming')
+  AND provider_name NOT IN ('unknown', 'pending')
+GROUP BY user_id
+ON DUPLICATE KEY UPDATE
+  total_requests = VALUES(total_requests), success_requests = VALUES(success_requests),
+  error_requests = VALUES(error_requests), input_tokens = VALUES(input_tokens),
+  output_tokens = VALUES(output_tokens), total_cost = VALUES(total_cost),
+  updated_at = VALUES(updated_at)
+"#,
+    )
+    .bind(hour_utc)
+    .bind(now_unix_secs)
+    .bind(now_unix_secs)
+    .bind(start_unix_secs)
+    .bind(end_unix_secs)
+    .execute(&mut **tx)
+    .await
+    .map_sql_err()?;
+    Ok(usize::try_from(result.rows_affected()).unwrap_or(usize::MAX))
+}
+
+async fn upsert_mysql_stats_hourly_user_model_rows(
+    tx: &mut sqlx::Transaction<'_, sqlx::MySql>,
+    hour_utc: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+    now_unix_secs: i64,
+) -> Result<usize, DataLayerError> {
+    let result = sqlx::query(
+        r#"
+INSERT INTO stats_hourly_user_model (
+  id, hour_utc, user_id, model, total_requests, input_tokens, output_tokens,
+  total_cost, created_at, updated_at
+)
+SELECT SHA2(UUID(), 256), ?, user_id, model, COUNT(*),
+  COALESCE(SUM(input_tokens), 0), COALESCE(SUM(output_tokens), 0),
+  COALESCE(SUM(total_cost_usd), 0), ?, ?
+FROM `usage`
+WHERE created_at_unix_ms >= ? AND created_at_unix_ms < ?
+  AND user_id IS NOT NULL AND user_id <> '' AND model IS NOT NULL AND model <> ''
+  AND status NOT IN ('pending', 'streaming')
+  AND provider_name NOT IN ('unknown', 'pending')
+GROUP BY user_id, model
+ON DUPLICATE KEY UPDATE
+  total_requests = VALUES(total_requests), input_tokens = VALUES(input_tokens),
+  output_tokens = VALUES(output_tokens), total_cost = VALUES(total_cost),
+  updated_at = VALUES(updated_at)
+"#,
+    )
+    .bind(hour_utc)
+    .bind(now_unix_secs)
+    .bind(now_unix_secs)
+    .bind(start_unix_secs)
+    .bind(end_unix_secs)
+    .execute(&mut **tx)
+    .await
+    .map_sql_err()?;
+    Ok(usize::try_from(result.rows_affected()).unwrap_or(usize::MAX))
+}
+
+async fn upsert_mysql_stats_hourly_model_rows(
+    tx: &mut sqlx::Transaction<'_, sqlx::MySql>,
+    hour_utc: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+    now_unix_secs: i64,
+) -> Result<usize, DataLayerError> {
+    let result = sqlx::query(
+        r#"
+INSERT INTO stats_hourly_model (
+  id, hour_utc, model, total_requests, input_tokens, output_tokens, total_cost,
+  avg_response_time_ms, created_at, updated_at
+)
+SELECT SHA2(UUID(), 256), ?, model, COUNT(*),
+  COALESCE(SUM(input_tokens), 0), COALESCE(SUM(output_tokens), 0),
+  COALESCE(SUM(total_cost_usd), 0), COALESCE(AVG(response_time_ms), 0), ?, ?
+FROM `usage`
+WHERE created_at_unix_ms >= ? AND created_at_unix_ms < ?
+  AND model IS NOT NULL AND model <> ''
+  AND status NOT IN ('pending', 'streaming')
+  AND provider_name NOT IN ('unknown', 'pending')
+GROUP BY model
+ON DUPLICATE KEY UPDATE
+  total_requests = VALUES(total_requests), input_tokens = VALUES(input_tokens),
+  output_tokens = VALUES(output_tokens), total_cost = VALUES(total_cost),
+  avg_response_time_ms = VALUES(avg_response_time_ms), updated_at = VALUES(updated_at)
+"#,
+    )
+    .bind(hour_utc)
+    .bind(now_unix_secs)
+    .bind(now_unix_secs)
+    .bind(start_unix_secs)
+    .bind(end_unix_secs)
+    .execute(&mut **tx)
+    .await
+    .map_sql_err()?;
+    Ok(usize::try_from(result.rows_affected()).unwrap_or(usize::MAX))
+}
+
+async fn upsert_mysql_stats_hourly_provider_rows(
+    tx: &mut sqlx::Transaction<'_, sqlx::MySql>,
+    hour_utc: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+    now_unix_secs: i64,
+) -> Result<usize, DataLayerError> {
+    let result = sqlx::query(
+        r#"
+INSERT INTO stats_hourly_provider (
+  id, hour_utc, provider_name, total_requests, input_tokens, output_tokens,
+  total_cost, created_at, updated_at
+)
+SELECT SHA2(UUID(), 256), ?, provider_name, COUNT(*),
+  COALESCE(SUM(input_tokens), 0), COALESCE(SUM(output_tokens), 0),
+  COALESCE(SUM(total_cost_usd), 0), ?, ?
+FROM `usage`
+WHERE created_at_unix_ms >= ? AND created_at_unix_ms < ?
+  AND status NOT IN ('pending', 'streaming')
+  AND provider_name NOT IN ('unknown', 'pending')
+GROUP BY provider_name
+ON DUPLICATE KEY UPDATE
+  total_requests = VALUES(total_requests), input_tokens = VALUES(input_tokens),
+  output_tokens = VALUES(output_tokens), total_cost = VALUES(total_cost),
+  updated_at = VALUES(updated_at)
+"#,
+    )
+    .bind(hour_utc)
+    .bind(now_unix_secs)
+    .bind(now_unix_secs)
+    .bind(start_unix_secs)
+    .bind(end_unix_secs)
+    .execute(&mut **tx)
+    .await
+    .map_sql_err()?;
+    Ok(usize::try_from(result.rows_affected()).unwrap_or(usize::MAX))
+}
+
+async fn upsert_mysql_stats_daily_model_rows(
+    tx: &mut sqlx::Transaction<'_, sqlx::MySql>,
+    day_start: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+    now_unix_secs: i64,
+) -> Result<usize, DataLayerError> {
+    let result = sqlx::query(
+        r#"
+INSERT INTO stats_daily_model (
+  id, `date`, model, total_requests, input_tokens, output_tokens,
+  cache_creation_tokens, cache_read_tokens, total_cost, avg_response_time_ms,
+  created_at, updated_at
+)
+SELECT SHA2(UUID(), 256), ?, model, COUNT(*),
+  COALESCE(SUM(input_tokens), 0), COALESCE(SUM(output_tokens), 0),
+  COALESCE(SUM(cache_creation_input_tokens), 0),
+  COALESCE(SUM(cache_read_input_tokens), 0), COALESCE(SUM(total_cost_usd), 0),
+  COALESCE(AVG(response_time_ms), 0), ?, ?
+FROM `usage`
+WHERE created_at_unix_ms >= ? AND created_at_unix_ms < ?
+  AND model IS NOT NULL AND model <> ''
+  AND status NOT IN ('pending', 'streaming')
+  AND provider_name NOT IN ('unknown', 'pending')
+GROUP BY model
+ON DUPLICATE KEY UPDATE
+  total_requests = VALUES(total_requests), input_tokens = VALUES(input_tokens),
+  output_tokens = VALUES(output_tokens), cache_creation_tokens = VALUES(cache_creation_tokens),
+  cache_read_tokens = VALUES(cache_read_tokens), total_cost = VALUES(total_cost),
+  avg_response_time_ms = VALUES(avg_response_time_ms), updated_at = VALUES(updated_at)
+"#,
+    )
+    .bind(day_start)
+    .bind(now_unix_secs)
+    .bind(now_unix_secs)
+    .bind(start_unix_secs)
+    .bind(end_unix_secs)
+    .execute(&mut **tx)
+    .await
+    .map_sql_err()?;
+    Ok(usize::try_from(result.rows_affected()).unwrap_or(usize::MAX))
+}
+
+async fn upsert_mysql_stats_daily_provider_rows(
+    tx: &mut sqlx::Transaction<'_, sqlx::MySql>,
+    day_start: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+    now_unix_secs: i64,
+) -> Result<usize, DataLayerError> {
+    let result = sqlx::query(
+        r#"
+INSERT INTO stats_daily_provider (
+  id, `date`, provider_name, total_requests, input_tokens, output_tokens,
+  cache_creation_tokens, cache_read_tokens, total_cost, created_at, updated_at
+)
+SELECT SHA2(UUID(), 256), ?, provider_name, COUNT(*),
+  COALESCE(SUM(input_tokens), 0), COALESCE(SUM(output_tokens), 0),
+  COALESCE(SUM(cache_creation_input_tokens), 0),
+  COALESCE(SUM(cache_read_input_tokens), 0), COALESCE(SUM(total_cost_usd), 0), ?, ?
+FROM `usage`
+WHERE created_at_unix_ms >= ? AND created_at_unix_ms < ?
+  AND status NOT IN ('pending', 'streaming')
+  AND provider_name NOT IN ('unknown', 'pending')
+GROUP BY provider_name
+ON DUPLICATE KEY UPDATE
+  total_requests = VALUES(total_requests), input_tokens = VALUES(input_tokens),
+  output_tokens = VALUES(output_tokens), cache_creation_tokens = VALUES(cache_creation_tokens),
+  cache_read_tokens = VALUES(cache_read_tokens), total_cost = VALUES(total_cost),
+  updated_at = VALUES(updated_at)
+"#,
+    )
+    .bind(day_start)
+    .bind(now_unix_secs)
+    .bind(now_unix_secs)
+    .bind(start_unix_secs)
+    .bind(end_unix_secs)
+    .execute(&mut **tx)
+    .await
+    .map_sql_err()?;
+    Ok(usize::try_from(result.rows_affected()).unwrap_or(usize::MAX))
+}
+
+async fn upsert_mysql_stats_daily_api_key_rows(
+    tx: &mut sqlx::Transaction<'_, sqlx::MySql>,
+    day_start: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+    now_unix_secs: i64,
+) -> Result<usize, DataLayerError> {
+    let result = sqlx::query(
+        r#"
+INSERT INTO stats_daily_api_key (
+  id, api_key_id, `date`, total_requests, success_requests, error_requests,
+  input_tokens, output_tokens, cache_creation_tokens, cache_read_tokens,
+  total_cost, api_key_name, created_at, updated_at
+)
+SELECT SHA2(UUID(), 256), usage.api_key_id, ?, COUNT(*),
+  COUNT(*) - COALESCE(SUM(CASE
+    WHEN usage.status = 'failed' OR usage.status_code >= 400
+      OR usage.error_message IS NOT NULL THEN 1 ELSE 0 END), 0),
+  COALESCE(SUM(CASE
+    WHEN usage.status = 'failed' OR usage.status_code >= 400
+      OR usage.error_message IS NOT NULL THEN 1 ELSE 0 END), 0),
+  COALESCE(SUM(usage.input_tokens), 0), COALESCE(SUM(usage.output_tokens), 0),
+  COALESCE(SUM(usage.cache_creation_input_tokens), 0),
+  COALESCE(SUM(usage.cache_read_input_tokens), 0),
+  COALESCE(SUM(usage.total_cost_usd), 0), MAX(api_keys.name), ?, ?
+FROM `usage` AS usage
+LEFT JOIN api_keys ON api_keys.id = usage.api_key_id
+WHERE usage.created_at_unix_ms >= ? AND usage.created_at_unix_ms < ?
+  AND usage.api_key_id IS NOT NULL AND usage.api_key_id <> ''
+GROUP BY usage.api_key_id
+ON DUPLICATE KEY UPDATE
+  total_requests = VALUES(total_requests), success_requests = VALUES(success_requests),
+  error_requests = VALUES(error_requests), input_tokens = VALUES(input_tokens),
+  output_tokens = VALUES(output_tokens), cache_creation_tokens = VALUES(cache_creation_tokens),
+  cache_read_tokens = VALUES(cache_read_tokens), total_cost = VALUES(total_cost),
+  api_key_name = COALESCE(VALUES(api_key_name), stats_daily_api_key.api_key_name),
+  updated_at = VALUES(updated_at)
+"#,
+    )
+    .bind(day_start)
+    .bind(now_unix_secs)
+    .bind(now_unix_secs)
+    .bind(start_unix_secs)
+    .bind(end_unix_secs)
+    .execute(&mut **tx)
+    .await
+    .map_sql_err()?;
+    Ok(usize::try_from(result.rows_affected()).unwrap_or(usize::MAX))
+}
+
+async fn refresh_mysql_stats_daily_error_rows(
+    tx: &mut sqlx::Transaction<'_, sqlx::MySql>,
+    day_start: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+    now_unix_secs: i64,
+) -> Result<usize, DataLayerError> {
+    sqlx::query("DELETE FROM stats_daily_error WHERE `date` = ?")
+        .bind(day_start)
+        .execute(&mut **tx)
+        .await
+        .map_sql_err()?;
+    let result = sqlx::query(
+        r#"
+INSERT INTO stats_daily_error (
+  id, `date`, error_category, provider_name, model, count, created_at, updated_at
+)
+SELECT SHA2(UUID(), 256), ?, error_category, provider_name, model, COUNT(*), ?, ?
+FROM `usage`
+WHERE created_at_unix_ms >= ? AND created_at_unix_ms < ?
+  AND error_category IS NOT NULL AND error_category <> ''
+GROUP BY error_category, provider_name, model
+"#,
+    )
+    .bind(day_start)
+    .bind(now_unix_secs)
+    .bind(now_unix_secs)
+    .bind(start_unix_secs)
+    .bind(end_unix_secs)
+    .execute(&mut **tx)
+    .await
+    .map_sql_err()?;
+    Ok(usize::try_from(result.rows_affected()).unwrap_or(usize::MAX))
+}
+
+async fn upsert_mysql_stats_user_daily_rows(
+    tx: &mut sqlx::Transaction<'_, sqlx::MySql>,
+    day_start: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+    now_unix_secs: i64,
+) -> Result<usize, DataLayerError> {
+    let result = sqlx::query(
+        r#"
+INSERT INTO stats_user_daily (
+  id, user_id, `date`, total_requests, success_requests, error_requests,
+  input_tokens, output_tokens, cache_creation_tokens, cache_read_tokens,
+  total_cost, username, created_at, updated_at
+)
+SELECT SHA2(UUID(), 256), usage.user_id, ?, COUNT(*),
+  COUNT(*) - COALESCE(SUM(CASE
+    WHEN usage.status = 'failed' OR usage.status_code >= 400
+      OR usage.error_message IS NOT NULL THEN 1 ELSE 0 END), 0),
+  COALESCE(SUM(CASE
+    WHEN usage.status = 'failed' OR usage.status_code >= 400
+      OR usage.error_message IS NOT NULL THEN 1 ELSE 0 END), 0),
+  COALESCE(SUM(usage.input_tokens), 0), COALESCE(SUM(usage.output_tokens), 0),
+  COALESCE(SUM(usage.cache_creation_input_tokens), 0),
+  COALESCE(SUM(usage.cache_read_input_tokens), 0),
+  COALESCE(SUM(usage.total_cost_usd), 0), MAX(users.username), ?, ?
+FROM `usage` AS usage
+LEFT JOIN users ON users.id = usage.user_id
+WHERE usage.created_at_unix_ms >= ? AND usage.created_at_unix_ms < ?
+  AND usage.user_id IS NOT NULL AND usage.user_id <> ''
+  AND usage.status NOT IN ('pending', 'streaming')
+  AND usage.provider_name NOT IN ('unknown', 'pending')
+GROUP BY usage.user_id
+ON DUPLICATE KEY UPDATE
+  total_requests = VALUES(total_requests), success_requests = VALUES(success_requests),
+  error_requests = VALUES(error_requests), input_tokens = VALUES(input_tokens),
+  output_tokens = VALUES(output_tokens), cache_creation_tokens = VALUES(cache_creation_tokens),
+  cache_read_tokens = VALUES(cache_read_tokens), total_cost = VALUES(total_cost),
+  username = COALESCE(VALUES(username), stats_user_daily.username),
+  updated_at = VALUES(updated_at)
+"#,
+    )
+    .bind(day_start)
+    .bind(now_unix_secs)
+    .bind(now_unix_secs)
+    .bind(start_unix_secs)
+    .bind(end_unix_secs)
+    .execute(&mut **tx)
+    .await
+    .map_sql_err()?;
+    Ok(usize::try_from(result.rows_affected()).unwrap_or(usize::MAX))
+}
+
+async fn mysql_daily_fallback_count(
+    tx: &mut sqlx::Transaction<'_, sqlx::MySql>,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+) -> Result<i64, DataLayerError> {
+    let start_unix_ms = start_unix_secs.checked_mul(1000).ok_or_else(|| {
+        DataLayerError::InvalidInput("stats fallback window start overflows milliseconds".into())
+    })?;
+    let end_unix_ms = end_unix_secs.checked_mul(1000).ok_or_else(|| {
+        DataLayerError::InvalidInput("stats fallback window end overflows milliseconds".into())
+    })?;
+    sqlx::query_scalar(
+        r#"
+SELECT COUNT(*)
+FROM (
+  SELECT request_id
+  FROM request_candidates
+  WHERE created_at >= ? AND created_at < ?
+    AND status IN ('success', 'failed')
+  GROUP BY request_id
+  HAVING COUNT(id) > 1
+) AS fallback_requests
+"#,
+    )
+    .bind(start_unix_ms)
+    .bind(end_unix_ms)
+    .fetch_one(&mut **tx)
+    .await
+    .map_sql_err()
+}
+
 async fn mysql_group_count(
    tx: &mut sqlx::Transaction<'_, sqlx::MySql>,
    group_columns: &str,
-    start_ms: i64,
-    end_ms: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
 ) -> Result<usize, DataLayerError> {
    let not_empty = group_columns
        .split(',')
@@ -330,42 +822,10 @@ FROM (
 "#
    );
    let count: i64 = sqlx::query_scalar(&sql)
-        .bind(start_ms)
-        .bind(end_ms)
+        .bind(start_unix_secs)
+        .bind(end_unix_secs)
        .fetch_one(&mut **tx)
        .await
        .map_sql_err()?;
    Ok(usize::try_from(count.max(0)).unwrap_or(usize::MAX))
 }
-
-async fn mysql_error_group_count(
-    tx: &mut sqlx::Transaction<'_, sqlx::MySql>,
-    start_ms: i64,
-    end_ms: i64,
-) -> Result<usize, DataLayerError> {
-    let count: i64 = sqlx::query_scalar(
-        r#"
-SELECT COUNT(*)
-FROM (
-  SELECT 1
-  FROM `usage`
-  WHERE created_at_unix_ms >= ?
-    AND created_at_unix_ms < ?
-    AND status NOT IN ('pending', 'streaming')
-    AND provider_name NOT IN ('unknown', 'pending')
-    AND (
-      status = 'failed'
-      OR status_code >= 400
-      OR (error_category IS NOT NULL AND error_category <> '')
-    )
-  GROUP BY COALESCE(NULLIF(error_category, ''), 'unknown_error'), provider_name, model
-) AS grouped
-"#,
-    )
-    .bind(start_ms)
-    .bind(end_ms)
-    .fetch_one(&mut **tx)
-    .await
-    .map_sql_err()?;
-    Ok(usize::try_from(count.max(0)).unwrap_or(usize::MAX))
-}
@@ -0,0 +1,973 @@
+use sqlx::MySql;
+
+use crate::backend::stats_common::stats_id;
+use crate::error::SqlResultExt;
+use crate::DataLayerError;
+
+const CACHE_5M: &str = r#"GREATEST(
+    COALESCE(usage.cache_creation_input_tokens_5m, 0),
+    COALESCE(usage.cache_creation_ephemeral_5m_input_tokens, 0)
+)"#;
+const CACHE_1H: &str = r#"GREATEST(
+    COALESCE(usage.cache_creation_input_tokens_1h, 0),
+    COALESCE(usage.cache_creation_ephemeral_1h_input_tokens, 0)
+)"#;
+const CACHE_CREATION: &str = r#"CASE
+    WHEN COALESCE(usage.cache_creation_input_tokens, 0) = 0
+      AND ({cache_5m} + {cache_1h}) > 0
+    THEN {cache_5m} + {cache_1h}
+    ELSE GREATEST(COALESCE(usage.cache_creation_input_tokens, 0), 0)
+END"#;
+const EFFECTIVE_INPUT: &str = r#"CASE
+    WHEN SUBSTRING_INDEX(
+        LOWER(COALESCE(usage.endpoint_api_format, usage.api_format, '')), ':', 1
+    ) IN ('openai', 'gemini', 'google')
+      AND COALESCE(usage.input_tokens, 0) > 0
+      AND COALESCE(usage.cache_read_input_tokens, 0) > 0
+    THEN GREATEST(COALESCE(usage.input_tokens, 0) - COALESCE(usage.cache_read_input_tokens, 0), 0)
+    ELSE GREATEST(COALESCE(usage.input_tokens, 0), 0)
+END"#;
+const SUCCESS: &str = r#"CASE
+    WHEN usage.status <> 'failed'
+      AND (usage.status_code IS NULL OR usage.status_code < 400)
+      AND usage.error_message IS NULL
+    THEN 1 ELSE 0
+END"#;
+const AGGREGATABLE: &str = r#"usage.status NOT IN ('pending', 'streaming')
+    AND usage.provider_name NOT IN ('unknown', 'pending')"#;
+const SETTLED: &str = r#"COALESCE(settlement.billing_status, usage.billing_status) = 'settled'
+    AND COALESCE(settlement.billing_total_cost_usd, usage.total_cost_usd, 0) > 0"#;
+
+fn cache_creation_expr() -> String {
+    CACHE_CREATION
+        .replace("{cache_5m}", CACHE_5M)
+        .replace("{cache_1h}", CACHE_1H)
+}
+
+fn total_input_context_expr() -> String {
+    format!(
+        "({EFFECTIVE_INPUT}) + ({}) + GREATEST(COALESCE(usage.cache_read_input_tokens, 0), 0)",
+        cache_creation_expr()
+    )
+}
+
+fn total_tokens_expr() -> String {
+    format!(
+        r#"COALESCE(
+    NULLIF(GREATEST(COALESCE(usage.total_tokens, 0), 0), 0),
+    ({EFFECTIVE_INPUT})
+      + GREATEST(COALESCE(usage.output_tokens, 0), 0)
+      + ({})
+      + GREATEST(COALESCE(usage.cache_read_input_tokens, 0), 0),
+    0
+)"#,
+        cache_creation_expr()
+    )
+}
+
+fn percentile_cont(sorted: &[i64], percentile: f64) -> Option<i64> {
+    if sorted.is_empty() {
+        return None;
+    }
+    let position = percentile * (sorted.len().saturating_sub(1) as f64);
+    let lower = position.floor() as usize;
+    let upper = position.ceil() as usize;
+    let fraction = position - lower as f64;
+    let value = sorted[lower] as f64 + (sorted[upper] - sorted[lower]) as f64 * fraction;
+    Some(value.round() as i64)
+}
+
+async fn load_percentiles(
+    tx: &mut sqlx::Transaction<'_, MySql>,
+    column: &str,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+) -> Result<(Option<i64>, Option<i64>, Option<i64>), DataLayerError> {
+    let sql = format!(
+        r#"
+SELECT {column}
+FROM `usage`
+WHERE created_at_unix_ms >= ? AND created_at_unix_ms < ?
+  AND status = 'completed'
+  AND provider_name NOT IN ('unknown', 'pending')
+  AND {column} IS NOT NULL
+ORDER BY {column}
+"#
+    );
+    let values: Vec<i64> = sqlx::query_scalar(&sql)
+        .bind(start_unix_secs)
+        .bind(end_unix_secs)
+        .fetch_all(&mut **tx)
+        .await
+        .map_sql_err()?;
+    if values.len() < 10 {
+        return Ok((None, None, None));
+    }
+    Ok((
+        percentile_cont(&values, 0.50),
+        percentile_cont(&values, 0.90),
+        percentile_cont(&values, 0.99),
+    ))
+}
+
+pub(super) async fn refresh_hourly(
+    tx: &mut sqlx::Transaction<'_, MySql>,
+    hour_utc: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+) -> Result<(), DataLayerError> {
+    let cache_creation = cache_creation_expr();
+    let total_context = total_input_context_expr();
+    let sql = format!(
+        r#"
+UPDATE stats_hourly AS target
+JOIN (
+  SELECT
+    COUNT(*) AS cache_hit_total_requests,
+    COALESCE(SUM(CASE WHEN COALESCE(usage.cache_read_input_tokens, 0) > 0 THEN 1 ELSE 0 END), 0) AS cache_hit_requests,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' THEN 1 ELSE 0 END), 0) AS completed_total_requests,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' AND COALESCE(usage.cache_read_input_tokens, 0) > 0 THEN 1 ELSE 0 END), 0) AS completed_cache_hit_requests,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' THEN GREATEST(COALESCE(usage.input_tokens, 0), 0) ELSE 0 END), 0) AS completed_input_tokens,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' THEN ({cache_creation}) ELSE 0 END), 0) AS completed_cache_creation_tokens,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' THEN GREATEST(COALESCE(usage.cache_read_input_tokens, 0), 0) ELSE 0 END), 0) AS completed_cache_read_tokens,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' THEN ({total_context}) ELSE 0 END), 0) AS completed_total_input_context,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' THEN COALESCE(usage.cache_creation_cost_usd, 0) ELSE 0 END), 0) AS completed_cache_creation_cost,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' THEN COALESCE(usage.cache_read_cost_usd, 0) ELSE 0 END), 0) AS completed_cache_read_cost,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN COALESCE(settlement.billing_total_cost_usd, usage.total_cost_usd, 0) ELSE 0 END), 0) AS settled_total_cost,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN 1 ELSE 0 END), 0) AS settled_total_requests,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN GREATEST(COALESCE(usage.input_tokens, 0), 0) ELSE 0 END), 0) AS settled_input_tokens,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN GREATEST(COALESCE(usage.output_tokens, 0), 0) ELSE 0 END), 0) AS settled_output_tokens,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN ({cache_creation}) ELSE 0 END), 0) AS settled_cache_creation_tokens,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN GREATEST(COALESCE(usage.cache_read_input_tokens, 0), 0) ELSE 0 END), 0) AS settled_cache_read_tokens,
+    MIN(CASE WHEN {SETTLED} THEN COALESCE(settlement.finalized_at, usage.finalized_at) END) AS settled_first_finalized_at_unix_secs,
+    MAX(CASE WHEN {SETTLED} THEN COALESCE(settlement.finalized_at, usage.finalized_at) END) AS settled_last_finalized_at_unix_secs,
+    COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL AND {AGGREGATABLE} THEN GREATEST(usage.response_time_ms, 0) ELSE 0 END), 0) AS response_time_sum_ms,
+    COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL AND {AGGREGATABLE} THEN 1 ELSE 0 END), 0) AS response_time_samples
+  FROM `usage` AS usage
+  LEFT JOIN usage_settlement_snapshots AS settlement ON settlement.request_id = usage.request_id
+  WHERE usage.created_at_unix_ms >= ? AND usage.created_at_unix_ms < ?
+) AS aggregated
+SET
+  target.cache_hit_total_requests = aggregated.cache_hit_total_requests,
+  target.cache_hit_requests = aggregated.cache_hit_requests,
+  target.completed_total_requests = aggregated.completed_total_requests,
+  target.completed_cache_hit_requests = aggregated.completed_cache_hit_requests,
+  target.completed_input_tokens = aggregated.completed_input_tokens,
+  target.completed_cache_creation_tokens = aggregated.completed_cache_creation_tokens,
+  target.completed_cache_read_tokens = aggregated.completed_cache_read_tokens,
+  target.completed_total_input_context = aggregated.completed_total_input_context,
+  target.completed_cache_creation_cost = aggregated.completed_cache_creation_cost,
+  target.completed_cache_read_cost = aggregated.completed_cache_read_cost,
+  target.settled_total_cost = aggregated.settled_total_cost,
+  target.settled_total_requests = aggregated.settled_total_requests,
+  target.settled_input_tokens = aggregated.settled_input_tokens,
+  target.settled_output_tokens = aggregated.settled_output_tokens,
+  target.settled_cache_creation_tokens = aggregated.settled_cache_creation_tokens,
+  target.settled_cache_read_tokens = aggregated.settled_cache_read_tokens,
+  target.settled_first_finalized_at_unix_secs = aggregated.settled_first_finalized_at_unix_secs,
+  target.settled_last_finalized_at_unix_secs = aggregated.settled_last_finalized_at_unix_secs,
+  target.response_time_sum_ms = aggregated.response_time_sum_ms,
+  target.response_time_samples = aggregated.response_time_samples
+WHERE target.hour_utc = ?
+"#
+    );
+    sqlx::query(&sql)
+        .bind(start_unix_secs)
+        .bind(end_unix_secs)
+        .bind(hour_utc)
+        .execute(&mut **tx)
+        .await
+        .map_sql_err()?;
+    refresh_hourly_user(tx, hour_utc, start_unix_secs, end_unix_secs).await?;
+    refresh_hourly_response_dimensions(tx, hour_utc, start_unix_secs, end_unix_secs).await
+}
+
+async fn refresh_hourly_user(
+    tx: &mut sqlx::Transaction<'_, MySql>,
+    hour_utc: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+) -> Result<(), DataLayerError> {
+    let cache_creation = cache_creation_expr();
+    let sql = format!(
+        r#"
+UPDATE stats_hourly_user AS target
+JOIN (
+  SELECT usage.user_id,
+    COALESCE(SUM({cache_creation}), 0) AS cache_creation_tokens,
+    COALESCE(SUM(GREATEST(COALESCE(usage.cache_read_input_tokens, 0), 0)), 0) AS cache_read_tokens,
+    COALESCE(SUM(COALESCE(settlement.billing_actual_total_cost_usd, usage.actual_total_cost_usd, 0)), 0) AS actual_total_cost,
+    COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL THEN GREATEST(usage.response_time_ms, 0) ELSE 0 END), 0) AS response_time_sum_ms,
+    COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL THEN 1 ELSE 0 END), 0) AS response_time_samples,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN COALESCE(settlement.billing_total_cost_usd, usage.total_cost_usd, 0) ELSE 0 END), 0) AS settled_total_cost,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN 1 ELSE 0 END), 0) AS settled_total_requests,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN GREATEST(COALESCE(usage.input_tokens, 0), 0) ELSE 0 END), 0) AS settled_input_tokens,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN GREATEST(COALESCE(usage.output_tokens, 0), 0) ELSE 0 END), 0) AS settled_output_tokens,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN ({cache_creation}) ELSE 0 END), 0) AS settled_cache_creation_tokens,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN GREATEST(COALESCE(usage.cache_read_input_tokens, 0), 0) ELSE 0 END), 0) AS settled_cache_read_tokens,
+    MIN(CASE WHEN {SETTLED} THEN COALESCE(settlement.finalized_at, usage.finalized_at) END) AS settled_first_finalized_at_unix_secs,
+    MAX(CASE WHEN {SETTLED} THEN COALESCE(settlement.finalized_at, usage.finalized_at) END) AS settled_last_finalized_at_unix_secs
+  FROM `usage` AS usage
+  LEFT JOIN usage_settlement_snapshots AS settlement ON settlement.request_id = usage.request_id
+  WHERE usage.created_at_unix_ms >= ? AND usage.created_at_unix_ms < ?
+    AND usage.user_id IS NOT NULL AND usage.user_id <> '' AND {AGGREGATABLE}
+  GROUP BY usage.user_id
+) AS aggregated ON target.user_id = aggregated.user_id
+SET target.cache_creation_tokens = aggregated.cache_creation_tokens,
+  target.cache_read_tokens = aggregated.cache_read_tokens,
+  target.actual_total_cost = aggregated.actual_total_cost,
+  target.response_time_sum_ms = aggregated.response_time_sum_ms,
+  target.response_time_samples = aggregated.response_time_samples,
+  target.settled_total_cost = aggregated.settled_total_cost,
+  target.settled_total_requests = aggregated.settled_total_requests,
+  target.settled_input_tokens = aggregated.settled_input_tokens,
+  target.settled_output_tokens = aggregated.settled_output_tokens,
+  target.settled_cache_creation_tokens = aggregated.settled_cache_creation_tokens,
+  target.settled_cache_read_tokens = aggregated.settled_cache_read_tokens,
+  target.settled_first_finalized_at_unix_secs = aggregated.settled_first_finalized_at_unix_secs,
+  target.settled_last_finalized_at_unix_secs = aggregated.settled_last_finalized_at_unix_secs
+WHERE target.hour_utc = ?
+"#
+    );
+    sqlx::query(&sql)
+        .bind(start_unix_secs)
+        .bind(end_unix_secs)
+        .bind(hour_utc)
+        .execute(&mut **tx)
+        .await
+        .map_sql_err()?;
+    Ok(())
+}
+
+async fn refresh_hourly_response_dimensions(
+    tx: &mut sqlx::Transaction<'_, MySql>,
+    hour_utc: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+) -> Result<(), DataLayerError> {
+    for (table, select_dimensions, group_by, join) in [
+        (
+            "stats_hourly_model",
+            "usage.model AS model",
+            "usage.model",
+            "target.model = aggregated.model",
+        ),
+        (
+            "stats_hourly_user_model",
+            "usage.user_id AS user_id, usage.model AS model",
+            "usage.user_id, usage.model",
+            "target.user_id = aggregated.user_id AND target.model = aggregated.model",
+        ),
+    ] {
+        let sql = format!(
+            r#"
+UPDATE {table} AS target
+JOIN (
+  SELECT {select_dimensions},
+    COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL THEN GREATEST(usage.response_time_ms, 0) ELSE 0 END), 0) AS response_time_sum_ms,
+    COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL THEN 1 ELSE 0 END), 0) AS response_time_samples
+  FROM `usage` AS usage
+  WHERE usage.created_at_unix_ms >= ? AND usage.created_at_unix_ms < ? AND {AGGREGATABLE}
+  GROUP BY {group_by}
+) AS aggregated ON {join}
+SET target.response_time_sum_ms = aggregated.response_time_sum_ms,
+    target.response_time_samples = aggregated.response_time_samples
+WHERE target.hour_utc = ?
+"#
+        );
+        sqlx::query(&sql)
+            .bind(start_unix_secs)
+            .bind(end_unix_secs)
+            .bind(hour_utc)
+            .execute(&mut **tx)
+            .await
+            .map_sql_err()?;
+    }
+    Ok(())
+}
+
+pub(super) async fn refresh_daily(
+    tx: &mut sqlx::Transaction<'_, MySql>,
+    day_start: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+    now_unix_secs: i64,
+) -> Result<(), DataLayerError> {
+    let response = load_percentiles(tx, "response_time_ms", start_unix_secs, end_unix_secs).await?;
+    let first_byte =
+        load_percentiles(tx, "first_byte_time_ms", start_unix_secs, end_unix_secs).await?;
+    refresh_daily_root(
+        tx,
+        day_start,
+        start_unix_secs,
+        end_unix_secs,
+        response,
+        first_byte,
+    )
+    .await?;
+    refresh_daily_existing_dimensions(tx, day_start, start_unix_secs, end_unix_secs).await?;
+    upsert_user_dimension(
+        tx,
+        "stats_user_daily_model",
+        "model",
+        "usage.model",
+        "usage.model IS NOT NULL AND usage.model <> ''",
+        day_start,
+        start_unix_secs,
+        end_unix_secs,
+        now_unix_secs,
+    )
+    .await?;
+    upsert_user_dimension(
+        tx,
+        "stats_user_daily_provider",
+        "provider_name",
+        "usage.provider_name",
+        "usage.provider_name IS NOT NULL AND usage.provider_name <> ''",
+        day_start,
+        start_unix_secs,
+        end_unix_secs,
+        now_unix_secs,
+    )
+    .await?;
+    upsert_user_dimension(
+        tx,
+        "stats_user_daily_api_format",
+        "api_format",
+        "LOWER(COALESCE(usage.endpoint_api_format, usage.api_format, ''))",
+        "COALESCE(usage.endpoint_api_format, usage.api_format, '') <> ''",
+        day_start,
+        start_unix_secs,
+        end_unix_secs,
+        now_unix_secs,
+    )
+    .await?;
+    upsert_model_provider_rows(tx, day_start, start_unix_secs, end_unix_secs, now_unix_secs)
+        .await?;
+    upsert_cost_savings_rows(tx, day_start, start_unix_secs, end_unix_secs, now_unix_secs).await?;
+    refresh_user_summary(tx, end_unix_secs, now_unix_secs).await
+}
+
+async fn refresh_daily_root(
+    tx: &mut sqlx::Transaction<'_, MySql>,
+    day_start: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+    response: (Option<i64>, Option<i64>, Option<i64>),
+    first_byte: (Option<i64>, Option<i64>, Option<i64>),
+) -> Result<(), DataLayerError> {
+    let cache_creation = cache_creation_expr();
+    let total_context = total_input_context_expr();
+    let sql = format!(
+        r#"
+UPDATE stats_daily AS target
+JOIN (
+  SELECT
+    COALESCE(SUM(CASE WHEN {AGGREGATABLE} THEN ({EFFECTIVE_INPUT}) ELSE 0 END), 0) AS effective_input_tokens,
+    COALESCE(SUM(CASE WHEN {AGGREGATABLE} THEN ({total_context}) ELSE 0 END), 0) AS total_input_context,
+    COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL AND {AGGREGATABLE} THEN GREATEST(usage.response_time_ms, 0) ELSE 0 END), 0) AS response_time_sum_ms,
+    COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL AND {AGGREGATABLE} THEN 1 ELSE 0 END), 0) AS response_time_samples,
+    COALESCE(SUM(CASE WHEN {AGGREGATABLE} THEN {CACHE_5M} ELSE 0 END), 0) AS cache_creation_ephemeral_5m_tokens,
+    COALESCE(SUM(CASE WHEN {AGGREGATABLE} THEN {CACHE_1H} ELSE 0 END), 0) AS cache_creation_ephemeral_1h_tokens,
+    COALESCE(SUM(CASE WHEN {AGGREGATABLE} THEN COALESCE(usage.input_cost_usd, 0) ELSE 0 END), 0) AS input_cost,
+    COALESCE(SUM(CASE WHEN {AGGREGATABLE} THEN COALESCE(usage.output_cost_usd, 0) ELSE 0 END), 0) AS output_cost,
+    COALESCE(SUM(CASE WHEN {AGGREGATABLE} THEN COALESCE(usage.cache_creation_cost_usd, 0) ELSE 0 END), 0) AS cache_creation_cost,
+    COALESCE(SUM(CASE WHEN {AGGREGATABLE} THEN COALESCE(usage.cache_read_cost_usd, 0) ELSE 0 END), 0) AS cache_read_cost,
+    COUNT(*) AS cache_hit_total_requests,
+    COALESCE(SUM(CASE WHEN COALESCE(usage.cache_read_input_tokens, 0) > 0 THEN 1 ELSE 0 END), 0) AS cache_hit_requests,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' THEN 1 ELSE 0 END), 0) AS completed_total_requests,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' AND COALESCE(usage.cache_read_input_tokens, 0) > 0 THEN 1 ELSE 0 END), 0) AS completed_cache_hit_requests,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' THEN GREATEST(COALESCE(usage.input_tokens, 0), 0) ELSE 0 END), 0) AS completed_input_tokens,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' THEN ({cache_creation}) ELSE 0 END), 0) AS completed_cache_creation_tokens,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' THEN GREATEST(COALESCE(usage.cache_read_input_tokens, 0), 0) ELSE 0 END), 0) AS completed_cache_read_tokens,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' THEN ({total_context}) ELSE 0 END), 0) AS completed_total_input_context,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' THEN COALESCE(usage.cache_creation_cost_usd, 0) ELSE 0 END), 0) AS completed_cache_creation_cost,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' THEN COALESCE(usage.cache_read_cost_usd, 0) ELSE 0 END), 0) AS completed_cache_read_cost,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN COALESCE(settlement.billing_total_cost_usd, usage.total_cost_usd, 0) ELSE 0 END), 0) AS settled_total_cost,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN 1 ELSE 0 END), 0) AS settled_total_requests,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN GREATEST(COALESCE(usage.input_tokens, 0), 0) ELSE 0 END), 0) AS settled_input_tokens,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN GREATEST(COALESCE(usage.output_tokens, 0), 0) ELSE 0 END), 0) AS settled_output_tokens,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN ({cache_creation}) ELSE 0 END), 0) AS settled_cache_creation_tokens,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN GREATEST(COALESCE(usage.cache_read_input_tokens, 0), 0) ELSE 0 END), 0) AS settled_cache_read_tokens,
+    MIN(CASE WHEN {SETTLED} THEN COALESCE(settlement.finalized_at, usage.finalized_at) END) AS settled_first_finalized_at_unix_secs,
+    MAX(CASE WHEN {SETTLED} THEN COALESCE(settlement.finalized_at, usage.finalized_at) END) AS settled_last_finalized_at_unix_secs
+  FROM `usage` AS usage
+  LEFT JOIN usage_settlement_snapshots AS settlement ON settlement.request_id = usage.request_id
+  WHERE usage.created_at_unix_ms >= ? AND usage.created_at_unix_ms < ?
+) AS aggregated
+SET target.effective_input_tokens = aggregated.effective_input_tokens,
+  target.total_input_context = aggregated.total_input_context,
+  target.response_time_sum_ms = aggregated.response_time_sum_ms,
+  target.response_time_samples = aggregated.response_time_samples,
+  target.cache_creation_ephemeral_5m_tokens = aggregated.cache_creation_ephemeral_5m_tokens,
+  target.cache_creation_ephemeral_1h_tokens = aggregated.cache_creation_ephemeral_1h_tokens,
+  target.input_cost = aggregated.input_cost,
+  target.output_cost = aggregated.output_cost,
+  target.cache_creation_cost = aggregated.cache_creation_cost,
+  target.cache_read_cost = aggregated.cache_read_cost,
+  target.cache_hit_total_requests = aggregated.cache_hit_total_requests,
+  target.cache_hit_requests = aggregated.cache_hit_requests,
+  target.completed_total_requests = aggregated.completed_total_requests,
+  target.completed_cache_hit_requests = aggregated.completed_cache_hit_requests,
+  target.completed_input_tokens = aggregated.completed_input_tokens,
+  target.completed_cache_creation_tokens = aggregated.completed_cache_creation_tokens,
+  target.completed_cache_read_tokens = aggregated.completed_cache_read_tokens,
+  target.completed_total_input_context = aggregated.completed_total_input_context,
+  target.completed_cache_creation_cost = aggregated.completed_cache_creation_cost,
+  target.completed_cache_read_cost = aggregated.completed_cache_read_cost,
+  target.settled_total_cost = aggregated.settled_total_cost,
+  target.settled_total_requests = aggregated.settled_total_requests,
+  target.settled_input_tokens = aggregated.settled_input_tokens,
+  target.settled_output_tokens = aggregated.settled_output_tokens,
+  target.settled_cache_creation_tokens = aggregated.settled_cache_creation_tokens,
+  target.settled_cache_read_tokens = aggregated.settled_cache_read_tokens,
+  target.settled_first_finalized_at_unix_secs = aggregated.settled_first_finalized_at_unix_secs,
+  target.settled_last_finalized_at_unix_secs = aggregated.settled_last_finalized_at_unix_secs,
+  target.p50_response_time_ms = ?, target.p90_response_time_ms = ?, target.p99_response_time_ms = ?,
+  target.p50_first_byte_time_ms = ?, target.p90_first_byte_time_ms = ?, target.p99_first_byte_time_ms = ?
+WHERE target.`date` = ?
+"#
+    );
+    sqlx::query(&sql)
+        .bind(start_unix_secs)
+        .bind(end_unix_secs)
+        .bind(response.0)
+        .bind(response.1)
+        .bind(response.2)
+        .bind(first_byte.0)
+        .bind(first_byte.1)
+        .bind(first_byte.2)
+        .bind(day_start)
+        .execute(&mut **tx)
+        .await
+        .map_sql_err()?;
+    Ok(())
+}
+
+async fn refresh_daily_existing_dimensions(
+    tx: &mut sqlx::Transaction<'_, MySql>,
+    day_start: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+) -> Result<(), DataLayerError> {
+    let cache_creation = cache_creation_expr();
+    let total_context = total_input_context_expr();
+    let model_sql = format!(
+        r#"
+UPDATE stats_daily_model AS target
+JOIN (
+  SELECT usage.model,
+    COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL THEN GREATEST(usage.response_time_ms, 0) ELSE 0 END), 0) AS response_time_sum_ms,
+    COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL THEN 1 ELSE 0 END), 0) AS response_time_samples,
+    COALESCE(SUM({CACHE_5M}), 0) AS cache_creation_ephemeral_5m_tokens,
+    COALESCE(SUM({CACHE_1H}), 0) AS cache_creation_ephemeral_1h_tokens
+  FROM `usage` AS usage
+  WHERE usage.created_at_unix_ms >= ? AND usage.created_at_unix_ms < ?
+    AND {AGGREGATABLE} AND usage.model IS NOT NULL AND usage.model <> ''
+  GROUP BY usage.model
+) AS aggregated ON target.model = aggregated.model
+SET target.response_time_sum_ms = aggregated.response_time_sum_ms,
+  target.response_time_samples = aggregated.response_time_samples,
+  target.cache_creation_ephemeral_5m_tokens = aggregated.cache_creation_ephemeral_5m_tokens,
+  target.cache_creation_ephemeral_1h_tokens = aggregated.cache_creation_ephemeral_1h_tokens
+WHERE target.`date` = ?
+"#
+    );
+    sqlx::query(&model_sql)
+        .bind(start_unix_secs)
+        .bind(end_unix_secs)
+        .bind(day_start)
+        .execute(&mut **tx)
+        .await
+        .map_sql_err()?;
+
+    let user_sql = format!(
+        r#"
+UPDATE stats_user_daily AS target
+JOIN (
+  SELECT usage.user_id,
+    COALESCE(SUM({EFFECTIVE_INPUT}), 0) AS effective_input_tokens,
+    COALESCE(SUM({total_context}), 0) AS total_input_context,
+    COALESCE(SUM(COALESCE(usage.cache_creation_cost_usd, 0)), 0) AS cache_creation_cost,
+    COALESCE(SUM(COALESCE(usage.cache_read_cost_usd, 0)), 0) AS cache_read_cost,
+    COALESCE(SUM(COALESCE(settlement.billing_actual_total_cost_usd, usage.actual_total_cost_usd, 0)), 0) AS actual_total_cost,
+    COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL THEN GREATEST(usage.response_time_ms, 0) ELSE 0 END), 0) AS response_time_sum_ms,
+    COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL THEN 1 ELSE 0 END), 0) AS response_time_samples,
+    COALESCE(SUM({CACHE_5M}), 0) AS cache_creation_ephemeral_5m_tokens,
+    COALESCE(SUM({CACHE_1H}), 0) AS cache_creation_ephemeral_1h_tokens,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN COALESCE(settlement.billing_total_cost_usd, usage.total_cost_usd, 0) ELSE 0 END), 0) AS settled_total_cost,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN 1 ELSE 0 END), 0) AS settled_total_requests,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN GREATEST(COALESCE(usage.input_tokens, 0), 0) ELSE 0 END), 0) AS settled_input_tokens,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN GREATEST(COALESCE(usage.output_tokens, 0), 0) ELSE 0 END), 0) AS settled_output_tokens,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN ({cache_creation}) ELSE 0 END), 0) AS settled_cache_creation_tokens,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN GREATEST(COALESCE(usage.cache_read_input_tokens, 0), 0) ELSE 0 END), 0) AS settled_cache_read_tokens,
+    MIN(CASE WHEN {SETTLED} THEN COALESCE(settlement.finalized_at, usage.finalized_at) END) AS settled_first_finalized_at_unix_secs,
+    MAX(CASE WHEN {SETTLED} THEN COALESCE(settlement.finalized_at, usage.finalized_at) END) AS settled_last_finalized_at_unix_secs
+  FROM `usage` AS usage
+  LEFT JOIN usage_settlement_snapshots AS settlement ON settlement.request_id = usage.request_id
+  WHERE usage.created_at_unix_ms >= ? AND usage.created_at_unix_ms < ?
+    AND usage.user_id IS NOT NULL AND usage.user_id <> '' AND {AGGREGATABLE}
+  GROUP BY usage.user_id
+) AS aggregated ON target.user_id = aggregated.user_id
+SET target.effective_input_tokens = aggregated.effective_input_tokens,
+  target.total_input_context = aggregated.total_input_context,
+  target.cache_creation_cost = aggregated.cache_creation_cost,
+  target.cache_read_cost = aggregated.cache_read_cost,
+  target.actual_total_cost = aggregated.actual_total_cost,
+  target.response_time_sum_ms = aggregated.response_time_sum_ms,
+  target.response_time_samples = aggregated.response_time_samples,
+  target.cache_creation_ephemeral_5m_tokens = aggregated.cache_creation_ephemeral_5m_tokens,
+  target.cache_creation_ephemeral_1h_tokens = aggregated.cache_creation_ephemeral_1h_tokens,
+  target.settled_total_cost = aggregated.settled_total_cost,
+  target.settled_total_requests = aggregated.settled_total_requests,
+  target.settled_input_tokens = aggregated.settled_input_tokens,
+  target.settled_output_tokens = aggregated.settled_output_tokens,
+  target.settled_cache_creation_tokens = aggregated.settled_cache_creation_tokens,
+  target.settled_cache_read_tokens = aggregated.settled_cache_read_tokens,
+  target.settled_first_finalized_at_unix_secs = aggregated.settled_first_finalized_at_unix_secs,
+  target.settled_last_finalized_at_unix_secs = aggregated.settled_last_finalized_at_unix_secs
+WHERE target.`date` = ?
+"#
+    );
+    sqlx::query(&user_sql)
+        .bind(start_unix_secs)
+        .bind(end_unix_secs)
+        .bind(day_start)
+        .execute(&mut **tx)
+        .await
+        .map_sql_err()?;
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn upsert_user_dimension(
+    tx: &mut sqlx::Transaction<'_, MySql>,
+    table: &str,
+    dimension_column: &str,
+    dimension_expr: &str,
+    dimension_filter: &str,
+    day_start: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+    now_unix_secs: i64,
+) -> Result<(), DataLayerError> {
+    let cache_creation = cache_creation_expr();
+    let total_context = total_input_context_expr();
+    let total_tokens = total_tokens_expr();
+    let sql = format!(
+        r#"
+INSERT INTO {table} (
+  id, user_id, username, `date`, {dimension_column}, total_requests, success_requests,
+  input_tokens, effective_input_tokens, output_tokens, total_tokens, total_input_context,
+  cache_creation_tokens, cache_creation_ephemeral_5m_tokens,
+  cache_creation_ephemeral_1h_tokens, cache_read_tokens, total_cost, actual_total_cost,
+  response_time_sum_ms, response_time_samples, successful_response_time_sum_ms,
+  successful_response_time_samples, created_at, updated_at
+)
+SELECT SHA2(UUID(), 256), usage.user_id,
+  MAX(COALESCE(usage.username, users.username)), ?, {dimension_expr}, COUNT(*),
+  COALESCE(SUM({SUCCESS}), 0),
+  COALESCE(SUM(GREATEST(COALESCE(usage.input_tokens, 0), 0)), 0),
+  COALESCE(SUM({EFFECTIVE_INPUT}), 0),
+  COALESCE(SUM(GREATEST(COALESCE(usage.output_tokens, 0), 0)), 0),
+  COALESCE(SUM({total_tokens}), 0), COALESCE(SUM({total_context}), 0),
+  COALESCE(SUM({cache_creation}), 0), COALESCE(SUM({CACHE_5M}), 0),
+  COALESCE(SUM({CACHE_1H}), 0),
+  COALESCE(SUM(GREATEST(COALESCE(usage.cache_read_input_tokens, 0), 0)), 0),
+  COALESCE(SUM(COALESCE(settlement.billing_total_cost_usd, usage.total_cost_usd, 0)), 0),
+  COALESCE(SUM(COALESCE(settlement.billing_actual_total_cost_usd, usage.actual_total_cost_usd, 0)), 0),
+  COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL THEN GREATEST(usage.response_time_ms, 0) ELSE 0 END), 0),
+  COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL THEN 1 ELSE 0 END), 0),
+  COALESCE(SUM(CASE WHEN ({SUCCESS}) = 1 AND usage.response_time_ms IS NOT NULL THEN GREATEST(usage.response_time_ms, 0) ELSE 0 END), 0),
+  COALESCE(SUM(CASE WHEN ({SUCCESS}) = 1 AND usage.response_time_ms IS NOT NULL THEN 1 ELSE 0 END), 0),
+  ?, ?
+FROM `usage` AS usage
+LEFT JOIN users ON users.id = usage.user_id
+LEFT JOIN usage_settlement_snapshots AS settlement ON settlement.request_id = usage.request_id
+WHERE usage.created_at_unix_ms >= ? AND usage.created_at_unix_ms < ?
+  AND usage.user_id IS NOT NULL AND usage.user_id <> ''
+  AND {dimension_filter} AND {AGGREGATABLE}
+GROUP BY usage.user_id, {dimension_expr}
+ON DUPLICATE KEY UPDATE
+  username = COALESCE(VALUES(username), {table}.username),
+  total_requests = VALUES(total_requests), success_requests = VALUES(success_requests),
+  input_tokens = VALUES(input_tokens), effective_input_tokens = VALUES(effective_input_tokens),
+  output_tokens = VALUES(output_tokens), total_tokens = VALUES(total_tokens),
+  total_input_context = VALUES(total_input_context),
+  cache_creation_tokens = VALUES(cache_creation_tokens),
+  cache_creation_ephemeral_5m_tokens = VALUES(cache_creation_ephemeral_5m_tokens),
+  cache_creation_ephemeral_1h_tokens = VALUES(cache_creation_ephemeral_1h_tokens),
+  cache_read_tokens = VALUES(cache_read_tokens), total_cost = VALUES(total_cost),
+  actual_total_cost = VALUES(actual_total_cost),
+  response_time_sum_ms = VALUES(response_time_sum_ms),
+  response_time_samples = VALUES(response_time_samples),
+  successful_response_time_sum_ms = VALUES(successful_response_time_sum_ms),
+  successful_response_time_samples = VALUES(successful_response_time_samples),
+  updated_at = VALUES(updated_at)
+"#
+    );
+    sqlx::query(&sql)
+        .bind(day_start)
+        .bind(now_unix_secs)
+        .bind(now_unix_secs)
+        .bind(start_unix_secs)
+        .bind(end_unix_secs)
+        .execute(&mut **tx)
+        .await
+        .map_sql_err()?;
+    Ok(())
+}
+
+async fn upsert_model_provider_rows(
+    tx: &mut sqlx::Transaction<'_, MySql>,
+    day_start: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+    now_unix_secs: i64,
+) -> Result<(), DataLayerError> {
+    let total_tokens = total_tokens_expr();
+    let model_provider_sql = format!(
+        r#"
+INSERT INTO stats_daily_model_provider (
+  id, `date`, model, provider_name, total_requests, total_tokens, total_cost,
+  response_time_sum_ms, response_time_samples, created_at, updated_at
+)
+SELECT SHA2(UUID(), 256), ?, usage.model, usage.provider_name, COUNT(*),
+  COALESCE(SUM({total_tokens}), 0),
+  COALESCE(SUM(COALESCE(settlement.billing_total_cost_usd, usage.total_cost_usd, 0)), 0),
+  COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL THEN GREATEST(usage.response_time_ms, 0) ELSE 0 END), 0),
+  COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL THEN 1 ELSE 0 END), 0), ?, ?
+FROM `usage` AS usage
+LEFT JOIN usage_settlement_snapshots AS settlement ON settlement.request_id = usage.request_id
+WHERE usage.created_at_unix_ms >= ? AND usage.created_at_unix_ms < ?
+  AND usage.model IS NOT NULL AND usage.model <> '' AND {AGGREGATABLE}
+GROUP BY usage.model, usage.provider_name
+ON DUPLICATE KEY UPDATE
+  total_requests = VALUES(total_requests), total_tokens = VALUES(total_tokens),
+  total_cost = VALUES(total_cost), response_time_sum_ms = VALUES(response_time_sum_ms),
+  response_time_samples = VALUES(response_time_samples), updated_at = VALUES(updated_at)
+"#
+    );
+    sqlx::query(&model_provider_sql)
+        .bind(day_start)
+        .bind(now_unix_secs)
+        .bind(now_unix_secs)
+        .bind(start_unix_secs)
+        .bind(end_unix_secs)
+        .execute(&mut **tx)
+        .await
+        .map_sql_err()?;
+
+    let user_model_provider_sql = format!(
+        r#"
+INSERT INTO stats_user_daily_model_provider (
+  id, user_id, username, `date`, model, provider_name, total_requests, total_tokens,
+  total_cost, response_time_sum_ms, response_time_samples, created_at, updated_at
+)
+SELECT SHA2(UUID(), 256), usage.user_id, MAX(COALESCE(usage.username, users.username)),
+  ?, usage.model, usage.provider_name, COUNT(*), COALESCE(SUM({total_tokens}), 0),
+  COALESCE(SUM(COALESCE(settlement.billing_total_cost_usd, usage.total_cost_usd, 0)), 0),
+  COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL THEN GREATEST(usage.response_time_ms, 0) ELSE 0 END), 0),
+  COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL THEN 1 ELSE 0 END), 0), ?, ?
+FROM `usage` AS usage
+LEFT JOIN users ON users.id = usage.user_id
+LEFT JOIN usage_settlement_snapshots AS settlement ON settlement.request_id = usage.request_id
+WHERE usage.created_at_unix_ms >= ? AND usage.created_at_unix_ms < ?
+  AND usage.user_id IS NOT NULL AND usage.user_id <> ''
+  AND usage.model IS NOT NULL AND usage.model <> '' AND {AGGREGATABLE}
+GROUP BY usage.user_id, usage.model, usage.provider_name
+ON DUPLICATE KEY UPDATE
+  username = COALESCE(VALUES(username), stats_user_daily_model_provider.username),
+  total_requests = VALUES(total_requests), total_tokens = VALUES(total_tokens),
+  total_cost = VALUES(total_cost), response_time_sum_ms = VALUES(response_time_sum_ms),
+  response_time_samples = VALUES(response_time_samples), updated_at = VALUES(updated_at)
+"#
+    );
+    sqlx::query(&user_model_provider_sql)
+        .bind(day_start)
+        .bind(now_unix_secs)
+        .bind(now_unix_secs)
+        .bind(start_unix_secs)
+        .bind(end_unix_secs)
+        .execute(&mut **tx)
+        .await
+        .map_sql_err()?;
+    Ok(())
+}
+
+async fn upsert_cost_savings_rows(
+    tx: &mut sqlx::Transaction<'_, MySql>,
+    day_start: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+    now_unix_secs: i64,
+) -> Result<(), DataLayerError> {
+    for (table, dimensions) in [
+        ("stats_daily_cost_savings", Vec::new()),
+        (
+            "stats_daily_cost_savings_provider",
+            vec![("provider_name", "COALESCE(usage.provider_name, '')")],
+        ),
+        (
+            "stats_daily_cost_savings_model",
+            vec![("model", "COALESCE(usage.model, '')")],
+        ),
+        (
+            "stats_daily_cost_savings_model_provider",
+            vec![
+                ("model", "COALESCE(usage.model, '')"),
+                ("provider_name", "COALESCE(usage.provider_name, '')"),
+            ],
+        ),
+    ] {
+        upsert_cost_savings_dimension(
+            tx,
+            table,
+            false,
+            &dimensions,
+            day_start,
+            start_unix_secs,
+            end_unix_secs,
+            now_unix_secs,
+        )
+        .await?;
+    }
+    for (table, dimensions) in [
+        ("stats_user_daily_cost_savings", Vec::new()),
+        (
+            "stats_user_daily_cost_savings_provider",
+            vec![("provider_name", "COALESCE(usage.provider_name, '')")],
+        ),
+        (
+            "stats_user_daily_cost_savings_model",
+            vec![("model", "COALESCE(usage.model, '')")],
+        ),
+        (
+            "stats_user_daily_cost_savings_model_provider",
+            vec![
+                ("model", "COALESCE(usage.model, '')"),
+                ("provider_name", "COALESCE(usage.provider_name, '')"),
+            ],
+        ),
+    ] {
+        upsert_cost_savings_dimension(
+            tx,
+            table,
+            true,
+            &dimensions,
+            day_start,
+            start_unix_secs,
+            end_unix_secs,
+            now_unix_secs,
+        )
+        .await?;
+    }
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn upsert_cost_savings_dimension(
+    tx: &mut sqlx::Transaction<'_, MySql>,
+    table: &str,
+    per_user: bool,
+    dimensions: &[(&str, &str)],
+    day_start: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+    now_unix_secs: i64,
+) -> Result<(), DataLayerError> {
+    let dimension_columns = dimensions
+        .iter()
+        .map(|(column, _)| *column)
+        .collect::<Vec<_>>();
+    let dimension_exprs = dimensions
+        .iter()
+        .map(|(_, expression)| *expression)
+        .collect::<Vec<_>>();
+    let user_columns = if per_user { "user_id, username, " } else { "" };
+    let user_select = if per_user {
+        "usage.user_id, MAX(COALESCE(usage.username, users.username)), "
+    } else {
+        ""
+    };
+    let user_join = if per_user {
+        "LEFT JOIN users ON users.id = usage.user_id"
+    } else {
+        ""
+    };
+    let user_filter = if per_user {
+        "AND usage.user_id IS NOT NULL AND usage.user_id <> ''"
+    } else {
+        ""
+    };
+    let mut group_by = Vec::new();
+    if per_user {
+        group_by.push("usage.user_id");
+    }
+    group_by.extend(dimension_exprs.iter().copied());
+    let dimension_columns_sql = if dimension_columns.is_empty() {
+        String::new()
+    } else {
+        format!("{}, ", dimension_columns.join(", "))
+    };
+    let dimension_select_sql = if dimension_exprs.is_empty() {
+        String::new()
+    } else {
+        format!("{}, ", dimension_exprs.join(", "))
+    };
+    let group_by_sql = if group_by.is_empty() {
+        String::new()
+    } else {
+        format!("GROUP BY {}", group_by.join(", "))
+    };
+    let sql = format!(
+        r#"
+INSERT INTO {table} (
+  id, {user_columns}`date`, {dimension_columns_sql}cache_read_tokens,
+  cache_read_cost, cache_creation_cost, estimated_full_cost, created_at, updated_at
+)
+SELECT SHA2(UUID(), 256), {user_select}?, {dimension_select_sql}
+  COALESCE(SUM(GREATEST(COALESCE(usage.cache_read_input_tokens, 0), 0)), 0),
+  COALESCE(SUM(COALESCE(usage.cache_read_cost_usd, 0)), 0),
+  COALESCE(SUM(COALESCE(usage.cache_creation_cost_usd, 0)), 0),
+  COALESCE(SUM(
+    COALESCE(settlement.input_price_per_1m, usage.input_price_per_1m, 0)
+      * GREATEST(COALESCE(usage.cache_read_input_tokens, 0), 0) / 1000000.0
+  ), 0), ?, ?
+FROM `usage` AS usage
+LEFT JOIN usage_settlement_snapshots AS settlement ON settlement.request_id = usage.request_id
+{user_join}
+WHERE usage.created_at_unix_ms >= ? AND usage.created_at_unix_ms < ? {user_filter}
+{group_by_sql}
+ON DUPLICATE KEY UPDATE
+  {}cache_read_tokens = VALUES(cache_read_tokens),
+  cache_read_cost = VALUES(cache_read_cost),
+  cache_creation_cost = VALUES(cache_creation_cost),
+  estimated_full_cost = VALUES(estimated_full_cost), updated_at = VALUES(updated_at)
+"#,
+        if per_user {
+            format!("username = COALESCE(VALUES(username), {table}.username), ")
+        } else {
+            String::new()
+        }
+    );
+    sqlx::query(&sql)
+        .bind(day_start)
+        .bind(now_unix_secs)
+        .bind(now_unix_secs)
+        .bind(start_unix_secs)
+        .bind(end_unix_secs)
+        .execute(&mut **tx)
+        .await
+        .map_sql_err()?;
+    Ok(())
+}
+
+async fn refresh_user_summary(
+    tx: &mut sqlx::Transaction<'_, MySql>,
+    cutoff_date: i64,
+    now_unix_secs: i64,
+) -> Result<(), DataLayerError> {
+    sqlx::query(
+        r#"
+INSERT INTO stats_user_summary (
+  id, user_id, username, cutoff_date, all_time_requests, all_time_success_requests,
+  all_time_error_requests, all_time_input_tokens, all_time_output_tokens,
+  all_time_cache_creation_tokens, all_time_cache_read_tokens, all_time_cost,
+  all_time_actual_cost, active_days, first_active_date, last_active_date,
+  created_at, updated_at
+)
+SELECT SHA2(UUID(), 256), user_id, MAX(username), ?,
+  COALESCE(SUM(total_requests), 0), COALESCE(SUM(success_requests), 0),
+  COALESCE(SUM(error_requests), 0), COALESCE(SUM(input_tokens), 0),
+  COALESCE(SUM(output_tokens), 0), COALESCE(SUM(cache_creation_tokens), 0),
+  COALESCE(SUM(cache_read_tokens), 0), COALESCE(SUM(total_cost), 0),
+  COALESCE(SUM(actual_total_cost), 0),
+  COALESCE(SUM(CASE WHEN total_requests > 0 THEN 1 ELSE 0 END), 0),
+  MIN(CASE WHEN total_requests > 0 THEN `date` END),
+  MAX(CASE WHEN total_requests > 0 THEN `date` END), ?, ?
+FROM stats_user_daily
+WHERE `date` < ?
+GROUP BY user_id
+ON DUPLICATE KEY UPDATE
+  username = COALESCE(VALUES(username), stats_user_summary.username),
+  cutoff_date = VALUES(cutoff_date), all_time_requests = VALUES(all_time_requests),
+  all_time_success_requests = VALUES(all_time_success_requests),
+  all_time_error_requests = VALUES(all_time_error_requests),
+  all_time_input_tokens = VALUES(all_time_input_tokens),
+  all_time_output_tokens = VALUES(all_time_output_tokens),
+  all_time_cache_creation_tokens = VALUES(all_time_cache_creation_tokens),
+  all_time_cache_read_tokens = VALUES(all_time_cache_read_tokens),
+  all_time_cost = VALUES(all_time_cost), all_time_actual_cost = VALUES(all_time_actual_cost),
+  active_days = VALUES(active_days), first_active_date = VALUES(first_active_date),
+  last_active_date = VALUES(last_active_date), updated_at = VALUES(updated_at)
+"#,
+    )
+    .bind(cutoff_date)
+    .bind(now_unix_secs)
+    .bind(now_unix_secs)
+    .bind(cutoff_date)
+    .execute(&mut **tx)
+    .await
+    .map_sql_err()?;
+    refresh_global_summary(tx, cutoff_date, now_unix_secs).await?;
+    Ok(())
+}
+
+async fn refresh_global_summary(
+    tx: &mut sqlx::Transaction<'_, MySql>,
+    cutoff_date: i64,
+    now_unix_secs: i64,
+) -> Result<(), DataLayerError> {
+    let existing_id: Option<String> =
+        sqlx::query_scalar("SELECT id FROM stats_summary ORDER BY created_at, id LIMIT 1")
+            .fetch_optional(&mut **tx)
+            .await
+            .map_sql_err()?;
+    let summary_id = existing_id.unwrap_or_else(|| stats_id("stats-summary"));
+    sqlx::query(
+        r#"
+INSERT INTO stats_summary (
+  id, cutoff_date, all_time_requests, all_time_success_requests,
+  all_time_error_requests, all_time_input_tokens, all_time_output_tokens,
+  all_time_cache_creation_tokens, all_time_cache_read_tokens, all_time_cost,
+  all_time_actual_cost, total_users, active_users, total_api_keys,
+  active_api_keys, created_at, updated_at
+)
+SELECT ?, ?, COALESCE(SUM(total_requests), 0), COALESCE(SUM(success_requests), 0),
+  COALESCE(SUM(error_requests), 0), COALESCE(SUM(input_tokens), 0),
+  COALESCE(SUM(output_tokens), 0), COALESCE(SUM(cache_creation_tokens), 0),
+  COALESCE(SUM(cache_read_tokens), 0), COALESCE(SUM(total_cost), 0),
+  COALESCE(SUM(actual_total_cost), 0),
+  (SELECT COUNT(*) FROM users),
+  (SELECT COUNT(*) FROM users WHERE is_active <> 0),
+  (SELECT COUNT(*) FROM api_keys),
+  (SELECT COUNT(*) FROM api_keys WHERE is_active <> 0), ?, ?
+FROM stats_daily
+WHERE `date` < ?
+ON DUPLICATE KEY UPDATE
+  cutoff_date = VALUES(cutoff_date),
+  all_time_requests = VALUES(all_time_requests),
+  all_time_success_requests = VALUES(all_time_success_requests),
+  all_time_error_requests = VALUES(all_time_error_requests),
+  all_time_input_tokens = VALUES(all_time_input_tokens),
+  all_time_output_tokens = VALUES(all_time_output_tokens),
+  all_time_cache_creation_tokens = VALUES(all_time_cache_creation_tokens),
+  all_time_cache_read_tokens = VALUES(all_time_cache_read_tokens),
+  all_time_cost = VALUES(all_time_cost),
+  all_time_actual_cost = VALUES(all_time_actual_cost),
+  total_users = VALUES(total_users), active_users = VALUES(active_users),
+  total_api_keys = VALUES(total_api_keys), active_api_keys = VALUES(active_api_keys),
+  updated_at = VALUES(updated_at)
+"#,
+    )
+    .bind(summary_id)
+    .bind(cutoff_date)
+    .bind(now_unix_secs)
+    .bind(now_unix_secs)
+    .bind(cutoff_date)
+    .execute(&mut **tx)
+    .await
+    .map_sql_err()?;
+    Ok(())
+}
@@ -1,7 +1,7 @@
 use chrono::{DateTime, Utc};
 use sqlx::Row;

-use crate::backend::stats_common::{stats_id, unix_ms, unix_secs, utc_from_unix_secs};
+use crate::backend::stats_common::{stats_id, unix_secs, utc_from_unix_secs};
 use crate::backend::SqliteBackend;
 use crate::driver::sqlite::{sqlite_real, SqlitePool};
 use crate::error::SqlResultExt;
@@ -10,6 +10,8 @@ use crate::{
    StatsHourlyAggregationInput, StatsHourlyAggregationSummary,
 };

+mod advanced;
+
 impl SqliteBackend {
    pub async fn aggregate_stats_hourly(
        &self,
@@ -64,7 +66,7 @@ async fn next_sqlite_stats_hourly_bucket(
    }
    let next_bucket: Option<i64> = sqlx::query_scalar(
        r#"
-SELECT MIN(CAST(created_at_unix_ms / 3600000 AS INTEGER) * 3600)
+SELECT MIN(CAST(created_at_unix_ms / 3600 AS INTEGER) * 3600)
 FROM "usage"
 WHERE created_at_unix_ms >= ?
  AND created_at_unix_ms < ?
@@ -72,8 +74,8 @@ WHERE created_at_unix_ms >= ?
  AND provider_name NOT IN ('unknown', 'pending')
 "#,
    )
-    .bind(unix_ms(search_from)?)
-    .bind(unix_ms(search_until)?)
+    .bind(search_from)
+    .bind(search_until)
    .fetch_one(pool)
    .await
    .map_sql_err()?;
@@ -96,7 +98,7 @@ async fn next_sqlite_stats_daily_bucket(
    }
    let next_bucket: Option<i64> = sqlx::query_scalar(
        r#"
-SELECT MIN(CAST(created_at_unix_ms / 86400000 AS INTEGER) * 86400)
+SELECT MIN(CAST(created_at_unix_ms / 86400 AS INTEGER) * 86400)
 FROM "usage"
 WHERE created_at_unix_ms >= ?
  AND created_at_unix_ms < ?
@@ -104,8 +106,8 @@ WHERE created_at_unix_ms >= ?
  AND provider_name NOT IN ('unknown', 'pending')
 "#,
    )
-    .bind(unix_ms(search_from)?)
-    .bind(unix_ms(search_until)?)
+    .bind(search_from)
+    .bind(search_until)
    .fetch_one(pool)
    .await
    .map_sql_err()?;
@@ -118,7 +120,7 @@ SELECT
  COALESCE(SUM(CASE
    WHEN status = 'failed'
      OR status_code >= 400
-      OR (error_category IS NOT NULL AND error_category <> '')
+      OR error_message IS NOT NULL
    THEN 1 ELSE 0 END), 0) AS error_requests,
  COALESCE(SUM(input_tokens), 0) AS input_tokens,
  COALESCE(SUM(output_tokens), 0) AS output_tokens,
@@ -139,13 +141,13 @@ async fn perform_sqlite_stats_hourly_aggregation(
    hour_utc_unix_secs: i64,
    aggregated_at: DateTime<Utc>,
 ) -> Result<StatsHourlyAggregationSummary, DataLayerError> {
-    let start_ms = unix_ms(hour_utc_unix_secs)?;
-    let end_ms = unix_ms(hour_utc_unix_secs + 3600)?;
+    let start_unix_secs = hour_utc_unix_secs;
+    let end_unix_secs = hour_utc_unix_secs + 3600;
    let aggregated_at_unix_secs = unix_secs(aggregated_at);
    let mut tx = pool.begin().await.map_sql_err()?;
    let row = sqlx::query(SQLITE_STATS_AGGREGATE_SQL)
-        .bind(start_ms)
-        .bind(end_ms)
+        .bind(start_unix_secs)
+        .bind(end_unix_secs)
        .fetch_one(&mut *tx)
        .await
        .map_sql_err()?;
@@ -198,10 +200,39 @@ ON CONFLICT (hour_utc) DO UPDATE SET
    .await
    .map_sql_err()?;

-    let user_rows = sqlite_group_count(&mut tx, "user_id", start_ms, end_ms).await?;
-    let user_model_rows = sqlite_group_count(&mut tx, "user_id, model", start_ms, end_ms).await?;
-    let model_rows = sqlite_group_count(&mut tx, "model", start_ms, end_ms).await?;
-    let provider_rows = sqlite_group_count(&mut tx, "provider_name", start_ms, end_ms).await?;
+    let user_rows = upsert_sqlite_stats_hourly_user_rows(
+        &mut tx,
+        hour_utc_unix_secs,
+        start_unix_secs,
+        end_unix_secs,
+        aggregated_at_unix_secs,
+    )
+    .await?;
+    let user_model_rows = upsert_sqlite_stats_hourly_user_model_rows(
+        &mut tx,
+        hour_utc_unix_secs,
+        start_unix_secs,
+        end_unix_secs,
+        aggregated_at_unix_secs,
+    )
+    .await?;
+    let model_rows = upsert_sqlite_stats_hourly_model_rows(
+        &mut tx,
+        hour_utc_unix_secs,
+        start_unix_secs,
+        end_unix_secs,
+        aggregated_at_unix_secs,
+    )
+    .await?;
+    let provider_rows = upsert_sqlite_stats_hourly_provider_rows(
+        &mut tx,
+        hour_utc_unix_secs,
+        start_unix_secs,
+        end_unix_secs,
+        aggregated_at_unix_secs,
+    )
+    .await?;
+    advanced::refresh_hourly(&mut tx, hour_utc_unix_secs, start_unix_secs, end_unix_secs).await?;
    tx.commit().await.map_sql_err()?;

    Ok(StatsHourlyAggregationSummary {
@@ -219,21 +250,24 @@ async fn perform_sqlite_stats_daily_aggregation(
    day_start_unix_secs: i64,
    aggregated_at: DateTime<Utc>,
 ) -> Result<StatsDailyAggregationSummary, DataLayerError> {
-    let start_ms = unix_ms(day_start_unix_secs)?;
-    let end_ms = unix_ms(day_start_unix_secs + 86_400)?;
+    let start_unix_secs = day_start_unix_secs;
+    let end_unix_secs = day_start_unix_secs + 86_400;
    let aggregated_at_unix_secs = unix_secs(aggregated_at);
    let mut tx = pool.begin().await.map_sql_err()?;
    let row = sqlx::query(SQLITE_STATS_AGGREGATE_SQL)
-        .bind(start_ms)
-        .bind(end_ms)
+        .bind(start_unix_secs)
+        .bind(end_unix_secs)
        .fetch_one(&mut *tx)
        .await
        .map_sql_err()?;
    let total_requests: i64 = row.try_get("total_requests").map_sql_err()?;
    let error_requests: i64 = row.try_get("error_requests").map_sql_err()?;
-    let unique_models = sqlite_group_count(&mut tx, "model", start_ms, end_ms).await? as i64;
+    let unique_models =
+        sqlite_group_count(&mut tx, "model", start_unix_secs, end_unix_secs).await? as i64;
    let unique_providers =
-        sqlite_group_count(&mut tx, "provider_name", start_ms, end_ms).await? as i64;
+        sqlite_group_count(&mut tx, "provider_name", start_unix_secs, end_unix_secs).await? as i64;
+    let fallback_count =
+        sqlite_daily_fallback_count(&mut tx, start_unix_secs, end_unix_secs).await?;

    sqlx::query(
        r#"
@@ -242,7 +276,7 @@ INSERT INTO stats_daily (
  input_tokens, output_tokens, cache_creation_tokens, cache_read_tokens,
  total_cost, actual_total_cost, avg_response_time_ms, fallback_count,
  unique_models, unique_providers, is_complete, aggregated_at, created_at, updated_at
-) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?, 1, ?, ?, ?)
+) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?, ?)
 ON CONFLICT ("date") DO UPDATE SET
  total_requests = excluded.total_requests,
  success_requests = excluded.success_requests,
@@ -277,6 +311,7 @@ ON CONFLICT ("date") DO UPDATE SET
    .bind(sqlite_real(&row, "total_cost")?)
    .bind(sqlite_real(&row, "actual_total_cost")?)
    .bind(sqlite_real(&row, "avg_response_time_ms")?)
+    .bind(fallback_count)
    .bind(unique_models)
    .bind(unique_providers)
    .bind(aggregated_at_unix_secs)
@@ -286,11 +321,54 @@ ON CONFLICT ("date") DO UPDATE SET
    .await
    .map_sql_err()?;

-    let model_rows = usize::try_from(unique_models).unwrap_or(usize::MAX);
-    let provider_rows = usize::try_from(unique_providers).unwrap_or(usize::MAX);
-    let api_key_rows = sqlite_group_count(&mut tx, "api_key_id", start_ms, end_ms).await?;
-    let error_rows = sqlite_error_group_count(&mut tx, start_ms, end_ms).await?;
-    let user_rows = sqlite_group_count(&mut tx, "user_id", start_ms, end_ms).await?;
+    let model_rows = upsert_sqlite_stats_daily_model_rows(
+        &mut tx,
+        day_start_unix_secs,
+        start_unix_secs,
+        end_unix_secs,
+        aggregated_at_unix_secs,
+    )
+    .await?;
+    let provider_rows = upsert_sqlite_stats_daily_provider_rows(
+        &mut tx,
+        day_start_unix_secs,
+        start_unix_secs,
+        end_unix_secs,
+        aggregated_at_unix_secs,
+    )
+    .await?;
+    let api_key_rows = upsert_sqlite_stats_daily_api_key_rows(
+        &mut tx,
+        day_start_unix_secs,
+        start_unix_secs,
+        end_unix_secs,
+        aggregated_at_unix_secs,
+    )
+    .await?;
+    let error_rows = refresh_sqlite_stats_daily_error_rows(
+        &mut tx,
+        day_start_unix_secs,
+        start_unix_secs,
+        end_unix_secs,
+        aggregated_at_unix_secs,
+    )
+    .await?;
+    let user_rows = upsert_sqlite_stats_user_daily_rows(
+        &mut tx,
+        day_start_unix_secs,
+        start_unix_secs,
+        end_unix_secs,
+        aggregated_at_unix_secs,
+    )
+    .await?;
+    advanced::refresh_daily(
+        &mut tx,
+        day_start_unix_secs,
+        start_unix_secs,
+        end_unix_secs,
+        aggregated_at_unix_secs,
+    )
+    .await?;
    tx.commit().await.map_sql_err()?;

    Ok(StatsDailyAggregationSummary {
@@ -304,11 +382,463 @@ ON CONFLICT ("date") DO UPDATE SET
    })
 }

+async fn upsert_sqlite_stats_hourly_user_rows(
+    tx: &mut sqlx::Transaction<'_, sqlx::Sqlite>,
+    hour_utc: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+    now_unix_secs: i64,
+) -> Result<usize, DataLayerError> {
+    let result = sqlx::query(
+        r#"
+INSERT INTO stats_hourly_user (
+  id, hour_utc, user_id, total_requests, success_requests, error_requests,
+  input_tokens, output_tokens, total_cost, created_at, updated_at
+)
+SELECT
+  lower(hex(randomblob(32))), ?, user_id, COUNT(*),
+  COUNT(*) - COALESCE(SUM(CASE
+    WHEN status = 'failed' OR status_code >= 400 OR error_message IS NOT NULL
+    THEN 1 ELSE 0 END), 0),
+  COALESCE(SUM(CASE
+    WHEN status = 'failed' OR status_code >= 400 OR error_message IS NOT NULL
+    THEN 1 ELSE 0 END), 0),
+  COALESCE(SUM(input_tokens), 0), COALESCE(SUM(output_tokens), 0),
+  CAST(COALESCE(SUM(total_cost_usd), 0) AS REAL), ?, ?
+FROM "usage"
+WHERE created_at_unix_ms >= ? AND created_at_unix_ms < ?
+  AND user_id IS NOT NULL AND user_id <> ''
+  AND status NOT IN ('pending', 'streaming')
+  AND provider_name NOT IN ('unknown', 'pending')
+GROUP BY user_id
+ON CONFLICT (hour_utc, user_id) DO UPDATE SET
+  total_requests = excluded.total_requests,
+  success_requests = excluded.success_requests,
+  error_requests = excluded.error_requests,
+  input_tokens = excluded.input_tokens,
+  output_tokens = excluded.output_tokens,
+  total_cost = excluded.total_cost,
+  updated_at = excluded.updated_at
+"#,
+    )
+    .bind(hour_utc)
+    .bind(now_unix_secs)
+    .bind(now_unix_secs)
+    .bind(start_unix_secs)
+    .bind(end_unix_secs)
+    .execute(&mut **tx)
+    .await
+    .map_sql_err()?;
+    Ok(usize::try_from(result.rows_affected()).unwrap_or(usize::MAX))
+}
+
+async fn upsert_sqlite_stats_hourly_user_model_rows(
+    tx: &mut sqlx::Transaction<'_, sqlx::Sqlite>,
+    hour_utc: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+    now_unix_secs: i64,
+) -> Result<usize, DataLayerError> {
+    let result = sqlx::query(
+        r#"
+INSERT INTO stats_hourly_user_model (
+  id, hour_utc, user_id, model, total_requests, input_tokens, output_tokens,
+  total_cost, created_at, updated_at
+)
+SELECT
+  lower(hex(randomblob(32))), ?, user_id, model, COUNT(*),
+  COALESCE(SUM(input_tokens), 0), COALESCE(SUM(output_tokens), 0),
+  CAST(COALESCE(SUM(total_cost_usd), 0) AS REAL), ?, ?
+FROM "usage"
+WHERE created_at_unix_ms >= ? AND created_at_unix_ms < ?
+  AND user_id IS NOT NULL AND user_id <> ''
+  AND model IS NOT NULL AND model <> ''
+  AND status NOT IN ('pending', 'streaming')
+  AND provider_name NOT IN ('unknown', 'pending')
+GROUP BY user_id, model
+ON CONFLICT (hour_utc, user_id, model) DO UPDATE SET
+  total_requests = excluded.total_requests,
+  input_tokens = excluded.input_tokens,
+  output_tokens = excluded.output_tokens,
+  total_cost = excluded.total_cost,
+  updated_at = excluded.updated_at
+"#,
+    )
+    .bind(hour_utc)
+    .bind(now_unix_secs)
+    .bind(now_unix_secs)
+    .bind(start_unix_secs)
+    .bind(end_unix_secs)
+    .execute(&mut **tx)
+    .await
+    .map_sql_err()?;
+    Ok(usize::try_from(result.rows_affected()).unwrap_or(usize::MAX))
+}
+
+async fn upsert_sqlite_stats_hourly_model_rows(
+    tx: &mut sqlx::Transaction<'_, sqlx::Sqlite>,
+    hour_utc: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+    now_unix_secs: i64,
+) -> Result<usize, DataLayerError> {
+    let result = sqlx::query(
+        r#"
+INSERT INTO stats_hourly_model (
+  id, hour_utc, model, total_requests, input_tokens, output_tokens, total_cost,
+  avg_response_time_ms, created_at, updated_at
+)
+SELECT
+  lower(hex(randomblob(32))), ?, model, COUNT(*),
+  COALESCE(SUM(input_tokens), 0), COALESCE(SUM(output_tokens), 0),
+  CAST(COALESCE(SUM(total_cost_usd), 0) AS REAL),
+  CAST(COALESCE(AVG(response_time_ms), 0) AS REAL), ?, ?
+FROM "usage"
+WHERE created_at_unix_ms >= ? AND created_at_unix_ms < ?
+  AND model IS NOT NULL AND model <> ''
+  AND status NOT IN ('pending', 'streaming')
+  AND provider_name NOT IN ('unknown', 'pending')
+GROUP BY model
+ON CONFLICT (hour_utc, model) DO UPDATE SET
+  total_requests = excluded.total_requests,
+  input_tokens = excluded.input_tokens,
+  output_tokens = excluded.output_tokens,
+  total_cost = excluded.total_cost,
+  avg_response_time_ms = excluded.avg_response_time_ms,
+  updated_at = excluded.updated_at
+"#,
+    )
+    .bind(hour_utc)
+    .bind(now_unix_secs)
+    .bind(now_unix_secs)
+    .bind(start_unix_secs)
+    .bind(end_unix_secs)
+    .execute(&mut **tx)
+    .await
+    .map_sql_err()?;
+    Ok(usize::try_from(result.rows_affected()).unwrap_or(usize::MAX))
+}
+
+async fn upsert_sqlite_stats_hourly_provider_rows(
+    tx: &mut sqlx::Transaction<'_, sqlx::Sqlite>,
+    hour_utc: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+    now_unix_secs: i64,
+) -> Result<usize, DataLayerError> {
+    let result = sqlx::query(
+        r#"
+INSERT INTO stats_hourly_provider (
+  id, hour_utc, provider_name, total_requests, input_tokens, output_tokens,
+  total_cost, created_at, updated_at
+)
+SELECT
+  lower(hex(randomblob(32))), ?, provider_name, COUNT(*),
+  COALESCE(SUM(input_tokens), 0), COALESCE(SUM(output_tokens), 0),
+  CAST(COALESCE(SUM(total_cost_usd), 0) AS REAL), ?, ?
+FROM "usage"
+WHERE created_at_unix_ms >= ? AND created_at_unix_ms < ?
+  AND status NOT IN ('pending', 'streaming')
+  AND provider_name NOT IN ('unknown', 'pending')
+GROUP BY provider_name
+ON CONFLICT (hour_utc, provider_name) DO UPDATE SET
+  total_requests = excluded.total_requests,
+  input_tokens = excluded.input_tokens,
+  output_tokens = excluded.output_tokens,
+  total_cost = excluded.total_cost,
+  updated_at = excluded.updated_at
+"#,
+    )
+    .bind(hour_utc)
+    .bind(now_unix_secs)
+    .bind(now_unix_secs)
+    .bind(start_unix_secs)
+    .bind(end_unix_secs)
+    .execute(&mut **tx)
+    .await
+    .map_sql_err()?;
+    Ok(usize::try_from(result.rows_affected()).unwrap_or(usize::MAX))
+}
+
+async fn upsert_sqlite_stats_daily_model_rows(
+    tx: &mut sqlx::Transaction<'_, sqlx::Sqlite>,
+    day_start: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+    now_unix_secs: i64,
+) -> Result<usize, DataLayerError> {
+    let result = sqlx::query(
+        r#"
+INSERT INTO stats_daily_model (
+  id, "date", model, total_requests, input_tokens, output_tokens,
+  cache_creation_tokens, cache_read_tokens, total_cost, avg_response_time_ms,
+  created_at, updated_at
+)
+SELECT
+  lower(hex(randomblob(32))), ?, model, COUNT(*),
+  COALESCE(SUM(input_tokens), 0), COALESCE(SUM(output_tokens), 0),
+  COALESCE(SUM(cache_creation_input_tokens), 0),
+  COALESCE(SUM(cache_read_input_tokens), 0),
+  CAST(COALESCE(SUM(total_cost_usd), 0) AS REAL),
+  CAST(COALESCE(AVG(response_time_ms), 0) AS REAL), ?, ?
+FROM "usage"
+WHERE created_at_unix_ms >= ? AND created_at_unix_ms < ?
+  AND model IS NOT NULL AND model <> ''
+  AND status NOT IN ('pending', 'streaming')
+  AND provider_name NOT IN ('unknown', 'pending')
+GROUP BY model
+ON CONFLICT ("date", model) DO UPDATE SET
+  total_requests = excluded.total_requests,
+  input_tokens = excluded.input_tokens,
+  output_tokens = excluded.output_tokens,
+  cache_creation_tokens = excluded.cache_creation_tokens,
+  cache_read_tokens = excluded.cache_read_tokens,
+  total_cost = excluded.total_cost,
+  avg_response_time_ms = excluded.avg_response_time_ms,
+  updated_at = excluded.updated_at
+"#,
+    )
+    .bind(day_start)
+    .bind(now_unix_secs)
+    .bind(now_unix_secs)
+    .bind(start_unix_secs)
+    .bind(end_unix_secs)
+    .execute(&mut **tx)
+    .await
+    .map_sql_err()?;
+    Ok(usize::try_from(result.rows_affected()).unwrap_or(usize::MAX))
+}
+
+async fn upsert_sqlite_stats_daily_provider_rows(
+    tx: &mut sqlx::Transaction<'_, sqlx::Sqlite>,
+    day_start: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+    now_unix_secs: i64,
+) -> Result<usize, DataLayerError> {
+    let result = sqlx::query(
+        r#"
+INSERT INTO stats_daily_provider (
+  id, "date", provider_name, total_requests, input_tokens, output_tokens,
+  cache_creation_tokens, cache_read_tokens, total_cost, created_at, updated_at
+)
+SELECT
+  lower(hex(randomblob(32))), ?, provider_name, COUNT(*),
+  COALESCE(SUM(input_tokens), 0), COALESCE(SUM(output_tokens), 0),
+  COALESCE(SUM(cache_creation_input_tokens), 0),
+  COALESCE(SUM(cache_read_input_tokens), 0),
+  CAST(COALESCE(SUM(total_cost_usd), 0) AS REAL), ?, ?
+FROM "usage"
+WHERE created_at_unix_ms >= ? AND created_at_unix_ms < ?
+  AND status NOT IN ('pending', 'streaming')
+  AND provider_name NOT IN ('unknown', 'pending')
+GROUP BY provider_name
+ON CONFLICT ("date", provider_name) DO UPDATE SET
+  total_requests = excluded.total_requests,
+  input_tokens = excluded.input_tokens,
+  output_tokens = excluded.output_tokens,
+  cache_creation_tokens = excluded.cache_creation_tokens,
+  cache_read_tokens = excluded.cache_read_tokens,
+  total_cost = excluded.total_cost,
+  updated_at = excluded.updated_at
+"#,
+    )
+    .bind(day_start)
+    .bind(now_unix_secs)
+    .bind(now_unix_secs)
+    .bind(start_unix_secs)
+    .bind(end_unix_secs)
+    .execute(&mut **tx)
+    .await
+    .map_sql_err()?;
+    Ok(usize::try_from(result.rows_affected()).unwrap_or(usize::MAX))
+}
+
+async fn upsert_sqlite_stats_daily_api_key_rows(
+    tx: &mut sqlx::Transaction<'_, sqlx::Sqlite>,
+    day_start: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+    now_unix_secs: i64,
+) -> Result<usize, DataLayerError> {
+    let result = sqlx::query(
+        r#"
+INSERT INTO stats_daily_api_key (
+  id, api_key_id, "date", total_requests, success_requests, error_requests,
+  input_tokens, output_tokens, cache_creation_tokens, cache_read_tokens,
+  total_cost, api_key_name, created_at, updated_at
+)
+SELECT
+  lower(hex(randomblob(32))), usage.api_key_id, ?, COUNT(*),
+  COUNT(*) - COALESCE(SUM(CASE
+    WHEN usage.status = 'failed' OR usage.status_code >= 400
+      OR usage.error_message IS NOT NULL THEN 1 ELSE 0 END), 0),
+  COALESCE(SUM(CASE
+    WHEN usage.status = 'failed' OR usage.status_code >= 400
+      OR usage.error_message IS NOT NULL THEN 1 ELSE 0 END), 0),
+  COALESCE(SUM(usage.input_tokens), 0), COALESCE(SUM(usage.output_tokens), 0),
+  COALESCE(SUM(usage.cache_creation_input_tokens), 0),
+  COALESCE(SUM(usage.cache_read_input_tokens), 0),
+  CAST(COALESCE(SUM(usage.total_cost_usd), 0) AS REAL), MAX(api_keys.name), ?, ?
+FROM "usage" AS usage
+LEFT JOIN api_keys ON api_keys.id = usage.api_key_id
+WHERE usage.created_at_unix_ms >= ? AND usage.created_at_unix_ms < ?
+  AND usage.api_key_id IS NOT NULL AND usage.api_key_id <> ''
+GROUP BY usage.api_key_id
+ON CONFLICT ("date", api_key_id) DO UPDATE SET
+  total_requests = excluded.total_requests,
+  success_requests = excluded.success_requests,
+  error_requests = excluded.error_requests,
+  input_tokens = excluded.input_tokens,
+  output_tokens = excluded.output_tokens,
+  cache_creation_tokens = excluded.cache_creation_tokens,
+  cache_read_tokens = excluded.cache_read_tokens,
+  total_cost = excluded.total_cost,
+  api_key_name = COALESCE(excluded.api_key_name, stats_daily_api_key.api_key_name),
+  updated_at = excluded.updated_at
+"#,
+    )
+    .bind(day_start)
+    .bind(now_unix_secs)
+    .bind(now_unix_secs)
+    .bind(start_unix_secs)
+    .bind(end_unix_secs)
+    .execute(&mut **tx)
+    .await
+    .map_sql_err()?;
+    Ok(usize::try_from(result.rows_affected()).unwrap_or(usize::MAX))
+}
+
+async fn refresh_sqlite_stats_daily_error_rows(
+    tx: &mut sqlx::Transaction<'_, sqlx::Sqlite>,
+    day_start: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+    now_unix_secs: i64,
+) -> Result<usize, DataLayerError> {
+    sqlx::query(r#"DELETE FROM stats_daily_error WHERE "date" = ?"#)
+        .bind(day_start)
+        .execute(&mut **tx)
+        .await
+        .map_sql_err()?;
+    let result = sqlx::query(
+        r#"
+INSERT INTO stats_daily_error (
+  id, "date", error_category, provider_name, model, count, created_at, updated_at
+)
+SELECT
+  lower(hex(randomblob(32))), ?, error_category, provider_name, model,
+  COUNT(*), ?, ?
+FROM "usage"
+WHERE created_at_unix_ms >= ? AND created_at_unix_ms < ?
+  AND error_category IS NOT NULL AND error_category <> ''
+GROUP BY error_category, provider_name, model
+"#,
+    )
+    .bind(day_start)
+    .bind(now_unix_secs)
+    .bind(now_unix_secs)
+    .bind(start_unix_secs)
+    .bind(end_unix_secs)
+    .execute(&mut **tx)
+    .await
+    .map_sql_err()?;
+    Ok(usize::try_from(result.rows_affected()).unwrap_or(usize::MAX))
+}
+
+async fn upsert_sqlite_stats_user_daily_rows(
+    tx: &mut sqlx::Transaction<'_, sqlx::Sqlite>,
+    day_start: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+    now_unix_secs: i64,
+) -> Result<usize, DataLayerError> {
+    let result = sqlx::query(
+        r#"
+INSERT INTO stats_user_daily (
+  id, user_id, "date", total_requests, success_requests, error_requests,
+  input_tokens, output_tokens, cache_creation_tokens, cache_read_tokens,
+  total_cost, username, created_at, updated_at
+)
+SELECT
+  lower(hex(randomblob(32))), usage.user_id, ?, COUNT(*),
+  COUNT(*) - COALESCE(SUM(CASE
+    WHEN usage.status = 'failed' OR usage.status_code >= 400
+      OR usage.error_message IS NOT NULL THEN 1 ELSE 0 END), 0),
+  COALESCE(SUM(CASE
+    WHEN usage.status = 'failed' OR usage.status_code >= 400
+      OR usage.error_message IS NOT NULL THEN 1 ELSE 0 END), 0),
+  COALESCE(SUM(usage.input_tokens), 0), COALESCE(SUM(usage.output_tokens), 0),
+  COALESCE(SUM(usage.cache_creation_input_tokens), 0),
+  COALESCE(SUM(usage.cache_read_input_tokens), 0),
+  CAST(COALESCE(SUM(usage.total_cost_usd), 0) AS REAL), MAX(users.username), ?, ?
+FROM "usage" AS usage
+LEFT JOIN users ON users.id = usage.user_id
+WHERE usage.created_at_unix_ms >= ? AND usage.created_at_unix_ms < ?
+  AND usage.user_id IS NOT NULL AND usage.user_id <> ''
+  AND usage.status NOT IN ('pending', 'streaming')
+  AND usage.provider_name NOT IN ('unknown', 'pending')
+GROUP BY usage.user_id
+ON CONFLICT ("date", user_id) DO UPDATE SET
+  total_requests = excluded.total_requests,
+  success_requests = excluded.success_requests,
+  error_requests = excluded.error_requests,
+  input_tokens = excluded.input_tokens,
+  output_tokens = excluded.output_tokens,
+  cache_creation_tokens = excluded.cache_creation_tokens,
+  cache_read_tokens = excluded.cache_read_tokens,
+  total_cost = excluded.total_cost,
+  username = COALESCE(excluded.username, stats_user_daily.username),
+  updated_at = excluded.updated_at
+"#,
+    )
+    .bind(day_start)
+    .bind(now_unix_secs)
+    .bind(now_unix_secs)
+    .bind(start_unix_secs)
+    .bind(end_unix_secs)
+    .execute(&mut **tx)
+    .await
+    .map_sql_err()?;
+    Ok(usize::try_from(result.rows_affected()).unwrap_or(usize::MAX))
+}
+
+async fn sqlite_daily_fallback_count(
+    tx: &mut sqlx::Transaction<'_, sqlx::Sqlite>,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+) -> Result<i64, DataLayerError> {
+    let start_unix_ms = start_unix_secs.checked_mul(1000).ok_or_else(|| {
+        DataLayerError::InvalidInput("stats fallback window start overflows milliseconds".into())
+    })?;
+    let end_unix_ms = end_unix_secs.checked_mul(1000).ok_or_else(|| {
+        DataLayerError::InvalidInput("stats fallback window end overflows milliseconds".into())
+    })?;
+    sqlx::query_scalar(
+        r#"
+SELECT COUNT(*)
+FROM (
+  SELECT request_id
+  FROM request_candidates
+  WHERE created_at >= ? AND created_at < ?
+    AND status IN ('success', 'failed')
+  GROUP BY request_id
+  HAVING COUNT(id) > 1
+)
+"#,
+    )
+    .bind(start_unix_ms)
+    .bind(end_unix_ms)
+    .fetch_one(&mut **tx)
+    .await
+    .map_sql_err()
+}
+
 async fn sqlite_group_count(
    tx: &mut sqlx::Transaction<'_, sqlx::Sqlite>,
    group_columns: &str,
-    start_ms: i64,
-    end_ms: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
 ) -> Result<usize, DataLayerError> {
    let not_empty = group_columns
        .split(',')
@@ -332,42 +862,10 @@ FROM (
 "#
    );
    let count: i64 = sqlx::query_scalar(&sql)
-        .bind(start_ms)
-        .bind(end_ms)
+        .bind(start_unix_secs)
+        .bind(end_unix_secs)
        .fetch_one(&mut **tx)
        .await
        .map_sql_err()?;
    Ok(usize::try_from(count.max(0)).unwrap_or(usize::MAX))
 }
-
-async fn sqlite_error_group_count(
-    tx: &mut sqlx::Transaction<'_, sqlx::Sqlite>,
-    start_ms: i64,
-    end_ms: i64,
-) -> Result<usize, DataLayerError> {
-    let count: i64 = sqlx::query_scalar(
-        r#"
-SELECT COUNT(*)
-FROM (
-  SELECT 1
-  FROM "usage"
-  WHERE created_at_unix_ms >= ?
-    AND created_at_unix_ms < ?
-    AND status NOT IN ('pending', 'streaming')
-    AND provider_name NOT IN ('unknown', 'pending')
-    AND (
-      status = 'failed'
-      OR status_code >= 400
-      OR (error_category IS NOT NULL AND error_category <> '')
-    )
-  GROUP BY COALESCE(NULLIF(error_category, ''), 'unknown_error'), provider_name, model
-)
-"#,
-    )
-    .bind(start_ms)
-    .bind(end_ms)
-    .fetch_one(&mut **tx)
-    .await
-    .map_sql_err()?;
-    Ok(usize::try_from(count.max(0)).unwrap_or(usize::MAX))
-}
@@ -0,0 +1,986 @@
+use sqlx::Sqlite;
+
+use crate::backend::stats_common::stats_id;
+use crate::error::SqlResultExt;
+use crate::DataLayerError;
+
+const CACHE_5M: &str = r#"MAX(
+    COALESCE(usage.cache_creation_input_tokens_5m, 0),
+    COALESCE(usage.cache_creation_ephemeral_5m_input_tokens, 0)
+)"#;
+const CACHE_1H: &str = r#"MAX(
+    COALESCE(usage.cache_creation_input_tokens_1h, 0),
+    COALESCE(usage.cache_creation_ephemeral_1h_input_tokens, 0)
+)"#;
+const CACHE_CREATION: &str = r#"CASE
+    WHEN COALESCE(usage.cache_creation_input_tokens, 0) = 0
+      AND ({cache_5m} + {cache_1h}) > 0
+    THEN {cache_5m} + {cache_1h}
+    ELSE MAX(COALESCE(usage.cache_creation_input_tokens, 0), 0)
+END"#;
+const EFFECTIVE_INPUT: &str = r#"CASE
+    WHEN (
+        LOWER(COALESCE(usage.endpoint_api_format, usage.api_format, '')) IN ('openai', 'gemini', 'google')
+        OR LOWER(COALESCE(usage.endpoint_api_format, usage.api_format, '')) LIKE 'openai:%'
+        OR LOWER(COALESCE(usage.endpoint_api_format, usage.api_format, '')) LIKE 'gemini:%'
+        OR LOWER(COALESCE(usage.endpoint_api_format, usage.api_format, '')) LIKE 'google:%'
+    )
+      AND COALESCE(usage.input_tokens, 0) > 0
+      AND COALESCE(usage.cache_read_input_tokens, 0) > 0
+    THEN MAX(COALESCE(usage.input_tokens, 0) - COALESCE(usage.cache_read_input_tokens, 0), 0)
+    ELSE MAX(COALESCE(usage.input_tokens, 0), 0)
+END"#;
+const SUCCESS: &str = r#"CASE
+    WHEN usage.status <> 'failed'
+      AND (usage.status_code IS NULL OR usage.status_code < 400)
+      AND usage.error_message IS NULL
+    THEN 1 ELSE 0
+END"#;
+const AGGREGATABLE: &str = r#"usage.status NOT IN ('pending', 'streaming')
+    AND usage.provider_name NOT IN ('unknown', 'pending')"#;
+const SETTLED: &str = r#"COALESCE(settlement.billing_status, usage.billing_status) = 'settled'
+    AND COALESCE(settlement.billing_total_cost_usd, usage.total_cost_usd, 0) > 0"#;
+
+fn cache_creation_expr() -> String {
+    CACHE_CREATION
+        .replace("{cache_5m}", CACHE_5M)
+        .replace("{cache_1h}", CACHE_1H)
+}
+
+fn total_input_context_expr() -> String {
+    format!(
+        "({EFFECTIVE_INPUT}) + ({}) + MAX(COALESCE(usage.cache_read_input_tokens, 0), 0)",
+        cache_creation_expr()
+    )
+}
+
+fn total_tokens_expr() -> String {
+    format!(
+        r#"COALESCE(
+    NULLIF(MAX(COALESCE(usage.total_tokens, 0), 0), 0),
+    ({EFFECTIVE_INPUT})
+      + MAX(COALESCE(usage.output_tokens, 0), 0)
+      + ({})
+      + MAX(COALESCE(usage.cache_read_input_tokens, 0), 0),
+    0
+)"#,
+        cache_creation_expr()
+    )
+}
+
+fn percentile_cont(sorted: &[i64], percentile: f64) -> Option<i64> {
+    if sorted.is_empty() {
+        return None;
+    }
+    let position = percentile * (sorted.len().saturating_sub(1) as f64);
+    let lower = position.floor() as usize;
+    let upper = position.ceil() as usize;
+    let fraction = position - lower as f64;
+    let value = sorted[lower] as f64 + (sorted[upper] - sorted[lower]) as f64 * fraction;
+    Some(value.round() as i64)
+}
+
+async fn load_percentiles(
+    tx: &mut sqlx::Transaction<'_, Sqlite>,
+    column: &str,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+) -> Result<(Option<i64>, Option<i64>, Option<i64>), DataLayerError> {
+    let sql = format!(
+        r#"
+SELECT {column}
+FROM "usage"
+WHERE created_at_unix_ms >= ? AND created_at_unix_ms < ?
+  AND status = 'completed'
+  AND provider_name NOT IN ('unknown', 'pending')
+  AND {column} IS NOT NULL
+ORDER BY {column}
+"#
+    );
+    let values: Vec<i64> = sqlx::query_scalar(&sql)
+        .bind(start_unix_secs)
+        .bind(end_unix_secs)
+        .fetch_all(&mut **tx)
+        .await
+        .map_sql_err()?;
+    if values.len() < 10 {
+        return Ok((None, None, None));
+    }
+    Ok((
+        percentile_cont(&values, 0.50),
+        percentile_cont(&values, 0.90),
+        percentile_cont(&values, 0.99),
+    ))
+}
+
+pub(super) async fn refresh_hourly(
+    tx: &mut sqlx::Transaction<'_, Sqlite>,
+    hour_utc: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+) -> Result<(), DataLayerError> {
+    let cache_creation = cache_creation_expr();
+    let total_context = total_input_context_expr();
+    let sql = format!(
+        r#"
+UPDATE stats_hourly AS target
+SET
+  cache_hit_total_requests = aggregated.cache_hit_total_requests,
+  cache_hit_requests = aggregated.cache_hit_requests,
+  completed_total_requests = aggregated.completed_total_requests,
+  completed_cache_hit_requests = aggregated.completed_cache_hit_requests,
+  completed_input_tokens = aggregated.completed_input_tokens,
+  completed_cache_creation_tokens = aggregated.completed_cache_creation_tokens,
+  completed_cache_read_tokens = aggregated.completed_cache_read_tokens,
+  completed_total_input_context = aggregated.completed_total_input_context,
+  completed_cache_creation_cost = aggregated.completed_cache_creation_cost,
+  completed_cache_read_cost = aggregated.completed_cache_read_cost,
+  settled_total_cost = aggregated.settled_total_cost,
+  settled_total_requests = aggregated.settled_total_requests,
+  settled_input_tokens = aggregated.settled_input_tokens,
+  settled_output_tokens = aggregated.settled_output_tokens,
+  settled_cache_creation_tokens = aggregated.settled_cache_creation_tokens,
+  settled_cache_read_tokens = aggregated.settled_cache_read_tokens,
+  settled_first_finalized_at_unix_secs = aggregated.settled_first_finalized_at_unix_secs,
+  settled_last_finalized_at_unix_secs = aggregated.settled_last_finalized_at_unix_secs,
+  response_time_sum_ms = aggregated.response_time_sum_ms,
+  response_time_samples = aggregated.response_time_samples
+FROM (
+  SELECT
+    COUNT(*) AS cache_hit_total_requests,
+    COALESCE(SUM(CASE WHEN COALESCE(usage.cache_read_input_tokens, 0) > 0 THEN 1 ELSE 0 END), 0) AS cache_hit_requests,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' THEN 1 ELSE 0 END), 0) AS completed_total_requests,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' AND COALESCE(usage.cache_read_input_tokens, 0) > 0 THEN 1 ELSE 0 END), 0) AS completed_cache_hit_requests,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' THEN MAX(COALESCE(usage.input_tokens, 0), 0) ELSE 0 END), 0) AS completed_input_tokens,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' THEN ({cache_creation}) ELSE 0 END), 0) AS completed_cache_creation_tokens,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' THEN MAX(COALESCE(usage.cache_read_input_tokens, 0), 0) ELSE 0 END), 0) AS completed_cache_read_tokens,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' THEN ({total_context}) ELSE 0 END), 0) AS completed_total_input_context,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' THEN COALESCE(usage.cache_creation_cost_usd, 0) ELSE 0 END), 0) AS completed_cache_creation_cost,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' THEN COALESCE(usage.cache_read_cost_usd, 0) ELSE 0 END), 0) AS completed_cache_read_cost,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN COALESCE(settlement.billing_total_cost_usd, usage.total_cost_usd, 0) ELSE 0 END), 0) AS settled_total_cost,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN 1 ELSE 0 END), 0) AS settled_total_requests,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN MAX(COALESCE(usage.input_tokens, 0), 0) ELSE 0 END), 0) AS settled_input_tokens,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN MAX(COALESCE(usage.output_tokens, 0), 0) ELSE 0 END), 0) AS settled_output_tokens,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN ({cache_creation}) ELSE 0 END), 0) AS settled_cache_creation_tokens,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN MAX(COALESCE(usage.cache_read_input_tokens, 0), 0) ELSE 0 END), 0) AS settled_cache_read_tokens,
+    MIN(CASE WHEN {SETTLED} THEN COALESCE(settlement.finalized_at, usage.finalized_at) END) AS settled_first_finalized_at_unix_secs,
+    MAX(CASE WHEN {SETTLED} THEN COALESCE(settlement.finalized_at, usage.finalized_at) END) AS settled_last_finalized_at_unix_secs,
+    COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL AND {AGGREGATABLE} THEN MAX(usage.response_time_ms, 0) ELSE 0 END), 0) AS response_time_sum_ms,
+    COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL AND {AGGREGATABLE} THEN 1 ELSE 0 END), 0) AS response_time_samples
+  FROM "usage" AS usage
+  LEFT JOIN usage_settlement_snapshots AS settlement ON settlement.request_id = usage.request_id
+  WHERE usage.created_at_unix_ms >= ? AND usage.created_at_unix_ms < ?
+) AS aggregated
+WHERE target.hour_utc = ?
+"#
+    );
+    sqlx::query(&sql)
+        .bind(start_unix_secs)
+        .bind(end_unix_secs)
+        .bind(hour_utc)
+        .execute(&mut **tx)
+        .await
+        .map_sql_err()?;
+
+    refresh_hourly_user(tx, hour_utc, start_unix_secs, end_unix_secs).await?;
+    refresh_hourly_response_dimensions(tx, hour_utc, start_unix_secs, end_unix_secs).await
+}
+
+async fn refresh_hourly_user(
+    tx: &mut sqlx::Transaction<'_, Sqlite>,
+    hour_utc: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+) -> Result<(), DataLayerError> {
+    let cache_creation = cache_creation_expr();
+    let sql = format!(
+        r#"
+UPDATE stats_hourly_user AS target
+SET
+  cache_creation_tokens = aggregated.cache_creation_tokens,
+  cache_read_tokens = aggregated.cache_read_tokens,
+  actual_total_cost = aggregated.actual_total_cost,
+  response_time_sum_ms = aggregated.response_time_sum_ms,
+  response_time_samples = aggregated.response_time_samples,
+  settled_total_cost = aggregated.settled_total_cost,
+  settled_total_requests = aggregated.settled_total_requests,
+  settled_input_tokens = aggregated.settled_input_tokens,
+  settled_output_tokens = aggregated.settled_output_tokens,
+  settled_cache_creation_tokens = aggregated.settled_cache_creation_tokens,
+  settled_cache_read_tokens = aggregated.settled_cache_read_tokens,
+  settled_first_finalized_at_unix_secs = aggregated.settled_first_finalized_at_unix_secs,
+  settled_last_finalized_at_unix_secs = aggregated.settled_last_finalized_at_unix_secs
+FROM (
+  SELECT
+    usage.user_id,
+    COALESCE(SUM({cache_creation}), 0) AS cache_creation_tokens,
+    COALESCE(SUM(MAX(COALESCE(usage.cache_read_input_tokens, 0), 0)), 0) AS cache_read_tokens,
+    COALESCE(SUM(COALESCE(settlement.billing_actual_total_cost_usd, usage.actual_total_cost_usd, 0)), 0) AS actual_total_cost,
+    COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL THEN MAX(usage.response_time_ms, 0) ELSE 0 END), 0) AS response_time_sum_ms,
+    COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL THEN 1 ELSE 0 END), 0) AS response_time_samples,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN COALESCE(settlement.billing_total_cost_usd, usage.total_cost_usd, 0) ELSE 0 END), 0) AS settled_total_cost,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN 1 ELSE 0 END), 0) AS settled_total_requests,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN MAX(COALESCE(usage.input_tokens, 0), 0) ELSE 0 END), 0) AS settled_input_tokens,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN MAX(COALESCE(usage.output_tokens, 0), 0) ELSE 0 END), 0) AS settled_output_tokens,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN ({cache_creation}) ELSE 0 END), 0) AS settled_cache_creation_tokens,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN MAX(COALESCE(usage.cache_read_input_tokens, 0), 0) ELSE 0 END), 0) AS settled_cache_read_tokens,
+    MIN(CASE WHEN {SETTLED} THEN COALESCE(settlement.finalized_at, usage.finalized_at) END) AS settled_first_finalized_at_unix_secs,
+    MAX(CASE WHEN {SETTLED} THEN COALESCE(settlement.finalized_at, usage.finalized_at) END) AS settled_last_finalized_at_unix_secs
+  FROM "usage" AS usage
+  LEFT JOIN usage_settlement_snapshots AS settlement ON settlement.request_id = usage.request_id
+  WHERE usage.created_at_unix_ms >= ? AND usage.created_at_unix_ms < ?
+    AND usage.user_id IS NOT NULL AND usage.user_id <> '' AND {AGGREGATABLE}
+  GROUP BY usage.user_id
+) AS aggregated
+WHERE target.hour_utc = ? AND target.user_id = aggregated.user_id
+"#
+    );
+    sqlx::query(&sql)
+        .bind(start_unix_secs)
+        .bind(end_unix_secs)
+        .bind(hour_utc)
+        .execute(&mut **tx)
+        .await
+        .map_sql_err()?;
+    Ok(())
+}
+
+async fn refresh_hourly_response_dimensions(
+    tx: &mut sqlx::Transaction<'_, Sqlite>,
+    hour_utc: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+) -> Result<(), DataLayerError> {
+    for (table, dimensions, group_by, target_match) in [
+        (
+            "stats_hourly_model",
+            "usage.model AS model",
+            "usage.model",
+            "target.model = aggregated.model",
+        ),
+        (
+            "stats_hourly_user_model",
+            "usage.user_id AS user_id, usage.model AS model",
+            "usage.user_id, usage.model",
+            "target.user_id = aggregated.user_id AND target.model = aggregated.model",
+        ),
+    ] {
+        let sql = format!(
+            r#"
+UPDATE {table} AS target
+SET response_time_sum_ms = aggregated.response_time_sum_ms,
+    response_time_samples = aggregated.response_time_samples
+FROM (
+  SELECT {dimensions},
+    COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL THEN MAX(usage.response_time_ms, 0) ELSE 0 END), 0) AS response_time_sum_ms,
+    COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL THEN 1 ELSE 0 END), 0) AS response_time_samples
+  FROM "usage" AS usage
+  WHERE usage.created_at_unix_ms >= ? AND usage.created_at_unix_ms < ?
+    AND {AGGREGATABLE}
+  GROUP BY {group_by}
+) AS aggregated
+WHERE target.hour_utc = ? AND {target_match}
+"#
+        );
+        sqlx::query(&sql)
+            .bind(start_unix_secs)
+            .bind(end_unix_secs)
+            .bind(hour_utc)
+            .execute(&mut **tx)
+            .await
+            .map_sql_err()?;
+    }
+    Ok(())
+}
+
+pub(super) async fn refresh_daily(
+    tx: &mut sqlx::Transaction<'_, Sqlite>,
+    day_start: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+    now_unix_secs: i64,
+) -> Result<(), DataLayerError> {
+    let response = load_percentiles(tx, "response_time_ms", start_unix_secs, end_unix_secs).await?;
+    let first_byte =
+        load_percentiles(tx, "first_byte_time_ms", start_unix_secs, end_unix_secs).await?;
+    refresh_daily_root(
+        tx,
+        day_start,
+        start_unix_secs,
+        end_unix_secs,
+        response,
+        first_byte,
+    )
+    .await?;
+    refresh_daily_existing_dimensions(tx, day_start, start_unix_secs, end_unix_secs).await?;
+    upsert_user_dimension(
+        tx,
+        "stats_user_daily_model",
+        "model",
+        "usage.model",
+        "usage.model IS NOT NULL AND usage.model <> ''",
+        day_start,
+        start_unix_secs,
+        end_unix_secs,
+        now_unix_secs,
+    )
+    .await?;
+    upsert_user_dimension(
+        tx,
+        "stats_user_daily_provider",
+        "provider_name",
+        "usage.provider_name",
+        "usage.provider_name IS NOT NULL AND usage.provider_name <> ''",
+        day_start,
+        start_unix_secs,
+        end_unix_secs,
+        now_unix_secs,
+    )
+    .await?;
+    upsert_user_dimension(
+        tx,
+        "stats_user_daily_api_format",
+        "api_format",
+        "LOWER(COALESCE(usage.endpoint_api_format, usage.api_format, ''))",
+        "COALESCE(usage.endpoint_api_format, usage.api_format, '') <> ''",
+        day_start,
+        start_unix_secs,
+        end_unix_secs,
+        now_unix_secs,
+    )
+    .await?;
+    upsert_model_provider_rows(tx, day_start, start_unix_secs, end_unix_secs, now_unix_secs)
+        .await?;
+    upsert_cost_savings_rows(tx, day_start, start_unix_secs, end_unix_secs, now_unix_secs).await?;
+    refresh_user_summary(tx, end_unix_secs, now_unix_secs).await
+}
+
+async fn refresh_daily_root(
+    tx: &mut sqlx::Transaction<'_, Sqlite>,
+    day_start: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+    response: (Option<i64>, Option<i64>, Option<i64>),
+    first_byte: (Option<i64>, Option<i64>, Option<i64>),
+) -> Result<(), DataLayerError> {
+    let cache_creation = cache_creation_expr();
+    let total_context = total_input_context_expr();
+    let sql = format!(
+        r#"
+UPDATE stats_daily AS target
+SET
+  effective_input_tokens = aggregated.effective_input_tokens,
+  total_input_context = aggregated.total_input_context,
+  response_time_sum_ms = aggregated.response_time_sum_ms,
+  response_time_samples = aggregated.response_time_samples,
+  cache_creation_ephemeral_5m_tokens = aggregated.cache_creation_ephemeral_5m_tokens,
+  cache_creation_ephemeral_1h_tokens = aggregated.cache_creation_ephemeral_1h_tokens,
+  input_cost = aggregated.input_cost,
+  output_cost = aggregated.output_cost,
+  cache_creation_cost = aggregated.cache_creation_cost,
+  cache_read_cost = aggregated.cache_read_cost,
+  cache_hit_total_requests = aggregated.cache_hit_total_requests,
+  cache_hit_requests = aggregated.cache_hit_requests,
+  completed_total_requests = aggregated.completed_total_requests,
+  completed_cache_hit_requests = aggregated.completed_cache_hit_requests,
+  completed_input_tokens = aggregated.completed_input_tokens,
+  completed_cache_creation_tokens = aggregated.completed_cache_creation_tokens,
+  completed_cache_read_tokens = aggregated.completed_cache_read_tokens,
+  completed_total_input_context = aggregated.completed_total_input_context,
+  completed_cache_creation_cost = aggregated.completed_cache_creation_cost,
+  completed_cache_read_cost = aggregated.completed_cache_read_cost,
+  settled_total_cost = aggregated.settled_total_cost,
+  settled_total_requests = aggregated.settled_total_requests,
+  settled_input_tokens = aggregated.settled_input_tokens,
+  settled_output_tokens = aggregated.settled_output_tokens,
+  settled_cache_creation_tokens = aggregated.settled_cache_creation_tokens,
+  settled_cache_read_tokens = aggregated.settled_cache_read_tokens,
+  settled_first_finalized_at_unix_secs = aggregated.settled_first_finalized_at_unix_secs,
+  settled_last_finalized_at_unix_secs = aggregated.settled_last_finalized_at_unix_secs,
+  p50_response_time_ms = ?, p90_response_time_ms = ?, p99_response_time_ms = ?,
+  p50_first_byte_time_ms = ?, p90_first_byte_time_ms = ?, p99_first_byte_time_ms = ?
+FROM (
+  SELECT
+    COALESCE(SUM(CASE WHEN {AGGREGATABLE} THEN ({EFFECTIVE_INPUT}) ELSE 0 END), 0) AS effective_input_tokens,
+    COALESCE(SUM(CASE WHEN {AGGREGATABLE} THEN ({total_context}) ELSE 0 END), 0) AS total_input_context,
+    COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL AND {AGGREGATABLE} THEN MAX(usage.response_time_ms, 0) ELSE 0 END), 0) AS response_time_sum_ms,
+    COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL AND {AGGREGATABLE} THEN 1 ELSE 0 END), 0) AS response_time_samples,
+    COALESCE(SUM(CASE WHEN {AGGREGATABLE} THEN {CACHE_5M} ELSE 0 END), 0) AS cache_creation_ephemeral_5m_tokens,
+    COALESCE(SUM(CASE WHEN {AGGREGATABLE} THEN {CACHE_1H} ELSE 0 END), 0) AS cache_creation_ephemeral_1h_tokens,
+    COALESCE(SUM(CASE WHEN {AGGREGATABLE} THEN COALESCE(usage.input_cost_usd, 0) ELSE 0 END), 0) AS input_cost,
+    COALESCE(SUM(CASE WHEN {AGGREGATABLE} THEN COALESCE(usage.output_cost_usd, 0) ELSE 0 END), 0) AS output_cost,
+    COALESCE(SUM(CASE WHEN {AGGREGATABLE} THEN COALESCE(usage.cache_creation_cost_usd, 0) ELSE 0 END), 0) AS cache_creation_cost,
+    COALESCE(SUM(CASE WHEN {AGGREGATABLE} THEN COALESCE(usage.cache_read_cost_usd, 0) ELSE 0 END), 0) AS cache_read_cost,
+    COUNT(*) AS cache_hit_total_requests,
+    COALESCE(SUM(CASE WHEN COALESCE(usage.cache_read_input_tokens, 0) > 0 THEN 1 ELSE 0 END), 0) AS cache_hit_requests,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' THEN 1 ELSE 0 END), 0) AS completed_total_requests,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' AND COALESCE(usage.cache_read_input_tokens, 0) > 0 THEN 1 ELSE 0 END), 0) AS completed_cache_hit_requests,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' THEN MAX(COALESCE(usage.input_tokens, 0), 0) ELSE 0 END), 0) AS completed_input_tokens,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' THEN ({cache_creation}) ELSE 0 END), 0) AS completed_cache_creation_tokens,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' THEN MAX(COALESCE(usage.cache_read_input_tokens, 0), 0) ELSE 0 END), 0) AS completed_cache_read_tokens,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' THEN ({total_context}) ELSE 0 END), 0) AS completed_total_input_context,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' THEN COALESCE(usage.cache_creation_cost_usd, 0) ELSE 0 END), 0) AS completed_cache_creation_cost,
+    COALESCE(SUM(CASE WHEN usage.status = 'completed' THEN COALESCE(usage.cache_read_cost_usd, 0) ELSE 0 END), 0) AS completed_cache_read_cost,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN COALESCE(settlement.billing_total_cost_usd, usage.total_cost_usd, 0) ELSE 0 END), 0) AS settled_total_cost,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN 1 ELSE 0 END), 0) AS settled_total_requests,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN MAX(COALESCE(usage.input_tokens, 0), 0) ELSE 0 END), 0) AS settled_input_tokens,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN MAX(COALESCE(usage.output_tokens, 0), 0) ELSE 0 END), 0) AS settled_output_tokens,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN ({cache_creation}) ELSE 0 END), 0) AS settled_cache_creation_tokens,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN MAX(COALESCE(usage.cache_read_input_tokens, 0), 0) ELSE 0 END), 0) AS settled_cache_read_tokens,
+    MIN(CASE WHEN {SETTLED} THEN COALESCE(settlement.finalized_at, usage.finalized_at) END) AS settled_first_finalized_at_unix_secs,
+    MAX(CASE WHEN {SETTLED} THEN COALESCE(settlement.finalized_at, usage.finalized_at) END) AS settled_last_finalized_at_unix_secs
+  FROM "usage" AS usage
+  LEFT JOIN usage_settlement_snapshots AS settlement ON settlement.request_id = usage.request_id
+  WHERE usage.created_at_unix_ms >= ? AND usage.created_at_unix_ms < ?
+) AS aggregated
+WHERE target."date" = ?
+"#
+    );
+    sqlx::query(&sql)
+        .bind(response.0)
+        .bind(response.1)
+        .bind(response.2)
+        .bind(first_byte.0)
+        .bind(first_byte.1)
+        .bind(first_byte.2)
+        .bind(start_unix_secs)
+        .bind(end_unix_secs)
+        .bind(day_start)
+        .execute(&mut **tx)
+        .await
+        .map_sql_err()?;
+    Ok(())
+}
+
+async fn refresh_daily_existing_dimensions(
+    tx: &mut sqlx::Transaction<'_, Sqlite>,
+    day_start: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+) -> Result<(), DataLayerError> {
+    let cache_creation = cache_creation_expr();
+    let total_context = total_input_context_expr();
+    let daily_model_sql = format!(
+        r#"
+UPDATE stats_daily_model AS target
+SET response_time_sum_ms = aggregated.response_time_sum_ms,
+    response_time_samples = aggregated.response_time_samples,
+    cache_creation_ephemeral_5m_tokens = aggregated.cache_creation_ephemeral_5m_tokens,
+    cache_creation_ephemeral_1h_tokens = aggregated.cache_creation_ephemeral_1h_tokens
+FROM (
+  SELECT usage.model,
+    COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL THEN MAX(usage.response_time_ms, 0) ELSE 0 END), 0) AS response_time_sum_ms,
+    COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL THEN 1 ELSE 0 END), 0) AS response_time_samples,
+    COALESCE(SUM({CACHE_5M}), 0) AS cache_creation_ephemeral_5m_tokens,
+    COALESCE(SUM({CACHE_1H}), 0) AS cache_creation_ephemeral_1h_tokens
+  FROM "usage" AS usage
+  WHERE usage.created_at_unix_ms >= ? AND usage.created_at_unix_ms < ?
+    AND {AGGREGATABLE} AND usage.model IS NOT NULL AND usage.model <> ''
+  GROUP BY usage.model
+) AS aggregated
+WHERE target."date" = ? AND target.model = aggregated.model
+"#
+    );
+    sqlx::query(&daily_model_sql)
+        .bind(start_unix_secs)
+        .bind(end_unix_secs)
+        .bind(day_start)
+        .execute(&mut **tx)
+        .await
+        .map_sql_err()?;
+
+    let user_sql = format!(
+        r#"
+UPDATE stats_user_daily AS target
+SET effective_input_tokens = aggregated.effective_input_tokens,
+    total_input_context = aggregated.total_input_context,
+    cache_creation_cost = aggregated.cache_creation_cost,
+    cache_read_cost = aggregated.cache_read_cost,
+    actual_total_cost = aggregated.actual_total_cost,
+    response_time_sum_ms = aggregated.response_time_sum_ms,
+    response_time_samples = aggregated.response_time_samples,
+    cache_creation_ephemeral_5m_tokens = aggregated.cache_creation_ephemeral_5m_tokens,
+    cache_creation_ephemeral_1h_tokens = aggregated.cache_creation_ephemeral_1h_tokens,
+    settled_total_cost = aggregated.settled_total_cost,
+    settled_total_requests = aggregated.settled_total_requests,
+    settled_input_tokens = aggregated.settled_input_tokens,
+    settled_output_tokens = aggregated.settled_output_tokens,
+    settled_cache_creation_tokens = aggregated.settled_cache_creation_tokens,
+    settled_cache_read_tokens = aggregated.settled_cache_read_tokens,
+    settled_first_finalized_at_unix_secs = aggregated.settled_first_finalized_at_unix_secs,
+    settled_last_finalized_at_unix_secs = aggregated.settled_last_finalized_at_unix_secs
+FROM (
+  SELECT usage.user_id,
+    COALESCE(SUM({EFFECTIVE_INPUT}), 0) AS effective_input_tokens,
+    COALESCE(SUM({total_context}), 0) AS total_input_context,
+    COALESCE(SUM(COALESCE(usage.cache_creation_cost_usd, 0)), 0) AS cache_creation_cost,
+    COALESCE(SUM(COALESCE(usage.cache_read_cost_usd, 0)), 0) AS cache_read_cost,
+    COALESCE(SUM(COALESCE(settlement.billing_actual_total_cost_usd, usage.actual_total_cost_usd, 0)), 0) AS actual_total_cost,
+    COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL THEN MAX(usage.response_time_ms, 0) ELSE 0 END), 0) AS response_time_sum_ms,
+    COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL THEN 1 ELSE 0 END), 0) AS response_time_samples,
+    COALESCE(SUM({CACHE_5M}), 0) AS cache_creation_ephemeral_5m_tokens,
+    COALESCE(SUM({CACHE_1H}), 0) AS cache_creation_ephemeral_1h_tokens,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN COALESCE(settlement.billing_total_cost_usd, usage.total_cost_usd, 0) ELSE 0 END), 0) AS settled_total_cost,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN 1 ELSE 0 END), 0) AS settled_total_requests,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN MAX(COALESCE(usage.input_tokens, 0), 0) ELSE 0 END), 0) AS settled_input_tokens,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN MAX(COALESCE(usage.output_tokens, 0), 0) ELSE 0 END), 0) AS settled_output_tokens,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN ({cache_creation}) ELSE 0 END), 0) AS settled_cache_creation_tokens,
+    COALESCE(SUM(CASE WHEN {SETTLED} THEN MAX(COALESCE(usage.cache_read_input_tokens, 0), 0) ELSE 0 END), 0) AS settled_cache_read_tokens,
+    MIN(CASE WHEN {SETTLED} THEN COALESCE(settlement.finalized_at, usage.finalized_at) END) AS settled_first_finalized_at_unix_secs,
+    MAX(CASE WHEN {SETTLED} THEN COALESCE(settlement.finalized_at, usage.finalized_at) END) AS settled_last_finalized_at_unix_secs
+  FROM "usage" AS usage
+  LEFT JOIN usage_settlement_snapshots AS settlement ON settlement.request_id = usage.request_id
+  WHERE usage.created_at_unix_ms >= ? AND usage.created_at_unix_ms < ?
+    AND usage.user_id IS NOT NULL AND usage.user_id <> '' AND {AGGREGATABLE}
+  GROUP BY usage.user_id
+) AS aggregated
+WHERE target."date" = ? AND target.user_id = aggregated.user_id
+"#
+    );
+    sqlx::query(&user_sql)
+        .bind(start_unix_secs)
+        .bind(end_unix_secs)
+        .bind(day_start)
+        .execute(&mut **tx)
+        .await
+        .map_sql_err()?;
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn upsert_user_dimension(
+    tx: &mut sqlx::Transaction<'_, Sqlite>,
+    table: &str,
+    dimension_column: &str,
+    dimension_expr: &str,
+    dimension_filter: &str,
+    day_start: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+    now_unix_secs: i64,
+) -> Result<(), DataLayerError> {
+    let cache_creation = cache_creation_expr();
+    let total_context = total_input_context_expr();
+    let total_tokens = total_tokens_expr();
+    let sql = format!(
+        r#"
+INSERT INTO {table} (
+  id, user_id, username, "date", {dimension_column}, total_requests, success_requests,
+  input_tokens, effective_input_tokens, output_tokens, total_tokens, total_input_context,
+  cache_creation_tokens, cache_creation_ephemeral_5m_tokens,
+  cache_creation_ephemeral_1h_tokens, cache_read_tokens, total_cost, actual_total_cost,
+  response_time_sum_ms, response_time_samples, successful_response_time_sum_ms,
+  successful_response_time_samples, created_at, updated_at
+)
+SELECT lower(hex(randomblob(32))), usage.user_id,
+  MAX(COALESCE(usage.username, users.username)), ?, {dimension_expr}, COUNT(*),
+  COALESCE(SUM({SUCCESS}), 0),
+  COALESCE(SUM(MAX(COALESCE(usage.input_tokens, 0), 0)), 0),
+  COALESCE(SUM({EFFECTIVE_INPUT}), 0),
+  COALESCE(SUM(MAX(COALESCE(usage.output_tokens, 0), 0)), 0),
+  COALESCE(SUM({total_tokens}), 0), COALESCE(SUM({total_context}), 0),
+  COALESCE(SUM({cache_creation}), 0), COALESCE(SUM({CACHE_5M}), 0),
+  COALESCE(SUM({CACHE_1H}), 0),
+  COALESCE(SUM(MAX(COALESCE(usage.cache_read_input_tokens, 0), 0)), 0),
+  COALESCE(SUM(COALESCE(settlement.billing_total_cost_usd, usage.total_cost_usd, 0)), 0),
+  COALESCE(SUM(COALESCE(settlement.billing_actual_total_cost_usd, usage.actual_total_cost_usd, 0)), 0),
+  COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL THEN MAX(usage.response_time_ms, 0) ELSE 0 END), 0),
+  COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL THEN 1 ELSE 0 END), 0),
+  COALESCE(SUM(CASE WHEN ({SUCCESS}) = 1 AND usage.response_time_ms IS NOT NULL THEN MAX(usage.response_time_ms, 0) ELSE 0 END), 0),
+  COALESCE(SUM(CASE WHEN ({SUCCESS}) = 1 AND usage.response_time_ms IS NOT NULL THEN 1 ELSE 0 END), 0),
+  ?, ?
+FROM "usage" AS usage
+LEFT JOIN users ON users.id = usage.user_id
+LEFT JOIN usage_settlement_snapshots AS settlement ON settlement.request_id = usage.request_id
+WHERE usage.created_at_unix_ms >= ? AND usage.created_at_unix_ms < ?
+  AND usage.user_id IS NOT NULL AND usage.user_id <> ''
+  AND {dimension_filter} AND {AGGREGATABLE}
+GROUP BY usage.user_id, {dimension_expr}
+ON CONFLICT (user_id, "date", {dimension_column}) DO UPDATE SET
+  username = COALESCE(excluded.username, {table}.username),
+  total_requests = excluded.total_requests, success_requests = excluded.success_requests,
+  input_tokens = excluded.input_tokens, effective_input_tokens = excluded.effective_input_tokens,
+  output_tokens = excluded.output_tokens, total_tokens = excluded.total_tokens,
+  total_input_context = excluded.total_input_context,
+  cache_creation_tokens = excluded.cache_creation_tokens,
+  cache_creation_ephemeral_5m_tokens = excluded.cache_creation_ephemeral_5m_tokens,
+  cache_creation_ephemeral_1h_tokens = excluded.cache_creation_ephemeral_1h_tokens,
+  cache_read_tokens = excluded.cache_read_tokens, total_cost = excluded.total_cost,
+  actual_total_cost = excluded.actual_total_cost,
+  response_time_sum_ms = excluded.response_time_sum_ms,
+  response_time_samples = excluded.response_time_samples,
+  successful_response_time_sum_ms = excluded.successful_response_time_sum_ms,
+  successful_response_time_samples = excluded.successful_response_time_samples,
+  updated_at = excluded.updated_at
+"#
+    );
+    sqlx::query(&sql)
+        .bind(day_start)
+        .bind(now_unix_secs)
+        .bind(now_unix_secs)
+        .bind(start_unix_secs)
+        .bind(end_unix_secs)
+        .execute(&mut **tx)
+        .await
+        .map_sql_err()?;
+    Ok(())
+}
+
+async fn upsert_model_provider_rows(
+    tx: &mut sqlx::Transaction<'_, Sqlite>,
+    day_start: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+    now_unix_secs: i64,
+) -> Result<(), DataLayerError> {
+    let total_tokens = total_tokens_expr();
+    let model_provider_sql = format!(
+        r#"
+INSERT INTO stats_daily_model_provider (
+  id, "date", model, provider_name, total_requests, total_tokens, total_cost,
+  response_time_sum_ms, response_time_samples, created_at, updated_at
+)
+SELECT lower(hex(randomblob(32))), ?, usage.model, usage.provider_name, COUNT(*),
+  COALESCE(SUM({total_tokens}), 0),
+  COALESCE(SUM(COALESCE(settlement.billing_total_cost_usd, usage.total_cost_usd, 0)), 0),
+  COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL THEN MAX(usage.response_time_ms, 0) ELSE 0 END), 0),
+  COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL THEN 1 ELSE 0 END), 0), ?, ?
+FROM "usage" AS usage
+LEFT JOIN usage_settlement_snapshots AS settlement ON settlement.request_id = usage.request_id
+WHERE usage.created_at_unix_ms >= ? AND usage.created_at_unix_ms < ?
+  AND usage.model IS NOT NULL AND usage.model <> '' AND {AGGREGATABLE}
+GROUP BY usage.model, usage.provider_name
+ON CONFLICT ("date", model, provider_name) DO UPDATE SET
+  total_requests = excluded.total_requests, total_tokens = excluded.total_tokens,
+  total_cost = excluded.total_cost, response_time_sum_ms = excluded.response_time_sum_ms,
+  response_time_samples = excluded.response_time_samples, updated_at = excluded.updated_at
+"#
+    );
+    sqlx::query(&model_provider_sql)
+        .bind(day_start)
+        .bind(now_unix_secs)
+        .bind(now_unix_secs)
+        .bind(start_unix_secs)
+        .bind(end_unix_secs)
+        .execute(&mut **tx)
+        .await
+        .map_sql_err()?;
+
+    let user_model_provider_sql = format!(
+        r#"
+INSERT INTO stats_user_daily_model_provider (
+  id, user_id, username, "date", model, provider_name, total_requests, total_tokens,
+  total_cost, response_time_sum_ms, response_time_samples, created_at, updated_at
+)
+SELECT lower(hex(randomblob(32))), usage.user_id, MAX(COALESCE(usage.username, users.username)),
+  ?, usage.model, usage.provider_name, COUNT(*), COALESCE(SUM({total_tokens}), 0),
+  COALESCE(SUM(COALESCE(settlement.billing_total_cost_usd, usage.total_cost_usd, 0)), 0),
+  COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL THEN MAX(usage.response_time_ms, 0) ELSE 0 END), 0),
+  COALESCE(SUM(CASE WHEN usage.response_time_ms IS NOT NULL THEN 1 ELSE 0 END), 0), ?, ?
+FROM "usage" AS usage
+LEFT JOIN users ON users.id = usage.user_id
+LEFT JOIN usage_settlement_snapshots AS settlement ON settlement.request_id = usage.request_id
+WHERE usage.created_at_unix_ms >= ? AND usage.created_at_unix_ms < ?
+  AND usage.user_id IS NOT NULL AND usage.user_id <> ''
+  AND usage.model IS NOT NULL AND usage.model <> '' AND {AGGREGATABLE}
+GROUP BY usage.user_id, usage.model, usage.provider_name
+ON CONFLICT (user_id, "date", model, provider_name) DO UPDATE SET
+  username = COALESCE(excluded.username, stats_user_daily_model_provider.username),
+  total_requests = excluded.total_requests, total_tokens = excluded.total_tokens,
+  total_cost = excluded.total_cost, response_time_sum_ms = excluded.response_time_sum_ms,
+  response_time_samples = excluded.response_time_samples, updated_at = excluded.updated_at
+"#
+    );
+    sqlx::query(&user_model_provider_sql)
+        .bind(day_start)
+        .bind(now_unix_secs)
+        .bind(now_unix_secs)
+        .bind(start_unix_secs)
+        .bind(end_unix_secs)
+        .execute(&mut **tx)
+        .await
+        .map_sql_err()?;
+    Ok(())
+}
+
+async fn upsert_cost_savings_rows(
+    tx: &mut sqlx::Transaction<'_, Sqlite>,
+    day_start: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+    now_unix_secs: i64,
+) -> Result<(), DataLayerError> {
+    for (table, dimensions) in [
+        ("stats_daily_cost_savings", Vec::new()),
+        (
+            "stats_daily_cost_savings_provider",
+            vec![("provider_name", "COALESCE(usage.provider_name, '')")],
+        ),
+        (
+            "stats_daily_cost_savings_model",
+            vec![("model", "COALESCE(usage.model, '')")],
+        ),
+        (
+            "stats_daily_cost_savings_model_provider",
+            vec![
+                ("model", "COALESCE(usage.model, '')"),
+                ("provider_name", "COALESCE(usage.provider_name, '')"),
+            ],
+        ),
+    ] {
+        upsert_cost_savings_dimension(
+            tx,
+            table,
+            false,
+            &dimensions,
+            day_start,
+            start_unix_secs,
+            end_unix_secs,
+            now_unix_secs,
+        )
+        .await?;
+    }
+    for (table, dimensions) in [
+        ("stats_user_daily_cost_savings", Vec::new()),
+        (
+            "stats_user_daily_cost_savings_provider",
+            vec![("provider_name", "COALESCE(usage.provider_name, '')")],
+        ),
+        (
+            "stats_user_daily_cost_savings_model",
+            vec![("model", "COALESCE(usage.model, '')")],
+        ),
+        (
+            "stats_user_daily_cost_savings_model_provider",
+            vec![
+                ("model", "COALESCE(usage.model, '')"),
+                ("provider_name", "COALESCE(usage.provider_name, '')"),
+            ],
+        ),
+    ] {
+        upsert_cost_savings_dimension(
+            tx,
+            table,
+            true,
+            &dimensions,
+            day_start,
+            start_unix_secs,
+            end_unix_secs,
+            now_unix_secs,
+        )
+        .await?;
+    }
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn upsert_cost_savings_dimension(
+    tx: &mut sqlx::Transaction<'_, Sqlite>,
+    table: &str,
+    per_user: bool,
+    dimensions: &[(&str, &str)],
+    day_start: i64,
+    start_unix_secs: i64,
+    end_unix_secs: i64,
+    now_unix_secs: i64,
+) -> Result<(), DataLayerError> {
+    let dimension_columns = dimensions
+        .iter()
+        .map(|(column, _)| *column)
+        .collect::<Vec<_>>();
+    let dimension_exprs = dimensions
+        .iter()
+        .map(|(_, expression)| *expression)
+        .collect::<Vec<_>>();
+    let user_columns = if per_user { "user_id, username, " } else { "" };
+    let user_select = if per_user {
+        "usage.user_id, MAX(COALESCE(usage.username, users.username)), "
+    } else {
+        ""
+    };
+    let user_join = if per_user {
+        "LEFT JOIN users ON users.id = usage.user_id"
+    } else {
+        ""
+    };
+    let user_filter = if per_user {
+        "AND usage.user_id IS NOT NULL AND usage.user_id <> ''"
+    } else {
+        ""
+    };
+    let mut conflict_columns = vec!["\"date\""];
+    let mut group_by = Vec::new();
+    if per_user {
+        conflict_columns.insert(0, "user_id");
+        group_by.push("usage.user_id");
+    }
+    conflict_columns.extend(dimension_columns.iter().copied());
+    group_by.extend(dimension_exprs.iter().copied());
+    let dimension_columns_sql = if dimension_columns.is_empty() {
+        String::new()
+    } else {
+        format!("{}, ", dimension_columns.join(", "))
+    };
+    let dimension_select_sql = if dimension_exprs.is_empty() {
+        String::new()
+    } else {
+        format!("{}, ", dimension_exprs.join(", "))
+    };
+    let group_by_sql = if group_by.is_empty() {
+        String::new()
+    } else {
+        format!("GROUP BY {}", group_by.join(", "))
+    };
+    let sql = format!(
+        r#"
+INSERT INTO {table} (
+  id, {user_columns}"date", {dimension_columns_sql}cache_read_tokens,
+  cache_read_cost, cache_creation_cost, estimated_full_cost, created_at, updated_at
+)
+SELECT lower(hex(randomblob(32))), {user_select}?, {dimension_select_sql}
+  COALESCE(SUM(MAX(COALESCE(usage.cache_read_input_tokens, 0), 0)), 0),
+  COALESCE(SUM(COALESCE(usage.cache_read_cost_usd, 0)), 0),
+  COALESCE(SUM(COALESCE(usage.cache_creation_cost_usd, 0)), 0),
+  COALESCE(SUM(
+    COALESCE(settlement.input_price_per_1m, usage.input_price_per_1m, 0)
+      * MAX(COALESCE(usage.cache_read_input_tokens, 0), 0) / 1000000.0
+  ), 0), ?, ?
+FROM "usage" AS usage
+LEFT JOIN usage_settlement_snapshots AS settlement ON settlement.request_id = usage.request_id
+{user_join}
+WHERE usage.created_at_unix_ms >= ? AND usage.created_at_unix_ms < ? {user_filter}
+{group_by_sql}
+ON CONFLICT ({}) DO UPDATE SET
+  {}cache_read_tokens = excluded.cache_read_tokens,
+  cache_read_cost = excluded.cache_read_cost,
+  cache_creation_cost = excluded.cache_creation_cost,
+  estimated_full_cost = excluded.estimated_full_cost,
+  updated_at = excluded.updated_at
+"#,
+        conflict_columns.join(", "),
+        if per_user {
+            format!("username = COALESCE(excluded.username, {table}.username), ")
+        } else {
+            String::new()
+        }
+    );
+    sqlx::query(&sql)
+        .bind(day_start)
+        .bind(now_unix_secs)
+        .bind(now_unix_secs)
+        .bind(start_unix_secs)
+        .bind(end_unix_secs)
+        .execute(&mut **tx)
+        .await
+        .map_sql_err()?;
+    Ok(())
+}
+
+async fn refresh_user_summary(
+    tx: &mut sqlx::Transaction<'_, Sqlite>,
+    cutoff_date: i64,
+    now_unix_secs: i64,
+) -> Result<(), DataLayerError> {
+    sqlx::query(
+        r#"
+INSERT INTO stats_user_summary (
+  id, user_id, username, cutoff_date, all_time_requests, all_time_success_requests,
+  all_time_error_requests, all_time_input_tokens, all_time_output_tokens,
+  all_time_cache_creation_tokens, all_time_cache_read_tokens, all_time_cost,
+  all_time_actual_cost, active_days, first_active_date, last_active_date,
+  created_at, updated_at
+)
+SELECT lower(hex(randomblob(32))), user_id, MAX(username), ?,
+  COALESCE(SUM(total_requests), 0), COALESCE(SUM(success_requests), 0),
+  COALESCE(SUM(error_requests), 0), COALESCE(SUM(input_tokens), 0),
+  COALESCE(SUM(output_tokens), 0), COALESCE(SUM(cache_creation_tokens), 0),
+  COALESCE(SUM(cache_read_tokens), 0), COALESCE(SUM(total_cost), 0),
+  COALESCE(SUM(actual_total_cost), 0),
+  COALESCE(SUM(CASE WHEN total_requests > 0 THEN 1 ELSE 0 END), 0),
+  MIN(CASE WHEN total_requests > 0 THEN "date" END),
+  MAX(CASE WHEN total_requests > 0 THEN "date" END), ?, ?
+FROM stats_user_daily
+WHERE "date" < ?
+GROUP BY user_id
+ON CONFLICT (user_id) DO UPDATE SET
+  username = COALESCE(excluded.username, stats_user_summary.username),
+  cutoff_date = excluded.cutoff_date, all_time_requests = excluded.all_time_requests,
+  all_time_success_requests = excluded.all_time_success_requests,
+  all_time_error_requests = excluded.all_time_error_requests,
+  all_time_input_tokens = excluded.all_time_input_tokens,
+  all_time_output_tokens = excluded.all_time_output_tokens,
+  all_time_cache_creation_tokens = excluded.all_time_cache_creation_tokens,
+  all_time_cache_read_tokens = excluded.all_time_cache_read_tokens,
+  all_time_cost = excluded.all_time_cost, all_time_actual_cost = excluded.all_time_actual_cost,
+  active_days = excluded.active_days, first_active_date = excluded.first_active_date,
+  last_active_date = excluded.last_active_date, updated_at = excluded.updated_at
+"#,
+    )
+    .bind(cutoff_date)
+    .bind(now_unix_secs)
+    .bind(now_unix_secs)
+    .bind(cutoff_date)
+    .execute(&mut **tx)
+    .await
+    .map_sql_err()?;
+    refresh_global_summary(tx, cutoff_date, now_unix_secs).await?;
+    Ok(())
+}
+
+async fn refresh_global_summary(
+    tx: &mut sqlx::Transaction<'_, Sqlite>,
+    cutoff_date: i64,
+    now_unix_secs: i64,
+) -> Result<(), DataLayerError> {
+    let existing_id: Option<String> =
+        sqlx::query_scalar("SELECT id FROM stats_summary ORDER BY created_at, id LIMIT 1")
+            .fetch_optional(&mut **tx)
+            .await
+            .map_sql_err()?;
+    let summary_id = existing_id.unwrap_or_else(|| stats_id("stats-summary"));
+    sqlx::query(
+        r#"
+INSERT INTO stats_summary (
+  id, cutoff_date, all_time_requests, all_time_success_requests,
+  all_time_error_requests, all_time_input_tokens, all_time_output_tokens,
+  all_time_cache_creation_tokens, all_time_cache_read_tokens, all_time_cost,
+  all_time_actual_cost, total_users, active_users, total_api_keys,
+  active_api_keys, created_at, updated_at
+)
+SELECT ?, ?, COALESCE(SUM(total_requests), 0), COALESCE(SUM(success_requests), 0),
+  COALESCE(SUM(error_requests), 0), COALESCE(SUM(input_tokens), 0),
+  COALESCE(SUM(output_tokens), 0), COALESCE(SUM(cache_creation_tokens), 0),
+  COALESCE(SUM(cache_read_tokens), 0), COALESCE(SUM(total_cost), 0),
+  COALESCE(SUM(actual_total_cost), 0),
+  (SELECT COUNT(*) FROM users),
+  (SELECT COUNT(*) FROM users WHERE is_active <> 0),
+  (SELECT COUNT(*) FROM api_keys),
+  (SELECT COUNT(*) FROM api_keys WHERE is_active <> 0), ?, ?
+FROM stats_daily
+WHERE "date" < ?
+ON CONFLICT (id) DO UPDATE SET
+  cutoff_date = excluded.cutoff_date,
+  all_time_requests = excluded.all_time_requests,
+  all_time_success_requests = excluded.all_time_success_requests,
+  all_time_error_requests = excluded.all_time_error_requests,
+  all_time_input_tokens = excluded.all_time_input_tokens,
+  all_time_output_tokens = excluded.all_time_output_tokens,
+  all_time_cache_creation_tokens = excluded.all_time_cache_creation_tokens,
+  all_time_cache_read_tokens = excluded.all_time_cache_read_tokens,
+  all_time_cost = excluded.all_time_cost,
+  all_time_actual_cost = excluded.all_time_actual_cost,
+  total_users = excluded.total_users, active_users = excluded.active_users,
+  total_api_keys = excluded.total_api_keys, active_api_keys = excluded.active_api_keys,
+  updated_at = excluded.updated_at
+"#,
+    )
+    .bind(summary_id)
+    .bind(cutoff_date)
+    .bind(now_unix_secs)
+    .bind(now_unix_secs)
+    .bind(cutoff_date)
+    .execute(&mut **tx)
+    .await
+    .map_sql_err()?;
+    Ok(())
+}
@@ -7,12 +7,6 @@ pub(crate) fn unix_secs(value: DateTime<Utc>) -> i64 {
    value.timestamp().max(0)
 }

-pub(crate) fn unix_ms(value: i64) -> Result<i64, DataLayerError> {
-    value.checked_mul(1000).ok_or_else(|| {
-        DataLayerError::InvalidInput(format!("timestamp overflow while converting {value} to ms"))
-    })
-}
-
 pub(crate) fn utc_from_unix_secs(
    value: i64,
    field_name: &str,
@@ -70,10 +70,12 @@ const ADMIN_STATS_PURGE_TABLES: &[&str] = &[
 ];

 const ADMIN_USAGE_CHILD_TABLES: &[&str] = &[
+    "usage_counter_deltas",
    "usage_body_blobs",
    "usage_http_audits",
    "usage_routing_snapshots",
    "usage_settlement_snapshots",
+    "user_model_usage_counts",
 ];

 const USAGE_BODY_FIELD_COLUMNS: &[&str] = &[
@@ -855,6 +855,22 @@ SET provider_id = NULL,
 WHERE provider_id IS NOT NULL
   OR provider_endpoint_id IS NOT NULL
   OR provider_api_key_id IS NOT NULL
+"#,
+                summary,
+            )
+            .await?;
+            mysql_execute_if_table(
+                tx,
+                "usage_routing_snapshots",
+                "usage_routing_provider_refs_cleared",
+                r#"
+UPDATE usage_routing_snapshots
+SET selected_provider_id = NULL,
+    selected_endpoint_id = NULL,
+    selected_provider_api_key_id = NULL
+WHERE selected_provider_id IS NOT NULL
+   OR selected_endpoint_id IS NOT NULL
+   OR selected_provider_api_key_id IS NOT NULL
 "#,
                summary,
            )
@@ -952,6 +968,14 @@ WHERE request_count <> 0
                summary,
            )
            .await?;
+            mysql_execute_if_table(
+                tx,
+                "global_models",
+                "global_model_usage_stats_reset",
+                "UPDATE global_models SET usage_count = 0 WHERE usage_count <> 0",
+                summary,
+            )
+            .await?;
        }
        AdminSystemPurgeTarget::AuditLogs => {
            mysql_delete_table(tx, "audit_logs", summary).await?;
@@ -460,6 +460,22 @@ SET provider_id = NULL,
 WHERE provider_id IS NOT NULL
   OR provider_endpoint_id IS NOT NULL
   OR provider_api_key_id IS NOT NULL
+"#,
+                summary,
+            )
+            .await?;
+            pg_execute_if_table(
+                tx,
+                "usage_routing_snapshots",
+                "usage_routing_provider_refs_cleared",
+                r#"
+UPDATE public.usage_routing_snapshots
+SET selected_provider_id = NULL,
+    selected_endpoint_id = NULL,
+    selected_provider_api_key_id = NULL
+WHERE selected_provider_id IS NOT NULL
+   OR selected_endpoint_id IS NOT NULL
+   OR selected_provider_api_key_id IS NOT NULL
 "#,
                summary,
            )
@@ -559,6 +575,14 @@ WHERE request_count <> 0
                summary,
            )
            .await?;
+            pg_execute_if_table(
+                tx,
+                "global_models",
+                "global_model_usage_stats_reset",
+                "UPDATE public.global_models SET usage_count = 0 WHERE usage_count <> 0",
+                summary,
+            )
+            .await?;
        }
        AdminSystemPurgeTarget::AuditLogs => {
            pg_delete_table(tx, "audit_logs", summary).await?;
@@ -601,6 +601,22 @@ SET provider_id = NULL,
 WHERE provider_id IS NOT NULL
   OR provider_endpoint_id IS NOT NULL
   OR provider_api_key_id IS NOT NULL
+"#,
+                summary,
+            )
+            .await?;
+            sqlite_execute_if_table(
+                tx,
+                "usage_routing_snapshots",
+                "usage_routing_provider_refs_cleared",
+                r#"
+UPDATE usage_routing_snapshots
+SET selected_provider_id = NULL,
+    selected_endpoint_id = NULL,
+    selected_provider_api_key_id = NULL
+WHERE selected_provider_id IS NOT NULL
+   OR selected_endpoint_id IS NOT NULL
+   OR selected_provider_api_key_id IS NOT NULL
 "#,
                summary,
            )
@@ -698,6 +714,14 @@ WHERE request_count <> 0
                summary,
            )
            .await?;
+            sqlite_execute_if_table(
+                tx,
+                "global_models",
+                "global_model_usage_stats_reset",
+                "UPDATE global_models SET usage_count = 0 WHERE usage_count <> 0",
+                summary,
+            )
+            .await?;
        }
        AdminSystemPurgeTarget::AuditLogs => {
            sqlite_delete_table(tx, "audit_logs", summary).await?;
@@ -1250,3 +1274,132 @@ pub(super) fn map_admin_system_stats(
            .max(0) as u64,
    })
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{purge_sqlite_admin_system_data, AdminSystemPurgeSummary, AdminSystemPurgeTarget};
+
+    #[tokio::test]
+    async fn usage_purge_removes_pending_counters_and_resets_model_usage() {
+        let pool = sqlx::sqlite::SqlitePoolOptions::new()
+            .max_connections(1)
+            .connect("sqlite::memory:")
+            .await
+            .expect("sqlite pool should connect");
+        crate::lifecycle::migrate::run_sqlite_migrations(&pool)
+            .await
+            .expect("sqlite migrations should run");
+
+        sqlx::raw_sql(
+            r#"
+INSERT INTO users (id, email, username, created_at, updated_at)
+VALUES ('purge-user', '[email protected]', 'purge-user', 1, 1);
+INSERT INTO global_models (id, name, usage_count, created_at, updated_at)
+VALUES ('purge-model', 'purge-model', 7, 1, 1);
+INSERT INTO "usage" (
+  request_id, user_id, provider_name, model, status, billing_status,
+  created_at_unix_ms, updated_at_unix_secs
+) VALUES ('purge-request', 'purge-user', 'provider', 'purge-model', 'completed', 'settled', 1, 1);
+INSERT INTO usage_counter_deltas (
+  id, request_id, kind, target_id, request_count_delta, created_at
+) VALUES ('purge-delta', 'purge-request', 'model', 'purge-model', 1, 1);
+INSERT INTO user_model_usage_counts (
+  id, user_id, model, usage_count, created_at, updated_at
+) VALUES ('purge-user-model', 'purge-user', 'purge-model', 7, 1, 1);
+"#,
+        )
+        .execute(&pool)
+        .await
+        .expect("usage purge fixtures should insert");
+
+        let mut tx = pool.begin().await.expect("purge transaction should begin");
+        let mut summary = AdminSystemPurgeSummary::default();
+        purge_sqlite_admin_system_data(&mut tx, AdminSystemPurgeTarget::Usage, &mut summary)
+            .await
+            .expect("usage purge should succeed");
+        tx.commit().await.expect("purge transaction should commit");
+
+        let usage_count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM \"usage\"")
+            .fetch_one(&pool)
+            .await
+            .expect("usage count should load");
+        let delta_count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM usage_counter_deltas")
+            .fetch_one(&pool)
+            .await
+            .expect("counter delta count should load");
+        let user_model_count: i64 =
+            sqlx::query_scalar("SELECT COUNT(*) FROM user_model_usage_counts")
+                .fetch_one(&pool)
+                .await
+                .expect("user model count should load");
+        let model_usage_count: i64 =
+            sqlx::query_scalar("SELECT usage_count FROM global_models WHERE id = 'purge-model'")
+                .fetch_one(&pool)
+                .await
+                .expect("global model usage count should load");
+
+        assert_eq!(usage_count, 0);
+        assert_eq!(delta_count, 0);
+        assert_eq!(user_model_count, 0);
+        assert_eq!(model_usage_count, 0);
+        assert_eq!(summary.affected.get("usage_counter_deltas"), Some(&1));
+        assert_eq!(summary.affected.get("user_model_usage_counts"), Some(&1));
+        assert_eq!(
+            summary.affected.get("global_model_usage_stats_reset"),
+            Some(&1)
+        );
+    }
+
+    #[tokio::test]
+    async fn config_purge_clears_canonical_routing_provider_refs() {
+        let pool = sqlx::sqlite::SqlitePoolOptions::new()
+            .max_connections(1)
+            .connect("sqlite::memory:")
+            .await
+            .expect("sqlite pool should connect");
+        crate::lifecycle::migrate::run_sqlite_migrations(&pool)
+            .await
+            .expect("sqlite migrations should run");
+
+        sqlx::raw_sql(
+            r#"
+INSERT INTO "usage" (
+  request_id, provider_name, model, status, billing_status,
+  created_at_unix_ms, updated_at_unix_secs
+) VALUES ('routing-purge-request', 'provider', 'model', 'completed', 'settled', 1, 1);
+INSERT INTO usage_routing_snapshots (
+  request_id, selected_provider_id, selected_endpoint_id,
+  selected_provider_api_key_id, created_at, updated_at
+) VALUES (
+  'routing-purge-request', 'provider-1', 'endpoint-1', 'key-1', 1, 1
+);
+"#,
+        )
+        .execute(&pool)
+        .await
+        .expect("routing purge fixture should insert");
+
+        let mut tx = pool.begin().await.expect("purge transaction should begin");
+        let mut summary = AdminSystemPurgeSummary::default();
+        purge_sqlite_admin_system_data(&mut tx, AdminSystemPurgeTarget::Config, &mut summary)
+            .await
+            .expect("config purge should succeed");
+        tx.commit().await.expect("purge transaction should commit");
+
+        let refs = sqlx::query_as::<_, (Option<String>, Option<String>, Option<String>)>(
+            r#"
+SELECT selected_provider_id, selected_endpoint_id, selected_provider_api_key_id
+FROM usage_routing_snapshots
+WHERE request_id = 'routing-purge-request'
+"#,
+        )
+        .fetch_one(&pool)
+        .await
+        .expect("routing refs should load");
+        assert_eq!(refs, (None, None, None));
+        assert_eq!(
+            summary.affected.get("usage_routing_provider_refs_cleared"),
+            Some(&1)
+        );
+    }
+}