Merge branch 'fix/receipt-contradictions' into fix/r68-contradictions

Author: kvlonge

.github/workflows/website.yml

@@ -0,0 +1,41 @@
+name: Website
+
+# Builds the site and checks its links and branding. Manual only, and it never deploys: the site is
+# not public yet. Add push and pull_request triggers, and a deploy job, once publishing is approved.
+on:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: website-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    name: Build the website
+    runs-on: ubuntu-24.04
+    defaults:
+      run:
+        working-directory: website
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: npm
+          cache-dependency-path: website/package-lock.json
+
+      - name: Check the diagnostics reference matches the registry
+        run: python3 scripts/generate_diagnostics.py --check
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Build
+        run: npm run build
+
+      - name: Check links
+        run: python3 scripts/check_links.py dist

Cargo.toml

@@ -54,7 +54,7 @@ sha2 = "0.10"
 sqlquack = { path = "crates/sqlquack" }
 sqlquack-compare = { path = "crates/sqlquack-compare" }
 sqlquack-core = { path = "crates/sqlquack-core" }
-sqlquack-duckdb = { path = "crates/sqlquack-duckdb" }
+sqlquack-duckdb = { path = "crates/sqlquack-duckdb", default-features = false }
 sqlquack-evidence = { path = "crates/sqlquack-evidence" }
 sqlquack-policy = { path = "crates/sqlquack-policy" }
 sqlquack-rules = { path = "crates/sqlquack-rules" }

crates/sqlquack-duckdb/Cargo.toml

@@ -9,11 +9,20 @@ homepage.workspace = true
 publish.workspace = true
 rust-version.workspace = true
 
+# `engine` links native DuckDB for check_printed's parse-and-bind check. Without it, the building
+# blocks and the lexical checks still compile, for targets such as wasm32 that bind elsewhere.
+[features]
+default = ["engine"]
+engine = ["dep:duckdb"]
+
 [dependencies]
-duckdb.workspace = true
+duckdb = { workspace = true, optional = true }
 serde_json.workspace = true
 sqlquack-core.workspace = true
 sqlquack-snowflake.workspace = true
 
+[dev-dependencies]
+duckdb.workspace = true
+
 [lints]
 workspace = true

crates/sqlquack-duckdb/src/checking/_helpers/binding.rs

@@ -0,0 +1,47 @@
+//! Binding printed SQL in DuckDB, when the crate is built with the engine.
+
+#[cfg(feature = "engine")]
+use crate::checking::_helpers::engine::with_engine;
+#[cfg(feature = "engine")]
+use crate::checking::_helpers::tables::{function_definitions, table_definitions};
+#[cfg(feature = "engine")]
+use crate::checking::constants::PARSER_ERROR;
+#[cfg(feature = "engine")]
+use crate::checking::errors::CheckStage;
+use crate::checking::errors::PrintedSqlFailure;
+use crate::checking::types::{FunctionLookup, RelationLookup};
+
+/// DuckDB parses `sql` and binds it over the relations and functions `names` reads.
+#[cfg(feature = "engine")]
+pub(crate) fn bound(
+    sql: &str,
+    names: &[String],
+    (lookup, functions): (RelationLookup<'_>, FunctionLookup<'_>),
+) -> Result<(), PrintedSqlFailure> {
+    with_engine(|engine| {
+        let mut definitions = table_definitions(names, lookup);
+        definitions.extend(function_definitions(names, functions));
+        engine.keep_only(&definitions.iter().map(|(name, _)| name.as_str()).collect())?;
+        for (name, statement) in &definitions {
+            engine.define_table(name, statement)?;
+        }
+        engine.connection.prepare(sql).map(drop).map_err(|error| {
+            let message = error.to_string();
+            let stage = match message.starts_with(PARSER_ERROR) {
+                true => CheckStage::Parse,
+                false => CheckStage::Bind,
+            };
+            PrintedSqlFailure { stage, message }
+        })
+    })
+}
+
+/// Without the engine the caller binds the SQL itself, so only the lexical checks apply.
+#[cfg(not(feature = "engine"))]
+pub(crate) fn bound(
+    _sql: &str,
+    _names: &[String],
+    _lookups: (RelationLookup<'_>, FunctionLookup<'_>),
+) -> Result<(), PrintedSqlFailure> {
+    Ok(())
+}

crates/sqlquack-duckdb/src/checking/_helpers/mod.rs

@@ -1,4 +1,7 @@
+pub(crate) mod binding;
 pub(crate) mod dotted_parameters;
+#[cfg(feature = "engine")]
 pub(crate) mod engine;
 pub(crate) mod lexing;
+#[cfg(feature = "engine")]
 pub(crate) mod tables;

crates/sqlquack-duckdb/src/checking/main/check_printed.rs

@@ -1,10 +1,8 @@
 //! `check_printed`: DuckDB parses printed SQL as one statement and binds it.
 
+use crate::checking::_helpers::binding::bound;
 use crate::checking::_helpers::dotted_parameters::dotted_parameters;
-use crate::checking::_helpers::engine::with_engine;
 use crate::checking::_helpers::lexing::lexed;
-use crate::checking::_helpers::tables::{function_definitions, table_definitions};
-use crate::checking::constants::PARSER_ERROR;
 use crate::checking::errors::{CheckStage, PrintedSqlFailure};
 use crate::checking::types::{FunctionLookup, RelationLookup};
 
@@ -28,22 +26,7 @@ pub fn check_printed(
         ));
     }
     let names: Vec<String> = lexed.names.into_iter().collect();
