Skip to main content

ch_database/migration/
mod.rs

1/// Splits a migration script into individual statements and trims whitespace.
2///
3/// Unlike a plain `split(';')`, this parser ignores semicolons inside:
4/// - single-quoted strings
5/// - double-quoted strings
6/// - backtick identifiers
7/// - line comments (`-- ...`, `# ...`)
8/// - block comments (`/* ... */`)
9pub fn iter_migration_statements(sql: &str) -> impl Iterator<Item = &str> {
10    #[derive(Clone, Copy, PartialEq, Eq)]
11    enum Mode {
12        Normal,
13        SingleQuote,
14        DoubleQuote,
15        Backtick,
16        LineComment,
17        BlockComment,
18    }
19
20    let bytes = sql.as_bytes();
21    let mut mode = Mode::Normal;
22    let mut statement_start = 0usize;
23    let mut i = 0usize;
24    std::iter::from_fn(move || {
25        while i < bytes.len() {
26            let b = bytes[i];
27            let next = bytes.get(i + 1).copied();
28
29            match mode {
30                Mode::Normal => match b {
31                    b'\'' => mode = Mode::SingleQuote,
32                    b'"' => mode = Mode::DoubleQuote,
33                    b'`' => mode = Mode::Backtick,
34                    b'-' if next == Some(b'-')
35                        && bytes.get(i + 2).is_none_or(|byte| {
36                            byte.is_ascii_whitespace() || byte.is_ascii_control()
37                        }) =>
38                    {
39                        mode = Mode::LineComment;
40                        i += 1;
41                    }
42                    b'#' => mode = Mode::LineComment,
43                    b'/' if next == Some(b'*') => {
44                        mode = Mode::BlockComment;
45                        i += 1;
46                    }
47                    b';' => {
48                        let statement = sql[statement_start..i]
49                            .trim()
50                            .trim_start_matches('\u{feff}')
51                            .trim();
52                        statement_start = i + 1;
53                        if !statement.is_empty() {
54                            i += 1;
55                            return Some(statement);
56                        }
57                    }
58                    _ => {}
59                },
60                Mode::SingleQuote => {
61                    if b == b'\\' {
62                        // Skip escaped character in string.
63                        i += 1;
64                    } else if b == b'\'' {
65                        mode = Mode::Normal;
66                    }
67                }
68                Mode::DoubleQuote => {
69                    if b == b'\\' {
70                        i += 1;
71                    } else if b == b'"' {
72                        mode = Mode::Normal;
73                    }
74                }
75                Mode::Backtick => {
76                    if b == b'`' {
77                        mode = Mode::Normal;
78                    }
79                }
80                Mode::LineComment => {
81                    if b == b'\n' || b == b'\r' {
82                        mode = Mode::Normal;
83                    }
84                }
85                Mode::BlockComment => {
86                    if b == b'*' && next == Some(b'/') {
87                        mode = Mode::Normal;
88                        i += 1;
89                    }
90                }
91            }
92
93            i += 1;
94        }
95
96        let tail = sql[statement_start..]
97            .trim()
98            .trim_start_matches('\u{feff}')
99            .trim();
100        statement_start = bytes.len();
101        (!tail.is_empty()).then_some(tail)
102    })
103}
104
105#[cfg(test)]
106mod tests {
107    use super::iter_migration_statements;
108
109    #[test]
110    fn distinguishes_mysql_comments_from_subtraction() {
111        assert_eq!(
112            iter_migration_statements("SELECT 3--1; SELECT 2; -- comment;\nSELECT 4;")
113                .collect::<Vec<_>>(),
114            ["SELECT 3--1", "SELECT 2", "-- comment;\nSELECT 4"]
115        );
116    }
117
118    #[test]
119    fn handles_empty_statements_and_repeated_exhaustion() {
120        let mut statements = iter_migration_statements(";; SELECT 1;; SELECT 2 ");
121        assert_eq!(statements.next(), Some("SELECT 1"));
122        assert_eq!(statements.next(), Some("SELECT 2"));
123        assert_eq!(statements.next(), None);
124        assert_eq!(statements.next(), None);
125    }
126
127    #[test]
128    fn preserves_quoted_escapes_unicode_and_hash_comments() {
129        let sql = "SELECT 'it''s; gültig', `a``;b`; # comment;\nSELECT 'a\\\';b';";
130        assert_eq!(iter_migration_statements(sql).count(), 2);
131    }
132
133    #[test]
134    fn strips_utf8_bom_from_first_statement() {
135        let sql = "\u{feff}CREATE TABLE first (id INT); CREATE TABLE second (id INT);";
136        let statements: Vec<_> = iter_migration_statements(sql).collect();
137        assert_eq!(
138            statements,
139            vec![
140                "CREATE TABLE first (id INT)",
141                "CREATE TABLE second (id INT)"
142            ]
143        );
144    }
145
146    #[test]
147    fn ignores_semicolons_in_line_comments() {
148        let sql = "-- comment with ; inside\nCREATE TABLE t1 (id INT);";
149        let statements: Vec<_> = iter_migration_statements(sql).collect();
150        assert_eq!(
151            statements,
152            vec!["-- comment with ; inside\nCREATE TABLE t1 (id INT)"]
153        );
154    }
155
156    #[test]
157    fn ignores_semicolons_in_block_comments() {
158        let sql = "/* comment ; inside */\nCREATE TABLE t1 (id INT);";
159        let statements: Vec<_> = iter_migration_statements(sql).collect();
160        assert_eq!(
161            statements,
162            vec!["/* comment ; inside */\nCREATE TABLE t1 (id INT)"]
163        );
164    }
165
166    #[test]
167    fn ignores_semicolons_in_strings() {
168        let sql = "INSERT INTO t1 (txt) VALUES ('a;b;c'); INSERT INTO t1 (txt) VALUES (\"x;y\");";
169        let statements: Vec<_> = iter_migration_statements(sql).collect();
170        assert_eq!(
171            statements,
172            vec![
173                "INSERT INTO t1 (txt) VALUES ('a;b;c')",
174                "INSERT INTO t1 (txt) VALUES (\"x;y\")",
175            ]
176        );
177    }
178}