//! 「预览变更」SQL 生成:把 SQL 编辑器里的一条 DML(UPDATE / INSERT / DELETE) //! 改写成一条只读 SELECT,用于在执行前干跑预览受影响的数据。 //! //! 思路:不手工重建 sqlparser AST,而是复用 sqlparser 对表达式 / 表 / WHERE 的 //! 方言正确渲染(`Display` round-trip),只在外层做字符串装配: //! UPDATE t SET a = 123 WHERE id = 1 //! → SELECT *, 123 AS "a (new)" FROM t WHERE id = 1 //! `SELECT *` 展开受影响行全部当前值,新值列(别名后缀 ` (new)`)追加在末尾; //! SET 表达式直接搬运(在行上下文中按旧值求值即得新值,`SET a = a + 1` 也能算对)。 //! 注意:SET / VALUES 表达式会在预览 SELECT 中重新求值,带副作用的表达式 //! (推进序列、volatile 函数)在预览中同样生效,非确定性函数的预览值可能与实际执行不同。 //! //! 无法安全改写的语句返回 Err(错误信息为英文,前端直接以 toast 展示,仍可正常执行原语句)。 use sqlparser::ast::{AssignmentTarget, Expr, Ident, ObjectNamePart, SetExpr, Statement, TableWithJoins}; use sqlparser::dialect::{ ClickHouseDialect, DuckDbDialect, GenericDialect, MsSqlDialect, MySqlDialect, PostgreSqlDialect, SQLiteDialect, SparkSqlDialect, }; use sqlparser::parser::Parser; #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] #[serde(rename_all = "camelCase")] pub struct DmlChangePreviewSqlOptions { /// 用户写的一条 DML 语句(通常是当前语句)。 pub sql: String, /// 连接类型(决定解析方言 / 默认标识符引号)。 pub database_type: Option, /// 连接的标识符引号字符(如 `"`、`` ` ``、`[`),None 时按方言回退。 pub identifier_quote: Option, /// 目标表的列(按 ordinal 顺序)。提供且为单表 UPDATE 时,新值列紧跟其原值列。 #[serde(default, skip_serializing_if = "Option::is_none")] pub columns: Option>, } #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] #[serde(rename_all = "camelCase")] pub struct DmlChangePreviewTableRef { pub catalog: Option, pub database: Option, pub schema: Option, pub table: Option, } #[derive(Debug, Clone, serde::Serialize)] #[serde(rename_all = "camelCase")] pub struct DmlChangePreviewSqlResult { /// 生成的只读 SELECT。 pub sql: String, /// 语句类型:update / insert / delete。 pub operation: String, /// 是否有「新值」列(仅 UPDATE 有,INSERT 的列本身即新值)。 pub has_new_value_columns: bool, /// 语句目标表引用(供前端拉取列元数据以交错展示新值列)。 pub tables: Vec, } fn normalize_dialect(database_type: Option<&str>) -> &'static str { match database_type.unwrap_or("generic").to_ascii_lowercase().as_str() { "postgres" | "postgresql" | "redshift" | "opengauss" | "gaussdb" | "highgo" | "uxdb" | "questdb" => "postgres", "mysql" | "mariadb" | "doris" | "starrocks" | "manticoresearch" | "oceanbase" | "tidb" => "mysql", "sqlite" => "sqlite", "sqlserver" | "mssql" => "sqlserver", "clickhouse" => "clickhouse", "duckdb" => "duckdb", "spark" | "sparksql" => "spark", _ => "generic", } } fn parse_statements(sql: &str, dialect_key: &str) -> Result, String> { match dialect_key { "postgres" => Parser::parse_sql(&PostgreSqlDialect {}, sql), "mysql" => Parser::parse_sql(&MySqlDialect {}, sql), "sqlite" => Parser::parse_sql(&SQLiteDialect {}, sql), "sqlserver" => Parser::parse_sql(&MsSqlDialect {}, sql), "clickhouse" => Parser::parse_sql(&ClickHouseDialect {}, sql), "duckdb" => Parser::parse_sql(&DuckDbDialect {}, sql), "spark" => Parser::parse_sql(&SparkSqlDialect {}, sql), _ => Parser::parse_sql(&GenericDialect {}, sql), } .map_err(|error| format!("Failed to parse the statement: {error}")) } fn quote_identifier(name: &str, quote: Option<&str>, dialect_key: &str) -> String { if let Some(value) = quote { if value == "`" || value == "\"" || value == "'" { return format!("{value}{name}{value}"); } if value == "[" { return format!("[{name}]"); } } match dialect_key { "mysql" => format!("`{name}`"), _ => format!("\"{name}\""), } } /// 从赋值目标里取出列名(`t.a` → `a`)。 fn assignment_target_column(target: &AssignmentTarget) -> Option<&Ident> { match target { AssignmentTarget::ColumnName(object_name) => object_name.0.last().and_then(ObjectNamePart::as_ident), AssignmentTarget::Tuple(_) => None, } } fn unsupported(reason: &str) -> String { format!("Preview is not supported: {reason}") } /// UPDATE → SELECT <列交错展开> FROM … WHERE … /// /// 提供目标表列清单且为单表时,按「原列, 原列 (new)」逐列交错展开,使新值列紧跟 /// 其原值列;否则退化为 `SELECT *, AS "列 (new)", …`(追加在末尾)。 fn build_update_preview( update: &sqlparser::ast::Update, dialect_key: &str, quote: Option<&str>, columns: Option<&[String]>, ) -> Result { // 收集 SET 新值表达式:同列重复赋值取最后一次,但保持首次出现的列序。 #[derive(Clone)] struct SetItem { column: String, expr: String, } let mut set_items: Vec = Vec::new(); let mut set_order: Vec = Vec::new(); // 小写列名 → 顺序 for assignment in &update.assignments { let Some(column) = assignment_target_column(&assignment.target) else { return Err(unsupported("UPDATE assignment target is not a single column")); }; let column_name = column.value.clone(); let key = column_name.to_lowercase(); if let Some(position) = set_order.iter().position(|existing| *existing == key) { set_order.remove(position); set_items.remove(position); } set_order.push(key); set_items.push(SetItem { column: column_name, expr: assignment.value.to_string() }); } // Postgres `UPDATE … FROM …`:同一目标行可能匹配多行来源,真实 UPDATE 只更新一次, // 而改写出的 SELECT 会把该行显示多次(跨连接重复计数),直接拒绝预览。 if let Some(from_kind) = &update.from { let extra_count = match from_kind { sqlparser::ast::UpdateTableFromKind::BeforeSet(list) | sqlparser::ast::UpdateTableFromKind::AfterSet(list) => list.len(), }; if extra_count > 0 { return Err(unsupported("UPDATE ... FROM")); } } let from_sql = update.table.to_string(); let render_new_value = |item: &SetItem| -> String { format!("{} AS {}", item.expr, quote_identifier(&format!("{} (new)", item.column), quote, dialect_key)) }; let append_items: Vec = set_items.iter().map(render_new_value).collect(); // 单表 + 提供了列清单 → 交错展开(新值列紧跟原值列)。 let single_table = update.table.joins.is_empty() && update.from.is_none(); let select_items = if single_table { match columns { Some(column_list) if !column_list.is_empty() => { let mut projection: Vec = Vec::new(); let mut placed: Vec = Vec::new(); for column in column_list { projection.push(quote_identifier(column, quote, dialect_key)); let key = column.to_lowercase(); if let Some(position) = set_order.iter().position(|existing| *existing == key) { projection.push(render_new_value(&set_items[position])); placed.push(key); } } // SET 列未在列清单中(大小写差异 / 虚拟列等)追加到末尾,避免遗漏。 for (index, key) in set_order.iter().enumerate() { if !placed.contains(key) { projection.push(render_new_value(&set_items[index])); } } projection.join(", ") } _ => { if append_items.is_empty() { "*".to_string() } else { format!("*, {}", append_items.join(", ")) } } } } else if append_items.is_empty() { "*".to_string() } else { format!("*, {}", append_items.join(", ")) }; let mut sql = format!("SELECT {select_items} FROM {from_sql}"); if let Some(selection) = &update.selection { sql.push_str(&format!(" WHERE {selection}")); } if !update.order_by.is_empty() { let order_by = update.order_by.iter().map(|item| item.to_string()).collect::>().join(", "); sql.push_str(&format!(" ORDER BY {order_by}")); } if let Some(limit) = &update.limit { sql.push_str(&format!(" LIMIT {limit}")); } Ok(sql) } /// INSERT … VALUES → SELECT 值行 UNION ALL …(列名来自插入列,直观展示即将插入的行)。 fn build_insert_preview( insert: &sqlparser::ast::Insert, dialect_key: &str, quote: Option<&str>, ) -> Result { // MySQL `INSERT INTO t SET a=1, b=2` if !insert.assignments.is_empty() { let items: Vec = insert .assignments .iter() .map(|assignment| { let col = assignment_target_column(&assignment.target) .ok_or_else(|| unsupported("INSERT ... SET assignment target is not a single column"))?; Ok(format!("{} AS {}", assignment.value, quote_identifier(&col.value, quote, dialect_key))) }) .collect::, String>>()?; if items.is_empty() { return Err(unsupported("INSERT ... SET has no assignments")); } return Ok(format!("SELECT {}", items.join(", "))); } let Some(source) = &insert.source else { return Err(unsupported("INSERT has no source")); }; match source.body.as_ref() { SetExpr::Values(values) => { let column_names: Vec = insert .columns .iter() .filter_map(|column| { column.0.last().and_then(ObjectNamePart::as_ident).map(|ident| ident.value.clone()) }) .collect(); if !column_names.is_empty() && values.rows.iter().any(|row| row.content.len() != column_names.len()) { return Err(unsupported("INSERT VALUES row length does not match the column list")); } let render_row = |row_exprs: &[Expr]| -> String { let cells: Vec = row_exprs .iter() .enumerate() .map(|(index, expr)| { let expr_text = expr.to_string(); if column_names.is_empty() { expr_text } else { format!("{expr_text} AS {}", quote_identifier(&column_names[index], quote, dialect_key)) } }) .collect(); format!("SELECT {}", cells.join(", ")) }; let rows = values.rows.iter().collect::>(); let Some(first) = rows.first() else { return Err(unsupported("INSERT VALUES is empty")); }; let mut sql = render_row(&first.content); for row in rows.iter().skip(1) { sql.push_str(" UNION ALL "); sql.push_str(&render_row(&row.content)); } Ok(sql) } _ => { // INSERT … SELECT:预览 = 源查询(即将会插入的行)。 Ok(source.to_string()) } } } /// DELETE → SELECT * FROM … WHERE …(标明将删除的行;无「新值」列)。 fn build_delete_preview( delete: &sqlparser::ast::Delete, _dialect_key: &str, _quote: Option<&str>, ) -> Result { let from_sql = match &delete.from { sqlparser::ast::FromTable::WithFromKeyword(tables) | sqlparser::ast::FromTable::WithoutKeyword(tables) => { tables.iter().map(|table: &TableWithJoins| table.to_string()).collect::>().join(", ") } }; if from_sql.is_empty() { return Err(unsupported("DELETE has no FROM")); } let mut sql = format!("SELECT * FROM {from_sql}"); if let Some(using) = &delete.using { if !using.is_empty() { let using_sql = using.iter().map(|table| table.to_string()).collect::>().join(", "); sql.push_str(&format!(", {using_sql}")); } } if let Some(selection) = &delete.selection { sql.push_str(&format!(" WHERE {selection}")); } if !delete.order_by.is_empty() { let order_by = delete.order_by.iter().map(|item| item.to_string()).collect::>().join(", "); sql.push_str(&format!(" ORDER BY {order_by}")); } if let Some(limit) = &delete.limit { sql.push_str(&format!(" LIMIT {limit}")); } Ok(sql) } pub fn build_dml_change_preview_sql(options: DmlChangePreviewSqlOptions) -> Result { let dialect_key = normalize_dialect(options.database_type.as_deref()); let statements = parse_statements(&options.sql, dialect_key)?; let statement = match statements.len() { 0 => return Err(unsupported("no statement to preview")), 1 => &statements[0], _ => return Err(unsupported("only one statement can be previewed at a time")), }; let quote = options.identifier_quote.as_deref(); let columns = options.columns.as_deref(); match statement { Statement::Update(update) => Ok(DmlChangePreviewSqlResult { sql: build_update_preview(update, dialect_key, quote, columns)?, operation: "update".to_string(), has_new_value_columns: true, tables: vec![update_primary_table_ref(update)], }), Statement::Insert(insert) => Ok(DmlChangePreviewSqlResult { sql: build_insert_preview(insert, dialect_key, quote)?, operation: "insert".to_string(), has_new_value_columns: true, tables: vec![insert_table_ref(insert)], }), Statement::Delete(delete) => Ok(DmlChangePreviewSqlResult { sql: build_delete_preview(delete, dialect_key, quote)?, operation: "delete".to_string(), has_new_value_columns: false, tables: vec![delete_table_ref(delete)], }), _ => Err(unsupported("only UPDATE / INSERT / DELETE statements can be previewed")), } } fn object_name_table_ref(name: &sqlparser::ast::ObjectName) -> DmlChangePreviewTableRef { let names: Vec = name.0.iter().filter_map(|part| part.as_ident().map(|ident| ident.value.clone())).collect(); match names.len() { 4 => DmlChangePreviewTableRef { catalog: Some(names[0].clone()), database: Some(names[1].clone()), schema: Some(names[2].clone()), table: Some(names[3].clone()), }, 3 => DmlChangePreviewTableRef { catalog: None, database: Some(names[0].clone()), schema: Some(names[1].clone()), table: Some(names[2].clone()), }, 2 => DmlChangePreviewTableRef { catalog: None, database: None, schema: Some(names[0].clone()), table: Some(names[1].clone()), }, 1 => DmlChangePreviewTableRef { catalog: None, database: None, schema: None, table: names.into_iter().next() }, _ => DmlChangePreviewTableRef { catalog: None, database: None, schema: None, table: None }, } } fn update_primary_table_ref(update: &sqlparser::ast::Update) -> DmlChangePreviewTableRef { match &update.table.relation { sqlparser::ast::TableFactor::Table { name, .. } => object_name_table_ref(name), _ => DmlChangePreviewTableRef { catalog: None, database: None, schema: None, table: None }, } } fn insert_table_ref(insert: &sqlparser::ast::Insert) -> DmlChangePreviewTableRef { match &insert.table { sqlparser::ast::TableObject::TableName(name) => object_name_table_ref(name), _ => DmlChangePreviewTableRef { catalog: None, database: None, schema: None, table: None }, } } fn delete_table_ref(delete: &sqlparser::ast::Delete) -> DmlChangePreviewTableRef { if let Some(first) = delete.tables.first() { return object_name_table_ref(first); } let tables = match &delete.from { sqlparser::ast::FromTable::WithFromKeyword(tables) | sqlparser::ast::FromTable::WithoutKeyword(tables) => { tables } }; match tables.first().and_then(|table| match &table.relation { sqlparser::ast::TableFactor::Table { name, .. } => Some(name), _ => None, }) { Some(name) => object_name_table_ref(name), None => DmlChangePreviewTableRef { catalog: None, database: None, schema: None, table: None }, } } #[cfg(test)] mod tests { use super::*; fn preview(sql: &str, database_type: &str) -> Result { build_dml_change_preview_sql(DmlChangePreviewSqlOptions { sql: sql.to_string(), database_type: Some(database_type.to_string()), identifier_quote: None, columns: None, }) } fn preview_with_columns( sql: &str, database_type: &str, columns: Vec, ) -> Result { build_dml_change_preview_sql(DmlChangePreviewSqlOptions { sql: sql.to_string(), database_type: Some(database_type.to_string()), identifier_quote: None, columns: Some(columns), }) } #[test] fn update_simple_single_table() { let result = preview("UPDATE admin_sessions SET public_id = 123 WHERE id = 1", "mysql").unwrap(); assert_eq!(result.operation, "update"); assert_eq!(result.sql, "SELECT *, 123 AS `public_id (new)` FROM admin_sessions WHERE id = 1"); } #[test] fn update_multiple_assignments_and_expression() { let result = preview("UPDATE t SET a = 1, b = a + 1", "postgres").unwrap(); assert_eq!(result.sql, "SELECT *, 1 AS \"a (new)\", a + 1 AS \"b (new)\" FROM t"); } #[test] fn update_deduplicates_same_column_last_wins() { let result = preview("UPDATE t SET x = 1, x = 2", "postgres").unwrap(); assert_eq!(result.sql, "SELECT *, 2 AS \"x (new)\" FROM t"); } #[test] fn update_with_alias_and_join() { let result = preview("UPDATE a JOIN b ON a.id = b.id SET a.x = b.x WHERE a.id = 1", "mysql").unwrap(); assert_eq!(result.sql, "SELECT *, b.x AS `x (new)` FROM a JOIN b ON a.id = b.id WHERE a.id = 1"); } #[test] fn update_postgres_from_clause_rejected() { // `UPDATE … FROM …` 的目标行可能匹配多行来源,跨连接改写会重复计数,应拒绝预览。 let error = preview("UPDATE t SET x = s.y FROM s WHERE t.id = s.id", "postgres").unwrap_err(); assert_eq!(error, "Preview is not supported: UPDATE ... FROM"); } #[test] fn update_where_missing() { let result = preview("UPDATE t SET x = 1", "sqlite").unwrap(); assert_eq!(result.sql, "SELECT *, 1 AS \"x (new)\" FROM t"); } #[test] fn insert_values_with_columns() { let result = preview("INSERT INTO t (a, b) VALUES (1, 'x'), (2, 'y')", "postgres").unwrap(); assert_eq!(result.sql, "SELECT 1 AS \"a\", 'x' AS \"b\" UNION ALL SELECT 2 AS \"a\", 'y' AS \"b\""); } #[test] fn insert_select_source() { let result = preview("INSERT INTO t SELECT id, name FROM src WHERE active", "postgres").unwrap(); assert_eq!(result.sql, "SELECT id, name FROM src WHERE active"); } #[test] fn insert_set_mysql() { let result = preview("INSERT INTO t SET a = 1, b = 'x'", "mysql").unwrap(); assert_eq!(result.sql, "SELECT 1 AS `a`, 'x' AS `b`"); } #[test] fn delete_simple() { let result = preview("DELETE FROM t WHERE id = 1", "postgres").unwrap(); assert_eq!(result.operation, "delete"); assert_eq!(result.sql, "SELECT * FROM t WHERE id = 1"); } #[test] fn delete_mysql_multi_table() { let result = preview("DELETE d FROM d JOIN logs l ON d.id = l.id WHERE l.ts < '2020-01-01'", "mysql").unwrap(); assert_eq!(result.sql, "SELECT * FROM d JOIN logs l ON d.id = l.id WHERE l.ts < '2020-01-01'"); } #[test] fn rejects_multiple_statements() { assert!(preview("UPDATE t SET a = 1; UPDATE t2 SET b = 2", "postgres").is_err()); } #[test] fn rejects_non_dml() { assert!(preview("SELECT * FROM t", "postgres").is_err()); } #[test] fn respects_identifier_quote() { let result = build_dml_change_preview_sql(DmlChangePreviewSqlOptions { sql: "UPDATE t SET a = 1 WHERE id = 1".to_string(), database_type: Some("postgres".to_string()), identifier_quote: Some("\"".to_string()), columns: None, }) .unwrap(); assert_eq!(result.sql, "SELECT *, 1 AS \"a (new)\" FROM t WHERE id = 1"); } #[test] fn update_sqlserver_bracket_quote() { let result = build_dml_change_preview_sql(DmlChangePreviewSqlOptions { sql: "UPDATE dbo.t SET a = 1 WHERE id = 1".to_string(), database_type: Some("sqlserver".to_string()), identifier_quote: Some("[".to_string()), columns: None, }) .unwrap(); assert_eq!(result.sql, "SELECT *, 1 AS [a (new)] FROM dbo.t WHERE id = 1"); } #[test] fn update_interleaves_new_value_after_its_original_column() { let result = preview_with_columns( "UPDATE admin_sessions SET public_id = 123 WHERE id = 1", "mysql", vec!["id".to_string(), "public_id".to_string(), "session".to_string()], ) .unwrap(); assert_eq!( result.sql, "SELECT `id`, `public_id`, 123 AS `public_id (new)`, `session` FROM admin_sessions WHERE id = 1" ); assert_eq!(result.tables.len(), 1); assert_eq!(result.tables[0].table.as_deref(), Some("admin_sessions")); } #[test] fn update_interleave_multiple_assignments_keeps_order() { let result = preview_with_columns( "UPDATE t SET b = 2, a = 1", "postgres", vec!["a".to_string(), "b".to_string(), "c".to_string()], ) .unwrap(); assert_eq!(result.sql, "SELECT \"a\", 1 AS \"a (new)\", \"b\", 2 AS \"b (new)\", \"c\" FROM t"); } #[test] fn update_interleave_missing_set_column_appends_at_end() { let result = preview_with_columns("UPDATE t SET z = 9", "postgres", vec!["a".to_string(), "b".to_string()]).unwrap(); assert_eq!(result.sql, "SELECT \"a\", \"b\", 9 AS \"z (new)\" FROM t"); } #[test] fn update_multi_table_ignores_columns_for_append_mode() { let result = preview_with_columns( "UPDATE a JOIN b ON a.id = b.id SET a.x = b.x WHERE a.id = 1", "mysql", vec!["a_x".to_string()], ) .unwrap(); assert_eq!(result.sql, "SELECT *, b.x AS `x (new)` FROM a JOIN b ON a.id = b.id WHERE a.id = 1"); } #[test] fn table_refs_extracted_for_dml() { let update = preview("UPDATE db.public.t SET a = 1", "postgres").unwrap(); assert_eq!(update.tables.len(), 1); assert_eq!(update.tables[0].database.as_deref(), Some("db")); assert_eq!(update.tables[0].schema.as_deref(), Some("public")); assert_eq!(update.tables[0].table.as_deref(), Some("t")); let insert = preview("INSERT INTO orders (id) VALUES (1)", "postgres").unwrap(); assert_eq!(insert.tables[0].table.as_deref(), Some("orders")); let delete = preview("DELETE FROM t WHERE id = 1", "postgres").unwrap(); assert_eq!(delete.tables[0].table.as_deref(), Some("t")); } }