snowflake-code-unit-registry 0.7.2__tar.gz → 0.7.5__tar.gz

{snowflake_code_unit_registry-0.7.2 → snowflake_code_unit_registry-0.7.5}/Cargo.lock

@@ -161,9 +161,9 @@ checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
 
 [[package]]
 name = "cc"
-version = "1.2.59"
+version = "1.2.60"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7a4d3ec6524d28a329fc53654bbadc9bdd7b0431f5d65f1a56ffb28a1ee5283"
+checksum = "43c5703da9466b66a946814e1adf53ea2c90f10063b86290cc9eb67ce3478a20"
 dependencies = [
  "find-msvc-tools",
  "jobserver",
@@ -778,6 +778,12 @@ dependencies = [
  "foldhash 0.2.0",
 ]
 
+[[package]]
+name = "hashbrown"
+version = "0.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4f467dd6dccf739c208452f8014c75c18bb8301b050ad1cfb27153803edb0f51"
+
 [[package]]
 name = "heck"
 version = "0.5.0"
@@ -1069,12 +1075,12 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.13.1"
+version = "2.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "45a8a2b9cb3e0b0c1803dbb0758ffac5de2f425b23c28f518faabd9d805342ff"
+checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"
 dependencies = [
  "equivalent",
- "hashbrown 0.16.1",
+ "hashbrown 0.17.0",
  "serde",
  "serde_core",
 ]
@@ -1204,9 +1210,9 @@ dependencies = [
 
 [[package]]
 name = "js-sys"
-version = "0.3.94"
+version = "0.3.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e04e2ef80ce82e13552136fabeef8a5ed1f985a96805761cbb9a2c34e7664d9"
+checksum = "2964e92d1d9dc3364cae4d718d93f227e3abb088e747d92e0395bfdedf1c12ca"
 dependencies = [
  "cfg-if",
  "futures-util",
@@ -2068,9 +2074,9 @@ checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f"
 
 [[package]]
 name = "rustls-webpki"
-version = "0.103.10"
+version = "0.103.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df33b2b81ac578cabaf06b89b0631153a3f416b0a886e8a7a1707fb51abbd1ef"
+checksum = "20a6af516fea4b20eccceaf166e8aa666ac996208e8a644ce3ef5aa783bc7cd4"
 dependencies = [
  "aws-lc-rs",
  "ring",
@@ -2095,7 +2101,7 @@ dependencies = [
 
 [[package]]
 name = "scai-error-derive"
-version = "0.7.2"
+version = "0.7.5"
 dependencies = [
  "err_code",
  "heck",
@@ -2109,7 +2115,7 @@ dependencies = [
 
 [[package]]
 name = "scai-state-core"
-version = "0.7.2"
+version = "0.7.5"
 dependencies = [
  "chrono",
  "err_code",
@@ -2134,7 +2140,7 @@ dependencies = [
 
 [[package]]
 name = "scai-state-csharp"
-version = "0.7.2"
+version = "0.7.5"
 dependencies = [
  "interoptopus",
  "interoptopus_backend_csharp",
@@ -2145,7 +2151,7 @@ dependencies = [
 
 [[package]]
 name = "scai-state-node"
-version = "0.7.2"
+version = "0.7.5"
 dependencies = [
  "napi",
  "napi-build",
@@ -2157,7 +2163,7 @@ dependencies = [
 
 [[package]]
 name = "scai-state-python"
-version = "0.7.2"
+version = "0.7.5"
 dependencies = [
  "pyo3",
  "pythonize",
@@ -2868,9 +2874,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.117"
+version = "0.2.118"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0551fc1bb415591e3372d0bc4780db7e587d84e2a7e79da121051c5c4b89d0b0"
+checksum = "0bf938a0bacb0469e83c1e148908bd7d5a6010354cf4fb73279b7447422e3a89"
 dependencies = [
  "cfg-if",
  "once_cell",
@@ -2881,9 +2887,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.67"
+version = "0.4.68"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03623de6905b7206edd0a75f69f747f134b7f0a2323392d664448bf2d3c5d87e"
+checksum = "f371d383f2fb139252e0bfac3b81b265689bf45b6874af544ffa4c975ac1ebf8"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -2891,9 +2897,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.117"
+version = "0.2.118"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fbdf9a35adf44786aecd5ff89b4563a90325f9da0923236f6104e603c7e86be"
+checksum = "eeff24f84126c0ec2db7a449f0c2ec963c6a49efe0698c4242929da037ca28ed"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -2901,9 +2907,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.117"
+version = "0.2.118"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dca9693ef2bab6d4e6707234500350d8dad079eb508dca05530c85dc3a529ff2"
+checksum = "9d08065faf983b2b80a79fd87d8254c409281cf7de75fc4b773019824196c904"
 dependencies = [
  "bumpalo",
  "proc-macro2",
@@ -2914,9 +2920,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.117"
+version = "0.2.118"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "39129a682a6d2d841b6c429d0c51e5cb0ed1a03829d8b3d1e69a011e62cb3d3b"
+checksum = "5fd04d9e306f1907bd13c6361b5c6bfc7b3b3c095ed3f8a9246390f8dbdee129"
 dependencies = [
  "unicode-ident",
 ]
@@ -2957,9 +2963,9 @@ dependencies = [
 
 [[package]]
 name = "web-sys"
-version = "0.3.94"
+version = "0.3.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd70027e39b12f0849461e08ffc50b9cd7688d942c1c8e3c7b22273236b4dd0a"
+checksum = "4f2dfbb17949fa2088e5d39408c48368947b86f7834484e87b73de55bc14d97d"
 dependencies = [
  "js-sys",
  "wasm-bindgen",

{snowflake_code_unit_registry-0.7.2 → snowflake_code_unit_registry-0.7.5}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/scai-error-derive", "crates/scai-state-core", "crates/scai-state-python"]
 
 [workspace.package]
-version = "0.7.2"
+version = "0.7.5"
 edition = "2021"
 license = "SEE LICENSE IN LICENSE"
 repository = "https://github.com/snowflake-eng/scai-state"

{snowflake_code_unit_registry-0.7.2 → snowflake_code_unit_registry-0.7.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-code-unit-registry
-Version: 0.7.2
+Version: 0.7.5
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License

{snowflake_code_unit_registry-0.7.2 → snowflake_code_unit_registry-0.7.5}/crates/scai-state-core/examples/code-unit.example.json

@@ -2,7 +2,6 @@
   "schemaVersion": 1,
   "isMissing": false,
   "inScope": true,
-  "containsCommit": true,
   "kind": "databaseObject",
   "id": "a3f1b2c4-5d6e-7f89-0a1b-2c3d4e5f6a7b",
   "updatedAt": "2025-01-15T10:30:00Z",
@@ -53,7 +52,8 @@
       "convertedChecksum": "defa8dbc2f2c5915579ade9fdc6aef24"
     },
     "assessment": {
-      "status": "completed"
+      "status": "completed",
+      "containsCommit": true
     },
     "dataQuality": {
       "status": "completed",

{snowflake_code_unit_registry-0.7.2 → snowflake_code_unit_registry-0.7.5}/crates/scai-state-core/schemas/code-unit.schema.json

@@ -58,10 +58,6 @@
       "description": "true if CodeUnit is in the migration scope",
       "default": true
     },
-    "containsCommit": {
-      "type": "boolean",
-      "description": "True if the stored procedure contains a commit transaction"
-    },
     "kind": {
       "type": "string",
       "title": "Kind",
@@ -208,6 +204,10 @@
           "properties": {
             "status": {
               "$ref": "#/definitions/OperationStatus"
+            },
+            "containsCommit": {
+              "type": "boolean",
+              "description": "True if the stored procedure contains a commit transaction"
             }
           }
         }

snowflake_code_unit_registry-0.7.5/crates/scai-state-core/src/canonical_name.rs

@@ -0,0 +1,457 @@
+//! Canonical name computation for code unit metadata.
+//!
+//! A canonical name is a dot-separated identifier built from a code unit's
+//! metadata fields: `database.schema.name` for most object types, or
+//! `database.schema.name(TYPE,TYPE,...)` for procedures and functions
+//! (using base parameter types with length/precision stripped).
+//!
+//! Two public entry points:
+//! - [`compute`] — low-level, accepts individual fields
+//! - [`for_code_unit`] — convenience wrapper that extracts fields from a [`CodeUnit`]
+
+use crate::generated::types::{CodeUnit, ObjectType, ParameterDef};
+
+/// Sentinel schema name used when a database is present but no schema
+/// is specified. Consumers should be aware this value may appear in
+/// canonical names for incompletely-specified metadata.
+pub const UNKNOWN_SCHEMA: &str = "UNKNOWN_SCHEMA";
+
+/// Selects which side of the code unit metadata to use.
+///
+/// A [`CodeUnit`] has one shared `signature` block containing both source
+/// and target type information on each parameter. `Side` controls which
+/// type field is read: `type_` for [`Source`](Side::Source), `target_type`
+/// for [`Target`](Side::Target).
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Side {
+    /// Use source metadata and source parameter types (`type_` field).
+    Source,
+    /// Use target metadata and target parameter types (`target_type` field).
+    Target,
+}
+
+/// Compute a canonical name from individual metadata fields.
+///
+/// Returns `None` when `name` is `None` and `object_type` is not a
+/// container type (`Database` or `Schema`).
+///
+/// `params` comes from the shared `signature.parameters.arguments` array.
+/// Each [`ParameterDef`] carries both source (`type_`) and target
+/// (`target_type`) types; `side` selects which one to use.
+///
+/// # Format
+///
+/// - `database.schema.name` — when all three parts are present
+/// - `schema.name` — when database is missing
+/// - `name` — when both database and schema are missing
+/// - Append `(TYPE,TYPE,...)` for `Procedure` and `Function` object types
+/// - If database is present but schema is missing, [`UNKNOWN_SCHEMA`] is
+///   substituted (except for `Database` object type which has no schema)
+pub fn compute(
+    database: Option<&str>,
+    schema: Option<&str>,
+    name: Option<&str>,
+    object_type: Option<&ObjectType>,
+    params: Option<&[ParameterDef]>,
+    side: Side,
+) -> Option<String> {
+    let is_container = matches!(object_type, Some(ObjectType::Database | ObjectType::Schema));
+
+    if name.is_none() && !is_container {
+        return None;
+    }
+
+    let mut parts: Vec<&str> = Vec::new();
+
+    if let Some(database) = database {
+        parts.push(database);
+        if !matches!(object_type, Some(ObjectType::Database)) {
+            parts.push(schema.unwrap_or(UNKNOWN_SCHEMA));
+        }
+    } else if let Some(schema) = schema {
+        parts.push(schema);
+    }
+
+    if let Some(name) = name {
+        parts.push(name);
+    }
+
+    let mut canonical = parts.join(".");
+
+    let needs_signature = matches!(
+        object_type,
+        Some(ObjectType::Procedure | ObjectType::Function)
+    );
+    if needs_signature {
+        if let Some(params) = params {
+            let param_types: Vec<&str> = params
+                .iter()
+                .filter_map(|param| {
+                    let raw_type = match side {
+                        Side::Source => param.type_.as_deref(),
+                        Side::Target => param.target_type.as_deref(),
+                    };
+                    raw_type.map(strip_type_precision)
+                })
+                .collect();
+            if !param_types.is_empty() {
+                canonical.push('(');
+                canonical.push_str(&param_types.join(","));
+                canonical.push(')');
+            }
+        }
+    }
+
+    Some(canonical)
+}
+
+/// Compute the canonical name for one side of a [`CodeUnit`].
+///
+/// Extracts metadata and signature fields from the unit, then delegates
+/// to [`compute`]. The shared `signature.parameters.arguments` array is
+/// passed through; `side` determines which type field is read from each
+/// parameter.
+pub fn for_code_unit(unit: &CodeUnit, side: Side) -> Option<String> {
+    let (database, schema, name, object_type) = match side {
+        Side::Source => {
+            let s = unit.source.as_ref()?;
+            (
+                s.database.as_deref(),
+                s.schema.as_deref(),
+                s.name.as_deref(),
+                s.object_type.as_ref(),
+            )
+        }
+        Side::Target => {
+            let t = unit.target.as_ref()?;
+            (
+                t.database.as_deref(),
+                t.schema.as_deref(),
+                t.name.as_deref(),
+                t.object_type.as_ref(),
+            )
+        }
+    };
+
+    let params = unit
+        .signature
+        .as_ref()
+        .and_then(|s| s.parameters.as_ref())
+        .map(|p| p.arguments.as_slice());
+
+    compute(database, schema, name, object_type, params, side)
+}
+
+/// Strip length/precision qualifiers from a SQL type.
+///
+/// `"NVARCHAR(50)"` → `"NVARCHAR"`, `"INT"` → `"INT"`.
+fn strip_type_precision(ty: &str) -> &str {
+    match ty.find('(') {
+        Some(pos) => &ty[..pos],
+        None => ty,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::generated::types::{Parameters, Signature, SourceMetadata, TargetMetadata};
+
+    #[test]
+    fn table_full_qualified() {
+        let result = compute(
+            Some("DB"),
+            Some("dbo"),
+            Some("MyTable"),
+            Some(&ObjectType::Table),
+            None,
+            Side::Source,
+        );
+        assert_eq!(result.as_deref(), Some("DB.dbo.MyTable"));
+    }
+
+    #[test]
+    fn procedure_with_params_source() {
+        let params = vec![
+            ParameterDef {
+                type_: Some("DATETIME".to_string()),
+                target_type: Some("TIMESTAMP_NTZ".to_string()),
+                ..Default::default()
+            },
+            ParameterDef {
+                type_: Some("NVARCHAR(50)".to_string()),
+                target_type: Some("VARCHAR(50)".to_string()),
+                ..Default::default()
+            },
+        ];
+        let result = compute(
+            Some("DB"),
+            Some("dbo"),
+            Some("MyProc"),
+            Some(&ObjectType::Procedure),
+            Some(&params),
+            Side::Source,
+        );
+        assert_eq!(result.as_deref(), Some("DB.dbo.MyProc(DATETIME,NVARCHAR)"));
+    }
+
+    #[test]
+    fn procedure_with_params_target() {
+        let params = vec![
+            ParameterDef {
+                type_: Some("DATETIME".to_string()),
+                target_type: Some("TIMESTAMP_NTZ".to_string()),
+                ..Default::default()
+            },
+            ParameterDef {
+                type_: Some("NVARCHAR(50)".to_string()),
+                target_type: Some("VARCHAR(50)".to_string()),
+                ..Default::default()
+            },
+        ];
+        let result = compute(
+            Some("DB"),
+            Some("DBO"),
+            Some("MYPROC"),
+            Some(&ObjectType::Procedure),
+            Some(&params),
+            Side::Target,
+        );
+        assert_eq!(
+            result.as_deref(),
+            Some("DB.DBO.MYPROC(TIMESTAMP_NTZ,VARCHAR)")
+        );
+    }
+
+    #[test]
+    fn function_with_params() {
+        let params = vec![ParameterDef {
+            type_: Some("INT".to_string()),
+            target_type: Some("NUMBER".to_string()),
+            ..Default::default()
+        }];
+        let result = compute(
+            Some("DB"),
+            Some("dbo"),
+            Some("MyFunc"),
+            Some(&ObjectType::Function),
+            Some(&params),
+            Side::Source,
+        );
+        assert_eq!(result.as_deref(), Some("DB.dbo.MyFunc(INT)"));
+    }
+
+    #[test]
+    fn view_ignores_params() {
+        let params = vec![ParameterDef {
+            type_: Some("INT".to_string()),
+            ..Default::default()
+        }];
+        let result = compute(
+            Some("DB"),
+            Some("dbo"),
+            Some("MyView"),
+            Some(&ObjectType::View),
+            Some(&params),
+            Side::Source,
+        );
+        assert_eq!(
+            result.as_deref(),
+            Some("DB.dbo.MyView"),
+            "views should not include parameter signature"
+        );
+    }
+
+    #[test]
+    fn schema_and_name_only() {
+        let result = compute(
+            None,
+            Some("dbo"),
+            Some("Orphan"),
+            Some(&ObjectType::Table),
+            None,
+            Side::Source,
+        );
+        assert_eq!(result.as_deref(), Some("dbo.Orphan"));
+    }
+
+    #[test]
+    fn name_only() {
+        let result = compute(
+            None,
+            None,
+            Some("Lonely"),
+            Some(&ObjectType::Table),
+            None,
+            Side::Source,
+        );
+        assert_eq!(result.as_deref(), Some("Lonely"));
+    }
+
+    #[test]
+    fn unknown_schema_fallback() {
+        let result = compute(
+            Some("MyDB"),
+            None,
+            Some("Widget"),
+            Some(&ObjectType::Table),
+            None,
+            Side::Source,
+        );
+        assert_eq!(result.as_deref(), Some("MyDB.UNKNOWN_SCHEMA.Widget"));
+    }
+
+    #[test]
+    fn none_when_name_missing() {
+        let result = compute(
+            Some("DB"),
+            Some("dbo"),
+            None,
+            Some(&ObjectType::Table),
+            None,
+            Side::Source,
+        );
+        assert_eq!(result, None);
+    }
+
+    #[test]
+    fn database_object_type() {
+        let result = compute(
+            Some("MyDB"),
+            None,
+            None,
+            Some(&ObjectType::Database),
+            None,
+            Side::Source,
+        );
+        assert_eq!(result.as_deref(), Some("MyDB"));
+    }
+
+    #[test]
+    fn schema_object_type_with_database() {
+        let result = compute(
+            Some("MyDB"),
+            Some("Sales"),
+            None,
+            Some(&ObjectType::Schema),
+            None,
+            Side::Source,
+        );
+        assert_eq!(result.as_deref(), Some("MyDB.Sales"));
+    }
+
+    #[test]
+    fn schema_object_type_without_database() {
+        let result = compute(
+            None,
+            Some("Sales"),
+            None,
+            Some(&ObjectType::Schema),
+            None,
+            Side::Source,
+        );
+        assert_eq!(result.as_deref(), Some("Sales"));
+    }
+
+    #[test]
+    fn procedure_no_params_no_parens() {
+        let result = compute(
+            Some("DB"),
+            Some("dbo"),
+            Some("NoArgs"),
+            Some(&ObjectType::Procedure),
+            None,
+            Side::Source,
+        );
+        assert_eq!(
+            result.as_deref(),
+            Some("DB.dbo.NoArgs"),
+            "procedures with no params should not have empty parens"
+        );
+    }
+
+    #[test]
+    fn strip_type_precision_works() {
+        assert_eq!(strip_type_precision("NVARCHAR(50)"), "NVARCHAR");
+        assert_eq!(strip_type_precision("DECIMAL(18,2)"), "DECIMAL");
+        assert_eq!(strip_type_precision("INT"), "INT");
+        assert_eq!(strip_type_precision("TIMESTAMP_NTZ"), "TIMESTAMP_NTZ");
+    }
+
+    #[test]
+    fn for_code_unit_source() {
+        let unit = CodeUnit {
+            source: Some(SourceMetadata {
+                object_type: Some(ObjectType::Table),
+                database: Some("DB".to_string()),
+                schema: Some("dbo".to_string()),
+                name: Some("Orders".to_string()),
+                ..Default::default()
+            }),
+            ..Default::default()
+        };
+        assert_eq!(
+            for_code_unit(&unit, Side::Source).as_deref(),
+            Some("DB.dbo.Orders")
+        );
+    }
+
+    #[test]
+    fn for_code_unit_target() {
+        let unit = CodeUnit {
+            target: Some(TargetMetadata {
+                object_type: Some(ObjectType::Table),
+                database: Some("DB".to_string()),
+                schema: Some("DBO".to_string()),
+                name: Some("ORDERS".to_string()),
+                ..Default::default()
+            }),
+            ..Default::default()
+        };
+        assert_eq!(
+            for_code_unit(&unit, Side::Target).as_deref(),
+            Some("DB.DBO.ORDERS")
+        );
+    }
+
+    #[test]
+    fn for_code_unit_with_signature() {
+        let unit = CodeUnit {
+            source: Some(SourceMetadata {
+                object_type: Some(ObjectType::Procedure),
+                database: Some("DB".to_string()),
+                schema: Some("dbo".to_string()),
+                name: Some("MyProc".to_string()),
+                ..Default::default()
+            }),
+            signature: Some(Signature {
+                parameters: Some(Parameters {
+                    arguments: vec![ParameterDef {
+                        type_: Some("DATETIME".to_string()),
+                        target_type: Some("TIMESTAMP_NTZ".to_string()),
+                        ..Default::default()
+                    }],
+                    ..Default::default()
+                }),
+                ..Default::default()
+            }),
+            ..Default::default()
+        };
+        assert_eq!(
+            for_code_unit(&unit, Side::Source).as_deref(),
+            Some("DB.dbo.MyProc(DATETIME)")
+        );
+        assert_eq!(
+            for_code_unit(&unit, Side::Target),
+            None,
+            "target metadata is None, should return None"
+        );
+    }
+
+    #[test]
+    fn for_code_unit_no_metadata() {
+        let unit = CodeUnit::default();
+        assert_eq!(for_code_unit(&unit, Side::Source), None);
+        assert_eq!(for_code_unit(&unit, Side::Target), None);
+    }
+}