polyglot-sql 0.5.1__tar.gz → 0.5.3__tar.gz

{polyglot_sql-0.5.1 → polyglot_sql-0.5.3}/Cargo.lock

@@ -605,7 +605,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql"
-version = "0.5.1"
+version = "0.5.3"
 dependencies = [
  "criterion",
  "once_cell",
@@ -621,7 +621,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ffi"
-version = "0.5.1"
+version = "0.5.3"
 dependencies = [
  "cbindgen",
  "polyglot-sql",
@@ -631,11 +631,11 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-function-catalogs"
-version = "0.5.1"
+version = "0.5.3"
 
 [[package]]
 name = "polyglot-sql-python"
-version = "0.5.1"
+version = "0.5.3"
 dependencies = [
  "polyglot-sql",
  "pyo3",
@@ -646,7 +646,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-wasm"
-version = "0.5.1"
+version = "0.5.3"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",

{polyglot_sql-0.5.1 → polyglot_sql-0.5.3}/Cargo.toml

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

{polyglot_sql-0.5.1 → polyglot_sql-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyglot-sql
-Version: 0.5.1
+Version: 0.5.3
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -125,22 +125,67 @@ emission are intentionally out of scope.
 
 ```python
 analysis = polyglot_sql.analyze_query(
-    "SELECT CAST(total AS TEXT) AS total_text FROM orders",
+    "WITH base AS (SELECT id, amount FROM orders) SELECT * FROM base",
     {
         "dialect": "generic",
         "schema": {
             "tables": [
                 {
                     "name": "orders",
-                    "columns": [{"name": "total", "type": "INT"}],
+                    "columns": [
+                        {"name": "id", "type": "INT", "nullable": False},
+                        {"name": "amount", "type": "DECIMAL(10,2)", "nullable": True},
+                    ],
                 }
             ]
         },
     },
 )
-print(analysis["projections"][0]["transformKind"])  # "cast"
+print(analysis["cteFacts"][0]["bodySql"])           # "SELECT id, amount FROM orders"
+print(analysis["starProjections"][0]["expandedColumns"])  # ["id", "amount"]
+print(analysis["projections"][0]["nullability"])    # "non_null"
+print(analysis["baseTables"][0]["name"])            # "orders"
 ```
 
+`analysis["relations"]` reports sources visible in the analyzed scope.
+`analysis["baseTables"]` reports deduplicated physical table dependencies across
+nested CTEs, derived tables, subqueries, and set-operation branches. Validation
+uses broad type families, while query analysis preserves parseable detailed
+schema type strings for projection `typeHint` values. `analysis["cteFacts"]`
+reports top-level CTE definitions, `analysis["starProjections"]` records the
+original star projections and schema-expanded columns, and each projection has
+conservative `nullability`: `"non_null"`, `"nullable"`, or `"unknown"`.
+
+Validation schema dictionaries use:
+
+```python
+schema = {
+    "strict": True,
+    "tables": [
+        {
+            "name": "orders",
+            "schema": "analytics",
+            "aliases": ["o"],
+            "primaryKey": ["id"],
+            "uniqueKeys": [["external_id"]],
+            "foreignKeys": [
+                {
+                    "columns": ["customer_id"],
+                    "references": {"table": "customers", "columns": ["id"]},
+                }
+            ],
+            "columns": [
+                {"name": "id", "type": "INT", "nullable": False, "primaryKey": True},
+                {"name": "amount", "type": "DECIMAL(10,2)", "nullable": True},
+            ],
+        }
+    ],
+}
+```
+
+Use the `type` key for column types. `dataType` / `data_type` are not accepted
+aliases in this payload.
+
 ## API Reference
 
 All functions are exported from `polyglot_sql`.

{polyglot_sql-0.5.1/crates/polyglot-sql-python → polyglot_sql-0.5.3}/README.md

@@ -98,22 +98,67 @@ emission are intentionally out of scope.
 
 ```python
 analysis = polyglot_sql.analyze_query(
-    "SELECT CAST(total AS TEXT) AS total_text FROM orders",
+    "WITH base AS (SELECT id, amount FROM orders) SELECT * FROM base",
     {
         "dialect": "generic",
         "schema": {
             "tables": [
                 {
                     "name": "orders",
-                    "columns": [{"name": "total", "type": "INT"}],
+                    "columns": [
+                        {"name": "id", "type": "INT", "nullable": False},
+                        {"name": "amount", "type": "DECIMAL(10,2)", "nullable": True},
+                    ],
                 }
             ]
         },
     },
 )
-print(analysis["projections"][0]["transformKind"])  # "cast"
+print(analysis["cteFacts"][0]["bodySql"])           # "SELECT id, amount FROM orders"
+print(analysis["starProjections"][0]["expandedColumns"])  # ["id", "amount"]
+print(analysis["projections"][0]["nullability"])    # "non_null"
+print(analysis["baseTables"][0]["name"])            # "orders"
 ```
 
+`analysis["relations"]` reports sources visible in the analyzed scope.
+`analysis["baseTables"]` reports deduplicated physical table dependencies across
+nested CTEs, derived tables, subqueries, and set-operation branches. Validation
+uses broad type families, while query analysis preserves parseable detailed
+schema type strings for projection `typeHint` values. `analysis["cteFacts"]`
+reports top-level CTE definitions, `analysis["starProjections"]` records the
+original star projections and schema-expanded columns, and each projection has
+conservative `nullability`: `"non_null"`, `"nullable"`, or `"unknown"`.
+
+Validation schema dictionaries use:
+
+```python
+schema = {
+    "strict": True,
+    "tables": [
+        {
+            "name": "orders",
+            "schema": "analytics",
+            "aliases": ["o"],
+            "primaryKey": ["id"],
+            "uniqueKeys": [["external_id"]],
+            "foreignKeys": [
+                {
+                    "columns": ["customer_id"],
+                    "references": {"table": "customers", "columns": ["id"]},
+                }
+            ],
+            "columns": [
+                {"name": "id", "type": "INT", "nullable": False, "primaryKey": True},
+                {"name": "amount", "type": "DECIMAL(10,2)", "nullable": True},
+            ],
+        }
+    ],
+}
+```
+
+Use the `type` key for column types. `dataType` / `data_type` are not accepted
+aliases in this payload.
+
 ## API Reference
 
 All functions are exported from `polyglot_sql`.

{polyglot_sql-0.5.1 → polyglot_sql-0.5.3}/crates/polyglot-sql/Cargo.toml

@@ -106,7 +106,7 @@ 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.5.1", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.5.3", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql-0.5.1 → polyglot_sql-0.5.3}/crates/polyglot-sql/README.md

@@ -313,23 +313,78 @@ Schema-aware validation emits stable codes such as:
 ### Compact Query Analysis
 
 Use `analyze_query` when you need high-level facts without consuming the full AST
-or full lineage graph:
+or full lineage graph. `relations` reports sources visible in the analyzed
+scope, while `base_tables` reports deduplicated physical table dependencies
+across CTEs, derived tables, subqueries, and set-operation branches. When a
+`ValidationSchema` is supplied, detailed type strings such as `DECIMAL(10,2)`
+are preserved in projection `type_hint` values when parseable.
+`cte_facts` reports top-level CTE names, declared columns, original CTE body SQL,
+and CTE output columns. `star_projections` reports the original top-level star
+projection index, optional table qualifier, and schema-expanded columns when
+known. Each projection also includes conservative `nullability`:
+`non_null`, `nullable`, or `unknown`.
 
 ```rust
-use polyglot_sql::{analyze_query, AnalyzeQueryOptions, DialectType, QueryShape};
+use polyglot_sql::{
+    analyze_query, AnalyzeQueryOptions, DialectType, ProjectionNullability, QueryShape,
+};
+
+let schema: polyglot_sql::ValidationSchema = serde_json::from_value(serde_json::json!({
+    "tables": [{
+        "name": "orders",
+        "columns": [
+            {"name": "id", "type": "INT", "nullable": false},
+            {"name": "amount", "type": "DECIMAL(10,2)", "nullable": true}
+        ]
+    }]
+})).unwrap();
 
 let analysis = analyze_query(
-    "SELECT o.total AS total FROM orders o",
+    "WITH base AS (SELECT id, amount FROM orders) SELECT * FROM base",
     AnalyzeQueryOptions {
         dialect: DialectType::Generic,
-        schema: None,
+        schema: Some(schema),
     },
 ).unwrap();
 
 assert_eq!(analysis.shape, QueryShape::Select);
-assert_eq!(analysis.projections[0].name.as_deref(), Some("total"));
+assert_eq!(analysis.cte_facts[0].name, "base");
+assert_eq!(analysis.cte_facts[0].body_sql, "SELECT id, amount FROM orders");
+assert_eq!(analysis.star_projections[0].expanded_columns, vec!["id", "amount"]);
+assert_eq!(analysis.projections[0].nullability, ProjectionNullability::NonNull);
+assert_eq!(analysis.base_tables[0].name, "orders");
 ```
 
+External JSON schemas use this shape:
+
+```json
+{
+  "strict": true,
+  "tables": [
+    {
+      "name": "orders",
+      "schema": "analytics",
+      "aliases": ["o"],
+      "primaryKey": ["id"],
+      "uniqueKeys": [["external_id"]],
+      "foreignKeys": [
+        {
+          "columns": ["customer_id"],
+          "references": { "table": "customers", "columns": ["id"] }
+        }
+      ],
+      "columns": [
+        { "name": "id", "type": "INT", "nullable": false, "primaryKey": true },
+        { "name": "amount", "type": "DECIMAL(10,2)", "nullable": true }
+      ]
+    }
+  ]
+}
+```
+
+Use the `type` key for column types in JSON. `dataType` / `data_type` are not
+accepted aliases.
+
 ### Tokenize
 
 Access the raw token stream with full source position spans. Each token carries a `Span` with byte offsets and line/column numbers.

{polyglot_sql-0.5.1 → polyglot_sql-0.5.3}/crates/polyglot-sql/src/generator.rs

@@ -12189,6 +12189,7 @@ impl Generator {
             let is_character_set = name_str == Some("CHARACTER SET");
             let is_names = name_str == Some("NAMES");
             let is_collate = name_str == Some("COLLATE");
+            let is_identity_insert = name_str == Some("IDENTITY_INSERT");
             let is_value_only =
                 matches!(&item.value, Expression::Identifier(id) if id.name.is_empty());
 
@@ -12216,6 +12217,11 @@ impl Generator {
                 self.write_keyword("COLLATE");
                 self.write_space();
                 self.generate_set_value(&item.value)?;
+            } else if is_identity_insert {
+                // T-SQL: SET IDENTITY_INSERT <table> ON|OFF
+                self.write_keyword("IDENTITY_INSERT");
+                self.write_space();
+                self.generate_identity_insert_value(&item.value)?;
             } else if has_variable_kind {
                 // Output: SET [VARIABLE] <name> = <value>
                 // VARIABLE keyword already written above if dialect requires it
@@ -12253,6 +12259,19 @@ impl Generator {
         Ok(())
     }
 
+    fn generate_identity_insert_value(&mut self, value: &Expression) -> Result<()> {
+        if let Expression::Tuple(tuple) = value {
+            if tuple.expressions.len() == 2 {
+                self.generate_expression(&tuple.expressions[0])?;
+                self.write_space();
+                self.generate_set_value(&tuple.expressions[1])?;
+                return Ok(());
+            }
+        }
+
+        self.generate_set_value(value)
+    }
+
     /// Generate a SET statement value, writing keyword values (DEFAULT, ON, OFF)
     /// directly to avoid reserved keyword quoting.
     fn generate_set_value(&mut self, value: &Expression) -> Result<()> {

{polyglot_sql-0.5.1 → polyglot_sql-0.5.3}/crates/polyglot-sql/src/lib.rs

@@ -93,9 +93,9 @@ pub use optimizer::{
 pub use parser::Parser;
 #[cfg(all(feature = "semantic", feature = "generate"))]
 pub use query_analysis::{
-    analyze_query, AnalyzeQueryOptions, ColumnReferenceFact, ProjectionFact, QueryAnalysis,
-    QueryShape, ReferenceConfidence, RelationFact, SetOperationBranchFact, SetOperationFact,
-    TransformKind,
+    analyze_query, AnalyzeQueryOptions, ColumnReferenceFact, CteFact, ProjectionFact,
+    ProjectionNullability, QueryAnalysis, QueryShape, ReferenceConfidence, RelationFact,
+    SetOperationBranchFact, SetOperationFact, StarProjectionFact, TransformKind,
 };
 #[cfg(feature = "semantic")]
 pub use resolver::{is_column_ambiguous, resolve_column, Resolver, ResolverError, ResolverResult};

{polyglot_sql-0.5.1 → polyglot_sql-0.5.3}/crates/polyglot-sql/src/lineage.rs

@@ -772,12 +772,32 @@ fn to_node_inner(
     apply_scope_context(&mut node, scope, source_name, reference_node_name);
 
     // 5. Star handling — add downstream for each source
-    if matches!(&select_expr, Expression::Star(_)) {
+    if let Expression::Star(star) = &select_expr {
+        let star_table = star
+            .table
+            .as_ref()
+            .map(|identifier| identifier.name.as_str());
         for (name, source_info) in &scope.sources {
+            if let Some(star_table) = star_table {
+                let table_matches = name.eq_ignore_ascii_case(star_table)
+                    || source_info
+                        .alias
+                        .as_deref()
+                        .is_some_and(|alias| alias.eq_ignore_ascii_case(star_table))
+                    || matches!(
+                        &source_info.expression,
+                        Expression::Table(table_ref)
+                            if table_name_from_table_ref(table_ref).eq_ignore_ascii_case(star_table)
+                    );
+                if !table_matches {
+                    continue;
+                }
+            }
+
             let mut child = LineageNode::new(
                 format!("{}.*", name),
                 Expression::Star(crate::expressions::Star {
-                    table: None,
+                    table: star.table.clone(),
                     except: None,
                     replace: None,
                     rename: None,

{polyglot_sql-0.5.1 → polyglot_sql-0.5.3}/crates/polyglot-sql/src/optimizer/qualify_columns.rs

@@ -653,21 +653,23 @@ fn expand_stars(
 
     for expr in &select.expressions {
         match expr {
-            Expression::Star(_) => {
+            Expression::Star(star) => {
                 has_star = true;
-                for source_name in &ordered_sources {
-                    if let Ok(columns) = resolver.get_source_columns(source_name) {
+                if let Some(table) = &star.table {
+                    let table_name = &table.name;
+                    if !ordered_sources.contains(table_name) {
+                        return Err(QualifyColumnsError::UnknownTable(table_name.clone()));
+                    }
+                    if let Ok(columns) = resolver.get_source_columns(table_name) {
                         if columns.contains(&"*".to_string()) || columns.is_empty() {
                             return Ok(());
                         }
                         for col_name in &columns {
                             if coalesced_columns.contains(col_name) {
-                                // Already emitted as COALESCE, skip
                                 continue;
                             }
                             if let Some(tables) = column_tables.get(col_name) {
-                                if tables.contains(source_name) {
-                                    // Emit COALESCE and mark as coalesced
+                                if tables.contains(table_name) {
                                     coalesced_columns.insert(col_name.clone());
                                     let coalesce = make_coalesce(col_name, tables);
                                     new_selections.push(Expression::Alias(Box::new(Alias {
@@ -684,7 +686,41 @@ fn expand_stars(
                                 }
                             }
                             new_selections
-                                .push(create_qualified_column(col_name, Some(source_name)));
+                                .push(create_qualified_column(col_name, Some(table_name)));
+                        }
+                    }
+                } else {
+                    for source_name in &ordered_sources {
+                        if let Ok(columns) = resolver.get_source_columns(source_name) {
+                            if columns.contains(&"*".to_string()) || columns.is_empty() {
+                                return Ok(());
+                            }
+                            for col_name in &columns {
+                                if coalesced_columns.contains(col_name) {
+                                    // Already emitted as COALESCE, skip
+                                    continue;
+                                }
+                                if let Some(tables) = column_tables.get(col_name) {
+                                    if tables.contains(source_name) {
+                                        // Emit COALESCE and mark as coalesced
+                                        coalesced_columns.insert(col_name.clone());
+                                        let coalesce = make_coalesce(col_name, tables);
+                                        new_selections.push(Expression::Alias(Box::new(Alias {
+                                            this: coalesce,
+                                            alias: Identifier::new(col_name),
+                                            column_aliases: vec![],
+                                            alias_explicit_as: false,
+                                            alias_keyword: None,
+                                            pre_alias_comments: vec![],
+                                            trailing_comments: vec![],
+                                            inferred_type: None,
+                                        })));
+                                        continue;
+                                    }
+                                }
+                                new_selections
+                                    .push(create_qualified_column(col_name, Some(source_name)));
+                            }
                         }
                     }
                 }

{polyglot_sql-0.5.1 → polyglot_sql-0.5.3}/crates/polyglot-sql/src/parser.rs

@@ -24377,6 +24377,34 @@ impl Parser {
             return self.fallback_to_command(statement_start);
         }
 
+        // T-SQL: SET IDENTITY_INSERT schema.table ON|OFF.
+        if matches!(
+            self.config.dialect,
+            Some(crate::dialects::DialectType::TSQL)
+        ) && self.match_identifier("IDENTITY_INSERT")
+        {
+            let table = self.parse_table_ref()?;
+            let state = if self.check(TokenType::On) || self.check_keyword_text("OFF") {
+                self.advance().text.to_uppercase()
+            } else {
+                return Err(self.parse_error("Expected ON or OFF after SET IDENTITY_INSERT table"));
+            };
+
+            items.push(SetItem {
+                name: Expression::Identifier(Identifier::new("IDENTITY_INSERT")),
+                value: Expression::Tuple(Box::new(crate::expressions::Tuple {
+                    expressions: vec![
+                        Expression::Table(Box::new(table)),
+                        Expression::Identifier(Identifier::new(state)),
+                    ],
+                })),
+                kind: None,
+                no_equals: true,
+            });
+
+            return Ok(Expression::SetStatement(Box::new(SetStatement { items })));
+        }
+
         // ClickHouse: SET DEFAULT ROLE ... TO user - parse as command
         if matches!(
             self.config.dialect,