Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

feat(grid): collapse MySQL batch deletes into IN clauses

U19c973a2ee378
diff --git a/crates/dbx-core/src/data_grid_sql.rs b/crates/dbx-core/src/data_grid_sql.rs
index bca0f02456..630166f71d 100644
--- a/crates/dbx-core/src/data_grid_sql.rs
+++ b/crates/dbx-core/src/data_grid_sql.rs
@@ -1510,7 +1510,7 @@ fn build_data_grid_save_statements(
}
}
if !delete_predicates.is_empty() {
- push_mysql_predicate_batches(&mut statements, &format!("DELETE FROM {table} WHERE "), delete_predicates);
+ push_mysql_delete_batches(&mut statements, &format!("DELETE FROM {table} WHERE "), delete_predicates);
}
for row in &options.new_rows {
@@ -1780,6 +1780,96 @@ fn push_mysql_predicate_batches(statements: &mut Vec<String>, prefix: &str, pred
push_mysql_joined_batches(statements, prefix, predicates, " OR ", true);
}
+/// Render a batch of delete predicates for MySQL. Rows deleted through the grid
+/// usually differ only in a single primary-key equality predicate, so equal-key
+/// runs collapse into `id IN (...)` instead of a chain of ORs (#8857). Anything
+/// that is not a plain `column = literal` equality (compound keys, NULL checks,
+/// BINARY comparisons, ...) falls back to the OR form, which stays correct for
+/// every predicate shape.
+fn push_mysql_delete_batches(statements: &mut Vec<String>, prefix: &str, predicates: Vec<String>) {
+ const IN_JOINER: &str = ", ";
+
+ struct InRun {
+ column: Option<String>,
+ values: Vec<String>,
+ bytes: usize,
+ }
+
+ fn flush_in(run: &mut InRun, batches: &mut Vec<String>) {
+ if let Some(column) = run.column.take() {
+ if run.values.len() == 1 {
+ batches.push(format!("{column} = {}", run.values[0]));
+ } else {
+ batches.push(format!("{column} IN ({})", run.values.join(IN_JOINER)));
+ }
+ run.values.clear();
+ run.bytes = 0;
+ }
+ }
+
+ let mut in_run = InRun { column: None, values: Vec::new(), bytes: 0 };
+ let mut in_batches: Vec<String> = Vec::new();
+ let mut pending_batches: Vec<String> = Vec::new();
+
+ for predicate in &predicates {
+ match parse_mysql_equality_predicate(predicate) {
+ Some((column, literal)) => {
+ let literal_bytes = literal.len() + IN_JOINER.len();
+ let column_switch = in_run.column.as_deref().is_some_and(|existing| existing != column);
+ let over_budget = in_run.bytes + literal_bytes > MYSQL_DATA_GRID_BATCH_TARGET_SQL_BYTES;
+ let over_rows = in_run.values.len() >= MYSQL_DATA_GRID_BATCH_MAX_ROWS;
+ if column_switch || over_budget || over_rows {
+ flush_in(&mut in_run, &mut in_batches);
+ }
+ if in_run.column.is_none() {
+ in_run.column = Some(column);
+ }
+ in_run.bytes += literal_bytes;
+ in_run.values.push(literal);
+ }
+ None => {
+ flush_in(&mut in_run, &mut in_batches);
+ pending_batches.push(predicate.clone());
+ }
+ }
+ }
+ flush_in(&mut in_run, &mut in_batches);
+
+ let mut batches = pending_batches;
+ batches.extend(in_batches);
+ if batches.len() == 1 {
+ statements.push(format!("{prefix}{};", batches.remove(0)));
+ } else if !batches.is_empty() {
+ push_mysql_predicate_batches(statements, prefix, batches);
+ }
+}
+
+/// Recognize predicates shaped exactly like `` `column` = literal `` (with or
+/// without backticks) so they can merge into an IN list. Anything else —
+/// compound-key AND chains, IS NULL, BINARY comparisons — returns None.
+fn parse_mysql_equality_predicate(predicate: &str) -> Option<(String, String)> {
+ let mut trimmed = predicate;
+ while let Some(inner) = trimmed.strip_prefix('(').and_then(|inner| inner.strip_suffix(')')) {
+ trimmed = inner;
+ }
+ let separator = trimmed.find(" = ")?;
+ let column = trimmed.get(..separator)?.trim().to_string();
+ if !column.starts_with('`') || !column.ends_with('`') || column.len() < 3 {
+ return None;
+ }
+ let literal = trimmed.get(separator + 3..)?.trim().to_string();
+ if literal.is_empty() || literal.eq_ignore_ascii_case("null") {
+ return None;
+ }
+ // Compound-key predicates contain further AND/OR/IS clauses after the first
+ // equality; merging those into an IN list would change the row targeting.
+ let upper = literal.to_ascii_uppercase();
+ if upper.contains(" AND ") || upper.contains(" OR ") || upper.starts_with("IS ") {
+ return None;
+ }
+ Some((column, literal))
+}
+
fn push_mysql_values_insert_batches(
statements: &mut Vec<String>,
table: &str,
@@ -7092,15 +7182,35 @@ mod tests {
options.deleted_rows = vec![0, 1, 2];
let result = prepare_data_grid_save(options);
+ for statement in &result.statements {
+ println!("statement: {statement}");
+ }
assert_eq!(result.validation_error, None);
- assert_eq!(result.statements, vec!["DELETE FROM `app`.`people` WHERE (`id` = 1) OR (`id` = 2) OR (`id` = 3);"]);
+ assert_eq!(result.statements, vec!["DELETE FROM `app`.`people` WHERE `id` IN (1, 2, 3);"]);
assert_eq!(
result.rollback_statements,
vec!["INSERT INTO `app`.`people` (`id`, `status`) VALUES (1, 'active'), (2, 'active'), (3, 'active');"]
);
}
+ #[test]
+ fn batches_mysql_compound_key_deletes_keep_or_form() {
+ let mut options = mysql_people_save_options(3);
+ options.table_meta.primary_keys = vec!["id".to_string(), "status".to_string()];
+ options.deleted_rows = vec![0, 1];
+
+ let result = prepare_data_grid_save(options);
+
+ assert_eq!(result.validation_error, None);
+ assert_eq!(
+ result.statements,
+ vec![
+ "DELETE FROM `app`.`people` WHERE (`id` = 1 AND `status` = 'active') OR (`id` = 2 AND `status` = 'active');"
+ ]
+ );
+ }
+
#[test]
fn chunks_large_mysql_data_grid_batches() {
let mut options = mysql_people_save_options(MYSQL_DATA_GRID_BATCH_MAX_ROWS + 1);
@@ -7108,9 +7218,11 @@ mod tests {
let result = prepare_data_grid_save(options);
- assert_eq!(result.statements.len(), 2);
- assert!(result.statements[0].contains("(`id` = 500)"));
- assert_eq!(result.statements[1], "DELETE FROM `app`.`people` WHERE `id` = 501;");
+ // IN lists are far more compact than OR chains, so the batch fits in a
+ // single statement up to the row limit.
+ assert_eq!(result.statements.len(), 1);
+ assert!(result.statements[0].contains("`id` IN ("));
+ assert!(result.statements[0].contains("501"));
assert_eq!(result.rollback_statements.len(), 2);
assert!(result.rollback_statements[0].contains("(500, 'active')"));
assert_eq!(
@@ -7128,6 +7240,8 @@ mod tests {
let result = prepare_data_grid_save(options);
+ // The IN list stays within the SQL byte budget, splitting into a
+ // second statement once the accumulated literals would exceed it.
assert_eq!(result.statements.len(), 2);
assert!(result.statements.iter().all(|statement| statement.len() <= MYSQL_DATA_GRID_BATCH_TARGET_SQL_BYTES));
}