Merge branch 'main' into test/duckshop-blocker-parity

Author: kvlonge

.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.187.1"
+  ".": "0.187.3"
 }

CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.187.3](https://github.com/sqlstack-io/sqlbuild/compare/v0.187.2...v0.187.3) (2026-11-02)
+
+
+### Bug Fixes
+
+* Snowflake time and timestamp precision no longer fails source contracts ([#1294](https://github.com/sqlstack-io/sqlbuild/issues/1294)) ([9c41a61](https://github.com/sqlstack-io/sqlbuild/commit/9c41a61825c3dd5db34f91447143821684bc718c))
+
+## [0.187.2](https://github.com/sqlstack-io/sqlbuild/compare/v0.187.1...v0.187.2) (2026-11-02)
+
+
+### Performance Improvements
+
+* **rules:** pin SQLClean 0.4.3 for cheaper unused-CTE facts ([#1296](https://github.com/sqlstack-io/sqlbuild/issues/1296)) ([1ba0a3d](https://github.com/sqlstack-io/sqlbuild/commit/1ba0a3df837cdf34c4ef81f9a163127fe62841a9))
+
 ## [0.187.1](https://github.com/sqlstack-io/sqlbuild/compare/v0.187.0...v0.187.1) (2026-11-02)
 
 

Cargo.lock

@@ -55,7 +55,7 @@ python-boundary = "sqlbuild-python"
 polyglot-floor = "sqlbuild-analysis"
 
 [workspace.package]
-version = "0.187.1"
+version = "0.187.3"
 edition = "2024"
 license = "Apache-2.0"
 publish = false
@@ -140,7 +140,7 @@ sqlbuild-scopes = { path = "crates/sqlbuild-scopes" }
 sqlbuild-sqltext = { path = "crates/sqlbuild-sqltext" }
 sqlbuild-state = { path = "crates/sqlbuild-state" }
 # SQL lint Rules, quality Rules, the formatter and the canonical token stream.
-sqlclean = { git = "https://github.com/sqlstack-io/sqlclean.git", rev = "571e40a746b3d8d20d6118620f05428eca45243c" }
+sqlclean = { git = "https://github.com/sqlstack-io/sqlclean.git", rev = "cf79656d247277a30bc81ef39b6dee420e721221" }
 stacker = "0.1"
 syn = { version = "2", features = ["full", "visit", "extra-traits"] }
 tempfile = "3"

Cargo.toml

@@ -43,3 +43,12 @@ pub(crate) const POLYGLOT_TYPE_NAME_ALIASES: &[(&str, &str)] = &[
 pub(crate) const MAX_FUNCTION_CALL_DEPTH: usize = 512;
 /// Python's `str(0)`, the only integer text Python treats as false.
 pub(crate) const ZERO_TEXT: &str = "0";
+/// Snowflake time and timestamp types, word separators removed, whose precision metadata omits.
+pub(crate) const SNOWFLAKE_PRECISION_TEMPORAL_TYPES: &[&str] =
+    &["TIME", "TIMESTAMPLTZ", "TIMESTAMPNTZ", "TIMESTAMPTZ"];
+/// The character that opens a type's parameter list.
+pub(crate) const TYPE_PARAMETERS_OPEN: char = '(';
+/// The word separator in Snowflake type names such as `TIMESTAMP_TZ`.
+pub(crate) const TYPE_WORD_SEPARATOR: char = '_';
+/// The character that closes a type's parameter list.
+pub(crate) const TYPE_PARAMETERS_CLOSE: char = ')';

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

@@ -1,2 +1,3 @@
 pub mod normalize_type;
 pub mod polyglot_type_args;
+pub mod same_type;

crates/sqlbuild-analysis/src/type_system/main/mod.rs

@@ -0,0 +1,41 @@
+//! `same_type`: equal normalized types, a Snowflake temporal precision left unstated matching any.
+
+use crate::type_system::_helpers::dialects::coerce_type_dialect;
+use crate::type_system::constants::{
+    SNOWFLAKE_PRECISION_TEMPORAL_TYPES, TYPE_PARAMETERS_CLOSE, TYPE_PARAMETERS_OPEN,
+    TYPE_WORD_SEPARATOR,
+};
+use crate::type_system::models::{NormalizedType, TypeDialect};
+
+/// Whether `left` and `right` name the same type under `dialect`, up to an unstated precision.
+#[must_use]
+pub fn same_type(left: &NormalizedType, right: &NormalizedType, dialect: &str) -> bool {
+    if left == right {
+        return true;
+    }
+    if coerce_type_dialect(dialect) != Some(TypeDialect::Snowflake) {
+        return false;
+    }
+    let (Some((left_base, left_precision)), Some((right_base, right_precision))) = (
+        temporal_parts(&left.normalized_name),
+        temporal_parts(&right.normalized_name),
+    ) else {
+        return false;
+    };
+    left_base == right_base
+        && (left_precision.is_none()
+            || right_precision.is_none()
+            || left_precision == right_precision)
+}
+
+/// A Snowflake time or timestamp type's compact base name and its stated precision text.
+fn temporal_parts(name: &str) -> Option<(String, Option<&str>)> {
+    let (base, parameters): (&str, Option<&str>) = match name.split_once(TYPE_PARAMETERS_OPEN) {
+        Some((base, rest)) => (base, rest.strip_suffix(TYPE_PARAMETERS_CLOSE)),
+        None => (name, None),
+    };
+    let compact: String = base.trim().replace(TYPE_WORD_SEPARATOR, "");
+    SNOWFLAKE_PRECISION_TEMPORAL_TYPES
+        .contains(&compact.as_str())
+        .then(|| (compact, parameters.map(str::trim)))
+}

crates/sqlbuild-analysis/src/type_system/main/same_type.rs

@@ -4,5 +4,7 @@ mod helpers;
 mod normalize_type;
 #[path = "tests/test_python_text.rs"]
 mod python_text;
+#[path = "tests/test_same_type.rs"]
+mod same_type;
 #[path = "tests/test_types.rs"]
 mod test_types;

crates/sqlbuild-analysis/src/type_system/tests.rs

@@ -0,0 +1,84 @@
+use crate::type_system::main::normalize_type::normalize_type;
+use crate::type_system::main::same_type::same_type;
+use crate::type_system::tests::test_types::SameTypeTestCase;
+
+#[test]
+fn given_two_types_when_comparing_then_an_unstated_snowflake_temporal_precision_matches() {
+    let test_cases = [
+        SameTypeTestCase {
+            description: "a declared millisecond time matches metadata's precision-less time",
+            dialect: "snowflake",
+            types: ("TIME(3)", "TIME"),
+            expected_same: true,
+        },
+        SameTypeTestCase {
+            description: "a declared nanosecond time matches metadata's precision-less time",
+            dialect: "snowflake",
+            types: ("TIME", "TIME(9)"),
+            expected_same: true,
+        },
+        SameTypeTestCase {
+            description: "two stated time precisions must agree",
+            dialect: "snowflake",
+            types: ("TIME(3)", "TIME(9)"),
+            expected_same: false,
+        },
+        SameTypeTestCase {
+            description: "a declared offset timestamp precision matches metadata's spelling",
+            dialect: "snowflake",
+            types: ("TIMESTAMP_TZ(9)", "TIMESTAMP_TZ"),
+            expected_same: true,
+        },
+        SameTypeTestCase {
+            description: "two stated offset timestamp precisions must agree",
+            dialect: "snowflake",
+            types: ("TIMESTAMP_TZ(3)", "TIMESTAMP_TZ(9)"),
+            expected_same: false,
+        },
+        SameTypeTestCase {
+            description: "local time zone timestamps with and without precision",
+            dialect: "snowflake",
+            types: ("TIMESTAMP_LTZ(6)", "TIMESTAMP_LTZ"),
+            expected_same: true,
+        },
+        SameTypeTestCase {
+            description: "an offset timestamp is not a local time zone timestamp",
+            dialect: "snowflake",
+            types: ("TIMESTAMP_TZ", "TIMESTAMP_LTZ(9)"),
+            expected_same: false,
+        },
+        SameTypeTestCase {
+            description: "time is not a timestamp",
+            dialect: "snowflake",
+            types: ("TIME(9)", "TIMESTAMP_NTZ"),
+            expected_same: false,
+        },
+        SameTypeTestCase {
+            description: "other dialects keep exact comparison",
+            dialect: "duckdb",
+            types: ("TIME(3)", "TIME"),
+            expected_same: false,
+        },
+        SameTypeTestCase {
+            description: "an unstated text length is still a different type",
+            dialect: "snowflake",
+            types: ("VARCHAR(10)", "VARCHAR(20)"),
+            expected_same: false,
+        },
+    ];
+    for test_case in test_cases {
+        let (left, right) = test_case.types;
+        let left = normalize_type(left, test_case.dialect)
+            .expect("the type normalizes")
+            .normalized;
+        let right = normalize_type(right, test_case.dialect)
+            .expect("the type normalizes")
+            .normalized;
+        assert_eq!(
+            same_type(&left, &right, test_case.dialect),
+            test_case.expected_same,
+            "{}",
+            test_case.description
+        );
+    }
+}