polyglot-sql 0.9.2__tar.gz → 0.11.0__tar.gz

{polyglot_sql-0.9.2 → polyglot_sql-0.11.0}/Cargo.lock

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

{polyglot_sql-0.9.2 → polyglot_sql-0.11.0}/Cargo.toml

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

{polyglot_sql-0.9.2 → polyglot_sql-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyglot-sql
-Version: 0.9.2
+Version: 0.11.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -110,6 +110,26 @@ polyglot_sql.generate(ast)
 # ["SELECT id FROM a UNION ALL SELECT id FROM b ORDER BY id LIMIT 100 OFFSET 10"]
 ```
 
+### Complexity Guard Options
+
+`transpile` also accepts `complexity_guard`, a `ComplexityGuardOptions` typed dictionary
+using the shared camelCase keys: `maxParserDepth`, `maxInputBytes`, `maxTokens`,
+`maxAstNodes`, `maxAstDepth`, `maxParenthesisDepth`, and `maxFunctionCallDepth`.
+Omit the argument, pass `None`, or omit a key to use its default. A field-level `None`
+disables that check; a nonnegative integer overrides it. For example:
+
+```python
+polyglot_sql.transpile(sql, complexity_guard={"maxParserDepth": 128})
+```
+
+Parser depth defaults to 1024 logical levels on native targets (32 on WASM) and is
+checked during parsing, before an AST exists. Zero rejects parsing descents.
+Other checks remain independent.
+Raising or disabling limits can permit stack exhaustion and process termination,
+even for trusted generated SQL. Increasing a limit does not increase stack space;
+these limits are not general time/memory budgets. Application owners should control
+overrides. Parsing APIs without guard options inherit the default protection.
+
 ### Format Guard Behavior
 
 `format_sql` uses Rust core formatting guards with default limits:
@@ -150,6 +170,29 @@ if result:
     print("valid")
 ```
 
+Schema-aware validation uses the same Rust validator as the TypeScript SDK:
+
+```python
+sql = "SELECT o.order_id FROM orders o WHERE o.missing_column = TRUE"
+schema = {"tables": [{"name": "orders", "columns": [{"name": "order_id", "type": "INT"}]}]}
+result = polyglot_sql.validate_with_schema(
+    sql, schema, dialect="snowflake", check_types=True, check_references=True,
+)
+for error in result.errors:
+    print(error.code, error.message)
+    if error.start is not None and error.end is not None:
+        print(sql[error.start:error.end])
+```
+
+Unknown tables, columns and aliases are checked by default. `check_references`
+also checks ambiguous columns and foreign-key metadata; `check_types` enables
+type checks. `strict` overrides the schema's `strict` value, which defaults to
+`True`; `strict=False` reports reference/type findings as warnings. An empty
+column list or a `*` column denotes an open schema, so unknown columns are not
+rejected solely because their names are absent. Nonempty lists without `*`
+are treated as complete. Options use snake_case keyword arguments, not an
+`options` dictionary. Invalid schemas and unknown dialects raise `ValueError`.
+
 ```python
 options = {
     "producer": "https://github.com/tobilg/polyglot",
@@ -195,6 +238,26 @@ print(analysis["baseTables"][0]["name"])            # "orders"
 print(analysis["baseTables"][0]["table"])           # "orders"
 ```
 
+Non-projection uses are available through the same shared Rust analysis:
+
+```python
+analysis = polyglot_sql.analyze_query(
+    "SELECT o.id FROM orders o WHERE o.amount > 0", dialect="duckdb"
+)
+use = analysis["columnUses"][0]
+print(use["context"])                          # "filter"
+print(use["references"][0]["column"])          # "amount"
+print(use["scopePath"])                        # "root"
+```
+
+`columnUses` groups references by clause expression without changing projection
+lineage. It covers joins, filters, grouping, HAVING/QUALIFY, window keys/frames,
+ordering and set-operation filter inputs. `scopePath`/`expressionPath` identify
+the scope and expression; `expressionSql` is dialect-rendered SQL. Optional
+`span` objects use half-open Unicode-character offsets in the original input.
+Reference spans locate uses, not upstream definitions. Unknown or ambiguous
+sources remain conservative; whole-expression spans are omitted when unavailable.
+
 `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. For
@@ -259,6 +322,7 @@ All functions are exported from `polyglot_sql`.
 - `format_sql(sql: str, dialect: str = "generic", *, max_input_bytes: int | None = None, max_tokens: int | None = None, max_ast_nodes: int | None = None, max_set_op_chain: int | None = None) -> str`
 - `format(sql: str, dialect: str = "generic", *, max_input_bytes: int | None = None, max_tokens: int | None = None, max_ast_nodes: int | None = None, max_set_op_chain: int | None = None) -> str` (alias of `format_sql`)
 - `validate(sql: str, dialect: str = "generic", *, strict_syntax: bool = False, semantic: bool = False) -> ValidationResult`
+- `validate_with_schema(sql: str, schema: dict, dialect: str = "generic", *, check_types: bool = False, check_references: bool = False, strict: bool | None = None, semantic: bool = False, strict_syntax: bool = False) -> ValidationResult`
 - `optimize(sql: str, dialect: str = "generic") -> str`
 - `lineage(column: str, sql: str, dialect: str = "generic") -> dict`
 - `lineage_at(ordinal: int, sql: str, dialect: str = "generic") -> dict`
@@ -294,7 +358,8 @@ Exception hierarchy:
 
 Unknown dialect names raise built-in `ValueError`.
 
-`validate(...)` returns `ValidationResult`:
+`validate(...)` and `validate_with_schema(...)` return `ValidationResult`:
+
 - `result.valid: bool`
 - `result.errors: list[ValidationErrorInfo]`
 - `bool(result)` works (`True` when valid)
@@ -305,11 +370,19 @@ clause boundaries. `semantic=True` adds warning diagnostics W001-W004 for
 `LIMIT` without `ORDER BY`; warnings do not make the result invalid.
 
 Each `ValidationErrorInfo` has:
+
 - `message: str`
 - `line: int`
 - `col: int`
 - `code: str`
 - `severity: str`
+- `start: int | None` (zero-based Unicode character offset)
+- `end: int | None` (exclusive Unicode character offset)
+
+Source ranges refer to the original SQL and support Python string slicing.
+Reference diagnostics point to the offending identifier when available;
+synthetic or schema-only findings have no source range. Existing `line` and
+`col` fields remain integers and use `0` when unavailable.
 
 ## Performance Note
 

{polyglot_sql-0.9.2/crates/polyglot-sql-python → polyglot_sql-0.11.0}/README.md

@@ -83,6 +83,26 @@ polyglot_sql.generate(ast)
 # ["SELECT id FROM a UNION ALL SELECT id FROM b ORDER BY id LIMIT 100 OFFSET 10"]
 ```
 
+### Complexity Guard Options
+
+`transpile` also accepts `complexity_guard`, a `ComplexityGuardOptions` typed dictionary
+using the shared camelCase keys: `maxParserDepth`, `maxInputBytes`, `maxTokens`,
+`maxAstNodes`, `maxAstDepth`, `maxParenthesisDepth`, and `maxFunctionCallDepth`.
+Omit the argument, pass `None`, or omit a key to use its default. A field-level `None`
+disables that check; a nonnegative integer overrides it. For example:
+
+```python
+polyglot_sql.transpile(sql, complexity_guard={"maxParserDepth": 128})
+```
+
+Parser depth defaults to 1024 logical levels on native targets (32 on WASM) and is
+checked during parsing, before an AST exists. Zero rejects parsing descents.
+Other checks remain independent.
+Raising or disabling limits can permit stack exhaustion and process termination,
+even for trusted generated SQL. Increasing a limit does not increase stack space;
+these limits are not general time/memory budgets. Application owners should control
+overrides. Parsing APIs without guard options inherit the default protection.
+
 ### Format Guard Behavior
 
 `format_sql` uses Rust core formatting guards with default limits:
@@ -123,6 +143,29 @@ if result:
     print("valid")
 ```
 
+Schema-aware validation uses the same Rust validator as the TypeScript SDK:
+
+```python
+sql = "SELECT o.order_id FROM orders o WHERE o.missing_column = TRUE"
+schema = {"tables": [{"name": "orders", "columns": [{"name": "order_id", "type": "INT"}]}]}
+result = polyglot_sql.validate_with_schema(
+    sql, schema, dialect="snowflake", check_types=True, check_references=True,
+)
+for error in result.errors:
+    print(error.code, error.message)
+    if error.start is not None and error.end is not None:
+        print(sql[error.start:error.end])
+```
+
+Unknown tables, columns and aliases are checked by default. `check_references`
+also checks ambiguous columns and foreign-key metadata; `check_types` enables
+type checks. `strict` overrides the schema's `strict` value, which defaults to
+`True`; `strict=False` reports reference/type findings as warnings. An empty
+column list or a `*` column denotes an open schema, so unknown columns are not
+rejected solely because their names are absent. Nonempty lists without `*`
+are treated as complete. Options use snake_case keyword arguments, not an
+`options` dictionary. Invalid schemas and unknown dialects raise `ValueError`.
+
 ```python
 options = {
     "producer": "https://github.com/tobilg/polyglot",
@@ -168,6 +211,26 @@ print(analysis["baseTables"][0]["name"])            # "orders"
 print(analysis["baseTables"][0]["table"])           # "orders"
 ```
 
+Non-projection uses are available through the same shared Rust analysis:
+
+```python
+analysis = polyglot_sql.analyze_query(
+    "SELECT o.id FROM orders o WHERE o.amount > 0", dialect="duckdb"
+)
+use = analysis["columnUses"][0]
+print(use["context"])                          # "filter"
+print(use["references"][0]["column"])          # "amount"
+print(use["scopePath"])                        # "root"
+```
+
+`columnUses` groups references by clause expression without changing projection
+lineage. It covers joins, filters, grouping, HAVING/QUALIFY, window keys/frames,
+ordering and set-operation filter inputs. `scopePath`/`expressionPath` identify
+the scope and expression; `expressionSql` is dialect-rendered SQL. Optional
+`span` objects use half-open Unicode-character offsets in the original input.
+Reference spans locate uses, not upstream definitions. Unknown or ambiguous
+sources remain conservative; whole-expression spans are omitted when unavailable.
+
 `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. For
@@ -232,6 +295,7 @@ All functions are exported from `polyglot_sql`.
 - `format_sql(sql: str, dialect: str = "generic", *, max_input_bytes: int | None = None, max_tokens: int | None = None, max_ast_nodes: int | None = None, max_set_op_chain: int | None = None) -> str`
 - `format(sql: str, dialect: str = "generic", *, max_input_bytes: int | None = None, max_tokens: int | None = None, max_ast_nodes: int | None = None, max_set_op_chain: int | None = None) -> str` (alias of `format_sql`)
 - `validate(sql: str, dialect: str = "generic", *, strict_syntax: bool = False, semantic: bool = False) -> ValidationResult`
+- `validate_with_schema(sql: str, schema: dict, dialect: str = "generic", *, check_types: bool = False, check_references: bool = False, strict: bool | None = None, semantic: bool = False, strict_syntax: bool = False) -> ValidationResult`
 - `optimize(sql: str, dialect: str = "generic") -> str`
 - `lineage(column: str, sql: str, dialect: str = "generic") -> dict`
 - `lineage_at(ordinal: int, sql: str, dialect: str = "generic") -> dict`
@@ -267,7 +331,8 @@ Exception hierarchy:
 
 Unknown dialect names raise built-in `ValueError`.
 
-`validate(...)` returns `ValidationResult`:
+`validate(...)` and `validate_with_schema(...)` return `ValidationResult`:
+
 - `result.valid: bool`
 - `result.errors: list[ValidationErrorInfo]`
 - `bool(result)` works (`True` when valid)
@@ -278,11 +343,19 @@ clause boundaries. `semantic=True` adds warning diagnostics W001-W004 for
 `LIMIT` without `ORDER BY`; warnings do not make the result invalid.
 
 Each `ValidationErrorInfo` has:
+
 - `message: str`
 - `line: int`
 - `col: int`
 - `code: str`
 - `severity: str`
+- `start: int | None` (zero-based Unicode character offset)
+- `end: int | None` (exclusive Unicode character offset)
+
+Source ranges refer to the original SQL and support Python string slicing.
+Reference diagnostics point to the offending identifier when available;
+synthetic or schema-only findings have no source range. Existing `line` and
+`col` fields remain integers and use `0` when unavailable.
 
 ## Performance Note
 

{polyglot_sql-0.9.2 → polyglot_sql-0.11.0}/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.11.0" }
 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.11.0", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql-0.9.2 → polyglot_sql-0.11.0}/crates/polyglot-sql/README.md

@@ -25,12 +25,12 @@ 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.11.0", default-features = false }
 ```
 
 ```toml
 polyglot-sql = {
-    version = "0.8.0",
+    version = "0.11.0",
     default-features = false,
     features = ["dialect-clickhouse"],
 }
@@ -44,14 +44,14 @@ Examples:
 ```toml
 # Parse and generate SQL for one dialect.
 polyglot-sql = {
-    version = "0.8.0",
+    version = "0.11.0",
     default-features = false,
     features = ["generate", "dialect-clickhouse"],
 }
 
 # Cross-dialect transpilation.
 polyglot-sql = {
-    version = "0.8.0",
+    version = "0.11.0",
     default-features = false,
     features = ["transpile", "dialect-clickhouse", "dialect-postgresql"],
 }
@@ -479,6 +479,11 @@ Athena, BigQuery, ClickHouse, CockroachDB, DataFusion, Databricks, Doris, Dremio
 | `time` | Enable time-format conversion helpers |
 | `bindings` | Enable `ts-rs` TypeScript type generation |
 
+With `default-features = false`, `ast-tools` and `semantic` can be used without
+enabling `builder` or `generate`. AST transforms reuse the same internal mutation
+primitives as the native and serializable builders, while the public builder APIs
+remain gated by `builder`.
+
 ## License
 
 [MIT](../../LICENSE)

{polyglot_sql-0.9.2 → polyglot_sql-0.11.0}/crates/polyglot-sql/benches/performance_hotspots.rs

@@ -81,6 +81,7 @@ fn many_numbers() -> String {
 
 fn disabled_guards() -> ComplexityGuardOptions {
     ComplexityGuardOptions {
+        max_parser_depth: None,
         max_input_bytes: None,
         max_tokens: None,
         max_ast_nodes: None,

polyglot_sql-0.9.2/crates/polyglot-sql/src/builder/engine.rs → polyglot_sql-0.11.0/crates/polyglot-sql/src/ast_mutation.rs

@@ -1,8 +1,12 @@
-//! Canonical AST construction and mutation primitives shared by builder façades.
+//! Canonical AST construction and mutation primitives shared by AST consumers.
 //!
-//! This module deliberately knows nothing about serde or a language binding. The
-//! native fluent API and [`super::plan`] both delegate their AST edits here so a
-//! clause has exactly one implementation.
+//! AST transform helpers, the native fluent builder, and serializable builder
+//! plans delegate their AST edits here so a clause has exactly one implementation.
+//! This module depends only on AST and error types, not the optional public builder
+//! API, SQL generation, serde, or a language binding.
+
+// AST-only consumers use a subset of the primitives; builders use the full set.
+#![cfg_attr(not(feature = "builder"), allow(dead_code))]
 
 use crate::error::{Error, Result};
 use crate::expressions::*;

{polyglot_sql-0.9.2 → polyglot_sql-0.11.0}/crates/polyglot-sql/src/ast_transforms.rs

@@ -9,7 +9,7 @@
 
 use std::collections::{HashMap, HashSet};
 
-use crate::builder::engine;
+use crate::ast_mutation as engine;
 use crate::expressions::*;
 use crate::traversal::{is_aggregate, ExpressionWalk};
 

{polyglot_sql-0.9.2 → polyglot_sql-0.11.0}/crates/polyglot-sql/src/builder/mod.rs

@@ -55,9 +55,9 @@
 //! .build();
 //! ```
 
-pub(crate) mod engine;
 pub mod plan;
 
+use crate::ast_mutation as engine;
 use crate::expressions::*;
 use crate::generator::{Generator, GeneratorConfig, NotInStyle};
 use crate::parser::Parser;
@@ -552,6 +552,7 @@ pub fn trim(expr: Expr) -> Expr {
         position: TrimPosition::Both,
         sql_standard_syntax: false,
         position_explicit: false,
+        inferred_type: None,
     })))
 }
 
