Merge pull request #78 from Incomplete-Outputs-Lab/feat/export-linear-interpolation

feat: interpolated export aggregations

Author: misei-nul

src-tauri/src/commands/channels.rs

@@ -172,6 +172,25 @@ pub async fn list_channels(
     Ok(channels_with_stats)
 }
 
+/// 軽量版チャンネル一覧取得
+///
+/// - DBの `channels` テーブルのみを参照し、Twitch API にはアクセスしない
+/// - タイムラインなど「配信者リストだけ欲しい」画面で使用する
+#[tauri::command]
+pub async fn list_channels_basic(
+    db_manager: State<'_, DatabaseManager>,
+) -> Result<Vec<Channel>, String> {
+    let channels: Vec<Channel> = db_manager
+        .with_connection(|conn| {
+            ChannelRepository::list_all(conn)
+                .db_context("list all channels (basic)")
+                .map_err(|e| e.to_string())
+        })
+        .await?;
+
+    Ok(channels)
+}
+
 /// チャンネル情報にTwitch API情報を統合
 async fn enrich_channels_with_twitch_info(
     channels: Vec<Channel>,

src-tauri/src/commands/export.rs

@@ -1,17 +1,35 @@
 use crate::database::{repositories::StreamStatsRepository, DatabaseManager};
 use crate::error::ResultExt;
+use chrono::{DateTime, FixedOffset, NaiveDateTime};
 use serde::{Deserialize, Serialize};
 use tauri::{AppHandle, State};
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct ExportQuery {
-    pub channel_id: Option<i64>,
+    pub channel_id: i64,
     pub start_time: Option<String>,
     pub end_time: Option<String>,
     pub aggregation: Option<String>, // "raw", "1min", "5min", "1hour"
     pub delimiter: Option<String>,   // Custom delimiter (default: comma)
 }
 
+fn normalize_timestamp(value: &str) -> String {
+    // 1) RFC3339 (元の文字列形式を想定)
+    if let Ok(dt) = DateTime::parse_from_rfc3339(value) {
+        return dt.to_rfc3339();
+    }
+    // 2) DuckDB の TIMESTAMP 表示形式を想定（秒以下あり/なし両対応）
+    if let Ok(naive) = NaiveDateTime::parse_from_str(value, "%Y-%m-%d %H:%M:%S%.f")
+        .or_else(|_| NaiveDateTime::parse_from_str(value, "%Y-%m-%d %H:%M:%S"))
+    {
+        if let Some(offset) = FixedOffset::east_opt(0) {
+            return DateTime::<FixedOffset>::from_naive_utc_and_offset(naive, offset).to_rfc3339();
+        }
+    }
+    // 3) どれにも当てはまらない場合は元の文字列を返す
+    value.to_string()
+}
+
 /// Helper function to escape field values for delimited output
 fn escape_field(value: &str, delimiter: &str) -> String {
     // Check if field needs escaping (contains delimiter, quotes, or newlines)
@@ -35,25 +53,47 @@ pub async fn export_to_delimited(
     file_path: String,
     include_bom: Option<bool>,
 ) -> Result<String, String> {
+    let ExportQuery {
+        channel_id,
+        start_time,
+        end_time,
+        aggregation,
+        delimiter,
+    } = query;
+
     let stats = db_manager
         .with_connection(|conn| {
-            StreamStatsRepository::get_stream_stats_filtered(
-                conn,
-                None,
-                query.channel_id,
-                query.start_time.as_deref(),
-                query.end_time.as_deref(),
-                true, // ORDER BY collected_at ASC for export
-            )
-            .db_context("query stats")
-            .map_err(|e| e.to_string())
+            let start_opt = start_time.as_deref();
+            let end_opt = end_time.as_deref();
+
+            let interval_minutes = match aggregation.as_deref() {
+                Some("1min") => Some(1),
+                Some("5min") => Some(5),
+                Some("1hour") => Some(60),
+                _ => None,
+            };
+
+            if let (Some(st), Some(et), Some(interval)) = (start_opt, end_opt, interval_minutes) {
+                StreamStatsRepository::get_interpolated_stream_stats_for_export(
+                    conn, None, Some(channel_id), st, et, interval,
+                )
+                .db_context("query interpolated stats for export")
+                .map_err(|e| e.to_string())
+            } else {
+                StreamStatsRepository::get_stream_stats_filtered(
+                    conn, None, Some(channel_id), start_opt, end_opt,
+                    true, // ORDER BY collected_at ASC for export
+                )
+                .db_context("query stats")
+                .map_err(|e| e.to_string())
+            }
         })
         .await?;
 
     let stats_len = stats.len();
 
     // Determine delimiter (default to comma)
-    let delimiter = query.delimiter.as_deref().unwrap_or(",");
+    let delimiter = delimiter.as_deref().unwrap_or(",");
 
     // Build delimited file content
     let mut output = String::new();
@@ -71,7 +111,7 @@ pub async fn export_to_delimited(
 
     // Data rows
     for stat in &stats {
-        let collected_at = &stat.collected_at;
+        let collected_at = normalize_timestamp(&stat.collected_at);
         let channel_name = stat.channel_name.as_deref().unwrap_or("");
         let viewer_count = stat.viewer_count.unwrap_or(0).to_string();
         let category = stat.category.as_deref().unwrap_or("");
@@ -83,7 +123,7 @@ pub async fn export_to_delimited(
 
         output.push_str(&format!(
             "{}{}{}{}{}{}{}{}{}{}{}\n",
-            escape_field(collected_at, delimiter),
+            escape_field(&collected_at, delimiter),
             delimiter,
             escape_field(channel_name, delimiter),
             delimiter,
@@ -115,18 +155,40 @@ pub async fn preview_export_data(
     query: ExportQuery,
     max_rows: Option<usize>,
 ) -> Result<String, String> {
+    let ExportQuery {
+        channel_id,
+        start_time,
+        end_time,
+        aggregation,
+        delimiter,
+    } = query;
+
     let stats = db_manager
         .with_connection(|conn| {
-            StreamStatsRepository::get_stream_stats_filtered(
-                conn,
-                None,
-                query.channel_id,
-                query.start_time.as_deref(),
-                query.end_time.as_deref(),
-                true, // ORDER BY collected_at ASC
-            )
-            .db_context("query stats")
-            .map_err(|e| e.to_string())
+            let start_opt = start_time.as_deref();
+            let end_opt = end_time.as_deref();
+
+            let interval_minutes = match aggregation.as_deref() {
+                Some("1min") => Some(1),
+                Some("5min") => Some(5),
+                Some("1hour") => Some(60),
+                _ => None,
+            };
+
+            if let (Some(st), Some(et), Some(interval)) = (start_opt, end_opt, interval_minutes) {
+                StreamStatsRepository::get_interpolated_stream_stats_for_export(
+                    conn, None, Some(channel_id), st, et, interval,
+                )
+                .db_context("query interpolated stats for preview")
+                .map_err(|e| e.to_string())
+            } else {
+                StreamStatsRepository::get_stream_stats_filtered(
+                    conn, None, Some(channel_id), start_opt, end_opt,
+                    true, // ORDER BY collected_at ASC
+                )
+                .db_context("query stats")
+                .map_err(|e| e.to_string())
+            }
         })
         .await?;
 
@@ -135,7 +197,7 @@ pub async fn preview_export_data(
     let preview_stats = stats.iter().take(max_rows);
 
     // Determine delimiter (default to comma)
-    let delimiter = query.delimiter.as_deref().unwrap_or(",");
+    let delimiter = delimiter.as_deref().unwrap_or(",");
 
     // Build preview content
     let mut output = String::new();
@@ -148,7 +210,7 @@ pub async fn preview_export_data(
 
     // Data rows (limited to max_rows)
     for stat in preview_stats {
-        let collected_at = &stat.collected_at;
+        let collected_at = normalize_timestamp(&stat.collected_at);
         let channel_name = stat.channel_name.as_deref().unwrap_or("");
         let viewer_count = stat.viewer_count.unwrap_or(0).to_string();
         let category = stat.category.as_deref().unwrap_or("");
@@ -160,7 +222,7 @@ pub async fn preview_export_data(
 
         output.push_str(&format!(
             "{}{}{}{}{}{}{}{}{}{}{}\n",
-            escape_field(collected_at, delimiter),
+            escape_field(&collected_at, delimiter),
             delimiter,
             escape_field(channel_name, delimiter),
             delimiter,

src-tauri/src/database/repositories/stream_stats_repository.rs

@@ -6,6 +6,7 @@ use crate::database::analytics::DailyStats;
 use crate::database::models::StreamStats;
 use crate::database::query_helpers::stream_stats_query;
 use crate::database::utils;
+use chrono::{DateTime, Duration, FixedOffset, NaiveDateTime};
 use duckdb::Connection;
 use serde::{Deserialize, Serialize};
 
@@ -101,6 +102,173 @@ impl StreamStatsRepository {
         results.collect::<Result<Vec<_>, _>>()
     }
 
+    /// 指定した時間範囲と間隔で線形補完した統計データを取得（エクスポート用）
+    ///
+    /// - 元データは get_stream_stats_filtered で取得
+    /// - viewer_count / chat_rate_1min を線形補完
+    /// - それ以外の文字列系は直前の値を採用
+    pub fn get_interpolated_stream_stats_for_export(
+        conn: &Connection,
+        stream_id: Option<i64>,
+        channel_id: Option<i64>,
+        start_time: &str,
+        end_time: &str,
+        interval_minutes: i64,
+    ) -> Result<Vec<StreamStats>, duckdb::Error> {
+        // ベースとなる生データを取得（昇順）
+        let base_stats = Self::get_stream_stats_filtered(
+            conn,
+            stream_id,
+            channel_id,
+            Some(start_time),
+            Some(end_time),
+            true,
+        )?;
+
+        if base_stats.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        // 補完の対象範囲は「実際にデータが存在する最初と最後の時刻」に限定する
+        let effective_start = &base_stats
+            .first()
+            .map(|s| s.collected_at.as_str())
+            .unwrap_or(start_time);
+        let effective_end = &base_stats
+            .last()
+            .map(|s| s.collected_at.as_str())
+            .unwrap_or(end_time);
+
+        Ok(Self::interpolate_stats(
+            &base_stats,
+            effective_start,
+            effective_end,
+            interval_minutes,
+        ))
+    }
+
+    /// 内部ヘルパー: 線形補完を行う
+    fn interpolate_stats(
+        stats: &[StreamStats],
+        start_time: &str,
+        end_time: &str,
+        interval_minutes: i64,
+    ) -> Vec<StreamStats> {
+        fn parse_ts(s: &str) -> Option<DateTime<FixedOffset>> {
+            // 1) RFC3339 (元の文字列形式を想定)
+            if let Ok(dt) = DateTime::parse_from_rfc3339(s) {
+                return Some(dt);
+            }
+            // 2) DuckDB の TIMESTAMP 表示形式を想定（秒以下あり/なし両対応）
+            if let Ok(naive) = NaiveDateTime::parse_from_str(s, "%Y-%m-%d %H:%M:%S%.f")
+                .or_else(|_| NaiveDateTime::parse_from_str(s, "%Y-%m-%d %H:%M:%S"))
+            {
+                let offset = FixedOffset::east_opt(0)?;
+                return Some(DateTime::from_naive_utc_and_offset(naive, offset));
+            }
+            None
+        }
+
+        fn lerp_i32(a: Option<i32>, b: Option<i32>, frac: f64) -> Option<i32> {
+            match (a, b) {
+                (Some(av), Some(bv)) => {
+                    let v = av as f64 + (bv as f64 - av as f64) * frac;
+                    Some(v.round() as i32)
+                }
+                (Some(av), None) => Some(av),
+                (None, Some(bv)) => Some(bv),
+                (None, None) => None,
+            }
+        }
+        fn lerp_i64(a: Option<i64>, b: Option<i64>, frac: f64) -> Option<i64> {
+            match (a, b) {
+                (Some(av), Some(bv)) => {
+                    let v = av as f64 + (bv as f64 - av as f64) * frac;
+                    Some(v.round() as i64)
+                }
+                (Some(av), None) => Some(av),
+                (None, Some(bv)) => Some(bv),
+                (None, None) => None,
+            }
+        }
+
+        // 元データのタイムスタンプをパース
+        let mut times: Vec<DateTime<FixedOffset>> = Vec::with_capacity(stats.len());
+        for s in stats {
+            if let Some(dt) = parse_ts(&s.collected_at) {
+                times.push(dt);
+            } else {
+                // パースできない場合は補完せずそのまま返す
+                return stats.to_vec();
+            }
+        }
+
+        let n = stats.len();
+        if n == 0 {
+            return Vec::new();
+        }
+
+        // 線形補完の範囲は start_time〜end_time（呼び出し元で first/last にクリップ済み）
+        let start_dt = parse_ts(start_time).unwrap_or(times[0]);
+        let end_dt = parse_ts(end_time).unwrap_or(*times.last().unwrap());
+
+        let step = Duration::minutes(interval_minutes.max(1));
+        let mut grid: Vec<DateTime<FixedOffset>> = Vec::new();
+        let mut t = start_dt;
+        while t <= end_dt {
+            grid.push(t);
+            t += step;
+        }
+
+        let mut result: Vec<StreamStats> = Vec::with_capacity(grid.len());
+
+        for t in grid {
+            // 前後のサンプルを探す
+            let mut j = 0usize;
+            while j < n && times[j] < t {
+                j += 1;
+            }
+
+            let prev_idx = if j == 0 { 0 } else { j - 1 };
+            let next_idx = if j >= n { n - 1 } else { j };
+
+            let prev_t = times[prev_idx];
+            let next_t = times[next_idx];
+
+            let prev = &stats[prev_idx];
+            let next = &stats[next_idx];
+
+            let frac = if next_t <= prev_t {
+                0.0
+            } else {
+                let total = (next_t - prev_t).num_seconds() as f64;
+                let elapsed = (t - prev_t).num_seconds() as f64;
+                (elapsed / total).clamp(0.0, 1.0)
+            };
+
+            let viewer = lerp_i32(prev.viewer_count, next.viewer_count, frac);
+            let chat = lerp_i64(prev.chat_rate_1min, next.chat_rate_1min, frac);
+
+            let base = prev; // カテゴリ等は直前の値を使用
+
+            result.push(StreamStats {
+                id: None,
+                stream_id: base.stream_id,
+                collected_at: t.to_rfc3339(),
+                viewer_count: viewer,
+                chat_rate_1min: chat,
+                category: base.category.clone(),
+                game_id: base.game_id.clone(),
+                title: base.title.clone(),
+                follower_count: base.follower_count,
+                twitch_user_id: base.twitch_user_id.clone(),
+                channel_name: base.channel_name.clone(),
+            });
+        }
+
+        result
+    }
+
     /// 自動発見された配信の統計データを挿入
     ///
     /// stream_idがNULLの状態で、自動発見時の統計データを記録します。