Function parse_statement

src/sql-parser/src/lib.rs:70–118

(tc: &TestCase)

    }

    fn parse_statement(tc: &TestCase) -> String {
        let input = tc.input.strip_suffix('\n').unwrap_or(&tc.input);
        match parser::parse_statements(input) {
            Ok(s) => {
                let stmt = s.into_element().ast;
                for printed in [stmt.to_ast_string_simple(), stmt.to_ast_string_stable()] {
                    let mut parsed = match parser::parse_statements(&printed) {
                        Ok(parsed) => parsed.into_element().ast,
                        Err(err) => panic!("reparse failed: {}: {}\n", stmt, err),
                    };
                    match (&mut parsed, &stmt) {
                        // DECLARE remembers the original SQL. Erase that here so it can differ if
                        // needed (for example, quoting identifiers vs not). This is ok because we
                        // still compare that the resulting ASTs are identical, and it's valid for
                        // those to come from different original strings.
                        (Statement::Declare(parsed), Statement::Declare(stmt)) => {
                            parsed.sql.clone_from(&stmt.sql);
                        }
                        _ => {}
                    }
                    if parsed != stmt {
                        panic!(
                            "reparse comparison failed:\n{:?}\n!=\n{:?}\n{printed}\n",
                            stmt, parsed
                        );
                    }
                }

                // Also check that the redacted version of the statement can be reparsed. This is
                // important so that we are still able to pretty-print redacted statements, which
                // helps during debugging.
                let redacted = stmt.to_ast_string_redacted();
                let res = parser::parse_statements(&redacted);
                assert!(
                    res.is_ok(),
                    "redacted statement could not be reparsed: {res:?}\noriginal:\n{stmt}\nredacted:\n{redacted}"
                );

                if tc.args.contains_key("roundtrip") {
                    format!("{}\n", stmt)
                } else {
                    // TODO(justin): it would be nice to have a middle-ground between this
                    // all-on-one-line and {:#?}'s huge number of lines.
                    format!("{}\n=>\n{:?}\n", stmt, stmt)
                }
            }
            Err(e) => render_error(input, e.error),
        }
    }

    fn parse_scalar(tc: &TestCase) -> String {
        let input = tc.input.trim();