@@ -2811,6 +2812,37 @@ mod tests {
         assert_eq!(sql, "SELECT CAST(id AS VARCHAR) FROM users");
     }
 
+    #[test]
+    fn test_cast_int128() {
+        for name in ["HUGEINT", "INT128"] {
+            let Expression::Cast(cast) = col("value").cast(name).0 else {
+                panic!("expected cast");
+            };
+            assert_eq!(cast.to, DataType::Int128);
+        }
+    }
+
+    #[test]
+    fn test_cast_unsigned_integer_types() {
+        for (name, expected) in [
+            ("UTINYINT", DataType::UInt8),
+            ("UINT8", DataType::UInt8),
+            ("USMALLINT", DataType::UInt16),
+            ("UINT16", DataType::UInt16),
+            ("UINTEGER", DataType::UInt32),
+            ("UINT32", DataType::UInt32),
+            ("UBIGINT", DataType::UInt64),
+            ("UINT64", DataType::UInt64),
+            ("UHUGEINT", DataType::UInt128),
+            ("UINT128", DataType::UInt128),
+        ] {
+            let Expression::Cast(cast) = col("value").cast(name).0 else {
+                panic!("expected cast")
+            };
+            assert_eq!(cast.to, expected, "{name}");
+        }
+    }
+
     #[test]
     fn test_from_starter() {
         let sql = from("users").select_cols(["id", "name"]).to_sql();

{polyglot_sql-0.9.2 → polyglot_sql-0.11.0}/crates/polyglot-sql/src/builder/plan.rs

@@ -4,7 +4,8 @@
 //! provides a serializable, immutable expression plan so language bindings can
 //! share coercion, parsing, and AST-editing semantics without duplicating them.
 
-use crate::builder::{self, engine, Expr};
+use crate::ast_mutation as engine;
+use crate::builder::{self, Expr};
 use crate::dialects::Dialect;
 use crate::error::{Error, Result};
 use crate::expressions::*;

{polyglot_sql-0.9.2 → polyglot_sql-0.11.0}/crates/polyglot-sql/src/dialects/bigquery.rs

@@ -34,6 +34,7 @@ impl DialectImpl for BigQueryDialect {
         // Remove double quote from identifiers (it's in the default config)
         config.identifiers.remove(&'"');
         config.identifiers.insert('`', '`');
+        config.identifier_backslash_escapes = true;
         // BigQuery supports double quotes for strings (in addition to single quotes)
         config.quotes.insert("\"".to_string(), "\"".to_string());
         // BigQuery supports triple-quoted strings

{polyglot_sql-0.9.2 → polyglot_sql-0.11.0}/crates/polyglot-sql/src/dialects/clickhouse.rs

@@ -28,6 +28,7 @@ impl DialectImpl for ClickHouseDialect {
         // ClickHouse uses double quotes and backticks for identifiers
         config.identifiers.insert('"', '"');
         config.identifiers.insert('`', '`');
+        config.identifier_backslash_escapes = true;
         // ClickHouse supports nested comments
         config.nested_comments = true;
         // ClickHouse allows identifiers to start with digits