feat(editor): show server time and fetch time separately in result status bar (#990) (#1021)

* feat(editor): show server time and fetch time breakdown in result status bar

* fix(editor): compute consistent total in timing tooltip, revert setup.ts, and ignore volatile timing in golden captures

* fix(editor): preserve frontend total duration in timing tooltip and deduplicate timing split helper

Author: Totopo27

src-tauri/src/drivers/common.rs

@@ -13,10 +13,10 @@ pub use blob::{
 };
 pub use pooled::DetachOnDrop;
 pub use query::{
-    build_paginated_query, calculate_offset, extract_user_limit, extract_user_offset,
-    is_explainable_query,
-    is_select_query, returns_result_set, strip_leading_sql_comments, strip_limit_offset,
-    transaction_effect, TransactionEffect,
+    build_paginated_query, calculate_offset, calculate_query_timing,
+    calculate_query_timing_from_start, extract_user_limit, extract_user_offset,
+    is_explainable_query, is_select_query, returns_result_set, strip_leading_sql_comments,
+    strip_limit_offset, transaction_effect, TransactionEffect,
 };
 pub use routines::{
     generic_drop_routine_sql, generic_routine_call_sql, quote_qualified, render_sql_literal,

src-tauri/src/drivers/common/query.rs

@@ -582,3 +582,28 @@ fn leading_keywords(query: &str, n: usize) -> Vec<String> {
     }
     words
 }
+
+/// Calculates `(server_time_ms, fetch_time_ms)` from the total elapsed time and
+/// the optional elapsed time until the first row was received.
+///
+/// If no rows were received (`first_row_elapsed_ms` is `None`), server execution
+/// time equals the total elapsed time, and fetch time is 0.0.
+pub fn calculate_query_timing(
+    total_elapsed_ms: f64,
+    first_row_elapsed_ms: Option<f64>,
+) -> (Option<f64>, Option<f64>) {
+    match first_row_elapsed_ms {
+        Some(s_ms) => (Some(s_ms), Some((total_elapsed_ms - s_ms).max(0.0))),
+        None => (Some(total_elapsed_ms), Some(0.0)),
+    }
+}
+
+/// Computes query timing given a `start_instant` and the optional
+/// first-row arrival time.
+pub fn calculate_query_timing_from_start(
+    start_instant: std::time::Instant,
+    first_row_elapsed_ms: Option<f64>,
+) -> (Option<f64>, Option<f64>) {
+    let total_elapsed_ms = start_instant.elapsed().as_secs_f64() * 1000.0;
+    calculate_query_timing(total_elapsed_ms, first_row_elapsed_ms)
+}

src-tauri/src/drivers/common/tests.rs

@@ -1,7 +1,8 @@
 use super::{
-    build_paginated_query, decode_blob_wire_format, encode_blob, encode_blob_full, i64_to_json,
-    is_explainable_query, is_select_query, parse_unsafe_bigint_string, strip_leading_sql_comments,
-    strip_limit_offset, transaction_effect, u64_to_json, TransactionEffect, DEFAULT_MAX_BLOB_SIZE,
+    build_paginated_query, calculate_query_timing, calculate_query_timing_from_start,
+    decode_blob_wire_format, encode_blob, encode_blob_full, i64_to_json, is_explainable_query,
+    is_select_query, parse_unsafe_bigint_string, strip_leading_sql_comments, strip_limit_offset,
+    transaction_effect, u64_to_json, TransactionEffect, DEFAULT_MAX_BLOB_SIZE,
     JS_MAX_SAFE_INTEGER, JS_MAX_SAFE_UINT, MAX_BLOB_PREVIEW_SIZE,
 };
 
@@ -867,6 +868,27 @@ fn transaction_effect_ignores_ordinary_statements() {
     }
 }
 
