added tests and a helper function

Author: Takahiro Ebato

src/test_utils.rs

@@ -212,6 +212,50 @@ pub fn all_dialects() -> TestedDialects {
     }
 }
 
+static ALL_DIALECT_NAMES: &[&str] = &[
+    "generic",
+    "mysql",
+    "postgresql",
+    "hive",
+    "sqlite",
+    "snowflake",
+    "redshift",
+    "mssql",
+    "clickhouse",
+    "bigquery",
+    "ansi",
+    "duckdb",
+];
+
+pub fn partition_all_dialects_by_inclusion(
+    dialect_names: Vec<&str>,
+) -> (TestedDialects, TestedDialects) {
+    for dialect_name in &dialect_names {
+        assert!(
+            ALL_DIALECT_NAMES.contains(dialect_name),
+            "Unknown dialect: {}",
+            dialect_name
+        );
+    }
+
+    let (included_dialect_names, excluded_dialect_names) = ALL_DIALECT_NAMES
+        .iter()
+        .partition(|&dialect_name| dialect_names.contains(dialect_name));
+
+    let build_tested_dialects = |names: Vec<&str>| TestedDialects {
+        dialects: names
+            .iter()
+            .map(|&name| dialect_from_str(name).unwrap())
+            .collect(),
+        options: None,
+    };
+
+    (
+        build_tested_dialects(included_dialect_names),
+        build_tested_dialects(excluded_dialect_names),
+    )
+}
+
 pub fn assert_eq_vec<T: ToString>(expected: &[&str], actual: &[T]) {
     assert_eq!(
         expected,

tests/sqlparser_sqlite.rs

@@ -22,7 +22,7 @@ use test_utils::*;
 use sqlparser::ast::SelectItem::UnnamedExpr;
 use sqlparser::ast::*;
 use sqlparser::dialect::{GenericDialect, SQLiteDialect};
-use sqlparser::parser::ParserOptions;
+use sqlparser::parser::{ParserError, ParserOptions};
 use sqlparser::tokenizer::Token;
 
 #[test]
@@ -433,12 +433,31 @@ fn invalid_empty_list() {
 
 #[test]
 fn parse_start_transaction_with_modifier() {
-    sqlite_and_generic().verified_stmt("BEGIN DEFERRED TRANSACTION");
-    sqlite_and_generic().verified_stmt("BEGIN IMMEDIATE TRANSACTION");
-    sqlite_and_generic().verified_stmt("BEGIN EXCLUSIVE TRANSACTION");
-    sqlite_and_generic().one_statement_parses_to("BEGIN DEFERRED", "BEGIN DEFERRED TRANSACTION");
-    sqlite_and_generic().one_statement_parses_to("BEGIN IMMEDIATE", "BEGIN IMMEDIATE TRANSACTION");
-    sqlite_and_generic().one_statement_parses_to("BEGIN EXCLUSIVE", "BEGIN EXCLUSIVE TRANSACTION");
+    let (supported_dialects, unsupported_dialects) =
+        partition_all_dialects_by_inclusion(vec!["generic", "sqlite"]);
+
+    supported_dialects.verified_stmt("BEGIN DEFERRED TRANSACTION");
+    supported_dialects.verified_stmt("BEGIN IMMEDIATE TRANSACTION");
+    supported_dialects.verified_stmt("BEGIN EXCLUSIVE TRANSACTION");
+    supported_dialects.one_statement_parses_to("BEGIN DEFERRED", "BEGIN DEFERRED TRANSACTION");
+    supported_dialects.one_statement_parses_to("BEGIN IMMEDIATE", "BEGIN IMMEDIATE TRANSACTION");
+    supported_dialects.one_statement_parses_to("BEGIN EXCLUSIVE", "BEGIN EXCLUSIVE TRANSACTION");
+
+    let res = unsupported_dialects.parse_sql_statements("BEGIN DEFERRED");
+    assert_eq!(
+        ParserError::ParserError("Expected end of statement, found: DEFERRED".to_string()),
+        res.unwrap_err(),
+    );
+    let res = unsupported_dialects.parse_sql_statements("BEGIN IMMEDIATE");
+    assert_eq!(
+        ParserError::ParserError("Expected end of statement, found: IMMEDIATE".to_string()),
+        res.unwrap_err(),
+    );
+    let res = unsupported_dialects.parse_sql_statements("BEGIN EXCLUSIVE");
+    assert_eq!(
+        ParserError::ParserError("Expected end of statement, found: EXCLUSIVE".to_string()),
+        res.unwrap_err(),
+    );
 }
 
 fn sqlite() -> TestedDialects {