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

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

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

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyglot-sql
-Version: 0.9.2
+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.2/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.2 → 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.2" }
+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.2", 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.2 → 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.2", 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.2/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.2 → 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};
 

{polyglot_sql-0.9.2 → 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;
@@ -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.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::*;

{polyglot_sql-0.9.2 → polyglot_sql-0.10.0}/crates/polyglot-sql/src/dialects/duckdb.rs

@@ -1520,6 +1520,9 @@ impl DuckDBDialect {
             DataType::Custom { ref name } => {
                 let upper = name.to_uppercase();
                 match upper.as_str() {
+                    name if DataType::from_unsigned_name(name).is_some() => {
+                        DataType::from_unsigned_name(name).unwrap()
+                    }
                     // INT64 -> BIGINT
                     "INT64" | "INT8" => DataType::BigInt { length: None },
                     // INT32, INT4, SIGNED -> INT
@@ -1532,13 +1535,7 @@ impl DuckDBDialect {
                     // INT1 -> TINYINT
                     "INT1" => DataType::TinyInt { length: None },
                     // HUGEINT -> INT128
-                    "HUGEINT" => DataType::Custom {
-                        name: "INT128".to_string(),
-                    },
-                    // UHUGEINT -> UINT128
-                    "UHUGEINT" => DataType::Custom {
-                        name: "UINT128".to_string(),
-                    },
+                    "HUGEINT" | "INT128" => DataType::Int128,
                     // BPCHAR -> TEXT
                     "BPCHAR" => DataType::Text,
                     // CHARACTER VARYING, CHAR VARYING -> TEXT
@@ -2160,6 +2157,7 @@ impl DuckDBDialect {
             // LIST_VALUE -> Array literal notation [...]
             "LIST_VALUE" => Ok(Expression::Array(Box::new(crate::expressions::Array {
                 expressions: f.args,
+                inferred_type: None,
             }))),
 
             // ARRAY_AGG -> LIST in DuckDB (or array_agg which is also supported)
@@ -3379,9 +3377,7 @@ impl DuckDBDialect {
                     Ok(Expression::BitwiseLeftShift(Box::new(BinaryOp {
                         left: Expression::Cast(Box::new(Cast {
                             this: a,
-                            to: DataType::Custom {
-                                name: "INT128".to_string(),
-                            },
+                            to: DataType::Int128,
                             trailing_comments: Vec::new(),
                             double_colon_syntax: false,
                             format: None,
@@ -3445,9 +3441,7 @@ impl DuckDBDialect {
                     Ok(Expression::BitwiseRightShift(Box::new(BinaryOp {
                         left: Expression::Cast(Box::new(Cast {
                             this: a,
-                            to: DataType::Custom {
-                                name: "INT128".to_string(),
-                            },
+                            to: DataType::Int128,
                             trailing_comments: Vec::new(),
                             double_colon_syntax: false,
                             format: None,
@@ -6464,6 +6458,7 @@ impl DuckDBDialect {
                 }));
                 let empty_result = Expression::Array(Box::new(crate::expressions::Array {
                     expressions: vec![null_struct],
+                    inferred_type: None,
                 }));
 
                 let range_upper = if n == 1 {
@@ -6513,6 +6508,7 @@ impl DuckDBDialect {
                 }));
                 let empty_array = Expression::Array(Box::new(crate::expressions::Array {
                     expressions: vec![],
+                    inferred_type: None,
                 }));
                 let zipped_struct = Expression::Struct(Box::new(Struct {
                     fields: args
@@ -7504,6 +7500,7 @@ impl DuckDBDialect {
 mod tests {
     use super::*;
     use crate::dialects::Dialect;
+    use crate::expressions::JoinKind;
 
     fn transpile_to_duckdb(sql: &str) -> String {
         transpile_to_duckdb_from(sql, DialectType::Generic)
@@ -7544,6 +7541,144 @@ mod tests {
         assert!(result.contains("FROM users"));
     }
 
+    #[test]
+    fn test_duckdb_keyword_relation_aliases() {
+        let dialect = Dialect::get(DialectType::DuckDB);
+        for alias in [
+            "top",
+            "TOP",
+            "ToP",
+            "first",
+            "last",
+            "begin",
+            "type",
+            "\"top\"",
+            "\"where\"",
+        ] {
+            for template in [
+                "SELECT {alias}.item_id FROM ranked_items {as}{alias}",
+                "WITH ranked_items AS (SELECT 1 AS item_id) SELECT {alias}.item_id FROM ranked_items {as}{alias}",
+                "WITH ranked_items AS (SELECT 1 AS item_id), selected_items AS (SELECT 1 AS item_id) SELECT {alias}.item_id FROM selected_items JOIN ranked_items {as}{alias} ON {alias}.item_id = selected_items.item_id",
+                "SELECT {alias}.item_id FROM (SELECT 1 AS item_id) {as}{alias}",
+                "SELECT {alias}.item_id FROM range(1) {as}{alias}(item_id)",
+                "SELECT {alias}.item_id FROM (VALUES (1)) {as}{alias}(item_id)",
+            ] {
+                let template = template.replace("{alias}", alias);
+                let explicit_sql = template.replace("{as}", "AS ");
+                let expected = transpile_to_duckdb_from(&explicit_sql, DialectType::DuckDB);
+                for as_keyword in ["", "AS "] {
+                    let sql = template.replace("{as}", as_keyword);
+                    let statements = dialect
+                        .parse(&sql)
+                        .unwrap_or_else(|error| panic!("Failed to parse {sql:?}: {error}"));
+                    assert_eq!(statements.len(), 1, "{sql}");
+                    let Expression::Select(select) = &statements[0] else {
+                        panic!("Expected SELECT for {sql}");
+                    };
+                    let relation = select.joins.last().map_or_else(
+                        || &select.from.as_ref().unwrap().expressions[0],
+                        |join| &join.this,
+                    );
+                    let (identifier, columns) = match relation {
+                        Expression::Table(table) => (table.alias.as_ref().unwrap(), &table.column_aliases),
+                        Expression::Subquery(subquery) => (subquery.alias.as_ref().unwrap(), &subquery.column_aliases),
+                        Expression::Alias(alias) => (&alias.alias, &alias.column_aliases),
+                        _ => panic!("Expected aliased relation for {sql}"),
+                    };
+                    assert_eq!(identifier.name, alias.trim_matches('"'), "{sql}");
+                    assert_eq!(identifier.quoted, alias.starts_with('"'), "{sql}");
+                    if template.contains("(item_id)") {
+                        assert_eq!(columns.len(), 1, "{sql}");
+                        assert_eq!(columns[0].name, "item_id", "{sql}");
+                    }
+                    assert_eq!(
+                        transpile_to_duckdb_from(&sql, DialectType::DuckDB),
+                        expected,
+                        "{sql}"
+                    );
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_duckdb_keyword_relation_aliases_preserve_clause_boundaries() {
+        let dialect = Dialect::get(DialectType::DuckDB);
+        for alias in ["", " top"] {
+            let sql = format!(
+                "SELECT item_id, ROW_NUMBER() OVER w AS rn FROM ranked_items{alias} \
+                 WHERE item_id > 0 GROUP BY item_id HAVING COUNT(*) > 0 \
+                 WINDOW w AS (ORDER BY item_id) QUALIFY rn = 1 \
+                 ORDER BY item_id NULLS FIRST, rn NULLS LAST LIMIT 5 OFFSET 1"
+            );
+            let statements = dialect.parse(&sql).unwrap();
+            let Expression::Select(select) = &statements[0] else {
+                panic!("Expected SELECT for {sql}");
+            };
+            assert!(select.where_clause.is_some());
+            assert!(select.group_by.is_some());
+            assert!(select.having.is_some());
+            assert!(select.windows.is_some());
+            assert!(select.qualify.is_some());
+            let ordering = &select.order_by.as_ref().unwrap().expressions;
+            assert_eq!(ordering.len(), 2);
+            assert_eq!(ordering[0].nulls_first, Some(true));
+            assert_eq!(ordering[1].nulls_first, Some(false));
+            assert!(select.limit.is_some());
+            assert!(select.offset.is_some());
+            let Expression::Table(table) = &select.from.as_ref().unwrap().expressions[0] else {
+                panic!("Expected table source for {sql}");
+            };
+            assert_eq!(
+                table.alias.as_ref().map(|a| a.name.as_str()),
+                if alias.is_empty() { None } else { Some("top") }
+            );
+
+            for (join, kind) in [
+                ("LEFT JOIN selected_items ON TRUE", JoinKind::Left),
+                ("POSITIONAL JOIN selected_items", JoinKind::Positional),
+            ] {
+                let sql = format!("SELECT * FROM ranked_items{alias} {join}");
+                let statements = dialect.parse(&sql).unwrap();
+                let Expression::Select(select) = &statements[0] else {
+                    panic!("Expected SELECT for {sql}");
+                };
+                assert_eq!(select.joins.len(), 1, "{sql}");
+                assert_eq!(select.joins[0].kind, kind, "{sql}");
+                let Expression::Table(table) = &select.from.as_ref().unwrap().expressions[0] else {
+                    panic!("Expected table source for {sql}");
+                };
+                assert_eq!(
+                    table.alias.as_ref().map(|a| a.name.as_str()),
+                    if alias.is_empty() { None } else { Some("top") }
+                );
+            }
+        }
+
+        // Truly reserved DuckDB words must not become implicit relation aliases.
+        for alias in ["end", "where", "qualify", "select", "join", "limit"] {
+            let sql = format!("SELECT * FROM ranked_items {alias}");
+            assert!(dialect.parse(&sql).is_err(), "Unexpectedly accepted {sql}");
+        }
+    }
+
+    #[test]
+    fn test_extract_quoted_date_parts() {
+        for (quoted, canonical) in [("year", "YEAR"), ("month", "MONTH"), ("day", "DAY")] {
+            let sql = format!("SELECT EXTRACT('{quoted}' FROM created_at) FROM events");
+            assert_eq!(
+                transpile_to_duckdb_from(&sql, DialectType::DuckDB),
+                format!("SELECT EXTRACT({canonical} FROM created_at) FROM events")
+            );
+        }
+
+        let unquoted = "SELECT EXTRACT(YEAR FROM created_at) FROM events";
+        assert_eq!(
+            transpile_to_duckdb_from(unquoted, DialectType::DuckDB),
+            unquoted
+        );
+    }
+
     #[test]
     fn test_group_concat_to_listagg() {
         let result = transpile_to_duckdb("SELECT GROUP_CONCAT(name)");

{polyglot_sql-0.9.2 → polyglot_sql-0.10.0}/crates/polyglot-sql/src/dialects/fabric.rs

@@ -362,8 +362,8 @@ impl FabricDialect {
                 name: "UNIQUEIDENTIFIER".to_string(),
             },
 
-            // TinyInt -> SMALLINT
-            DataType::TinyInt { .. } => DataType::Custom {
+            // Preserve the existing signed/unsigned 8-bit mapping for typed ASTs.
+            DataType::TinyInt { .. } | DataType::UInt8 => DataType::Custom {
                 name: "SMALLINT".to_string(),
             },
 

{polyglot_sql-0.9.2 → polyglot_sql-0.10.0}/crates/polyglot-sql/src/dialects/mod.rs

@@ -278,11 +278,12 @@ pub enum DialectType {
 
 impl DialectType {
     /// Whether SELECT projections may use string literals as column aliases.
-    pub(crate) const fn supports_string_aliases(self) -> bool {
+    /// DuckDB permits this only when the alias has an explicit AS keyword.
+    pub(crate) const fn supports_string_aliases(self, explicit_as: bool) -> bool {
         matches!(
             self,
             DialectType::TSQL | DialectType::Fabric | DialectType::MySQL | DialectType::SQLite
-        )
+        ) || (matches!(self, DialectType::DuckDB) && explicit_as)
     }
 }
 

{polyglot_sql-0.9.2 → polyglot_sql-0.10.0}/crates/polyglot-sql/src/dialects/mysql.rs

@@ -800,6 +800,13 @@ impl MySQLDialect {
             DataType::Boolean => DataType::Custom {
                 name: "SIGNED".to_string(),
             },
+            // First-class counterparts of the legacy unsigned Custom types below.
+            // UINT128 is intentionally excluded: MySQL UNSIGNED is only 64 bits.
+            DataType::UInt8 | DataType::UInt16 | DataType::UInt32 | DataType::UInt64 => {
+                DataType::Custom {
+                    name: "UNSIGNED".to_string(),
+                }
+            }
 
             // Custom types that need mapping
             DataType::Custom { name } => {

{polyglot_sql-0.9.2 → polyglot_sql-0.10.0}/crates/polyglot-sql/src/dialects/normalization/aggregates.rs

@@ -252,6 +252,7 @@ pub(super) fn rewrite(
 
                         let array_expr = Expression::Array(Box::new(crate::expressions::Array {
                             expressions: quantiles,
+                            inferred_type: None,
                         }));
 
                         let mut new_agg = *agg;