sql-parser: add dev deps for dataset tests

Author: Almaz-KG

Cargo.lock

@@ -12,6 +12,10 @@ description = "An SQLite fully compatible tokenizer and parser written in Rust"
 [dependencies]
 once_cell = "1.20.2"
 
+[dev-dependencies]
+sqlite3-parser = "0.13.0"
+fallible-iterator = "0.3.0"
+
 [profile.release]
 lto = true
 codegen-units = 16

Cargo.toml

@@ -1,6 +1,8 @@
 use std::{fs, path::Path};
+mod sqlite_parser;
 
 use db_academy_sql_parser::Parser;
+use sqlite_parser::parse_sql_file;
 
 #[test]
 fn run_codeschool_sqlite_parser_test() {
@@ -46,3 +48,41 @@ fn run_test(sql_content: &str) -> bool {
     let statement = parser.parse_statement();
     statement.is_ok()
 }
+
+#[test]
+fn run_codeschool_sqlite_parser_with_sqlite3_parser() {
+    let test_set_path = Path::new("tests/codeschool-sqlite-parser-test-files/sql");
+
+    let mut total_tests = 0;
+    let mut passed_test = 0;
+
+    for group in fs::read_dir(test_set_path).expect("Failed to read test_set directory") {
+        let group = group.expect("Failed to read directory entry").path();
+        if !group.is_dir() {
+            continue;
+        }
+
+        for entry in fs::read_dir(group).expect("Failed to read test_set directory") {
+            let file = entry.expect("Failed to read directory entry").path();
+
+            if file.extension().and_then(|ext| ext.to_str()) == Some("sql") {
+                let parsing_result = parse_sql_file(&file.to_str().unwrap());
+                if parsing_result {
+                    passed_test += 1;
+                }
+                total_tests += 1;
+            }
+        }
+    }
+
+    println!("Tested {} SQL files", total_tests);
+    println!(
+        "Passed {} SQL files, {} failed",
+        passed_test,
+        total_tests - passed_test
+    );
+    println!(
+        "Passed {:.2}% of the tests",
+        passed_test as f64 / total_tests as f64 * 100.0
+    );
+}

tests/codeschool-sqlite-parser-test-files/main.rs

@@ -0,0 +1,43 @@
+use fallible_iterator::FallibleIterator;
+use std::fs::read;
+
+use sqlite3_parser::lexer::sql::Parser;
+
+/// Parse specified files and check all commands.
+pub fn parse_sql_file(file_path: &str) -> bool {
+    let input = read(file_path).unwrap();
+    let mut parser = Parser::new(&input);
+    loop {
+        match parser.next() {
+            Ok(None) => return true,
+            Err(err) => {
+                eprintln!("Err: {err} in {file_path}");
+                return false;
+            }
+            Ok(Some(cmd)) => {
+                let input = cmd.to_string();
+                let mut checker = Parser::new(input.as_bytes());
+                match checker.next() {
+                    Err(err) => {
+                        eprintln!(
+                            "Check Err in {}:{}, {} in\n{}\n{:?}",
+                            file_path,
+                            parser.line(),
+                            err,
+                            input,
+                            cmd
+                        );
+                    }
+                    Ok(None) => {
+                        eprintln!("Check Err in {}:{}, {:?}", file_path, parser.line(), cmd);
+                    }
+                    Ok(Some(check)) => {
+                        if cmd != check {
+                            eprintln!("{cmd:?}\n<>\n{check:?}");
+                        }
+                    }
+                }
+            }
+        }
+    }
+}