fix!: correctness, adapter, rules and parser bug batch

CONTRIBUTING.md

@@ -62,6 +62,13 @@ Do not compare development-profile timings with release benchmarks. Dependency o
 changes still require `uv sync --all-extras`; `--skip-install` does not refresh installed metadata,
 dependencies or console scripts.
 
+Always pass `--skip-install` to `maturin develop`, or use `make dev-native` or `make fast-native`.
+Without it, maturin installs the `sqlbuild-cli` version that `pyproject.toml` pins from the package
+index, not this checkout's `crates/sqlbuild-cli`: the `sqb` executable is then a released build,
+and between a release commit and its publication the install fails because that version does not
+exist yet. `uv sync` and `uv run` install the workspace `sqlbuild-cli` and rebuild the extension
+when Rust sources change.
+
 Before opening a pull request, run:
 
 ```bash

Cargo.toml

@@ -72,14 +72,14 @@ junction = { version = "2.1.0", default-features = false }
 mimalloc = { version = "0.1", default-features = false, features = ["local_dynamic_tls"] }
 proc-macro2 = { version = "1", features = ["span-locations"] }
 pyo3 = { version = "0.26", features = ["abi3-py312"] }
-polyglot-sql = { git = "https://github.com/chio-labs/polyglot.git", rev = "1ef5056c2b315e69bd13023bd90ffe60d94880a3", default-features = false, features = [
+polyglot-sql = { git = "https://github.com/chio-labs/polyglot.git", rev = "8767d688c5b504ad609645e27ab77a260d91c5a1", default-features = false, features = [
     "ast-tools",
     "builder",
     "all-dialects",
     "semantic",
     "stacker",
 ] }
-polyglot-sql-function-catalogs = { git = "https://github.com/chio-labs/polyglot.git", rev = "1ef5056c2b315e69bd13023bd90ffe60d94880a3", default-features = false, features = [
+polyglot-sql-function-catalogs = { git = "https://github.com/chio-labs/polyglot.git", rev = "8767d688c5b504ad609645e27ab77a260d91c5a1", default-features = false, features = [
     "dialect-duckdb",
 ] }
 blake3 = { version = "1", features = ["rayon"] }

Makefile

@@ -113,6 +113,8 @@ E2E_DUCKDB_BUILD_CORE_PATHS := \
 	tests/e2e/src/sqlbuild/cli/commands/main/build/test_no_load_sources.py \
 	tests/e2e/src/sqlbuild/cli/commands/main/build/test_duckdb_storage_key.py \
 	tests/e2e/src/sqlbuild/cli/commands/main/build/test_source_end_audits.py \
+	tests/e2e/src/sqlbuild/cli/commands/main/build/test_python_check_outcomes.py \
+	tests/e2e/src/sqlbuild/cli/commands/main/build/test_duckdb_attach.py \
 	tests/e2e/src/sqlbuild/cli/commands/main/build/test_unbuilt_dependencies.py \
 	tests/e2e/src/sqlbuild/cli/commands/main/build/test_validation_failures.py
 
@@ -370,9 +372,13 @@ planner-differential:
 
 skills:
 	uv run python -m scripts.generate_docs_skill
-	uv run sqb skills --global --target opencode
 	uv run fensu skills
 
+# Installs this checkout's development skill into your user-level OpenCode skills; never run by CI.
+.PHONY: install-global-skill
+install-global-skill:
+	uv run sqb skills --global --target opencode
+
 
 DBT_EXECUTABLE ?= dbt
 export DBT_EXECUTABLE

crates/sqlbuild-analysis/src/binding_locations/constants.rs

@@ -4,3 +4,5 @@
 pub(crate) const UNKNOWN_TABLE_INTERNAL_CODE: &str = "B000";
 /// The severity whose repeats at a known span compile drops.
 pub(crate) const ERROR_SEVERITY: &str = "error";
+/// SQLite temporal-cast warnings, which every binding pass reports, so they are kept once.
+pub(crate) const SQLITE_TEMPORAL_CAST_CODE: &str = "B104";

crates/sqlbuild-analysis/src/binding_locations/main/locate_binding_diagnostics.rs

@@ -2,7 +2,9 @@
 
 use std::collections::HashSet;
 
-use crate::binding_locations::constants::{ERROR_SEVERITY, UNKNOWN_TABLE_INTERNAL_CODE};
+use crate::binding_locations::constants::{
+    ERROR_SEVERITY, SQLITE_TEMPORAL_CAST_CODE, UNKNOWN_TABLE_INTERNAL_CODE,
+};
 use crate::binding_locations::models::{
     AuthoredSpan, BindingSource, LocatedDiagnostic, SeenDiagnostic,
 };
@@ -56,7 +58,10 @@ pub fn locate_binding_diagnostics(
             line,
             column,
         };
-        if seen.contains(&key) && start.is_some() && severity == ERROR_SEVERITY {
+        if seen.contains(&key)
+            && start.is_some()
+            && (severity == ERROR_SEVERITY || code == SQLITE_TEMPORAL_CAST_CODE)
+        {
             continue;
         }
         seen.insert(key);

crates/sqlbuild-analysis/src/compiled_project/_helpers/plain.rs

@@ -40,5 +40,6 @@ pub(crate) fn plain_model_facts(model: PlainModel) -> CompiledModelFacts {
         constant_declarations: model.constant_declarations,
         analysis: None,
         typed_calls: model.typed_calls,
+        expansion_passes: model.expansion_passes,
     }
 }

crates/sqlbuild-analysis/src/compiled_project/models.rs

@@ -5,6 +5,7 @@ use std::collections::{BTreeMap, HashMap};
 use std::sync::Arc;
 
 use serde_json::Value;
+use sqlbuild_sqltext::compiler::models::CharSpan;
 
 /// One compile's project facts; models keep the order the compile-input stage produced them.
 #[derive(Clone, Debug, Default, PartialEq)]
@@ -34,6 +35,8 @@ pub struct CompiledModelFacts {
     pub analysis: Option<ModelAnalysisFact>,
     /// Each expression SQL macro call in `query_sql`, by byte range.
     pub typed_calls: Vec<TypedCall>,
+    /// The expansion passes from `authored_query_sql` to `query_sql`; empty when unknown.
+    pub expansion_passes: Vec<Vec<CharSpan>>,
 }
 
 /// A model's effective config values with sorted keys, as the rules request has always read them.
@@ -217,6 +220,8 @@ pub struct PlainModel {
     pub constant_declarations: Vec<DeclarationFact>,
     /// Each expression SQL macro call in `query_sql`, by byte range.
     pub typed_calls: Vec<TypedCall>,
+    /// The expansion passes from `authored_query_sql` to `query_sql`; empty when unknown.
+    pub expansion_passes: Vec<Vec<CharSpan>>,
 }
 
 /// A one-based line and column, counted in characters.

crates/sqlbuild-analysis/src/compiler/_helpers/sql_tests/relation_markers.rs

@@ -24,7 +24,20 @@ fn node_marker_calls(mut calls: Vec<MarkerCall>, node: &Expression) -> Vec<Marke
         ),
         Expression::From(from) => calls.extend(from_markers(from)),
         Expression::Delete(delete) => calls.extend(join_markers(&delete.joins)),
-        Expression::JoinedTable(table) => calls.extend(join_markers(&table.joins)),
+        Expression::JoinedTable(table) => {
+            calls.extend(
+                marker(&table.left)
+                    .into_iter()
+                    .chain(join_markers(&table.joins)),
+            );
+        }
+        Expression::Update(update) => calls.extend(
+            update
+                .from_clause
+                .iter()
+                .flat_map(from_markers)
+                .chain(join_markers(&update.from_joins)),
+        ),
         Expression::DataDeletionProperty(property) => {
             return property.on.dfs().fold(calls, node_marker_calls);
         }

crates/sqlbuild-analysis/src/compiler/tests/helpers.rs

@@ -1574,17 +1574,18 @@ type MarkerCalls = Option<Vec<(String, String)>>;
 
 /// The original JSON-tree walk, kept as the oracle the direct relation walk must match.
 fn json_relation_marker_calls(value: &Value) -> Vec<(String, String)> {
-    let from_markers = value
-        .get("from")
-        .and_then(|from| from.get("expressions"))
-        .and_then(Value::as_array)
+    let from_markers = ["from", "from_clause"]
         .into_iter()
+        .filter_map(|key| value.get(key))
+        .filter_map(|from| from.get("expressions"))
+        .filter_map(Value::as_array)
         .flatten()
+        .chain(value.get("left").filter(|_| value.get("joins").is_some()))
         .filter_map(json_marker);
-    let join_markers = value
-        .get("joins")
-        .and_then(Value::as_array)
+    let join_markers = ["joins", "from_joins"]
         .into_iter()
+        .filter_map(|key| value.get(key))
+        .filter_map(Value::as_array)
         .flatten()
         .filter_map(|join| join.get("this"))
         .filter_map(json_marker);

crates/sqlbuild-analysis/src/compiler/tests/test_sql_test_relation_markers.rs

@@ -63,6 +63,18 @@ fn given_parsed_statements_when_collecting_relation_markers_then_json_walk_order
             sql: "SELECT __ref(\"orders\") AS value FROM __table_fn(\"orders\", 2) WHERE id IN (SELECT id FROM t)",
             expected_calls: &[],
         },
+        RelationMarkersTestCase {
+            description: "a parenthesised join keeps its left side",
+            dialect: "duckdb",
+            sql: "SELECT * FROM (__ref(\"orders\") JOIN __ref(\"customers\") ON TRUE)",
+            expected_calls: &[("__ref", "orders"), ("__ref", "customers")],
+        },
+        RelationMarkersTestCase {
+            description: "update from relations are collected",
+            dialect: "postgres",
+            sql: "UPDATE t SET x = 1 FROM __ref(\"orders\") JOIN __ref(\"customers\") ON TRUE",
+            expected_calls: &[("__ref", "orders"), ("__ref", "customers")],
+        },
         RelationMarkersTestCase {
             description: "set operations walk each branch",
             dialect: "postgres",

crates/sqlbuild-analysis/src/contracts/_helpers/columns.rs

@@ -72,15 +72,25 @@ pub(crate) fn model_contract_diagnostics(
         .map(|column| (column.name.as_str(), column))
         .collect();
     if contract_enforced {
-        diagnostics.extend(extra_columns(model, schema, inferred_columns));
+        diagnostics.extend(extra_columns(
+            model,
+            schema,
+            inferred_columns,
+            types.folds_upper(),
+        ));
     }
     let unchecked: HashSet<&str> = model
         .unchecked_output_columns
         .iter()
         .map(String::as_str)
         .collect();
     for (index, declared) in schema.columns.iter().enumerate() {
-        let Some(inferred) = inferred_by_name.get(declared.name.as_str()) else {
+        let Some(inferred) = inferred_by_name.get(declared.name.as_str()).or_else(|| {
+            types
+                .folds_upper()
+                .then(|| inferred_by_name.get(declared.name.to_uppercase().as_str()))
+                .flatten()
+        }) else {
             if validate_declared_shape && !model.fast_lineage_has_star {
                 diagnostics.push(missing_column(model, index, declared, contract_enforced));
             }
@@ -147,15 +157,20 @@ fn missing_declarations(model: &ContractModel) -> ContractDiagnostic {
     }
 }
 
+/// Inferred columns no declared column names; a folded `order_id` also names a star's `ORDER_ID`.
 fn extra_columns(
     model: &ContractModel,
     schema: &ContractSchema,
     inferred_columns: &[InferredOutputColumn],
+    folds_upper: bool,
 ) -> Vec<ContractDiagnostic> {
-    let declared_names: HashSet<&str> = schema
+    let declared_names: HashSet<String> = schema
         .columns
         .iter()
-        .map(|column| column.name.as_str())
+        .flat_map(|column| {
+            let folded: Option<String> = folds_upper.then(|| column.name.to_uppercase());
+            std::iter::once(column.name.clone()).chain(folded)
+        })
         .collect();
     let help: &str = if schema.named_schema {
         EXTRA_COLUMN_NAMED_SCHEMA_HELP

crates/sqlbuild-analysis/src/contracts/_helpers/type_comparison.rs

@@ -3,6 +3,7 @@
 use std::cell::RefCell;
 use std::collections::HashMap;
 
+use crate::contracts::constants::UPPER_FOLDING_DIALECT;
 use crate::type_system::errors::TypeNormalizationError;
 use crate::type_system::main::normalize_type::normalize_type;
 use crate::type_system::models::{NormalizedType, TypeNormalization};
@@ -21,6 +22,11 @@ pub(crate) struct TypeComparer<'a> {
 }
 
 impl<'a> TypeComparer<'a> {
+    /// Whether the dialect folds unquoted identifiers to upper case, as star expansion names them.
+    pub(crate) fn folds_upper(&self) -> bool {
+        self.dialect == UPPER_FOLDING_DIALECT
+    }
+
     pub(crate) fn new(dialect: &'a str) -> Self {
         Self {
             dialect,

crates/sqlbuild-analysis/src/contracts/constants.rs

@@ -39,3 +39,5 @@ pub(crate) const PROMOTION_REMOVE_CONTRACT_HELP: &str = "or remove the model's e
 
 pub(crate) const SETTING_SNIPPET_INDENT: &str = "            ";
 pub(crate) const ADDITIONAL_HELP_SEPARATOR: &str = "\n  = help: ";
+/// The dialect that folds unquoted identifiers to upper case.
+pub(crate) const UPPER_FOLDING_DIALECT: &str = "snowflake";

crates/sqlbuild-analysis/src/lineage/tests/test_build_fast_lineage.rs

@@ -196,16 +196,15 @@ fn given_models_without_compact_facts_when_building_then_matches_python_lineage(
             expected_detail: Some("Expected 1 statement, found 2"),
         },
         ParsedLineageTestCase {
-            description: "a parser panic on truncated T-SQL fails as an internal error",
+            description: "truncated T-SQL reports its parse error",
             sql: "SELECT IF(region > 1, re",
             dialect: Some("tsql"),
             inferred_columns: &[],
-            expected_status: "error",
+            expected_status: "unparsed",
             expected_lines: &[],
             expected_has_star: false,
             expected_detail: Some(
-                "NativeCompilerError: native SQL compilation panicked \
-                 (native fast lineage of request model 0)",
+                "Parse error at line 1, column 25: Expected ')' to close the IF condition",
             ),
         },
         ParsedLineageTestCase {

crates/sqlbuild-analysis/src/planner_warehouse/main/cursor_query_sql.rs

@@ -2,19 +2,19 @@
 
 use crate::planner_warehouse::models::PhysicalCursorQuery;
 
-/// Select the requested bounds of the cursor column as text.
-pub fn cursor_query_sql(query: &PhysicalCursorQuery) -> String {
+/// Select the requested bounds of the cursor column as text, each through `as_text`.
+pub fn cursor_query_sql(query: &PhysicalCursorQuery, as_text: &dyn Fn(&str) -> String) -> String {
     let mut parts: Vec<String> = Vec::new();
     if !query.min_tags.is_empty() {
         parts.push(format!(
-            "CAST(MIN({}) AS VARCHAR) AS _min",
-            query.cursor_column
+            "{} AS _min",
+            as_text(&format!("MIN({})", query.cursor_column))
         ));
     }
     if !query.max_tags.is_empty() {
         parts.push(format!(
-            "CAST(MAX({}) AS VARCHAR) AS _max",
-            query.cursor_column
+            "{} AS _max",
+            as_text(&format!("MAX({})", query.cursor_column))
         ));
     }
     format!("SELECT {} FROM {}", parts.join(", "), query.relation)

crates/sqlbuild-analysis/src/planner_warehouse/tests/test_cursor_queries.rs

@@ -47,7 +47,10 @@ fn given_logical_bounds_when_grouping_then_reads_each_relation_once_in_first_ord
     ];
     for test_case in test_cases {
         let groups = cursor_query_groups(&test_case.requests);
-        let sql: Vec<String> = groups.iter().map(cursor_query_sql).collect();
+        let sql: Vec<String> = groups
+            .iter()
+            .map(|group| cursor_query_sql(group, &|bound| format!("CAST({bound} AS VARCHAR)")))
+            .collect();
         let identities: Vec<String> = groups
             .iter()
             .enumerate()

crates/sqlbuild-analysis/src/semantic_checks/_helpers/metadata_checks/checks.rs

@@ -30,6 +30,8 @@ static SQL_TEST_CTE: LazyLock<Result<Regex, String>> =
     LazyLock::new(|| compiled(SQL_TEST_CTE_PATTERN));
 
 const INTEGER_CURSOR_FAMILIES: &[TypeFamily] = &[TypeFamily::Integer, TypeFamily::Decimal];
+/// The dialect that stores timestamps as ISO-8601 text, so a text column is a timestamp cursor.
+const TEXT_TIMESTAMP_DIALECT: &str = "sqlite";
 const TEMPORAL_CURSOR_FAMILIES: &[TypeFamily] = &[
     TypeFamily::Timestamp,
     TypeFamily::Datetime,
@@ -170,7 +172,7 @@ fn reference_errors(
             )?);
         }
     }
-    if let Some(error) = cursor_error(model, shape, context.families)? {
+    if let Some(error) = cursor_error(model, shape, (context.families, context.dialect))? {
         errors.push(error);
     }
     Ok(errors)
@@ -180,7 +182,7 @@ fn reference_errors(
 fn cursor_error(
     model: &MetadataModel,
     shape: &[(String, String)],
-    families: &Families,
+    (families, dialect): (&Families, Option<&str>),
 ) -> Result<Option<MetadataFinding>, SemanticFailure> {
     let (Some(cursor), Some(cursor_type)) = (model.cursor.as_deref(), model.cursor_type.as_deref())
     else {
@@ -203,6 +205,12 @@ fn cursor_error(
     if family == TypeFamily::Other || allowed.contains(&family) {
         return Ok(None);
     }
+    if family == TypeFamily::String
+        && allowed == TEMPORAL_CURSOR_FAMILIES
+        && dialect == Some(TEXT_TIMESTAMP_DIALECT)
+    {
+        return Ok(None);
+    }
     let message =
         format!("cursor_type {cursor_type} does not match column '{cursor}' type {actual}");
     Ok(Some(model_error(

crates/sqlbuild-analysis/src/semantic_checks/constants.rs

@@ -132,6 +132,11 @@ pub(crate) const SEMANTIC_HELP: &[(&str, &str)] = &[
         "rewrite the truth-value test null-safely, for example COALESCE(x, FALSE) for x IS TRUE, \
          and NOT COALESCE(x, FALSE) or x IS DISTINCT FROM TRUE for x IS NOT TRUE",
     ),
+    (
+        "B104",
+        "keep the ISO-8601 text without a cast, or convert it with datetime(), date() or \
+         strftime()",
+    ),
     (
         "B210",
         "use an expression whose inferred type satisfies this SQL construct",