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

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

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

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyglot-sql
-Version: 0.5.2
+Version: 0.5.3
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -125,21 +125,25 @@ emission are intentionally out of scope.
 
 ```python
 analysis = polyglot_sql.analyze_query(
-    "SELECT SUM(o.amount) AS total FROM orders AS o",
+    "WITH base AS (SELECT id, amount FROM orders) SELECT * FROM base",
     {
         "dialect": "generic",
         "schema": {
             "tables": [
                 {
                     "name": "orders",
-                    "columns": [{"name": "amount", "type": "DECIMAL(10,2)"}],
+                    "columns": [
+                        {"name": "id", "type": "INT", "nullable": False},
+                        {"name": "amount", "type": "DECIMAL(10,2)", "nullable": True},
+                    ],
                 }
             ]
         },
     },
 )
-print(analysis["projections"][0]["transformKind"])  # "aggregation"
-print(analysis["projections"][0]["typeHint"])       # "DECIMAL(10, 2)"
+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"
 ```
 
@@ -147,7 +151,40 @@ print(analysis["baseTables"][0]["name"])            # "orders"
 `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.
+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
 

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

@@ -98,21 +98,25 @@ emission are intentionally out of scope.
 
 ```python
 analysis = polyglot_sql.analyze_query(
-    "SELECT SUM(o.amount) AS total FROM orders AS o",
+    "WITH base AS (SELECT id, amount FROM orders) SELECT * FROM base",
     {
         "dialect": "generic",
         "schema": {
             "tables": [
                 {
                     "name": "orders",
-                    "columns": [{"name": "amount", "type": "DECIMAL(10,2)"}],
+                    "columns": [
+                        {"name": "id", "type": "INT", "nullable": False},
+                        {"name": "amount", "type": "DECIMAL(10,2)", "nullable": True},
+                    ],
                 }
             ]
         },
     },
 )
-print(analysis["projections"][0]["transformKind"])  # "aggregation"
-print(analysis["projections"][0]["typeHint"])       # "DECIMAL(10, 2)"
+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"
 ```
 
@@ -120,7 +124,40 @@ print(analysis["baseTables"][0]["name"])            # "orders"
 `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.
+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
 

{polyglot_sql-0.5.2 → 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.2", 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.2 → polyglot_sql-0.5.3}/crates/polyglot-sql/README.md

@@ -318,19 +318,29 @@ 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": "amount", "type": "DECIMAL(10,2)"}]
+        "columns": [
+            {"name": "id", "type": "INT", "nullable": false},
+            {"name": "amount", "type": "DECIMAL(10,2)", "nullable": true}
+        ]
     }]
 })).unwrap();
 
 let analysis = analyze_query(
-    "SELECT SUM(o.amount) AS total FROM orders o",
+    "WITH base AS (SELECT id, amount FROM orders) SELECT * FROM base",
     AnalyzeQueryOptions {
         dialect: DialectType::Generic,
         schema: Some(schema),
@@ -338,12 +348,43 @@ let analysis = analyze_query(
 ).unwrap();
 
 assert_eq!(analysis.shape, QueryShape::Select);
-assert_eq!(analysis.projections[0].name.as_deref(), Some("total"));
-assert_eq!(analysis.projections[0].transform_kind, polyglot_sql::TransformKind::Aggregation);
+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");
-assert_eq!(analysis.base_tables[0].alias.as_deref(), Some("o"));
 ```
 
+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.2 → 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.2 → 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.2 → 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,