Skip to main content

ch_database/
migration.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    let mut statements: Vec<&str> = Vec::new();
25
26    while i < bytes.len() {
27        let b = bytes[i];
28        let next = bytes.get(i + 1).copied();
29
30        match mode {
31            Mode::Normal => match b {
32                b'\'' => mode = Mode::SingleQuote,
33                b'"' => mode = Mode::DoubleQuote,
34                b'`' => mode = Mode::Backtick,
35                b'-' if next == Some(b'-') => {
36                    mode = Mode::LineComment;
37                    i += 1;
38                }
39                b'#' => mode = Mode::LineComment,
40                b'/' if next == Some(b'*') => {
41                    mode = Mode::BlockComment;
42                    i += 1;
43                }
44                b';' => {
45                    let statement = sql[statement_start..i]
46                        .trim()
47                        .trim_start_matches('\u{feff}')
48                        .trim();
49                    if !statement.is_empty() {
50                        statements.push(statement);
51                    }
52                    statement_start = i + 1;
53                }
54                _ => {}
55            },
56            Mode::SingleQuote => {
57                if b == b'\\' {
58                    // Skip escaped character in string.
59                    i += 1;
60                } else if b == b'\'' {
61                    mode = Mode::Normal;
62                }
63            }
64            Mode::DoubleQuote => {
65                if b == b'\\' {
66                    i += 1;
67                } else if b == b'"' {
68                    mode = Mode::Normal;
69                }
70            }
71            Mode::Backtick => {
72                if b == b'`' {
73                    mode = Mode::Normal;
74                }
75            }
76            Mode::LineComment => {
77                if b == b'\n' || b == b'\r' {
78                    mode = Mode::Normal;
79                }
80            }
81            Mode::BlockComment => {
82                if b == b'*' && next == Some(b'/') {
83                    mode = Mode::Normal;
84                    i += 1;
85                }
86            }
87        }
88
89        i += 1;
90    }
91
92    let tail = sql[statement_start..]
93        .trim()
94        .trim_start_matches('\u{feff}')
95        .trim();
96    if !tail.is_empty() {
97        statements.push(tail);
98    }
99
100    statements.into_iter()
101}
102
103#[cfg(test)]
104mod tests {
105    use super::iter_migration_statements;
106
107    #[test]
108    fn strips_utf8_bom_from_first_statement() {
109        let sql = "\u{feff}CREATE TABLE first (id INT); CREATE TABLE second (id INT);";
110        let statements: Vec<_> = iter_migration_statements(sql).collect();
111        assert_eq!(
112            statements,
113            vec![
114                "CREATE TABLE first (id INT)",
115                "CREATE TABLE second (id INT)"
116            ]
117        );
118    }
119
120    #[test]
121    fn ignores_semicolons_in_line_comments() {
122        let sql = "-- comment with ; inside\nCREATE TABLE t1 (id INT);";
123        let statements: Vec<_> = iter_migration_statements(sql).collect();
124        assert_eq!(
125            statements,
126            vec!["-- comment with ; inside\nCREATE TABLE t1 (id INT)"]
127        );
128    }
129
130    #[test]
131    fn ignores_semicolons_in_block_comments() {
132        let sql = "/* comment ; inside */\nCREATE TABLE t1 (id INT);";
133        let statements: Vec<_> = iter_migration_statements(sql).collect();
134        assert_eq!(
135            statements,
136            vec!["/* comment ; inside */\nCREATE TABLE t1 (id INT)"]
137        );
138    }
139
140    #[test]
141    fn ignores_semicolons_in_strings() {
142        let sql = "INSERT INTO t1 (txt) VALUES ('a;b;c'); INSERT INTO t1 (txt) VALUES (\"x;y\");";
143        let statements: Vec<_> = iter_migration_statements(sql).collect();
144        assert_eq!(
145            statements,
146            vec![
147                "INSERT INTO t1 (txt) VALUES ('a;b;c')",
148                "INSERT INTO t1 (txt) VALUES (\"x;y\")",
149            ]
150        );
151    }
152}