Merge remote-tracking branch 'github/main' into fix/receipt-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/Cargo.toml

@@ -24,7 +24,7 @@ serde_json.workspace = true
 sha2.workspace = true
 sqlquack-compare.workspace = true
 sqlquack-core.workspace = true
-sqlquack-duckdb.workspace = true
+sqlquack-duckdb = { workspace = true, features = ["engine"] }
 sqlquack-evidence.workspace = true
 sqlquack-policy.workspace = true
 sqlquack-rules.workspace = true

website/.gitignore

@@ -0,0 +1,5 @@
+node_modules/
+dist/
+.astro/
+public/playground/engine/
+wasm/target/

website/.nvmrc

@@ -0,0 +1 @@
+22