-    with_engine(|engine| {
-        let mut definitions = table_definitions(&names, lookup);
-        definitions.extend(function_definitions(&names, functions));
-        engine.keep_only(&definitions.iter().map(|(name, _)| name.as_str()).collect())?;
-        for (name, statement) in &definitions {
-            engine.define_table(name, statement)?;
-        }
-        engine.connection.prepare(sql).map(drop).map_err(|error| {
-            let message = error.to_string();
-            let stage = match message.starts_with(PARSER_ERROR) {
-                true => CheckStage::Parse,
-                false => CheckStage::Bind,
-            };
-            failure(stage, message)
-        })
-    })
+    bound(sql, &names, (lookup, functions))
 }
 
 fn failure(stage: CheckStage, message: String) -> PrintedSqlFailure {

crates/sqlquack-rules/Cargo.toml

@@ -9,6 +9,12 @@ homepage.workspace = true
 publish.workspace = true
 rust-version.workspace = true
 
+# `engine`: DuckDB parses and binds every converted statement. Off, the converter skips that check,
+# and the caller binds the SQL itself (the browser playground does, in DuckDB-WASM).
+[features]
+default = ["engine"]
+engine = ["sqlquack-duckdb/engine"]
+
 [dependencies]
 serde.workspace = true
 serde_json.workspace = true

crates/sqlquack-syntax-coverage/src/check/_helpers/contradictions.rs

@@ -0,0 +1,64 @@
+//! Every current receipt against the parser, whether or not a catalogued case cites it (decision D141).
+
+use std::collections::{BTreeMap, BTreeSet};
+
+use crate::check::_helpers::receipts::snowflake_syntax;
+use crate::check::models::{CaseResult, LocalVerdict, SnowflakeSyntax};
+use crate::formats::models::{Receipt, SyntaxCoverage};
+
+/// Whether the parser's verdict contradicts what Snowflake's parser did with the same statement.
+fn contradicts(snowflake: SnowflakeSyntax, local: &LocalVerdict) -> bool {
+    match snowflake {
+        SnowflakeSyntax::Parsed => !matches!(local, LocalVerdict::Accepted { .. }),
+        SnowflakeSyntax::Refused => matches!(local, LocalVerdict::Accepted { .. }),
+    }
+}
+
+/// The receipt case ids the parser contradicts by SQL, setup and session, and those without SQL.
+pub(crate) fn receipt_contradictions(
+    coverage: &SyntaxCoverage,
+    cases: &BTreeMap<&str, CaseResult>,
+    parse: &dyn Fn(&str) -> LocalVerdict,
+) -> (BTreeSet<String>, BTreeSet<String>) {
+    let mut statements: BTreeMap<(&str, &str, &str), Vec<&Receipt>> = BTreeMap::new();
+    for receipt in &coverage.receipts {
+        statements
+            .entry((
+                receipt.sql_sha256.as_str(),
+                receipt.setup_sha256.as_str(),
+                receipt.session_sha256.as_str(),
+            ))
+            .or_default()
+            .push(receipt);
+    }
+    let mut judged: BTreeMap<&str, LocalVerdict> = cases
+        .values()
+        .map(|case| (case.sql_sha256.as_str(), case.local.clone()))
+        .collect();
+    let case_sql: BTreeMap<&str, &str> = coverage
+        .cases
+        .values()
+        .flatten()
+        .map(|case| (case.sql_sha256.as_str(), case.sql.as_str()))
+        .collect();
+    let mut contradicted: BTreeSet<String> = BTreeSet::new();
+    let mut unjudged: BTreeSet<String> = BTreeSet::new();
+    for ((sql_sha256, _, _), receipts) in &statements {
+        let Some(snowflake) = snowflake_syntax(receipts) else {
+            continue;
+        };
+        let sql: Option<&str> = case_sql
+            .get(sql_sha256)
+            .copied()
+            .or_else(|| coverage.receipt_sql.get(*sql_sha256).map(String::as_str));
+        let Some(sql) = sql else {
+            unjudged.extend(receipts.iter().map(|receipt| receipt.case_id.clone()));
+            continue;
+        };
+        let local: &LocalVerdict = judged.entry(sql_sha256).or_insert_with(|| parse(sql));
+        if contradicts(snowflake, local) {
+            contradicted.extend(receipts.iter().map(|receipt| receipt.case_id.clone()));
+        }
+    }
+    (contradicted, unjudged)
+}

crates/sqlquack-syntax-coverage/src/check/_helpers/mod.rs

@@ -1,3 +1,4 @@
+pub(crate) mod contradictions;
 pub(crate) mod fingerprints;
 pub(crate) mod forms;
 pub(crate) mod join;

crates/sqlquack-syntax-coverage/src/check/_helpers/receipts.rs

@@ -63,7 +63,7 @@ fn agreement(phase: Phase, local: &LocalVerdict, terminates: bool) -> Result<boo
 }
 
 /// What Snowflake's parser did by the syntax receipts of the case's statement; none unless all agree.
-fn snowflake_syntax(statement_receipts: &[&Receipt]) -> Option<SnowflakeSyntax> {
+pub(crate) fn snowflake_syntax(statement_receipts: &[&Receipt]) -> Option<SnowflakeSyntax> {
     let verdicts: BTreeSet<Option<SnowflakeSyntax>> = statement_receipts
         .iter()
         .filter(|receipt| receipt.measure.is_none())