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

This commit is contained in:
U1 authored and GitHub committed 2026-09-14 13:23:12 +08:00
1 parent 8efb24f2c7
commit 9c973a2ee3
1 file changed
+119 -5
+119 -5
View File
@@ -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));
}