polyglot-sql 0.9.1__tar.gz → 0.10.0__tar.gz

{polyglot_sql-0.9.1 → polyglot_sql-0.10.0}/Cargo.lock

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

{polyglot_sql-0.9.1 → polyglot_sql-0.10.0}/Cargo.toml

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

{polyglot_sql-0.9.1 → polyglot_sql-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyglot-sql
-Version: 0.9.1
+Version: 0.10.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -150,6 +150,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 +218,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 +302,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 +338,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 +350,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.1/crates/polyglot-sql-python → polyglot_sql-0.10.0}/README.md

@@ -123,6 +123,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 +191,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 +275,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 +311,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 +323,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.1 → polyglot_sql-0.10.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.1" }
+polyglot-sql-ast-derive = { path = "../polyglot-sql-ast-derive", version = "0.10.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.1", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.10.0", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql-0.9.1 → polyglot_sql-0.10.0}/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.1", default-features = false }
+polyglot-sql = { version = "0.10.0", default-features = false }
 ```
 
 ```toml
@@ -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.1/crates/polyglot-sql/src/builder/engine.rs → polyglot_sql-0.10.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.1 → polyglot_sql-0.10.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};
 
@@ -897,4 +897,25 @@ mod tests {
 
         assert_eq!(aggregate_types, vec!["count_if", "median", "first"]);
     }
+
+    #[test]
+    fn test_get_duckdb_null_preserving_arg_extrema() {
+        let expr = crate::parse_one(
+            "SELECT ARG_MAX_NULL(label, score), ARG_MIN_NULL(label, score) FROM source_table",
+            crate::dialects::DialectType::DuckDB,
+        )
+        .unwrap();
+        let aggregates = get_aggregate_functions(&expr);
+
+        assert_eq!(aggregates.len(), 2);
+        for (aggregate, expected_name) in
+            aggregates.into_iter().zip(["ARG_MAX_NULL", "ARG_MIN_NULL"])
+        {
+            let Expression::AggregateFunction(function) = aggregate else {
+                panic!("expected a generic aggregate node, got {aggregate:?}");
+            };
+            assert_eq!(function.name, expected_name);
+            assert_eq!(function.args.len(), 2);
+        }
+    }
 }

{polyglot_sql-0.9.1 → polyglot_sql-0.10.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;
@@ -186,6 +186,7 @@ pub fn col(name: &str) -> Expr {
             expr = Expression::Dot(Box::new(DotAccess {
                 this: expr,
                 field: builder_identifier(field),
+                inferred_type: None,
             }));
         }
 
@@ -551,6 +552,7 @@ pub fn trim(expr: Expr) -> Expr {
         position: TrimPosition::Both,
         sql_standard_syntax: false,
         position_explicit: false,
+        inferred_type: None,
     })))
 }
 
@@ -2783,12 +2785,64 @@ mod tests {
         assert_eq!(sql, "SELECT price * quantity AS total FROM items");
     }
 
+    #[test]
+    fn test_nested_operator_grouping() {
+        assert_eq!(
+            or(col("a").eq(lit(1)), col("b").eq(lit(2)))
+                .and(col("c").eq(lit(3)))
+                .to_sql(),
+            "(a = 1 OR b = 2) AND c = 3"
+        );
+        assert_eq!(
+            col("a")
+                .eq(lit(1))
+                .and(or(col("b").eq(lit(2)), col("c").eq(lit(3))))
+                .to_sql(),
+            "a = 1 AND (b = 2 OR c = 3)"
+        );
+        assert_eq!(col("a").add(col("b")).mul(col("c")).to_sql(), "(a + b) * c");
+        assert_eq!(col("a").mul(col("b").add(col("c"))).to_sql(), "a * (b + c)");
+        assert_eq!(col("a").sub(col("b").sub(col("c"))).to_sql(), "a - (b - c)");
+        assert_eq!(col("a").div(col("b").div(col("c"))).to_sql(), "a / (b / c)");
+    }
+
     #[test]
     fn test_cast() {
         let sql = select([col("id").cast("VARCHAR")]).from("users").to_sql();
         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.1 → polyglot_sql-0.10.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::*;