//! 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, /// Upper-cased key, for case-insensitive matching. key: String, /// Raw value (without surrounding quotes), if the option had `= value`. value: Option, } 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, &'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 ( ) ` 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> { // `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, (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] ` 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 { 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 { 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 { 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); } }