refactor(workspace): split SQL and database driver crates

This commit is contained in:
t8y2 committed 2026-09-25 15:51:58 +08:00
1 parent b99c60aff6
commit e0da2d09d3
180 files changed
+1422 -538

No files matched your search

+599
View File
@@ -0,0 +1,599 @@
//! 「预览变更」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<String>,
/// 连接的标识符引号字符(如 `"`、`` ` ``、`[`),None 时按方言回退。
pub identifier_quote: Option<String>,
/// 目标表的列(按 ordinal 顺序)。提供且为单表 UPDATE 时,新值列紧跟其原值列。
#[serde(default, skip_serializing_if = "Option::is_none")]
pub columns: Option<Vec<String>>,
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DmlChangePreviewTableRef {
pub catalog: Option<String>,
pub database: Option<String>,
pub schema: Option<String>,
pub table: Option<String>,
}
#[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<DmlChangePreviewTableRef>,
}
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<Vec<Statement>, 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 *, <SET 表达式> AS "列 (new)", …`(追加在末尾)。
fn build_update_preview(
update: &sqlparser::ast::Update,
dialect_key: &str,
quote: Option<&str>,
columns: Option<&[String]>,
) -> Result<String, String> {
// 收集 SET 新值表达式:同列重复赋值取最后一次,但保持首次出现的列序。
#[derive(Clone)]
struct SetItem {
column: String,
expr: String,
}
let mut set_items: Vec<SetItem> = Vec::new();
let mut set_order: Vec<String> = 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<String> = 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<String> = Vec::new();
let mut placed: Vec<String> = 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::<Vec<_>>().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<String, String> {
// MySQL `INSERT INTO t SET a=1, b=2`
if !insert.assignments.is_empty() {
let items: Vec<String> = 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::<Result<Vec<_>, 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<String> = 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<String> = 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::<Vec<_>>();
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<String, String> {
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::<Vec<_>>().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::<Vec<_>>().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::<Vec<_>>().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<DmlChangePreviewSqlResult, String> {
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<String> =
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<DmlChangePreviewSqlResult, String> {
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<String>,
) -> Result<DmlChangePreviewSqlResult, String> {
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"));
}
}
+18
View File
@@ -0,0 +1,18 @@
#![recursion_limit = "256"]
pub use dbx_types::{database_manifest, models, types};
pub mod dml_preview_sql;
pub mod mysql_ddl_normalize;
pub mod mysql_event_sql;
pub mod object_source_sql;
pub mod query_execution_sql;
pub mod sql;
pub mod sql_analysis;
pub mod sql_diagnostics;
pub mod sql_editability;
pub mod sql_error_position;
pub mod sql_risk;
pub mod sqlserver_temporal;
pub mod tdsql_mysql;
pub mod value_literals;
@@ -0,0 +1,377 @@
//! Post-processing of MySQL `SHOW CREATE TABLE` DDL for database export.
//!
//! Two transforms, both applied to the table-options tail (the text after the
//! column list's closing `)`):
//! - **opt-in** strip of the table-level `AUTO_INCREMENT=N` clause. The value `N`
//! is the source table's current sequence position — correct for the source
//! DB, but noise (and misleading) in a fresh-install script.
//! - **always-on** rewrite of legacy `ROW_FORMAT=COMPACT|REDUNDANT` to
//! `ROW_FORMAT=DYNAMIC`, for MySQL 8+ export compatibility.
//!
//! The options tail is parsed with [`winnow`] into structured `(key, value, span)`
//! records. Edits are applied to the *original* string by byte span, so every
//! byte that is not an edited option is preserved verbatim (parse-to-locate,
//! not re-serialize — no fidelity drift). Any parse failure **fails open**: the
//! original DDL is returned unchanged, because the correctness of exported DDL
//! matters more than this cosmetic option.
//!
//! Why winnow and not a regex: the value of `AUTO_INCREMENT`/`COMMENT` options
//! can contain the literal text `AUTO_INCREMENT=N` inside a quoted string (e.g.
//! `COMMENT='starts at AUTO_INCREMENT=1000'`). A quote-aware parser skips those
//! correctly; a blind regex cannot. winnow 1.x is already in the build graph
//! (transitively, via `toml_edit`), so adding it as a direct dependency compiles
//! no new code.
use std::ops::Range;
use winnow::ascii::multispace1;
use winnow::combinator::{alt, delimited, opt, preceded, repeat};
use winnow::prelude::*;
use winnow::stream::LocatingSlice;
use winnow::token::{none_of, take_till, take_until, take_while};
use winnow::ModalResult;
/// Knobs for [`normalize_mysql_export_ddl`].
#[derive(Debug, Clone, Copy, Default)]
pub struct DdlNormalizeOptions {
/// When true, drop the table-level `AUTO_INCREMENT=N` option from the DDL.
pub omit_auto_increment: bool,
}
/// One parsed MySQL table option, e.g. `ENGINE=InnoDB`, `AUTO_INCREMENT=121`,
/// `COMMENT='...'`, or a bare keyword such as `DEFAULT`.
#[derive(Debug, Clone)]
struct ParsedOption {
/// Byte span of the option *core* (`KEY[=VALUE]`, excluding surrounding
/// whitespace), relative to the options tail.
span: Range<usize>,
/// Upper-cased key, for case-insensitive matching.
key: String,
/// Raw value (without surrounding quotes), if the option had `= value`.
value: Option<String>,
}
const AUTO_INCREMENT: &str = "AUTO_INCREMENT";
const ROW_FORMAT: &str = "ROW_FORMAT";
/// Entry point. Returns the (possibly edited) DDL. On any structural surprise
/// the input is returned unchanged.
pub fn normalize_mysql_export_ddl(ddl: &str, opts: DdlNormalizeOptions) -> String {
// One winnow pass over the whole DDL (wrapped in `LocatingSlice`), so every
// option carries an absolute byte span into `ddl` — no offset math.
let Some(options) = parse_create_table_options(ddl) else {
return ddl.to_string(); // fail-open: unparseable DDL returned verbatim
};
// Compute edits as absolute byte ranges in `ddl`. An empty replacement means
// "delete this range".
let bytes = ddl.as_bytes();
let mut edits: Vec<(Range<usize>, &'static str)> = Vec::new();
for opt in &options {
let Range { start, end } = opt.span;
if opts.omit_auto_increment && opt.key == AUTO_INCREMENT {
// Preserve line endings because they may terminate a preceding line comment.
let start = if start > 0 && matches!(bytes[start - 1], b' ' | b'\t') { start - 1 } else { start };
edits.push((start..end, ""));
} else if opt.key == ROW_FORMAT {
if let Some(value) = opt.value.as_deref() {
let value = value.to_ascii_uppercase();
if value == "COMPACT" || value == "REDUNDANT" {
edits.push((start..end, "ROW_FORMAT=DYNAMIC"));
}
}
}
}
if edits.is_empty() {
return ddl.to_string();
}
// Apply edits to the original string. Distinct options never overlap; sort
// by start and stitch the kept slices around each edit.
edits.sort_by_key(|(range, _)| range.start);
let mut out = String::with_capacity(ddl.len());
let mut cursor = 0usize;
for (range, replacement) in &edits {
if range.start < cursor {
continue; // defensive: never expected for distinct options
}
out.push_str(&ddl[cursor..range.start]);
out.push_str(replacement);
cursor = range.end;
}
out.push_str(&ddl[cursor..]);
out
}
// ---------------------------------------------------------------------------
// winnow parser.
//
// One pass over the whole DDL (wrapped in `LocatingSlice`), so every parsed
// option carries an absolute byte span into `ddl`. The column-definition body
// is skipped with a recursive balanced-`(...)` parser — it never inspects
// column content, only tracks nesting and quoted spans so a `(` inside a type
// like `decimal(30,6)` or inside a backtick-quoted table name doesn't fool it.
// Any parse failure fails open (the caller returns the original DDL).
// ---------------------------------------------------------------------------
/// Parse `CREATE TABLE <name> ( <columns> ) <options…>` into the table options,
/// each with an absolute byte span. The column body is skipped, not modeled.
fn parse_create_table_options(ddl: &str) -> Option<Vec<ParsedOption>> {
// `skip_create_table_prefix` + `skip_column_body` position the stream at the
// options tail; `preceded` discards them. `parse_peek` allows a trailing `;`
// or an unmodeled option shape without failing the whole parse.
let mut parser = preceded(
(skip_create_table_prefix, skip_column_body),
repeat(0.., preceded(skip_ws_and_comments, table_option.with_span())).fold(
Vec::new,
|mut acc: Vec<ParsedOption>, (mut option, span)| {
option.span = span;
acc.push(option);
acc
},
),
);
match parser.parse_peek(LocatingSlice::new(ddl)) {
Ok((_remaining, options)) => Some(options),
Err(_) => None,
}
}
/// Consume the `CREATE TABLE [IF NOT EXISTS] <name>` prefix, stopping just before
/// the column-list opening `(`. Quoted identifiers and comments are consumed
/// whole, so a `(` inside e.g. `` `weird(name)` `` is not mistaken for the
/// column-list opener.
fn skip_create_table_prefix(input: &mut LocatingSlice<&str>) -> ModalResult<()> {
repeat(0.., alt((sql_quoted, sql_line_comment, sql_block_comment, none_of('(').void())))
.fold(|| (), |(), _| ())
.parse_next(input)
}
/// Consume one balanced `(...)` group (the column body), skipping nested parens,
/// quoted strings, and comments. Produces no value.
fn skip_column_body(input: &mut LocatingSlice<&str>) -> ModalResult<()> {
delimited('(', repeat(0.., column_body_token).fold(|| (), |(), _| ()), ')').parse_next(input)
}
/// One token inside the column body: a nested balanced group, a quoted string,
/// a comment, or any single non-`)` character. `skip_column_body` is tried first
/// so nested `(` is handled recursively, not as a plain character.
fn column_body_token(input: &mut LocatingSlice<&str>) -> ModalResult<()> {
alt((skip_column_body, sql_quoted, sql_line_comment, sql_block_comment, none_of(')').void())).parse_next(input)
}
/// A `-- …` or `# …` line comment (to end of line). Produces no value.
fn sql_line_comment(input: &mut LocatingSlice<&str>) -> ModalResult<()> {
alt((("--", take_till(0.., ['\n', '\r'])).void(), ('#', take_till(0.., ['\n', '\r'])).void())).parse_next(input)
}
/// A `/* … */` block comment (MySQL block comments do not nest). Produces no value.
fn sql_block_comment(input: &mut LocatingSlice<&str>) -> ModalResult<()> {
("/*", take_until(0.., "*/"), "*/").void().parse_next(input)
}
/// Parses one table option: `KEY`, `KEY=VALUE`, or `KEY = VALUE`.
fn table_option(input: &mut LocatingSlice<&str>) -> ModalResult<ParsedOption> {
let key = option_key.parse_next(input)?;
let value =
opt(preceded(delimited(skip_ws_and_comments, '=', skip_ws_and_comments), option_value)).parse_next(input)?;
Ok(ParsedOption { span: 0..0, key, value })
}
/// An option key: run of ASCII alphanumerics and `_`, upper-cased for matching.
fn option_key(input: &mut LocatingSlice<&str>) -> ModalResult<String> {
take_while(1.., |c: char| c.is_ascii_alphanumeric() || c == '_')
.map(|s: &str| s.to_ascii_uppercase())
.parse_next(input)
}
/// An option value: either a quoted SQL token (whose content we do not need —
/// only its byte span, to keep the tail parse moving past `COMMENT='...'`) or a
/// bare token (identifier/number).
fn option_value(input: &mut LocatingSlice<&str>) -> ModalResult<String> {
alt((sql_quoted.value(String::new()), bare_value.map(|s: &str| s.to_string()))).parse_next(input)
}
fn bare_value<'i>(input: &mut LocatingSlice<&'i str>) -> ModalResult<&'i str> {
take_while(1.., |c: char| c.is_ascii_alphanumeric() || c == '_').parse_next(input)
}
/// Skip any run of whitespace and/or SQL comments. Used as the separator between
/// table options so that a comment sitting between options (or between `)` and
/// the first option, or around `=`) does not stop the parse short of later
/// options like `AUTO_INCREMENT`. Matches zero or more chunks (so it also acts
/// like `multispace0` when there is nothing but whitespace).
fn skip_ws_and_comments(input: &mut LocatingSlice<&str>) -> ModalResult<()> {
repeat(0.., alt((multispace1.void(), sql_line_comment, sql_block_comment)))
.fold(|| (), |(), _| ())
.parse_next(input)
}
/// Any single-, double-, or backtick-quoted SQL token (content discarded).
fn sql_quoted(input: &mut LocatingSlice<&str>) -> ModalResult<()> {
alt((sql_single_quoted, sql_double_quoted, sql_backtick_quoted)).parse_next(input)
}
/// Consumes a `'…'` token honoring `''` doubling, producing no value. The
/// `repeat(...).fold((), ..)` discards fragments while pinning the accumulator
/// type (a bare `repeat(...).void()` cannot infer it).
fn sql_single_quoted(input: &mut LocatingSlice<&str>) -> ModalResult<()> {
delimited('\'', repeat(0.., alt(("''", take_till(1.., '\'')))).fold(|| (), |(), _| ()), '\'').parse_next(input)
}
fn sql_double_quoted(input: &mut LocatingSlice<&str>) -> ModalResult<()> {
delimited('"', repeat(0.., alt(("\"\"", take_till(1.., '"')))).fold(|| (), |(), _| ()), '"').parse_next(input)
}
fn sql_backtick_quoted(input: &mut LocatingSlice<&str>) -> ModalResult<()> {
delimited('`', repeat(0.., alt(("``", take_till(1.., '`')))).fold(|| (), |(), _| ()), '`').parse_next(input)
}
#[cfg(test)]
mod tests {
use super::*;
fn opts(omit_auto_increment: bool) -> DdlNormalizeOptions {
DdlNormalizeOptions { omit_auto_increment }
}
#[test]
fn strips_table_level_auto_increment() {
let ddl = "CREATE TABLE `t` (`id` bigint NOT NULL AUTO_INCREMENT) ENGINE=InnoDB AUTO_INCREMENT=121 DEFAULT CHARSET=utf8mb4";
let out = normalize_mysql_export_ddl(ddl, opts(true));
assert_eq!(out, "CREATE TABLE `t` (`id` bigint NOT NULL AUTO_INCREMENT) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4");
}
#[test]
fn preserves_column_level_auto_increment() {
let ddl = "CREATE TABLE `t` (`id` bigint NOT NULL AUTO_INCREMENT) ENGINE=InnoDB AUTO_INCREMENT=5";
let out = normalize_mysql_export_ddl(ddl, opts(true));
// Table-level gone, column-level bare AUTO_INCREMENT untouched.
assert!(out.contains("`id` bigint NOT NULL AUTO_INCREMENT"));
assert!(!out.contains("AUTO_INCREMENT=5"));
}
#[test]
fn keeps_auto_increment_when_option_off() {
let ddl = "CREATE TABLE `t` (`id` bigint NOT NULL AUTO_INCREMENT) ENGINE=InnoDB AUTO_INCREMENT=121";
assert_eq!(normalize_mysql_export_ddl(ddl, opts(false)), ddl);
}
#[test]
fn no_double_space_left_behind() {
let ddl = "CREATE TABLE `t` (`id` int) ENGINE=InnoDB AUTO_INCREMENT=7 COLLATE=utf8mb4_bin";
let out = normalize_mysql_export_ddl(ddl, opts(true));
assert_eq!(out, "CREATE TABLE `t` (`id` int) ENGINE=InnoDB COLLATE=utf8mb4_bin");
assert!(!out.contains(" "));
}
#[test]
fn auto_increment_inside_comment_is_not_stripped() {
let ddl =
"CREATE TABLE `t` (`id` int) ENGINE=InnoDB AUTO_INCREMENT=9 COMMENT='see AUTO_INCREMENT=1000 in docs'";
let out = normalize_mysql_export_ddl(ddl, opts(true));
// Table-level `AUTO_INCREMENT=9` is removed; the COMMENT literal (including
// its inner `AUTO_INCREMENT=1000` text) is preserved verbatim — this is the
// quote-awareness a blind regex could not provide.
assert_eq!(out, "CREATE TABLE `t` (`id` int) ENGINE=InnoDB COMMENT='see AUTO_INCREMENT=1000 in docs'");
}
#[test]
fn comment_between_close_paren_and_first_option() {
let ddl = "CREATE TABLE `t` (`id` int) /* generated by tool x */ ENGINE=InnoDB AUTO_INCREMENT=5";
let out = normalize_mysql_export_ddl(ddl, opts(true));
assert_eq!(out, "CREATE TABLE `t` (`id` int) /* generated by tool x */ ENGINE=InnoDB");
}
#[test]
fn block_comment_between_options_ignores_inner_parens() {
// The `(` and `)` inside the block comment must stay opaque; they must
// not be mistaken for column-list delimiters or option boundaries.
let ddl = "CREATE TABLE `t` (`id` int) ENGINE=InnoDB /* see (a) and )b( */ AUTO_INCREMENT=5";
let out = normalize_mysql_export_ddl(ddl, opts(true));
assert_eq!(out, "CREATE TABLE `t` (`id` int) ENGINE=InnoDB /* see (a) and )b( */");
}
#[test]
fn auto_increment_inside_block_comment_not_stripped() {
// Only the real table-level option is removed; the one inside the block
// comment is opaque and preserved verbatim.
let ddl = "CREATE TABLE `t` (`id` int) ENGINE=InnoDB /* AUTO_INCREMENT=999 */ AUTO_INCREMENT=5";
let out = normalize_mysql_export_ddl(ddl, opts(true));
assert_eq!(out, "CREATE TABLE `t` (`id` int) ENGINE=InnoDB /* AUTO_INCREMENT=999 */");
}
#[test]
fn line_comment_between_options() {
let ddl = "CREATE TABLE `t` (`id` int) ENGINE=InnoDB -- remember to bump\nAUTO_INCREMENT=5";
let out = normalize_mysql_export_ddl(ddl, opts(true));
assert_eq!(out, "CREATE TABLE `t` (`id` int) ENGINE=InnoDB -- remember to bump\n");
}
#[test]
fn comment_around_equals_sign_in_option() {
let ddl = "CREATE TABLE `t` (`id` int) ENGINE=InnoDB AUTO_INCREMENT/*c*/=/*c*/5";
let out = normalize_mysql_export_ddl(ddl, opts(true));
assert_eq!(out, "CREATE TABLE `t` (`id` int) ENGINE=InnoDB");
}
#[test]
fn rewrites_legacy_row_format() {
let ddl = "CREATE TABLE `t` (`p` varchar(9)) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=COMPACT";
let out = normalize_mysql_export_ddl(ddl, opts(false));
assert_eq!(out, "CREATE TABLE `t` (`p` varchar(9)) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC");
}
#[test]
fn row_format_rewrite_is_case_insensitive_and_normalizes_output() {
let ddl = "CREATE TABLE `t` (`p` text) engine=InnoDB row_format = redundant";
let out = normalize_mysql_export_ddl(ddl, opts(false));
assert_eq!(out, "CREATE TABLE `t` (`p` text) engine=InnoDB ROW_FORMAT=DYNAMIC");
}
#[test]
fn non_legacy_row_format_untouched() {
let ddl = "CREATE TABLE `t` (`p` text) ENGINE=InnoDB ROW_FORMAT=COMPRESSED";
assert_eq!(normalize_mysql_export_ddl(ddl, opts(false)), ddl);
}
#[test]
fn both_transforms_compose() {
let ddl = "CREATE TABLE `t` (`p` text) ENGINE=InnoDB AUTO_INCREMENT=42 ROW_FORMAT=COMPACT DEFAULT CHARSET=utf8";
let out = normalize_mysql_export_ddl(ddl, opts(true));
assert_eq!(out, "CREATE TABLE `t` (`p` text) ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8");
}
#[test]
fn nested_parens_in_column_body_do_not_confuse_tail_location() {
let ddl = "CREATE TABLE `t` (`amount` decimal(30,6) NOT NULL, `st` enum('a','b') NOT NULL, CHECK (amount > 0)) ENGINE=InnoDB AUTO_INCREMENT=3";
let out = normalize_mysql_export_ddl(ddl, opts(true));
assert!(out.contains("decimal(30,6)"));
assert!(out.contains("enum('a','b')"));
assert!(out.contains("CHECK (amount > 0)"));
assert!(!out.contains("AUTO_INCREMENT=3"));
}
#[test]
fn table_name_containing_paren_does_not_mislocate_tail() {
// The `(` inside the backtick-quoted table name must not be mistaken for
// the column-list opener; the real options tail is after the column list.
let ddl = "CREATE TABLE `weird(name)` (`id` int) ENGINE=InnoDB AUTO_INCREMENT=7";
let out = normalize_mysql_export_ddl(ddl, opts(true));
assert_eq!(out, "CREATE TABLE `weird(name)` (`id` int) ENGINE=InnoDB");
}
#[test]
fn multibyte_comment_survives_byte_offset_edit() {
let ddl = "CREATE TABLE `t` (`id` int) ENGINE=InnoDB AUTO_INCREMENT=11 COMMENT='每日收益表'";
let out = normalize_mysql_export_ddl(ddl, opts(true));
assert_eq!(out, "CREATE TABLE `t` (`id` int) ENGINE=InnoDB COMMENT='每日收益表'");
}
#[test]
fn malformed_ddl_fails_open_unchanged() {
let ddl = "CREATE TABLE `t` (`id` int"; // unbalanced paren
assert_eq!(normalize_mysql_export_ddl(ddl, opts(true)), ddl);
}
}
+150
View File
@@ -0,0 +1,150 @@
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum MysqlEventSchedule {
At { execute_at: String },
Every { interval_value: String, interval_unit: String },
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct MysqlEventDefinition {
pub name: String,
pub schema: Option<String>,
pub schedule: MysqlEventSchedule,
pub starts: Option<String>,
pub ends: Option<String>,
pub on_completion_preserve: Option<bool>,
pub enabled: Option<bool>,
pub comment: Option<String>,
pub body: String,
}
pub use dbx_types::mysql_event::MysqlEventInfo;
fn ident(value: &str) -> Result<String, String> {
let value = value.trim();
if value.is_empty() {
return Err("event name must not be empty".into());
}
Ok(format!("`{}`", value.replace('`', "``")))
}
fn literal(value: &str) -> String {
format!("'{}'", value.replace('\\', "\\\\").replace('\'', "\\'"))
}
fn unit(value: &str) -> Result<&'static str, String> {
match value.trim().to_ascii_uppercase().as_str() {
"SECOND" => Ok("SECOND"),
"MINUTE" => Ok("MINUTE"),
"HOUR" => Ok("HOUR"),
"DAY" => Ok("DAY"),
"WEEK" => Ok("WEEK"),
"MONTH" => Ok("MONTH"),
"QUARTER" => Ok("QUARTER"),
"YEAR" => Ok("YEAR"),
_ => Err(format!("invalid event interval unit: {value}")),
}
}
pub fn create_event_sql(definition: &MysqlEventDefinition) -> Result<String, String> {
build_event_sql("CREATE EVENT", definition)
}
pub fn alter_event_sql(definition: &MysqlEventDefinition) -> Result<String, String> {
build_event_sql("ALTER EVENT", definition)
}
fn build_event_sql(prefix: &str, definition: &MysqlEventDefinition) -> Result<String, String> {
let name = ident(&definition.name)?;
if definition.body.trim().is_empty() {
return Err("event body must not be empty".into());
}
let schedule = match &definition.schedule {
MysqlEventSchedule::At { execute_at } if execute_at.trim().is_empty() => {
return Err("event AT schedule must include execute_at".into())
}
MysqlEventSchedule::At { execute_at } => format!("AT {}", literal(execute_at)),
MysqlEventSchedule::Every { interval_value, interval_unit } => {
let interval_value = interval_value.trim();
if !interval_value.bytes().all(|byte| byte.is_ascii_digit())
|| interval_value.bytes().all(|byte| byte == b'0')
{
return Err("event EVERY schedule requires a positive integer interval_value".into());
}
format!("EVERY {} {}", interval_value, unit(interval_unit)?)
}
};
let mut sql = format!("{prefix} {name} ON SCHEDULE {schedule}");
if let Some(value) = definition.starts.as_deref().filter(|v| !v.trim().is_empty()) {
sql.push_str(&format!(" STARTS {}", literal(value)));
}
if let Some(value) = definition.ends.as_deref().filter(|v| !v.trim().is_empty()) {
sql.push_str(&format!(" ENDS {}", literal(value)));
}
if let Some(value) = definition.on_completion_preserve {
sql.push_str(if value { " ON COMPLETION PRESERVE" } else { " ON COMPLETION NOT PRESERVE" });
}
if let Some(value) = definition.enabled {
sql.push_str(if value { " ENABLE" } else { " DISABLE" });
}
if let Some(value) = definition.comment.as_deref() {
sql.push_str(&format!(" COMMENT {}", literal(value)));
}
sql.push_str(" DO ");
sql.push_str(definition.body.trim());
Ok(sql)
}
pub fn drop_event_sql(schema: Option<&str>, name: &str, if_exists: bool) -> Result<String, String> {
let qualified = match schema.filter(|s| !s.trim().is_empty()) {
Some(schema) => format!("{}.{}", ident(schema)?, ident(name)?),
None => ident(name)?,
};
Ok(format!("DROP EVENT {}{}", if if_exists { "IF EXISTS " } else { "" }, qualified))
}
#[cfg(test)]
mod tests {
use super::*;
fn definition() -> MysqlEventDefinition {
MysqlEventDefinition {
name: "daily`sync".into(),
schema: Some("shop".into()),
schedule: MysqlEventSchedule::Every { interval_value: "1".into(), interval_unit: "day".into() },
starts: Some("2026-01-01 00:00:00".into()),
ends: None,
on_completion_preserve: Some(true),
enabled: Some(false),
comment: Some("owner's job".into()),
body: "CALL `refresh`();".into(),
}
}
#[test]
fn builds_every_event_with_escaped_values() {
assert_eq!(create_event_sql(&definition()).unwrap(), "CREATE EVENT `daily``sync` ON SCHEDULE EVERY 1 DAY STARTS '2026-01-01 00:00:00' ON COMPLETION PRESERVE DISABLE COMMENT 'owner\\'s job' DO CALL `refresh`();");
}
#[test]
fn validates_schedule_and_body() {
let mut def = definition();
def.body = " ".into();
assert!(create_event_sql(&def).is_err());
def.body = "SELECT 1".into();
def.schedule = MysqlEventSchedule::Every { interval_value: "1".into(), interval_unit: "fortnight".into() };
assert!(create_event_sql(&def).is_err());
}
#[test]
fn rejects_non_positive_or_non_numeric_interval_values() {
let mut def = definition();
for interval_value in ["", "0", " 000 ", "1 DAY", "1; DROP EVENT other"] {
def.schedule =
MysqlEventSchedule::Every { interval_value: interval_value.into(), interval_unit: "DAY".into() };
assert!(create_event_sql(&def).is_err(), "unexpectedly accepted {interval_value:?}");
}
}
#[test]
fn builds_at_and_drop_sql() {
let mut def = definition();
def.schedule = MysqlEventSchedule::At { execute_at: "2026-02-01 10:00:00".into() };
assert!(create_event_sql(&def).unwrap().contains("ON SCHEDULE AT '2026-02-01 10:00:00'"));
assert_eq!(
drop_event_sql(Some("shop"), "daily`sync", true).unwrap(),
"DROP EVENT IF EXISTS `shop`.`daily``sync`"
);
}
}
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
+259
View File
@@ -0,0 +1,259 @@
const DEFAULT_SQL_DIAGNOSTIC_MAX_CHARS: usize = 512;
fn is_sensitive_key(key: &str) -> bool {
let key = key.to_ascii_lowercase();
key.contains("password")
|| key.contains("passwd")
|| key == "pwd"
|| key.contains("secret")
|| key.contains("token")
|| key.contains("api_key")
|| key.contains("apikey")
|| key.contains("access_key")
|| key.contains("private_key")
|| key.contains("credential")
|| key.contains("authorization")
|| key.contains("bearer")
}
fn truncate_for_diagnostics(value: String, max_chars: usize, input_truncated: bool) -> String {
if value.chars().count() <= max_chars {
return if input_truncated { format!("{value}…[truncated]") } else { value };
}
let head: String = value.chars().take(max_chars).collect();
format!("{head}…[truncated]")
}
fn bounded_input(sql: &str, max_chars: usize) -> (&str, bool) {
if max_chars == 0 {
return ("", !sql.is_empty());
}
match sql.char_indices().nth(max_chars) {
Some((index, _)) => (&sql[..index], true),
None => (sql, false),
}
}
fn redact_literals(sql: &str) -> String {
let chars: Vec<char> = sql.chars().collect();
let mut out = String::new();
let mut i = 0;
while i < chars.len() {
let ch = chars[i];
let next = chars.get(i + 1).copied();
if matches!(ch, '\'' | '"' | '`') {
out.push(ch);
out.push_str("[REDACTED]");
out.push(ch);
i += 1;
while i < chars.len() {
let current = chars[i];
if current == ch {
if chars.get(i + 1).copied() == Some(ch) {
i += 2;
continue;
}
i += 1;
break;
}
if current == '\\' && ch != '`' {
i += 2;
} else {
i += 1;
}
}
continue;
}
if ch == '$' {
let j = i + 1;
if j >= chars.len() {
out.push(ch);
i += 1;
continue;
}
if chars[j] == '$' {
// $$...$$ dollar-quoted string
out.push_str("$$[REDACTED]$$");
i += 2;
while i + 1 < chars.len() && !(chars[i] == '$' && chars[i + 1] == '$') {
i += 1;
}
if i + 1 < chars.len() {
i += 2;
}
continue;
}
// $tag$...$tag$ dollar-quoted string
let tag_start = j;
let mut tag_end = j;
while tag_end < chars.len() && (chars[tag_end].is_ascii_alphanumeric() || chars[tag_end] == '_') {
tag_end += 1;
}
if tag_end > tag_start && tag_end < chars.len() && chars[tag_end] == '$' {
let tag: String = chars[tag_start..tag_end].iter().collect();
out.push_str("$[REDACTED]$");
i = tag_end + 1;
let closing: Vec<char> = format!("${}$", tag).chars().collect();
while i + closing.len() <= chars.len() {
if chars[i..i + closing.len()] == closing[..] {
i += closing.len();
break;
}
i += 1;
}
continue;
}
out.push(ch);
i += 1;
continue;
}
if ch == '-' && next == Some('-') {
out.push_str("--[REDACTED_COMMENT]");
i += 2;
while i < chars.len() && chars[i] != '\n' && chars[i] != '\r' {
i += 1;
}
continue;
}
if ch == '/' && next == Some('*') {
out.push_str("/*[REDACTED_COMMENT]*/");
i += 2;
while i + 1 < chars.len() && !(chars[i] == '*' && chars[i + 1] == '/') {
i += 1;
}
if i + 1 < chars.len() {
i += 2;
}
continue;
}
out.push(ch);
i += 1;
}
out
}
fn redact_sensitive_assignments(sql: &str) -> String {
let chars: Vec<char> = sql.chars().collect();
let mut out = String::new();
let mut i = 0;
while i < chars.len() {
if chars[i].is_whitespace() {
out.push(chars[i]);
i += 1;
continue;
}
let start = i;
while i < chars.len()
&& (chars[i].is_ascii_alphanumeric() || chars[i] == '_' || chars[i] == '-' || chars[i] == '.')
{
i += 1;
}
if i == start {
out.push(chars[i]);
i += 1;
continue;
}
let key: String = chars[start..i].iter().collect();
let mut j = i;
while j < chars.len() && chars[j].is_whitespace() {
j += 1;
}
if j < chars.len() && (chars[j] == '=' || chars[j] == ':') && is_sensitive_key(&key) {
out.push_str(&key);
out.extend(chars[i..j].iter().copied());
out.push(chars[j]);
j += 1;
while j < chars.len() && chars[j].is_whitespace() {
out.push(chars[j]);
j += 1;
}
while j < chars.len() && !chars[j].is_whitespace() {
j += 1;
}
out.push_str("[REDACTED]");
i = j;
continue;
}
out.push_str(&key);
}
out
}
pub fn redact_sql_for_diagnostics(sql: &str) -> String {
let max_chars = DEFAULT_SQL_DIAGNOSTIC_MAX_CHARS;
let (bounded_sql, input_truncated) = bounded_input(sql, max_chars);
truncate_for_diagnostics(redact_sensitive_assignments(&redact_literals(bounded_sql)), max_chars, input_truncated)
}
pub fn debug_sql(scope: &str, sql: &str) {
log::debug!("[{scope}] sql={}", redact_sql_for_diagnostics(sql));
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn redacts_sensitive_literals_and_bounds_large_sql() {
let sql = format!(
"select * from users where password = 'secret-123' and api_key=abc and name = 'alice' {};",
"x".repeat(900)
);
let redacted = redact_sql_for_diagnostics(&sql);
assert!(!redacted.contains("secret-123"));
assert!(!redacted.contains("api_key=abc"));
assert!(!redacted.contains("alice"));
// Literals not part of sensitive assignments retain single-quote redaction
assert!(redacted.contains("'[REDACTED]'"), "name literal should be redacted: {}", redacted);
// Sensitive assignment values are redacted with bracket notation
assert!(redacted.contains("password = [REDACTED]"));
assert!(redacted.contains("api_key=[REDACTED]"));
assert!(redacted.contains("truncated"));
assert!(redacted.len() < sql.len());
}
#[test]
fn redacts_space_separated_sensitive_assignments() {
let sql = "select * from users where password = hunter2";
let redacted = redact_sensitive_assignments(sql);
assert!(!redacted.contains("hunter2"));
assert!(redacted.contains("password = [REDACTED]"));
assert!(redacted.contains("select"));
}
#[test]
fn redacts_dollar_quoted_strings() {
let sql = "select $$secret$$, $tag$hello$tag$ from t";
let redacted = redact_sql_for_diagnostics(sql);
assert!(redacted.contains("$$[REDACTED]$$"));
assert!(redacted.contains("$[REDACTED]$"));
assert!(!redacted.contains("secret"));
assert!(!redacted.contains("hello"));
}
#[test]
fn large_input_bounded_allocation() {
let sql = "x".repeat(1_000_000);
let redacted = redact_sql_for_diagnostics(&sql);
assert!(redacted.len() <= 550);
}
#[test]
fn truncation_inside_unclosed_literal_does_not_leak_prefix() {
let sql = format!("select '{}'", "secret-".repeat(1_000));
let redacted = truncate_for_diagnostics(redact_literals(bounded_input(&sql, 32).0), 32, true);
assert!(!redacted.contains("secret-"));
assert!(redacted.contains("[REDACTED]"));
assert!(redacted.contains("truncated"));
}
#[test]
fn truncation_inside_sensitive_assignment_does_not_leak_prefix() {
let sql = format!("password = {}", "secret-token".repeat(1_000));
let (bounded, truncated) = bounded_input(&sql, 24);
let redacted = truncate_for_diagnostics(redact_sensitive_assignments(&redact_literals(bounded)), 24, truncated);
assert!(!redacted.contains("secret-token"));
assert!(redacted.contains("password = [REDACTED]"));
assert!(redacted.contains("truncated"));
}
}
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,255 @@
//! Driver-reported SQL error positions (currently PostgreSQL only).
//!
//! PostgreSQL reports a 1-based *character* cursor position for many SQL
//! errors (`tokio_postgres::error::ErrorPosition::Original`). The native
//! driver error path in `db::postgres` only exposes a `String` to the query
//! layer, so the raw cursor is carried across that `String` ABI as a small
//! machine-readable suffix and resolved back into a typed [`SqlErrorPosition`]
//! as soon as the executed statement text is available.
//!
//! The suffix is a position carrier, not an error classifier: nothing about the
//! error category, retryability or recovery is inferred from it, and
//! [`strip_marker`] guarantees it can never surface in a user-facing message.
use serde::{Deserialize, Serialize};
/// Suffix appended to a driver error message to carry a raw PostgreSQL cursor
/// position across the `Result<_, String>` boundary of the `db` layer.
pub const SQL_ERROR_POSITION_MARKER: &str = "\nDBX_SQL_ERROR_POSITION:";
/// A SQL error position relative to the statement text that was actually sent
/// to the database.
///
/// `line`/`column` are 1-based and counted in Unicode scalar values (matching
/// PostgreSQL's character-based cursor positions); `offset` is the 0-based
/// scalar-value index into the statement text.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SqlErrorPosition {
pub line: u32,
pub column: u32,
pub offset: u32,
}
impl SqlErrorPosition {
/// Convert a PostgreSQL 1-based character cursor into a line/column/offset.
///
/// Returns `None` when the cursor is unusable (zero, non-positive, or the
/// statement is empty). A cursor past the end (`position == len + 1`, e.g.
/// "unexpected end of input") is clamped to the last character.
pub fn from_pg_cursor(statement_sql: &str, cursor: u32) -> Option<Self> {
if cursor == 0 {
return None;
}
let total = statement_sql.chars().count() as u32;
if total == 0 {
return None;
}
let target = (cursor - 1).min(total - 1);
let mut line = 1u32;
let mut column = 1u32;
for (index, ch) in statement_sql.chars().enumerate() {
if index as u32 == target {
return Some(Self { line, column, offset: target });
}
if ch == '\n' {
line += 1;
column = 1;
} else {
column += 1;
}
}
None
}
}
/// Encode a raw cursor as the transport suffix.
pub fn encode_marker(cursor: u32) -> String {
format!("{SQL_ERROR_POSITION_MARKER}{cursor}")
}
/// Remove every marker from `message` and return the cursors they carried.
///
/// Markers are removed even when followed by more text (the read-only
/// transaction path can append a cleanup error after one, e.g.
/// `...<marker>15; rollback failed`), so the trailing text is preserved. A
/// malformed or absent suffix leaves `message` untouched and is not collected.
fn take_all_markers(message: &mut String) -> Vec<u32> {
let mut cursors = Vec::new();
while let Some(cursor) = take_marker(message) {
cursors.push(cursor);
}
cursors
}
/// Remove a marker from `message` and return the raw cursor it carried.
///
/// See [`take_all_markers`] for the multi-marker behaviour.
pub fn take_marker(message: &mut String) -> Option<u32> {
let index = message.rfind(SQL_ERROR_POSITION_MARKER)?;
let digits_start = index + SQL_ERROR_POSITION_MARKER.len();
let digits_end = message[digits_start..]
.find(|ch: char| !ch.is_ascii_digit())
.map_or(message.len(), |offset| digits_start + offset);
let cursor = message[digits_start..digits_end].parse::<u32>().ok()?;
message.replace_range(index..digits_end, "");
Some(cursor)
}
/// Return `message` with every transport suffix stripped.
pub fn strip_marker(message: &str) -> String {
let mut owned = message.to_string();
let _ = take_all_markers(&mut owned);
owned
}
/// Strip all transport suffixes from `message` and, when possible, resolve the
/// carried cursor against the executed statement text into a typed position.
///
/// The returned message is always marker-free. The position is only resolved
/// when exactly one marker was present: a message carrying several markers (e.g.
/// a user-statement error merged with an infrastructure error) cannot be
/// attributed to a single statement, and guessing would point at the wrong spot.
pub fn take_message_position(message: &str, statement_sql: &str) -> (String, Option<SqlErrorPosition>) {
let mut cleaned = message.to_string();
let cursors = take_all_markers(&mut cleaned);
if cursors.len() != 1 {
return (cleaned, None);
}
let position = SqlErrorPosition::from_pg_cursor(statement_sql, cursors[0]);
(cleaned, position)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn cursor_maps_to_line_and_column() {
let sql = "SELECT *\nFROM no_such_table";
// 1-based cursor of the 'n' in no_such_table (second line, column 6).
let cursor = sql.find("no_such_table").unwrap() as u32 + 1;
let position = SqlErrorPosition::from_pg_cursor(sql, cursor).unwrap();
assert_eq!(position.line, 2);
assert_eq!(position.column, 6);
assert_eq!(position.offset, sql[..sql.find("no_such_table").unwrap()].chars().count() as u32);
}
#[test]
fn first_character_is_line_one_column_one() {
let position = SqlErrorPosition::from_pg_cursor("SELECT 1", 1).unwrap();
assert_eq!((position.line, position.column, position.offset), (1, 1, 0));
}
#[test]
fn crlf_treats_carriage_return_as_a_column() {
let sql = "SELECT 1\r\nFROM t";
let cursor = sql.find("FROM").unwrap() as u32 + 1;
let position = SqlErrorPosition::from_pg_cursor(sql, cursor).unwrap();
assert_eq!(position.line, 2);
assert_eq!(position.column, 1);
}
#[test]
fn multi_byte_characters_count_as_one_column() {
// '表' is 3 UTF-8 bytes; cursor positions are character based.
let sql = "SELECT '表' FROM t";
let from_byte = sql.find("FROM").unwrap();
let cursor = sql[..from_byte].chars().count() as u32 + 1;
let position = SqlErrorPosition::from_pg_cursor(sql, cursor).unwrap();
assert_eq!(position.line, 1);
assert_eq!(position.column, 12);
assert_eq!(position.offset, 11);
}
#[test]
fn cursor_past_end_is_clamped() {
let sql = "SELECT";
let position = SqlErrorPosition::from_pg_cursor(sql, 999).unwrap();
assert_eq!(position.offset, 5);
assert_eq!(position.column, 6);
}
#[test]
fn zero_cursor_and_empty_sql_are_rejected() {
assert!(SqlErrorPosition::from_pg_cursor("SELECT 1", 0).is_none());
assert!(SqlErrorPosition::from_pg_cursor("", 1).is_none());
}
#[test]
fn marker_round_trips_and_strips() {
let mut message = format!("ERROR: relation does not exist{}", encode_marker(15));
assert_eq!(take_marker(&mut message), Some(15));
assert_eq!(message, "ERROR: relation does not exist");
let mut without_marker = "ERROR: nope".to_string();
assert_eq!(take_marker(&mut without_marker), None);
assert_eq!(without_marker, "ERROR: nope");
}
#[test]
fn malformed_marker_is_left_untouched() {
let text = format!("{SQL_ERROR_POSITION_MARKER}not-a-number");
let mut message = text.clone();
assert_eq!(take_marker(&mut message), None);
assert_eq!(message, text);
}
#[test]
fn marker_followed_by_text_is_stripped_and_preserves_the_tail() {
let mut message = format!("ERROR: boom{}; rollback failed", encode_marker(7));
assert_eq!(take_marker(&mut message), Some(7));
assert_eq!(message, "ERROR: boom; rollback failed");
}
#[test]
fn take_message_position_strips_marker_and_resolves_position() {
let sql = "SELECT 1\nFROM missing";
let cursor = sql.find("missing").unwrap() as u32 + 1;
let raw = format!("ERROR: relation \"missing\" does not exist{}", encode_marker(cursor));
let (message, position) = take_message_position(&raw, sql);
assert_eq!(message, "ERROR: relation \"missing\" does not exist");
let position = position.unwrap();
assert_eq!(position.line, 2);
assert_eq!(position.column, 6);
}
#[test]
fn take_message_position_still_strips_when_the_cursor_is_unusable() {
// cursor 0 cannot be resolved, but the marker must not leak.
let raw = format!("ERROR: boom{}", encode_marker(0));
let (message, position) = take_message_position(&raw, "SELECT 1");
assert_eq!(message, "ERROR: boom");
assert!(position.is_none());
// Empty statement: nothing to map onto.
let raw = format!("ERROR: boom{}", encode_marker(5));
let (message, position) = take_message_position(&raw, "");
assert_eq!(message, "ERROR: boom");
assert!(position.is_none());
}
#[test]
fn take_message_position_without_marker_is_identity() {
let (message, position) = take_message_position("ERROR: x", "SELECT 1");
assert_eq!(message, "ERROR: x");
assert!(position.is_none());
}
#[test]
fn multiple_markers_are_all_stripped_and_never_resolved() {
// A user-statement error merged with an infrastructure error carries two
// cursors; the position cannot be attributed to a single statement.
let raw =
format!("ERROR: relation missing does not exist{}; cleanup failed{}", encode_marker(15), encode_marker(3));
let (message, position) = take_message_position(&raw, "SELECT * FROM missing");
assert_eq!(message, "ERROR: relation missing does not exist; cleanup failed");
assert!(position.is_none());
assert_eq!(strip_marker(&raw), "ERROR: relation missing does not exist; cleanup failed");
}
#[test]
fn strip_marker_without_marker_is_identity() {
assert_eq!(strip_marker("ERROR: x"), "ERROR: x");
}
}
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,223 @@
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum SqlServerTemporalKind {
Date,
Time { scale: u8 },
SmallDateTime,
DateTime,
DateTime2 { scale: u8 },
DateTimeOffset { scale: u8 },
}
pub fn format_sqlserver_datetime_display(value: &chrono::NaiveDateTime) -> String {
let rounded = value.checked_add_signed(chrono::Duration::microseconds(500)).unwrap_or(*value);
let base = rounded.format("%Y-%m-%d %H:%M:%S").to_string();
let millis = rounded.and_utc().timestamp_subsec_millis();
if millis == 0 {
base
} else {
format!("{base}.{millis:03}")
}
}
pub fn normalize_sqlserver_temporal_literal(value: &str, column_type: Option<&str>) -> Option<String> {
let kind = sqlserver_temporal_kind(column_type?)?;
let parts = parse_sqlserver_temporal(value)?;
match kind {
SqlServerTemporalKind::Date => Some(parts.date),
SqlServerTemporalKind::Time { scale } => Some(format_sqlserver_time_text(&parts.time, scale)),
SqlServerTemporalKind::SmallDateTime => {
Some(format!("{} {}", parts.date, format_sqlserver_time_text(&parts.time, 0)))
}
SqlServerTemporalKind::DateTime => Some(format_sqlserver_datetime_parts(&parts.date, &parts.time)),
SqlServerTemporalKind::DateTime2 { scale } => {
Some(format!("{} {}", parts.date, format_sqlserver_time_text(&parts.time, scale)))
}
SqlServerTemporalKind::DateTimeOffset { scale } => {
let offset = parts.offset?;
Some(format!("{} {}{}", parts.date, format_sqlserver_time_text(&parts.time, scale), offset))
}
}
}
fn sqlserver_temporal_kind(column_type: &str) -> Option<SqlServerTemporalKind> {
let lower = column_type.trim().to_ascii_lowercase();
let base = lower.split(['(', ' ', '\t', '\n']).next().unwrap_or("");
match base {
"date" | "daten" => Some(SqlServerTemporalKind::Date),
"smalldatetime" => Some(SqlServerTemporalKind::SmallDateTime),
"datetime" | "datetimen" => Some(SqlServerTemporalKind::DateTime),
"datetime4" => Some(SqlServerTemporalKind::SmallDateTime),
"datetime2" => Some(SqlServerTemporalKind::DateTime2 { scale: temporal_scale(&lower).unwrap_or(7) }),
"time" | "timen" => Some(SqlServerTemporalKind::Time { scale: temporal_scale(&lower).unwrap_or(7) }),
"datetimeoffset" | "datetimeoffsetn" => {
Some(SqlServerTemporalKind::DateTimeOffset { scale: temporal_scale(&lower).unwrap_or(7) })
}
_ => None,
}
}
fn temporal_scale(column_type: &str) -> Option<u8> {
let start = column_type.find('(')?;
let end = column_type[start + 1..].find(')')? + start + 1;
let scale = column_type[start + 1..end].trim().parse::<u8>().ok()?;
Some(scale.min(7))
}
struct SqlServerTemporalParts {
date: String,
time: String,
offset: Option<String>,
}
fn parse_sqlserver_temporal(value: &str) -> Option<SqlServerTemporalParts> {
let trimmed = value.trim();
let bytes = trimmed.as_bytes();
if bytes.len() >= 10 && is_date_prefix(bytes) {
let date = trimmed[..10].to_string();
let mut rest = trimmed[10..].trim_start();
if rest.starts_with('T') || rest.starts_with('t') {
rest = rest[1..].trim_start();
}
if rest.is_empty() {
return Some(SqlServerTemporalParts { date, time: "00:00:00".to_string(), offset: None });
}
let (time, offset) = split_time_and_offset(rest)?;
return Some(SqlServerTemporalParts { date, time, offset });
}
let (time, offset) = split_time_and_offset(trimmed)?;
Some(SqlServerTemporalParts { date: "1900-01-01".to_string(), time, offset })
}
fn is_date_prefix(bytes: &[u8]) -> bool {
bytes.len() >= 10
&& bytes[4] == b'-'
&& bytes[7] == b'-'
&& bytes[0..4].iter().all(u8::is_ascii_digit)
&& bytes[5..7].iter().all(u8::is_ascii_digit)
&& bytes[8..10].iter().all(u8::is_ascii_digit)
}
fn split_time_and_offset(value: &str) -> Option<(String, Option<String>)> {
if value.len() < 8 {
return None;
}
let bytes = value.as_bytes();
if bytes.get(2) != Some(&b':') || bytes.get(5) != Some(&b':') {
return None;
}
if !bytes[0..2].iter().all(u8::is_ascii_digit)
|| !bytes[3..5].iter().all(u8::is_ascii_digit)
|| !bytes[6..8].iter().all(u8::is_ascii_digit)
{
return None;
}
let mut end = 8;
if bytes.get(end) == Some(&b'.') {
end += 1;
let fraction_start = end;
while end < bytes.len() && bytes[end].is_ascii_digit() {
end += 1;
}
if end == fraction_start {
return None;
}
}
let time = value[..end].to_string();
let suffix = value[end..].trim();
if suffix.is_empty() {
return Some((time, None));
}
if suffix.eq_ignore_ascii_case("z") {
return Some((time, Some("+00:00".to_string())));
}
if is_timezone_offset(suffix) {
return Some((time, Some(suffix.to_string())));
}
None
}
fn is_timezone_offset(value: &str) -> bool {
let bytes = value.as_bytes();
bytes.len() == 6
&& matches!(bytes[0], b'+' | b'-')
&& bytes[3] == b':'
&& bytes[1].is_ascii_digit()
&& bytes[2].is_ascii_digit()
&& bytes[4].is_ascii_digit()
&& bytes[5].is_ascii_digit()
}
fn format_sqlserver_time_text(value: &str, scale: u8) -> String {
let (base, fraction) = value.split_once('.').unwrap_or((value, ""));
if scale == 0 {
return base.to_string();
}
let mut digits = fraction.chars().take_while(|ch| ch.is_ascii_digit()).take(scale as usize).collect::<String>();
while digits.len() < scale as usize {
digits.push('0');
}
if digits.chars().all(|ch| ch == '0') {
base.to_string()
} else {
format!("{base}.{digits}")
}
}
fn format_sqlserver_datetime_parts(date: &str, time: &str) -> String {
let value = format!("{date} {time}");
chrono::NaiveDateTime::parse_from_str(&value, "%Y-%m-%d %H:%M:%S%.f")
.map(|value| format_sqlserver_datetime_display(&value))
.unwrap_or_else(|_| format!("{date} {}", format_sqlserver_time_text(time, 3)))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn formats_sqlserver_datetime_display_with_millisecond_precision() {
let value =
chrono::NaiveDate::from_ymd_opt(2026, 6, 29).unwrap().and_hms_nano_opt(10, 11, 12, 896_666_666).unwrap();
assert_eq!(format_sqlserver_datetime_display(&value), "2026-06-29 10:11:12.897");
let boundary =
chrono::NaiveDate::from_ymd_opt(2026, 6, 29).unwrap().and_hms_nano_opt(23, 59, 59, 999_600_000).unwrap();
assert_eq!(format_sqlserver_datetime_display(&boundary), "2026-06-30 00:00:00");
}
#[test]
fn normalizes_sqlserver_datetime_literals_by_column_type() {
assert_eq!(
normalize_sqlserver_temporal_literal("2026-06-29 10:11:12.896666666", Some("datetime")),
Some("2026-06-29 10:11:12.897".to_string())
);
assert_eq!(
normalize_sqlserver_temporal_literal("2026-06-29T10:11:12.8966666Z", Some("datetime2(7)")),
Some("2026-06-29 10:11:12.8966666".to_string())
);
assert_eq!(
normalize_sqlserver_temporal_literal("2026-06-29T10:11:12.8966666Z", Some("datetime2(3)")),
Some("2026-06-29 10:11:12.896".to_string())
);
assert_eq!(
normalize_sqlserver_temporal_literal("2026-06-29 10:11:12.8966666+08:00", Some("datetimeoffset(4)")),
Some("2026-06-29 10:11:12.8966+08:00".to_string())
);
assert_eq!(
normalize_sqlserver_temporal_literal("10:11:12.8966666", Some("time(2)")),
Some("10:11:12.89".to_string())
);
assert_eq!(
normalize_sqlserver_temporal_literal("2026-06-29 10:11:12.8966666", Some("date")),
Some("2026-06-29".to_string())
);
assert_eq!(
normalize_sqlserver_temporal_literal("2026-06-29 10:11:12.8966666", Some("smalldatetime")),
Some("2026-06-29 10:11:12".to_string())
);
}
}
+66
View File
@@ -0,0 +1,66 @@
use crate::models::connection::{ConnectionConfig, DatabaseType};
pub const DRIVER_PROFILE: &str = "tdsql";
pub fn is_config(config: &ConnectionConfig) -> bool {
is_profile(&config.db_type, config.driver_profile.as_deref())
}
pub fn is_profile(db_type: &DatabaseType, driver_profile: Option<&str>) -> bool {
*db_type == DatabaseType::Mysql
&& driver_profile.is_some_and(|profile| profile.eq_ignore_ascii_case(DRIVER_PROFILE))
}
pub fn preserves_leading_directives_for_database_type(db_type: DatabaseType) -> bool {
db_type == DatabaseType::Mysql
}
pub fn leading_directive_start(statement: &str, executable_start: usize) -> Option<usize> {
let prefix = statement.get(..executable_start)?;
let line_start = prefix.rfind(['\r', '\n']).map_or(0, |index| index + 1);
let line_prefix = &prefix[line_start..];
let trimmed_line_start = line_prefix.trim_start();
if trimmed_line_start.starts_with("/*") && trimmed_line_start.trim_end().ends_with("*/") {
return Some(line_start + line_prefix.len() - trimmed_line_start.len());
}
let trimmed_prefix = prefix.trim_end();
trimmed_prefix.strip_suffix("/*proxy*/").map(|before| before.len())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn profile_is_isolated_from_standard_mysql() {
assert!(is_profile(&DatabaseType::Mysql, Some("TDSQL")));
assert!(!is_profile(&DatabaseType::Mysql, None));
assert!(!is_profile(&DatabaseType::Postgres, Some("tdsql")));
}
#[test]
fn leading_directives_are_available_only_to_mysql_parsing() {
assert!(preserves_leading_directives_for_database_type(DatabaseType::Mysql));
assert!(!preserves_leading_directives_for_database_type(DatabaseType::Postgres));
}
#[test]
fn leading_directives_preserve_same_line_and_exact_proxy_behavior() {
let exact = "/*proxy*/ \n\tSHOW PROXY STATUS";
let executable_start = exact.find("SHOW").unwrap();
assert_eq!(leading_directive_start(exact, executable_start), Some(0));
let same_line = " /*sets:allsets */ SELECT 1";
let executable_start = same_line.find("SELECT").unwrap();
assert_eq!(leading_directive_start(same_line, executable_start), Some(2));
let separate_line = "/*sets:allsets */\nSELECT 1";
let executable_start = separate_line.find("SELECT").unwrap();
assert_eq!(leading_directive_start(separate_line, executable_start), None);
let separated = "/*proxy*/\n/* audit */\nSHOW PROXY STATUS";
let executable_start = separated.find("SHOW").unwrap();
assert_eq!(leading_directive_start(separated, executable_start), None);
}
}
+150
View File
@@ -0,0 +1,150 @@
pub fn format_pg_array_sql_literal(arr: &[serde_json::Value]) -> String {
if arr.is_empty() {
return "'{}'".to_string();
}
let elements: Vec<String> = arr.iter().map(format_pg_array_element).collect();
let inner = format!("{{{}}}", elements.join(","));
format!("'{}'", inner.replace('\\', "\\\\").replace('\'', "''"))
}
pub fn format_pg_array_element(val: &serde_json::Value) -> String {
match val {
serde_json::Value::Null => "NULL".to_string(),
serde_json::Value::Array(arr) => {
if arr.is_empty() {
return "{}".to_string();
}
let elements: Vec<String> = arr.iter().map(format_pg_array_element).collect();
format!("{{{}}}", elements.join(","))
}
serde_json::Value::String(s) => {
let escaped = s.replace('\\', "\\\\").replace('"', "\\\"");
format!("\"{}\"", escaped)
}
serde_json::Value::Number(n) => n.to_string(),
serde_json::Value::Bool(b) => {
if *b {
"true".to_string()
} else {
"false".to_string()
}
}
serde_json::Value::Object(o) => {
let json = serde_json::to_string(o).unwrap_or_default();
let escaped = json.replace('\\', "\\\\").replace('"', "\\\"");
format!("\"{}\"", escaped)
}
}
}
pub fn format_ch_array_sql_literal(arr: &[serde_json::Value]) -> String {
if arr.is_empty() {
return "[]".to_string();
}
let elements: Vec<String> = arr.iter().map(format_ch_array_element).collect();
format!("[{}]", elements.join(","))
}
pub fn format_ch_array_element(val: &serde_json::Value) -> String {
match val {
serde_json::Value::Null => "NULL".to_string(),
serde_json::Value::Array(arr) => {
if arr.is_empty() {
return "[]".to_string();
}
let elements: Vec<String> = arr.iter().map(format_ch_array_element).collect();
format!("[{}]", elements.join(","))
}
serde_json::Value::String(s) => {
let escaped = s.replace('\\', "\\\\").replace('\'', "''");
format!("'{}'", escaped)
}
serde_json::Value::Number(n) => n.to_string(),
serde_json::Value::Bool(b) => {
if *b {
"true".to_string()
} else {
"false".to_string()
}
}
serde_json::Value::Object(o) => {
let json = serde_json::to_string(o).unwrap_or_default();
format!("'{}'", json.replace('\\', "\\\\").replace('\'', "''"))
}
}
}
pub fn quote_postgres_string_literal(value: &str) -> String {
if !value.contains('\\') && !value.chars().any(|character| character.is_ascii_control()) {
return quote_string_literal(value);
}
let mut escaped = String::with_capacity(value.len());
for character in value.chars() {
match character {
'\\' => escaped.push_str("\\\\"),
'\n' => escaped.push_str("\\n"),
'\r' => escaped.push_str("\\r"),
'\t' => escaped.push_str("\\t"),
'\x08' => escaped.push_str("\\b"),
'\x0c' => escaped.push_str("\\f"),
'\'' => escaped.push_str("''"),
character if character.is_ascii_control() => {
const HEX: &[u8; 16] = b"0123456789ABCDEF";
let byte = character as u8;
escaped.push_str("\\x");
escaped.push(HEX[(byte >> 4) as usize] as char);
escaped.push(HEX[(byte & 0x0F) as usize] as char);
}
character => escaped.push(character),
}
}
// Escape string constants keep control characters out of the physical
// script and remain correct regardless of standard_conforming_strings.
format!("E'{escaped}'")
}
pub fn is_postgres_vector_type(column_type: Option<&str>) -> bool {
column_type
.map(|column_type| {
let normalized = column_type.trim().trim_matches('"').to_ascii_lowercase();
if normalized.trim_end().ends_with("[]") {
return false;
}
let base = normalized.split(['(', ' ', '\t', '\n']).next().unwrap_or("").trim_matches('"');
matches!(base, "vector" | "halfvec") || base.ends_with(".vector") || base.ends_with(".halfvec")
})
.unwrap_or(false)
}
pub fn format_postgres_vector_sql_literal(value: &serde_json::Value) -> String {
if value.is_null() {
return "NULL".to_string();
}
let text = match value {
// pgvector vector/halfvec are scalar extension types whose importable
// literal grammar uses square brackets, unlike PostgreSQL arrays.
serde_json::Value::Array(arr) => {
let elements = arr.iter().map(format_postgres_vector_element).collect::<Vec<_>>();
format!("[{}]", elements.join(","))
}
serde_json::Value::String(text) => text.to_string(),
_ => value.to_string(),
};
quote_postgres_string_literal(&text)
}
pub fn format_postgres_vector_element(value: &serde_json::Value) -> String {
match value {
serde_json::Value::String(text) => text.trim().to_string(),
serde_json::Value::Number(number) => number.to_string(),
serde_json::Value::Bool(value) => value.to_string(),
serde_json::Value::Null => "NULL".to_string(),
_ => value.to_string(),
}
}
pub fn quote_string_literal(value: &str) -> String {
format!("'{}'", value.replace('\'', "''"))
}