polyglot-sql-chio 0.9.2__tar.gz → 0.9.3__tar.gz

{polyglot_sql_chio-0.9.2 → polyglot_sql_chio-0.9.3}/Cargo.lock

@@ -605,7 +605,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql"
-version = "0.9.2"
+version = "0.9.3"
 dependencies = [
  "criterion",
  "once_cell",
@@ -623,7 +623,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ast-derive"
-version = "0.9.2"
+version = "0.9.3"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -632,7 +632,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ffi"
-version = "0.9.2"
+version = "0.9.3"
 dependencies = [
  "cbindgen",
  "polyglot-sql",
@@ -642,11 +642,11 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-function-catalogs"
-version = "0.9.2"
+version = "0.9.3"
 
 [[package]]
 name = "polyglot-sql-python"
-version = "0.9.2"
+version = "0.9.3"
 dependencies = [
  "polyglot-sql",
  "pyo3",
@@ -657,7 +657,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-wasm"
-version = "0.9.2"
+version = "0.9.3"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",

{polyglot_sql_chio-0.9.2 → polyglot_sql_chio-0.9.3}/Cargo.toml

@@ -6,7 +6,7 @@ exclude = [
 ]
 
 [workspace.package]
-version = "0.9.2"
+version = "0.9.3"
 edition = "2021"
 license = "MIT"
 authors = ["polyglot contributors"]

{polyglot_sql_chio-0.9.2 → polyglot_sql_chio-0.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyglot-sql-chio
-Version: 0.9.2
+Version: 0.9.3
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{polyglot_sql_chio-0.9.2 → polyglot_sql_chio-0.9.3}/crates/polyglot-sql/Cargo.toml

@@ -100,14 +100,14 @@ function-catalog-all-dialects = [
 ]
 
 [dependencies]
-polyglot-sql-ast-derive = { path = "../polyglot-sql-ast-derive", version = "0.9.2" }
+polyglot-sql-ast-derive = { path = "../polyglot-sql-ast-derive", version = "0.9.3" }
 serde = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
 unicode-segmentation = { workspace = true }
 stacker = { version = "0.1", optional = true }
 ts-rs = { version = "12.0", features = ["serde-compat"], optional = true }
-polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.9.2", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.9.3", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql_chio-0.9.2 → polyglot_sql_chio-0.9.3}/crates/polyglot-sql/README.md

@@ -25,7 +25,7 @@ By default, `polyglot-sql` enables the full public API. Parser-only consumers ca
 disable default features and opt into only the dialect parsers they need:
 
 ```toml
-polyglot-sql = { version = "0.9.2", default-features = false }
+polyglot-sql = { version = "0.9.3", default-features = false }
 ```
 
 ```toml

{polyglot_sql_chio-0.9.2 → polyglot_sql_chio-0.9.3}/crates/polyglot-sql/src/validation/tests.rs

@@ -166,6 +166,18 @@ fn test_function_catalog() -> Arc<HashMapFunctionCatalog> {
     Arc::new(catalog)
 }
 
+fn schema_validation_dialects() -> [DialectType; 7] {
+    [
+        DialectType::Generic,
+        DialectType::Snowflake,
+        DialectType::DuckDB,
+        DialectType::BigQuery,
+        DialectType::Databricks,
+        DialectType::PostgreSQL,
+        DialectType::TSQL,
+    ]
+}
+
 #[test]
 fn test_validate_with_schema_known_table_column() {
     let schema = base_schema();
@@ -182,36 +194,205 @@ fn test_validate_with_schema_known_table_column() {
 
 #[test]
 fn test_validate_with_schema_qualified_cte_column_is_not_ambiguous() {
+    let schema = base_schema();
+    let opts = SchemaValidationOptions {
+        check_references: true,
+        ..Default::default()
+    };
+    for dialect in schema_validation_dialects() {
+        let result = validate_with_schema(
+            "WITH selected_users AS (SELECT id FROM users), \
+             selected_orders AS (SELECT id FROM orders) \
+             SELECT selected_users.id FROM selected_users \
+             JOIN selected_orders ON selected_users.id = selected_orders.id",
+            dialect,
+            &schema,
+            &opts,
+        );
+
+        assert!(result.valid, "{dialect}: {:#?}", result.errors);
+    }
+}
+
+#[test]
+fn test_validate_with_schema_correlated_subquery_resolves_outer_alias() {
+    let schema = base_schema();
+    let opts = SchemaValidationOptions {
+        check_references: true,
+        ..Default::default()
+    };
+    for dialect in schema_validation_dialects() {
+        let result = validate_with_schema(
+            "SELECT outer_users.id FROM users outer_users \
+             WHERE EXISTS (SELECT 1 FROM orders inner_orders \
+             WHERE inner_orders.user_id = outer_users.id)",
+            dialect,
+            &schema,
+            &opts,
+        );
+
+        assert!(result.valid, "{dialect}: {:#?}", result.errors);
+    }
+}
+
+#[test]
+fn test_validate_with_schema_correlated_subquery_prefers_inner_unqualified_column() {
+    let schema = base_schema();
+    let opts = SchemaValidationOptions {
+        check_references: true,
+        ..Default::default()
+    };
+    for dialect in schema_validation_dialects() {
+        let result = validate_with_schema(
+            "SELECT outer_users.id FROM users outer_users \
+             WHERE EXISTS (SELECT 1 FROM orders inner_orders \
+             WHERE id = outer_users.id)",
+            dialect,
+            &schema,
+            &opts,
+        );
+
+        assert!(result.valid, "{dialect}: {:#?}", result.errors);
+    }
+}
+
+#[test]
+fn test_validate_with_schema_subsequent_cte_resolves_prior_projection() {
+    let schema = base_schema();
+    let opts = SchemaValidationOptions {
+        check_references: true,
+        ..Default::default()
+    };
+    for dialect in schema_validation_dialects() {
+        let result = validate_with_schema(
+            "WITH derived AS (SELECT total AS derived_total FROM orders), \
+             next AS (SELECT derived_total FROM derived) \
+             SELECT derived_total FROM next",
+            dialect,
+            &schema,
+            &opts,
+        );
+
+        assert!(result.valid, "{dialect}: {:#?}", result.errors);
+    }
+}
+
+#[test]
+fn test_validate_with_schema_window_resolves_prior_cte_projection() {
+    let schema = base_schema();
+    let opts = SchemaValidationOptions {
+        check_references: true,
+        ..Default::default()
+    };
+    for dialect in schema_validation_dialects() {
+        let result = validate_with_schema(
+            "WITH scored AS (SELECT user_id, total AS order_total FROM orders), \
+             ranked AS (SELECT user_id, ROW_NUMBER() OVER ( \
+             PARTITION BY user_id ORDER BY order_total DESC) AS row_number FROM scored) \
+             SELECT user_id FROM ranked",
+            dialect,
+            &schema,
+            &opts,
+        );
+        assert!(result.valid, "{dialect}: {:#?}", result.errors);
+    }
+}
+
+#[test]
+fn test_validate_with_schema_joined_cte_projection_preserves_scope() {
+    let schema = base_schema();
+    let opts = SchemaValidationOptions {
+        check_references: true,
+        ..Default::default()
+    };
+    for dialect in schema_validation_dialects() {
+        let result = validate_with_schema(
+            "WITH selected_users AS (SELECT id, name FROM users), \
+             selected_orders AS (SELECT id, user_id, total FROM orders), \
+             combined AS (SELECT selected_users.*, selected_orders.total \
+             FROM selected_users JOIN selected_orders \
+             ON selected_users.id = selected_orders.user_id) \
+             SELECT id, name, total FROM combined",
+            dialect,
+            &schema,
+            &opts,
+        );
+
+        assert!(result.valid, "{dialect}: {:#?}", result.errors);
+    }
+}
+
+#[test]
+fn test_validate_with_schema_chained_star_projection_preserves_aliases() {
+    let schema = base_schema();
+    let opts = SchemaValidationOptions {
+        check_references: true,
+        ..Default::default()
+    };
+    for dialect in schema_validation_dialects() {
+        let result = validate_with_schema(
+            "WITH totals AS (SELECT user_id, total AS order_total FROM orders), \
+             copied AS (SELECT * FROM totals), \
+             scored AS (SELECT *, order_total + 1 AS adjusted_total FROM copied) \
+             SELECT user_id, order_total, adjusted_total FROM scored",
+            dialect,
+            &schema,
+            &opts,
+        );
+
+        assert!(result.valid, "{dialect}: {:#?}", result.errors);
+    }
+}
+
+#[test]
+fn test_validate_with_schema_snowflake_qualify_resolves_projection_columns() {
     let schema = base_schema();
     let opts = SchemaValidationOptions {
         check_references: true,
         ..Default::default()
     };
     let result = validate_with_schema(
-        "WITH selected_users AS (SELECT id FROM users), \
-         selected_orders AS (SELECT id FROM orders) \
-         SELECT selected_users.id FROM selected_users \
-         JOIN selected_orders ON selected_users.id = selected_orders.id",
-        DialectType::Generic,
+        "WITH ranked AS (SELECT user_id, total, \
+         ROW_NUMBER() OVER (PARTITION BY user_id ORDER BY total DESC) AS row_number \
+         FROM orders QUALIFY row_number = 1) \
+         SELECT user_id, total FROM ranked",
+        DialectType::Snowflake,
         &schema,
         &opts,
     );
+    assert!(result.valid, "{:#?}", result.errors);
+}
 
+#[test]
+fn test_validate_with_schema_snowflake_union_by_name_preserves_projection() {
+    let schema = base_schema();
+    let opts = SchemaValidationOptions {
+        check_references: true,
+        ..Default::default()
+    };
+    let result = validate_with_schema(
+        "WITH records AS (SELECT id, name FROM users \
+         UNION ALL BY NAME SELECT id, CAST(total AS VARCHAR) AS name FROM orders) \
+         SELECT id, name FROM records",
+        DialectType::Snowflake,
+        &schema,
+        &opts,
+    );
     assert!(result.valid, "{:#?}", result.errors);
 }
 
 #[test]
-fn test_validate_with_schema_correlated_subquery_resolves_outer_alias() {
+fn test_validate_with_schema_snowflake_join_using_resolves_cte_column() {
     let schema = base_schema();
     let opts = SchemaValidationOptions {
         check_references: true,
         ..Default::default()
     };
     let result = validate_with_schema(
-        "SELECT outer_users.id FROM users outer_users \
-         WHERE EXISTS (SELECT 1 FROM orders inner_orders \
-         WHERE inner_orders.user_id = outer_users.id)",
-        DialectType::Generic,
+        "WITH selected_users AS (SELECT id, name FROM users) \
+         SELECT orders.id, selected_users.name FROM orders \
+         INNER JOIN selected_users USING (id)",
+        DialectType::Snowflake,
         &schema,
         &opts,
     );
@@ -220,17 +401,18 @@ fn test_validate_with_schema_correlated_subquery_resolves_outer_alias() {
 }
 
 #[test]
-fn test_validate_with_schema_correlated_subquery_prefers_inner_unqualified_column() {
+fn test_validate_with_schema_snowflake_join_using_cte_from_same_table() {
     let schema = base_schema();
     let opts = SchemaValidationOptions {
         check_references: true,
         ..Default::default()
     };
     let result = validate_with_schema(
-        "SELECT outer_users.id FROM users outer_users \
-         WHERE EXISTS (SELECT 1 FROM orders inner_orders \
-         WHERE id = outer_users.id)",
-        DialectType::Generic,
+        "WITH selected_users AS (SELECT id FROM users WHERE age >= 18), \
+         combined AS (SELECT users.* FROM users \
+         INNER JOIN selected_users USING (id)) \
+         SELECT id, name FROM combined",
+        DialectType::Snowflake,
         &schema,
         &opts,
     );
@@ -239,17 +421,18 @@ fn test_validate_with_schema_correlated_subquery_prefers_inner_unqualified_colum
 }
 
 #[test]
-fn test_validate_with_schema_subsequent_cte_resolves_prior_projection() {
+fn test_validate_with_schema_snowflake_nested_qualify_resolves_cte_projection() {
     let schema = base_schema();
     let opts = SchemaValidationOptions {
         check_references: true,
         ..Default::default()
     };
     let result = validate_with_schema(
-        "WITH derived AS (SELECT total AS derived_total FROM orders), \
-         next AS (SELECT derived_total FROM derived) \
-         SELECT derived_total FROM next",
-        DialectType::Generic,
+        "WITH customer_orders AS (SELECT user_id, id AS order_id, total FROM orders), \
+         deduplicated AS (SELECT * FROM (SELECT user_id, order_id, total \
+         FROM customer_orders QUALIFY ROW_NUMBER() OVER (PARTITION BY user_id \
+         ORDER BY order_id) = 1)) SELECT user_id, order_id, total FROM deduplicated",
+        DialectType::Snowflake,
         &schema,
         &opts,
     );
@@ -258,18 +441,19 @@ fn test_validate_with_schema_subsequent_cte_resolves_prior_projection() {
 }
 
 #[test]
-fn test_validate_with_schema_window_resolves_prior_cte_projection() {
+fn test_validate_with_schema_snowflake_deep_nested_qualify_resolves_cte_projection() {
     let schema = base_schema();
     let opts = SchemaValidationOptions {
         check_references: true,
         ..Default::default()
     };
     let result = validate_with_schema(
-        "WITH scored AS (SELECT user_id, total AS order_total FROM orders), \
-         ranked AS (SELECT user_id, ROW_NUMBER() OVER ( \
-         PARTITION BY user_id ORDER BY order_total DESC) AS row_number FROM scored) \
-         SELECT user_id FROM ranked",
-        DialectType::Generic,
+        "WITH base AS (SELECT id AS user_id, name, age FROM users), \
+         flags AS (SELECT user_id FROM (SELECT user_id FROM ( \
+         SELECT user_id, name, age FROM base \
+         QUALIFY ROW_NUMBER() OVER (PARTITION BY user_id, name ORDER BY age) = 1))) \
+         SELECT user_id FROM flags",
+        DialectType::Snowflake,
         &schema,
         &opts,
     );
@@ -277,6 +461,96 @@ fn test_validate_with_schema_window_resolves_prior_cte_projection() {
     assert!(result.valid, "{:#?}", result.errors);
 }
 
+#[test]
+fn test_validate_with_schema_deep_star_chain_preserves_computed_alias() {
+    let schema = base_schema();
+    let opts = SchemaValidationOptions {
+        check_references: true,
+        ..Default::default()
+    };
+    for dialect in schema_validation_dialects() {
+        let result = validate_with_schema(
+            "WITH base AS (SELECT user_id, total FROM orders), \
+             first_copy AS (SELECT *, total + 1 AS adjusted_total FROM base), \
+             second_copy AS (SELECT * FROM first_copy), \
+             third_copy AS (SELECT * FROM second_copy), \
+             fourth_copy AS (SELECT *, adjusted_total * 2 AS score FROM third_copy) \
+             SELECT user_id, adjusted_total, score FROM fourth_copy",
+            dialect,
+            &schema,
+            &opts,
+        );
+
+        assert!(result.valid, "{dialect}: {:#?}", result.errors);
+    }
+}
+
+#[test]
+fn test_validate_with_schema_nested_scalar_subquery_resolves_outer_column() {
+    let schema = base_schema();
+    let opts = SchemaValidationOptions {
+        check_references: true,
+        ..Default::default()
+    };
+    for dialect in schema_validation_dialects() {
+        let result = validate_with_schema(
+            "WITH metrics AS (SELECT user_id, total AS score FROM orders), \
+             adjusted AS (SELECT score, CASE WHEN score IS NULL THEN NULL ELSE ( \
+             SELECT adjusted_score FROM (SELECT score + 1 AS adjusted_score)) END AS result \
+             FROM metrics) SELECT score, result FROM adjusted",
+            dialect,
+            &schema,
+            &opts,
+        );
+
+        assert!(result.valid, "{dialect}: {:#?}", result.errors);
+    }
+}
+
+#[test]
+fn test_validate_with_schema_ambiguous_outer_column_stays_invalid() {
+    let schema = base_schema();
+    let opts = SchemaValidationOptions {
+        check_references: true,
+        ..Default::default()
+    };
+    let result = validate_with_schema(
+        "SELECT users.id FROM users JOIN orders ON users.id = orders.user_id \
+         WHERE EXISTS (SELECT 1 WHERE id > 0)",
+        DialectType::Generic,
+        &schema,
+        &opts,
+    );
+
+    assert!(!result.valid);
+    assert!(result.errors.iter().any(|error| {
+        error.code == validation_codes::E_AMBIGUOUS_COLUMN_REFERENCE
+            && error.message.contains("outer sources")
+    }));
+}
+
+#[test]
+fn test_validate_with_schema_unknown_column_after_cte_projection_stays_invalid() {
+    let schema = base_schema();
+    let opts = SchemaValidationOptions {
+        check_references: true,
+        ..Default::default()
+    };
+    let result = validate_with_schema(
+        "WITH selected_users AS (SELECT id, name FROM users) \
+         SELECT missing_column FROM selected_users",
+        DialectType::Generic,
+        &schema,
+        &opts,
+    );
+
+    assert!(!result.valid);
+    assert!(result
+        .errors
+        .iter()
+        .any(|error| error.code == validation_codes::E_UNKNOWN_COLUMN));
+}
+
 #[test]
 fn test_validate_with_schema_unknown_column_in_derived_table() {
     let schema = base_schema();