feat(sql-file): show per-file execution statistics

This commit is contained in:
Abeautifulsnow authored and GitHub committed 2026-07-30 18:41:56 +08:00
1 parent 51315e549f
commit 6c3c6864f3
14 files changed
+496 -26

No files matched your search

+6
View File
@@ -237,6 +237,12 @@ pub struct SqlFileProgress {
pub elapsed_ms: u128,
pub statement_summary: String,
pub error: Option<String>,
/// When processing multiple files, the 0-based index of the current file.
#[serde(skip_serializing_if = "Option::is_none")]
pub file_index: Option<usize>,
/// When processing multiple files, the name of the current file.
#[serde(skip_serializing_if = "Option::is_none")]
pub file_name: Option<String>,
}
pub fn decode_sql_file_bytes(bytes: &[u8]) -> Result<String, String> {
+117 -3
View File
@@ -62,8 +62,11 @@ where
}
pub fn emit(&mut self, progress: SqlFileProgress) {
if sql_file_progress_is_immediate(progress.status) {
// Preserve ordering and final counters before terminal or failure events.
if sql_file_progress_is_immediate(progress.status) || progress.file_index.is_some() {
// Preserve ordering and final counters before terminal or failure
// events. File-boundary events (file_index is Some) are also
// emitted immediately so rapid multi-file runs don't lose per-file
// summaries through throttling.
self.flush_pending();
(self.emit)(progress);
return;
@@ -390,7 +393,32 @@ pub async fn execute_sql_file_paths(
return Err(error);
}
};
for file_path in file_paths {
let file_count = file_paths.len();
let mut prev_statement_index = 0usize;
let mut prev_success_count = 0usize;
let mut prev_failure_count = 0usize;
let mut prev_affected_rows = 0u64;
for (file_index, file_path) in file_paths.iter().enumerate() {
let file_name = file_path.file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_default();
// Emit a file-boundary progress event so the frontend knows which file is
// currently executing and can display a "File N/M" indicator.
if file_count > 1 {
emit(SqlFileProgress {
execution_id: request.execution_id.clone(),
status: SqlFileStatus::Running,
statement_index: progress.statement_index,
success_count: progress.success_count,
failure_count: progress.failure_count,
affected_rows: progress.affected_rows,
elapsed_ms: started_at.elapsed().as_millis(),
statement_summary: String::new(),
error: None,
file_index: Some(file_index),
file_name: Some(file_name.clone()),
});
}
let mut splitter = StreamingSqlFileSplitter::new(database_type, options);
let mut pending_statements = Vec::with_capacity(SQL_FILE_STATEMENT_BATCH_SIZE);
let mut decoder = match SqlFileStreamDecoder::open(file_path).await {
@@ -457,6 +485,28 @@ pub async fn execute_sql_file_paths(
&mut emit,
)
.await?;
// After each file, emit a per-file summary with diff-based counters so
// the frontend can build a per-file breakdown table.
if file_count > 1 {
emit(SqlFileProgress {
execution_id: request.execution_id.clone(),
status: SqlFileStatus::StatementDone,
statement_index: progress.statement_index - prev_statement_index,
success_count: progress.success_count - prev_success_count,
failure_count: progress.failure_count - prev_failure_count,
affected_rows: progress.affected_rows - prev_affected_rows,
elapsed_ms: started_at.elapsed().as_millis(),
statement_summary: String::new(),
error: None,
file_index: Some(file_index),
file_name: Some(file_name),
});
prev_statement_index = progress.statement_index;
prev_success_count = progress.success_count;
prev_failure_count = progress.failure_count;
prev_affected_rows = progress.affected_rows;
}
}
emit_sql_file_terminal_progress(request, &token, started_at, &progress, &mut emit);
Ok(())
@@ -753,6 +803,8 @@ pub fn sql_file_progress(
elapsed_ms: started_at.elapsed().as_millis(),
statement_summary: statement_summary.to_string(),
error,
file_index: None,
file_name: None,
}
}
@@ -1415,6 +1467,21 @@ mod tests {
elapsed_ms: statement_index as u128,
statement_summary: format!("statement {statement_index}"),
error: None,
file_index: None,
file_name: None,
}
}
fn test_file_progress(
status: SqlFileStatus,
statement_index: usize,
file_index: usize,
file_name: &str,
) -> SqlFileProgress {
SqlFileProgress {
file_index: Some(file_index),
file_name: Some(file_name.to_string()),
..test_progress(status, statement_index)
}
}
@@ -1760,4 +1827,51 @@ mod tests {
assert_eq!(mysql_use_database_target("USE"), None);
assert_eq!(mysql_use_database_target("USE app_db SELECT 1"), None);
}
#[test]
fn file_boundary_events_bypass_throttling_and_retain_order() {
// Regression: rapid multi-file runs must not lose per-file boundary
// events through the progress emitter's 100 ms throttle window.
let base = Instant::now();
let elapsed = Cell::new(Duration::ZERO);
let mut emitted = Vec::new();
{
let mut emitter =
SqlFileProgressEmitter::with_clock(|progress| emitted.push(progress), || base + elapsed.get());
// Simulate two small files executing within the same throttle window.
for statement_index in 1..=3 {
emitter.emit(test_progress(SqlFileStatus::StatementDone, statement_index));
}
// File 0 start + done.
emitter.emit(test_file_progress(SqlFileStatus::Running, 3, 0, "a.sql"));
emitter.emit(test_file_progress(SqlFileStatus::StatementDone, 3, 0, "a.sql"));
for statement_index in 4..=6 {
emitter.emit(test_progress(SqlFileStatus::StatementDone, statement_index));
}
// File 1 start + done — still within the same throttle window.
emitter.emit(test_file_progress(SqlFileStatus::Running, 6, 1, "b.sql"));
emitter.emit(test_file_progress(SqlFileStatus::StatementDone, 6, 1, "b.sql"));
emitter.emit(test_progress(SqlFileStatus::Done, 6));
}
let file_boundary_events: Vec<_> = emitted
.iter()
.filter(|p| p.file_index.is_some())
.map(|p| (p.status, p.file_index, p.file_name.clone()))
.collect();
assert_eq!(
file_boundary_events,
vec![
(SqlFileStatus::Running, Some(0), Some("a.sql".to_string())),
(SqlFileStatus::StatementDone, Some(0), Some("a.sql".to_string())),
(SqlFileStatus::Running, Some(1), Some("b.sql".to_string())),
(SqlFileStatus::StatementDone, Some(1), Some("b.sql".to_string())),
],
"file-boundary events must be emitted immediately, in order, without being dropped by throttling"
);
assert_eq!(emitted.last().unwrap().status, SqlFileStatus::Done);
}
}