feat: support matching sqlstate with [statement|query] error (CCSSS) (#269)

Author: BugenZhao

.github/workflows/ci.yml

@@ -65,10 +65,9 @@ jobs:
           profile: minimal
           toolchain: stable
       - name: Install semver-checks
-        uses: actions-rs/cargo@v1
+        uses: taiki-e/install-action@v2
         with:
-          command: install
-          args: cargo-semver-checks --version ^0.43 --locked
+          tool: cargo-semver-checks
       - name: Check semver
         run: |
          cargo semver-checks check-release -p sqllogictest

CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+## [0.29.0] - 2025-12-19
+
+* parser/runner: Support matching expected failures by SQLSTATE via `statement|query error (<SQLSTATE>)`.
+
 ## [0.28.4] - 2025-09-04
 
 * bin: support skip files with regex

Cargo.lock

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["sqllogictest", "sqllogictest-bin", "sqllogictest-engines", "tests"]
 
 [workspace.package]
-version = "0.28.4"
+version = "0.29.0"
 edition = "2021"
 homepage = "https://github.com/risinglightdb/sqllogictest-rs"
 keywords = ["sql", "database", "parser", "cli"]

Cargo.toml

@@ -86,11 +86,12 @@ Seq Scan on t  (cost=<slt:ignore> rows=<slt:ignore> width=<slt:ignore>)
    Filter: (x > 1)  
 ```
 
-### Extension: Run a query/statement that should fail with the expacted error message
+### Extension: Run a query/statement that should fail with the expected error message
 
 The syntax:
 - Do not check the error message: `[statement|query] error`
 - Single line error message (regexp match): `[statement|query] error <regex>`
+- Match SQLSTATE (exact match): `[statement|query] error (<SQLSTATE>)`
 - Multiline error message (exact match): Use `----`.
 
 ```text
@@ -99,6 +100,11 @@ The syntax:
 statement error Multiple object drop not supported
 DROP VIEW foo, bar;
 
+# Ensure that the statement errors and that the SQLSTATE is exactly the expected one.
+# (This requires the engine to expose the SQLSTATE via `DB::error_sql_state` / `AsyncDB::error_sql_state`.)
+statement error (42P01)
+SELECT * FROM non_existent_table;
+
 # The output error message must be the exact match of the expected one to pass the test,
 # except for the leading and trailing whitespaces.
 # Empty lines (not consecutive) are allowed in the expected error message. As a result, the message must end with 2 consecutive empty lines.

README.md

@@ -25,8 +25,8 @@ fancy-regex = "0.16"
 itertools = "0.13"
 quick-junit = { version = "0.5" }
 rand = "0.8"
-sqllogictest = { path = "../sqllogictest", version = "0.28" }
-sqllogictest-engines = { path = "../sqllogictest-engines", version = "0.28" }
+sqllogictest = { path = "../sqllogictest", version = "0.29" }
+sqllogictest-engines = { path = "../sqllogictest-engines", version = "0.29" }
 tokio = { version = "1", features = [
     "rt",
     "rt-multi-thread",

sqllogictest-bin/Cargo.toml

@@ -73,17 +73,17 @@ pub(crate) async fn connect(
         EngineConfig::MySql => Engines::MySql(
             MySql::connect(config.into())
                 .await
-                .map_err(|e| EnginesError(e.into()))?,
+                .map_err(EnginesError::without_state)?,
         ),
         EngineConfig::Postgres => Engines::Postgres(
             PostgresSimple::connect(config.into())
                 .await
-                .map_err(|e| EnginesError(e.into()))?,
+                .map_err(EnginesError::without_state)?,
         ),
         EngineConfig::PostgresExtended => Engines::PostgresExtended(
             PostgresExtended::connect(config.into())
                 .await
-                .map_err(|e| EnginesError(e.into()))?,
+                .map_err(EnginesError::without_state)?,
         ),
         EngineConfig::External(cmd_tmpl) => {
             let (host, port) = config.random_addr();
@@ -98,24 +98,36 @@ pub(crate) async fn connect(
             Engines::External(
                 ExternalDriver::connect(cmd)
                     .await
-                    .map_err(|e| EnginesError(e.into()))?,
+                    .map_err(EnginesError::without_state)?,
             )
         }
     })
 }
 
 #[derive(Debug)]
-pub(crate) struct EnginesError(anyhow::Error);
+pub(crate) struct EnginesError {
+    error: anyhow::Error,
+    sqlstate: Option<String>,
+}
+
+impl EnginesError {
+    fn without_state(error: impl Into<anyhow::Error>) -> Self {
+        Self {
+            error: error.into(),
+            sqlstate: None,
+        }
+    }
+}
 
 impl Display for EnginesError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        self.0.fmt(f)
+        self.error.fmt(f)
     }
 }
 
 impl std::error::Error for EnginesError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        self.0.source()
+        self.error.source()
     }
 }
 
@@ -130,16 +142,21 @@ macro_rules! dispatch_engines {
     }};
 }
 
+fn error_sql_state<E: AsyncDB>(_engine: &E, error: &E::Error) -> Option<String> {
+    E::error_sql_state(error)
+}
+
 #[async_trait]
 impl AsyncDB for Engines {
     type Error = EnginesError;
     type ColumnType = DefaultColumnType;
 
     async fn run(&mut self, sql: &str) -> Result<DBOutput<Self::ColumnType>, Self::Error> {
         dispatch_engines!(self, e, {
-            e.run(sql)
-                .await
-                .map_err(|e| EnginesError(anyhow::Error::from(e)))
+            e.run(sql).await.map_err(|error| EnginesError {
+                sqlstate: error_sql_state(e, &error),
+                error: anyhow::Error::from(error),
+            })
         })
     }
 
@@ -158,4 +175,8 @@ impl AsyncDB for Engines {
     async fn shutdown(&mut self) {
         dispatch_engines!(self, e, { e.shutdown().await })
     }
+
+    fn error_sql_state(err: &Self::Error) -> Option<String> {
+        err.sqlstate.clone()
+    }
 }

sqllogictest-bin/src/engines.rs

@@ -20,7 +20,7 @@ postgres-types = { version = "0.2.8", features = ["derive", "with-chrono-0_4"] }
 rust_decimal = { version = "1.36.0", features = ["tokio-pg"] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-sqllogictest = { path = "../sqllogictest", version = "0.28" }
+sqllogictest = { path = "../sqllogictest", version = "0.29" }
 thiserror = "2"
 tokio = { version = "1", features = [
     "rt",

sqllogictest-engines/Cargo.toml

@@ -81,4 +81,12 @@ impl sqllogictest::AsyncDB for MySql {
     async fn run_command(command: Command) -> std::io::Result<std::process::Output> {
         tokio::process::Command::from(command).output().await
     }
+
+    fn error_sql_state(err: &Self::Error) -> Option<String> {
+        if let mysql_async::Error::Server(err) = err {
+            Some(err.state.clone())
+        } else {
+            None
+        }
+    }
 }

sqllogictest-engines/src/mysql.rs

@@ -326,4 +326,8 @@ impl sqllogictest::AsyncDB for Postgres<Extended> {
     async fn run_command(command: Command) -> std::io::Result<std::process::Output> {
         tokio::process::Command::from(command).output().await
     }
+
+    fn error_sql_state(err: &Self::Error) -> Option<String> {
+        err.code().map(|s| s.code().to_owned())
+    }
 }