+#[test]
+fn test_calculate_query_timing_with_rows() {
+    let (server, fetch) = calculate_query_timing(50.0, Some(20.0));
+    assert_eq!(server, Some(20.0));
+    assert_eq!(fetch, Some(30.0));
+}
+
+#[test]
+fn test_calculate_query_timing_no_rows() {
+    let (server, fetch) = calculate_query_timing(50.0, None);
+    assert_eq!(server, Some(50.0));
+    assert_eq!(fetch, Some(0.0));
+}
+
+#[test]
+fn test_calculate_query_timing_fetch_non_negative() {
+    let (server, fetch) = calculate_query_timing(50.0, Some(55.0));
+    assert_eq!(server, Some(55.0));
+    assert_eq!(fetch, Some(0.0));
+}
+
 #[test]
 fn transaction_effect_sees_through_leading_comments() {
     assert_eq!(

src-tauri/src/drivers/mysql/mod.rs

@@ -1407,6 +1407,8 @@ async fn exec_on_mysql_conn(
             truncated: false,
             pagination: None,
             additional_results: None,
+            server_time_ms: None,
+            fetch_time_ms: None,
         });
     }
 
@@ -1428,6 +1430,8 @@ async fn exec_on_mysql_conn(
             truncated: false,
             pagination: None,
             additional_results: None,
+            server_time_ms: None,
+            fetch_time_ms: None,
         });
     }
 
@@ -1460,6 +1464,9 @@ async fn exec_on_mysql_conn(
     // terminator per result set, which the collector folds into discrete sets.
     let mut collector = multi_result::ResultSetCollector::new(manual_limit);
 
+    let start_instant = std::time::Instant::now();
+    let mut server_time_ms: Option<f64> = None;
+
     // Scope the stream so `conn` borrow is released before returning
     {
         use futures::stream::StreamExt;
@@ -1471,6 +1478,9 @@ async fn exec_on_mysql_conn(
         };
 
         while let Some(result) = event_stream.next().await {
+            if server_time_ms.is_none() {
+                server_time_ms = Some(start_instant.elapsed().as_secs_f64() * 1000.0);
+            }
             match result {
                 Ok(sqlx::Either::Left(_)) => collector.end_result_set(),
                 Ok(sqlx::Either::Right(row)) => {
@@ -1501,6 +1511,9 @@ async fn exec_on_mysql_conn(
         }
     } // event_stream dropped here — conn borrow released
 
+    let (server_time, fetch_time) =
+        crate::drivers::common::calculate_query_timing_from_start(start_instant, server_time_ms);
+
     let mut result_sets = collector.finish();
     let primary = if result_sets.is_empty() {
         multi_result::ResultSetData::default()
@@ -1525,6 +1538,8 @@ async fn exec_on_mysql_conn(
                     truncated: set.truncated,
                     pagination: None,
                     additional_results: None,
+                    server_time_ms: None,
+                    fetch_time_ms: None,
                 })
                 .collect(),
         )
@@ -1547,6 +1562,8 @@ async fn exec_on_mysql_conn(
         truncated,
         pagination,
         additional_results,
+        server_time_ms: server_time,
+        fetch_time_ms: fetch_time,
     })
 }
 

src-tauri/src/drivers/postgres/mod.rs

@@ -1090,6 +1090,8 @@ async fn exec_on_pg_client(
             truncated: false,
             pagination: None,
             additional_results: None,
+            server_time_ms: None,
+            fetch_time_ms: None,
         });
     }
 
@@ -1106,6 +1108,9 @@ async fn exec_on_pg_client(
         (query.to_string(), None)
     };
 
+    let start_instant = std::time::Instant::now();
+    let mut server_time_ms: Option<f64> = None;
+
     let pg_params: Vec<i32> = vec![];
     let mut rows_stream = std::pin::pin!(client
         .query_raw(&final_query, &pg_params)
@@ -1118,6 +1123,9 @@ async fn exec_on_pg_client(
     use futures::stream::StreamExt;
 
     while let Some(result) = rows_stream.next().await {
+        if server_time_ms.is_none() {
+            server_time_ms = Some(start_instant.elapsed().as_secs_f64() * 1000.0);
+        }
         match result {
             Ok(row) => {
                 if columns.is_empty() {
@@ -1142,6 +1150,9 @@ async fn exec_on_pg_client(
         }
     }
 
+    let (server_time, fetch_time) =
+        crate::drivers::common::calculate_query_timing_from_start(start_instant, server_time_ms);
+
     let pagination = if let Some((page_size, p)) = pagination_meta {
         let has_more = json_rows.len() > page_size as usize;
         if has_more {
@@ -1165,6 +1176,8 @@ async fn exec_on_pg_client(
         truncated,
         pagination,
         additional_results: None,
+        server_time_ms: server_time,
+        fetch_time_ms: fetch_time,
     })
 }
 

src-tauri/src/drivers/sqlite/mod.rs

@@ -666,6 +666,8 @@ async fn exec_on_sqlite_conn(
             truncated: false,
             pagination: None,
             additional_results: None,
+            server_time_ms: None,
+            fetch_time_ms: None,
         });
     }
 
@@ -692,6 +694,8 @@ async fn exec_on_sqlite_conn(
     }
 
     // Streaming
+    let start_instant = std::time::Instant::now();
+    let mut server_time_ms: Option<f64> = None;
     let mut rows_stream = sqlx::query(&final_query).fetch(&mut *conn);
 
     let mut columns: Vec<String> = Vec::new();
@@ -701,6 +705,9 @@ async fn exec_on_sqlite_conn(
     use futures::stream::StreamExt;
 
     while let Some(result) = rows_stream.next().await {
+        if server_time_ms.is_none() {
+            server_time_ms = Some(start_instant.elapsed().as_secs_f64() * 1000.0);
+        }
         match result {
             Ok(row) => {
                 if columns.is_empty() {
@@ -725,6 +732,9 @@ async fn exec_on_sqlite_conn(
         }
     }
 
+    let (server_time, fetch_time) =
+        crate::drivers::common::calculate_query_timing_from_start(start_instant, server_time_ms);
+
     // Apply LIMIT +1 result: if we got page_size+1 rows, has_more=true
     if let Some(ref mut p) = pagination {
         let has_more = json_rows.len() > p.page_size as usize;
@@ -742,6 +752,8 @@ async fn exec_on_sqlite_conn(
         truncated,
         pagination,
         additional_results: None,
+        server_time_ms: server_time,
+        fetch_time_ms: fetch_time,
     })
 }
 

src-tauri/src/models.rs

@@ -517,6 +517,10 @@ pub struct QueryResult {
     /// of multi-result statements keep working unchanged.
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub additional_results: Option<Vec<QueryResult>>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub server_time_ms: Option<f64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub fetch_time_ms: Option<f64>,
 }
 
 /// One statement's outcome within an `execute_batch` call. Exactly one of
@@ -765,4 +769,24 @@ mod appearance_tests {
         let s = serde_json::to_string(&a).unwrap();
         assert_eq!(s, r##"{"accentColor":"#ff0000"}"##);
     }
+
+    #[test]
+    fn query_result_roundtrip_with_timing() {
+        let qr = QueryResult {
+            columns: vec!["id".into()],
+            rows: vec![vec![serde_json::json!(1)]],
+            affected_rows: 0,
+            truncated: false,
+            pagination: None,
+            additional_results: None,
+            server_time_ms: Some(12.5),
+            fetch_time_ms: Some(3.2),
+        };
+        let s = serde_json::to_string(&qr).unwrap();
+        assert!(s.contains("server_time_ms"));
+        assert!(s.contains("fetch_time_ms"));
+        let back: QueryResult = serde_json::from_str(&s).unwrap();
+        assert_eq!(back.server_time_ms, Some(12.5));
+        assert_eq!(back.fetch_time_ms, Some(3.2));
+    }
 }

src-tauri/tests/postgres_integration/golden.rs

@@ -172,7 +172,7 @@ async fn golden_get_triggers() {
 async fn golden_execute_query_all_types() {
     require_pg!();
     let params = pg_params();
-    let result = postgres::execute_query(
+    let mut result = postgres::execute_query(
         &params,
         "SELECT * FROM test_schema.all_types WHERE id = 1",
         None,
@@ -181,6 +181,8 @@ async fn golden_execute_query_all_types() {
     )
     .await
     .expect("execute_query");
+    result.server_time_ms = None;
+    result.fetch_time_ms = None;
     write_golden("execute_query_all_types.json", &result);
     assert_golden("execute_query_all_types.json", &result);
 }
@@ -312,7 +314,7 @@ async fn golden_get_trigger_definition() {
 async fn golden_execute_query_with_pagination() {
     require_pg!();
     let params = pg_params();
-    let result = postgres::execute_query(
+    let mut result = postgres::execute_query(
         &params,
         "SELECT id, col_text FROM test_schema.all_types ORDER BY id",
         Some(2),
@@ -321,6 +323,8 @@ async fn golden_execute_query_with_pagination() {
     )
     .await
     .expect("execute_query with pagination");
+    result.server_time_ms = None;
+    result.fetch_time_ms = None;
     write_golden("execute_query_with_pagination.json", &result);
     assert_golden("execute_query_with_pagination.json", &result);
 }
@@ -348,7 +352,7 @@ async fn golden_explain_analyze() {
 async fn golden_count_query() {
     require_pg!();
     let params = pg_params();
-    let result = postgres::execute_query(
+    let mut result = postgres::execute_query(
         &params,
         "SELECT COUNT(*) AS cnt FROM test_schema.all_types",
         None,
@@ -357,6 +361,8 @@ async fn golden_count_query() {
     )
     .await
     .expect("count query");
+    result.server_time_ms = None;
+    result.fetch_time_ms = None;
     write_golden("count_query.json", &result);
     assert_golden("count_query.json", &result);
 }

src/components/ui/ResultEntryContent.tsx

@@ -4,7 +4,8 @@ import { CheckCircle2 } from "lucide-react";
 import { DataGrid, type DataGridCommandTarget } from "./DataGrid";
 import { ErrorDisplay } from "./ErrorDisplay";
 import { PaginationControls } from "./PaginationControls";
-import { formatDuration } from "../../utils/formatTime";
+import { formatDuration, formatTimingTooltip } from "../../utils/formatTime";
+import { useTimingLabels } from "../../hooks/useTimingLabels";
 import { getStackedGridHeight } from "../../utils/multiResult";
 import type { QueryResultEntry } from "../../types/editor";
 
@@ -36,6 +37,7 @@ export function ResultEntryContent({
   onScrollTopChange,
 }: ResultEntryContentProps) {
   const { t } = useTranslation();
+  const timingLabels = useTimingLabels();
 
   if (entry.isLoading) {
     if (compact) {
@@ -71,14 +73,25 @@ export function ResultEntryContent({
     );
   }
 
+  const timingTooltip = entry.result
+    ? formatTimingTooltip(
+        {
+          serverTimeMs: entry.result.server_time_ms,
+          fetchTimeMs: entry.result.fetch_time_ms,
+          totalTimeMs: entry.executionTime,
+        },
+        timingLabels,
+      ) ?? undefined
+    : undefined;
+
   // A statement that returns no result set (INSERT/UPDATE/DELETE/DDL such as
   // CREATE/ALTER/DROP VIEW) still succeeded — surface that explicitly instead
   // of an empty grid with a misleading "0 rows retrieved" header.
   if (entry.result.columns.length === 0) {
     const affected = entry.result.affected_rows ?? 0;
     const time =
       entry.executionTime !== null ? (
-        <span className="text-muted font-mono">
+        <span className="text-muted font-mono" title={timingTooltip}>
           ({formatDuration(entry.executionTime)})
         </span>
       ) : null;
@@ -152,7 +165,10 @@ export function ResultEntryContent({
               count: entry.result.rows.length,
             })}{" "}
             {entry.executionTime !== null && (
-              <span className="hidden @[400px]:inline text-muted ml-2 font-mono">
+              <span
+                className="hidden @[400px]:inline text-muted ml-2 font-mono"
+                title={timingTooltip}
+              >
                 ({formatDuration(entry.executionTime)})
               </span>
             )}