polyglot-sql 0.5.15__tar.gz → 0.6.0__tar.gz

{polyglot_sql-0.5.15 → polyglot_sql-0.6.0}/Cargo.lock

@@ -605,23 +605,34 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql"
-version = "0.5.15"
+version = "0.6.0"
 dependencies = [
  "criterion",
  "once_cell",
+ "polyglot-sql-ast-derive",
  "polyglot-sql-function-catalogs",
  "pretty_assertions",
  "serde",
  "serde_json",
  "stacker",
+ "stats_alloc",
  "thiserror 1.0.69",
  "ts-rs",
  "unicode-segmentation",
 ]
 
+[[package]]
+name = "polyglot-sql-ast-derive"
+version = "0.6.0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "polyglot-sql-ffi"
-version = "0.5.15"
+version = "0.6.0"
 dependencies = [
  "cbindgen",
  "polyglot-sql",
@@ -631,11 +642,11 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-function-catalogs"
-version = "0.5.15"
+version = "0.6.0"
 
 [[package]]
 name = "polyglot-sql-python"
-version = "0.5.15"
+version = "0.6.0"
 dependencies = [
  "polyglot-sql",
  "pyo3",
@@ -646,7 +657,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-wasm"
-version = "0.5.15"
+version = "0.6.0"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",
@@ -957,6 +968,12 @@ dependencies = [
  "windows-sys",
 ]
 
+[[package]]
+name = "stats_alloc"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c0e04424e733e69714ca1bbb9204c1a57f09f5493439520f9f68c132ad25eec"
+
 [[package]]
 name = "strsim"
 version = "0.11.1"

{polyglot_sql-0.5.15 → polyglot_sql-0.6.0}/Cargo.toml

@@ -1,12 +1,12 @@
 [workspace]
 resolver = "2"
-members = ["crates/polyglot-sql", "crates/polyglot-sql-function-catalogs", "crates/polyglot-sql-python"]
+members = ["crates/polyglot-sql", "crates/polyglot-sql-ast-derive", "crates/polyglot-sql-function-catalogs", "crates/polyglot-sql-python"]
 exclude = [
     "examples/rust",
 ]
 
 [workspace.package]
-version = "0.5.15"
+version = "0.6.0"
 edition = "2021"
 license = "MIT"
 authors = ["polyglot contributors"]
@@ -46,6 +46,18 @@ opt-level = 3
 lto = true
 codegen-units = 1
 
+[profile.native_release]
+inherits = "release"
+opt-level = 3
+panic = "unwind"
+
+[profile.python_release]
+inherits = "release"
+opt-level = 2
+lto = "thin"
+
 [profile.ffi_release]
 inherits = "release"
+opt-level = 2
+lto = "thin"
 panic = "unwind"

{polyglot_sql-0.5.15 → polyglot_sql-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyglot-sql
-Version: 0.5.15
+Version: 0.6.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -14,7 +14,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Database
 Classifier: Topic :: Software Development :: Libraries
-Summary: Rust-powered SQL transpiler for 32+ dialects. Parse, generate, transpile, format, and validate SQL.
+Summary: Rust-powered SQL transpiler for more than 30 SQL dialects. Parse, generate, transpile, format, and validate SQL.
 Keywords: sql,transpiler,parser,dialect,database
 Home-Page: https://github.com/tobilg/polyglot
 License: MIT
@@ -27,7 +27,7 @@ Project-URL: Repository, https://github.com/tobilg/polyglot
 
 # polyglot-sql (Python)
 
-Rust-powered SQL transpiler for 30+ dialects.
+Rust-powered SQL transpiler for more than 30 SQL dialects.
 
 The `polyglot-sql` Python package exposes an API backed by the Rust `polyglot-sql` engine for fast parse/transpile/generate/format/validate workflows.
 
@@ -108,7 +108,12 @@ pretty = polyglot_sql.format_sql(
 ```
 
 ```python
-result = polyglot_sql.validate("SELECT 1", dialect="postgres")
+result = polyglot_sql.validate(
+    "SELECT * FROM users LIMIT 10",
+    dialect="postgres",
+    strict_syntax=True,
+    semantic=True,
+)
 if result:
     print("valid")
 ```
@@ -214,7 +219,7 @@ All functions are exported from `polyglot_sql`.
 - `generate(ast: dict | list[dict], dialect: str = "generic", *, pretty: bool = False) -> list[str]`
 - `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") -> ValidationResult`
+- `validate(sql: str, dialect: str = "generic", *, strict_syntax: bool = False, semantic: bool = False) -> ValidationResult`
 - `optimize(sql: str, dialect: str = "generic") -> str`
 - `lineage(column: str, sql: str, dialect: str = "generic") -> dict`
 - `source_tables(column: str, sql: str, dialect: str = "generic") -> list[str]`
@@ -249,6 +254,11 @@ Unknown dialect names raise built-in `ValueError`.
 - `result.errors: list[ValidationErrorInfo]`
 - `bool(result)` works (`True` when valid)
 
+`strict_syntax=True` rejects compatibility forms such as trailing commas before
+clause boundaries. `semantic=True` adds warning diagnostics W001-W004 for
+`SELECT *`, mixed aggregate projections, `DISTINCT` with `ORDER BY`, and
+`LIMIT` without `ORDER BY`; warnings do not make the result invalid.
+
 Each `ValidationErrorInfo` has:
 - `message: str`
 - `line: int`
@@ -259,6 +269,11 @@ Each `ValidationErrorInfo` has:
 ## Performance Note
 
 The package uses Rust internals directly via PyO3 and has zero runtime Python dependencies for SQL processing.
+Published wheels use the dedicated Cargo `python_release` profile with
+`opt-level=2` and thin LTO. This favors Python query throughput without changing
+the size-oriented release profile used by WASM. FFI/Go artifacts use their own
+native throughput profile. Editable development installs continue to use
+Cargo's `dev` profile.
 
 ## Development
 
@@ -268,7 +283,7 @@ uv sync --group dev
 uv run maturin develop
 uv run pytest
 uv run pyright python/polyglot_sql/
-uv run maturin build --release
+uv run maturin build --profile python_release
 uv run --with mkdocs mkdocs build --strict --clean --config-file mkdocs.yml --site-dir ../../packages/python-docs/dist
 ```
 

{polyglot_sql-0.5.15/crates/polyglot-sql-python → polyglot_sql-0.6.0}/README.md

@@ -1,6 +1,6 @@
 # polyglot-sql (Python)
 
-Rust-powered SQL transpiler for 30+ dialects.
+Rust-powered SQL transpiler for more than 30 SQL dialects.
 
 The `polyglot-sql` Python package exposes an API backed by the Rust `polyglot-sql` engine for fast parse/transpile/generate/format/validate workflows.
 
@@ -81,7 +81,12 @@ pretty = polyglot_sql.format_sql(
 ```
 
 ```python
-result = polyglot_sql.validate("SELECT 1", dialect="postgres")
+result = polyglot_sql.validate(
+    "SELECT * FROM users LIMIT 10",
+    dialect="postgres",
+    strict_syntax=True,
+    semantic=True,
+)
 if result:
     print("valid")
 ```
@@ -187,7 +192,7 @@ All functions are exported from `polyglot_sql`.
 - `generate(ast: dict | list[dict], dialect: str = "generic", *, pretty: bool = False) -> list[str]`
 - `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") -> ValidationResult`
+- `validate(sql: str, dialect: str = "generic", *, strict_syntax: bool = False, semantic: bool = False) -> ValidationResult`
 - `optimize(sql: str, dialect: str = "generic") -> str`
 - `lineage(column: str, sql: str, dialect: str = "generic") -> dict`
 - `source_tables(column: str, sql: str, dialect: str = "generic") -> list[str]`
@@ -222,6 +227,11 @@ Unknown dialect names raise built-in `ValueError`.
 - `result.errors: list[ValidationErrorInfo]`
 - `bool(result)` works (`True` when valid)
 
+`strict_syntax=True` rejects compatibility forms such as trailing commas before
+clause boundaries. `semantic=True` adds warning diagnostics W001-W004 for
+`SELECT *`, mixed aggregate projections, `DISTINCT` with `ORDER BY`, and
+`LIMIT` without `ORDER BY`; warnings do not make the result invalid.
+
 Each `ValidationErrorInfo` has:
 - `message: str`
 - `line: int`
@@ -232,6 +242,11 @@ Each `ValidationErrorInfo` has:
 ## Performance Note
 
 The package uses Rust internals directly via PyO3 and has zero runtime Python dependencies for SQL processing.
+Published wheels use the dedicated Cargo `python_release` profile with
+`opt-level=2` and thin LTO. This favors Python query throughput without changing
+the size-oriented release profile used by WASM. FFI/Go artifacts use their own
+native throughput profile. Editable development installs continue to use
+Cargo's `dev` profile.
 
 ## Development
 
@@ -241,7 +256,7 @@ uv sync --group dev
 uv run maturin develop
 uv run pytest
 uv run pyright python/polyglot_sql/
-uv run maturin build --release
+uv run maturin build --profile python_release
 uv run --with mkdocs mkdocs build --strict --clean --config-file mkdocs.yml --site-dir ../../packages/python-docs/dist
 ```
 

{polyglot_sql-0.5.15 → polyglot_sql-0.6.0}/crates/polyglot-sql/Cargo.toml

@@ -100,18 +100,20 @@ function-catalog-all-dialects = [
 ]
 
 [dependencies]
+polyglot-sql-ast-derive = { path = "../polyglot-sql-ast-derive" }
 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.5.15", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.6.0", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"
 once_cell = "1.19"
 criterion = { version = "0.5", features = ["html_reports"] }
+stats_alloc = "0.1"
 
 [[bench]]
 name = "parsing"
@@ -121,6 +123,10 @@ harness = false
 name = "transpile"
 harness = false
 
+[[bench]]
+name = "ast_traversal"
+harness = false
+
 [[bench]]
 name = "in_list"
 harness = false
@@ -128,3 +134,11 @@ harness = false
 [[bench]]
 name = "rust_parsing"
 harness = false
+
+[[bench]]
+name = "performance_hotspots"
+harness = false
+
+[[bench]]
+name = "allocation_hotspots"
+harness = false

{polyglot_sql-0.5.15 → polyglot_sql-0.6.0}/crates/polyglot-sql/README.md

@@ -1,6 +1,6 @@
 # polyglot-sql
 
-Core SQL parsing and dialect translation library for Rust. Parses, generates, transpiles, and formats SQL across 32 database dialects.
+Core SQL parsing and dialect translation library for Rust. Parses, generates, transpiles, and formats SQL across more than 30 SQL dialects.
 
 Part of the [Polyglot](https://github.com/tobilg/polyglot) project.
 
@@ -9,7 +9,7 @@ Part of the [Polyglot](https://github.com/tobilg/polyglot) project.
 - **Parse** SQL into a fully-typed AST with 200+ expression types
 - **Parse standalone data types** such as `DECIMAL(10, 2)` without a statement wrapper
 - **Generate** SQL from AST nodes for any target dialect
-- **Transpile** between any pair of 32 dialects in one call
+- **Transpile** between any pair of more than 30 SQL dialects in one call
 - **Format** / pretty-print SQL
 - **Fluent builder API** for constructing queries programmatically
 - **AST traversal** utilities (DFS/BFS iterators, transform, walk)
@@ -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.5", default-features = false }
+polyglot-sql = { version = "0.6.0", default-features = false }
 ```
 
 ```toml
@@ -245,10 +245,17 @@ let tables = get_tables(&ast[0]);
 ### Validation
 
 ```rust
-use polyglot_sql::{validate, DialectType};
+use polyglot_sql::{validate_with_options, DialectType, ValidationOptions};
 
-let result = validate("SELECT * FORM users", DialectType::Generic);
-// result contains error with line/column location
+let result = validate_with_options(
+    "SELECT * FROM users LIMIT 10",
+    DialectType::Generic,
+    &ValidationOptions {
+        strict_syntax: false,
+        semantic: true,
+    },
+);
+// W001 and W004 are warnings, so result.valid remains true.
 ```
 
 ```rust
@@ -448,7 +455,7 @@ assert_eq!(err.line(), None);
 
 ## Supported Dialects
 
-Athena, BigQuery, ClickHouse, CockroachDB, Databricks, Doris, Dremio, Drill, Druid, DuckDB, Dune, Exasol, Fabric, Hive, Materialize, MySQL, Oracle, PostgreSQL, Presto, Redshift, RisingWave, SingleStore, Snowflake, Solr, Spark, SQLite, StarRocks, Tableau, Teradata, TiDB, Trino, TSQL
+Athena, BigQuery, ClickHouse, CockroachDB, DataFusion, Databricks, Doris, Dremio, Drill, Druid, DuckDB, Dune, Exasol, Fabric, Generic SQL, Hive, Materialize, MySQL, Oracle, PostgreSQL, Presto, Redshift, RisingWave, SingleStore, Snowflake, Solr, Spark, SQLite, StarRocks, Tableau, Teradata, TiDB, Trino, TSQL
 
 ## Feature Flags
 

polyglot_sql-0.6.0/crates/polyglot-sql/benches/allocation_hotspots.rs

@@ -0,0 +1,122 @@
+use polyglot_sql::dialects::{Dialect, DialectType};
+use stats_alloc::{Region, Stats, StatsAlloc, INSTRUMENTED_SYSTEM};
+use std::alloc::System;
+use std::hint::black_box;
+
+#[global_allocator]
+static GLOBAL: &StatsAlloc<System> = &INSTRUMENTED_SYSTEM;
+
+const SHORT_ASCII: &str =
+    "SELECT a, b, SUM(c) AS total FROM events WHERE created_at >= '2025-01-01' GROUP BY a, b";
+const UNICODE: &str =
+    "SELECT \"Kundennummer\", 'Gr\u{00fc}\u{00df}e aus Z\u{00fc}rich' AS \"Mitteilung\" FROM \"Bestellungen\" WHERE \"Stadt\" = 'M\u{00fc}nchen'";
+const COMMENT_AND_STRING_HEAVY: &str = r#"
+-- leading comment
+SELECT 'alpha''beta' AS value, "quoted name", E'line\nvalue'
+FROM events /* source comment */
+WHERE payload = '{"key":"value"}' -- trailing comment
+"#;
+
+fn large_token_list() -> String {
+    let values = (0..20_000)
+        .map(|value| value.to_string())
+        .collect::<Vec<_>>()
+        .join(", ");
+    format!("SELECT * FROM events WHERE event_id IN ({values})")
+}
+
+fn many_columns() -> String {
+    format!(
+        "SELECT {} FROM t",
+        (0..1_000)
+            .map(|index| format!("c{index}"))
+            .collect::<Vec<_>>()
+            .join(", ")
+    )
+}
+
+fn nested_functions() -> String {
+    format!(
+        "SELECT {}x{} FROM t",
+        "COALESCE(".repeat(20),
+        ", NULL)".repeat(20)
+    )
+}
+
+fn large_strings() -> String {
+    format!(
+        "SELECT {} FROM t",
+        vec![format!("'{}'", "x".repeat(100)); 500].join(", ")
+    )
+}
+
+fn many_numbers() -> String {
+    format!(
+        "SELECT {} FROM t",
+        (0..10_000)
+            .map(|value| value.to_string())
+            .collect::<Vec<_>>()
+            .join(", ")
+    )
+}
+
+fn measure<T>(operation: impl FnOnce() -> T) -> Stats {
+    let region = Region::new(GLOBAL);
+    black_box(operation());
+    region.change()
+}
+
+fn print_stats(case: &str, operation: &str, input_bytes: usize, stats: Stats) {
+    println!(
+        "{{\"case\":\"{case}\",\"operation\":\"{operation}\",\"input_bytes\":{input_bytes},\"allocations\":{},\"deallocations\":{},\"bytes_allocated\":{},\"bytes_deallocated\":{}}}",
+        stats.allocations,
+        stats.deallocations,
+        stats.bytes_allocated,
+        stats.bytes_deallocated,
+    );
+}
+
+fn main() {
+    let dialect = Dialect::get(DialectType::PostgreSQL);
+    let large = large_token_list();
+    let columns = many_columns();
+    let functions = nested_functions();
+    let strings = large_strings();
+    let numbers = many_numbers();
+    let inputs = [
+        ("short_ascii", SHORT_ASCII),
+        ("unicode", UNICODE),
+        ("comments_strings", COMMENT_AND_STRING_HEAVY),
+        ("large_tokens", large.as_str()),
+        ("many_columns", columns.as_str()),
+        ("nested_functions", functions.as_str()),
+        ("large_strings", strings.as_str()),
+        ("many_numbers", numbers.as_str()),
+    ];
+
+    black_box(dialect.tokenize(SHORT_ASCII).unwrap());
+    black_box(dialect.parse(SHORT_ASCII).unwrap());
+    black_box(Dialect::get(DialectType::PostgreSQL));
+
+    for (case, sql) in inputs {
+        print_stats(
+            case,
+            "tokenize",
+            sql.len(),
+            measure(|| dialect.tokenize(sql).unwrap()),
+        );
+        print_stats(
+            case,
+            "parse",
+            sql.len(),
+            measure(|| dialect.parse(sql).unwrap()),
+        );
+    }
+
+    print_stats(
+        "postgresql",
+        "dialect_get",
+        0,
+        measure(|| Dialect::get(DialectType::PostgreSQL)),
+    );
+}

polyglot_sql-0.6.0/crates/polyglot-sql/benches/ast_traversal.rs

@@ -0,0 +1,43 @@
+use criterion::{black_box, criterion_group, criterion_main, BatchSize, Criterion};
+use polyglot_sql::dialects::transform_recursive;
+use polyglot_sql::{ExpressionWalk, Parser};
+
+const COMPLEX_QUERY: &str = r#"
+WITH active_users AS (
+    SELECT id, name FROM users WHERE active = TRUE
+), order_totals AS (
+    SELECT user_id, SUM(amount) AS total
+    FROM orders
+    GROUP BY user_id
+)
+SELECT u.id, u.name, COALESCE(o.total, 0) AS total
+FROM active_users AS u
+LEFT JOIN order_totals AS o ON u.id = o.user_id
+WHERE o.total > 100 OR o.total IS NULL
+ORDER BY total DESC
+LIMIT 100
+"#;
+
+fn benchmark_ast_traversal(c: &mut Criterion) {
+    let expression = Parser::parse_sql(COMPLEX_QUERY)
+        .expect("benchmark query should parse")
+        .remove(0);
+
+    let mut group = c.benchmark_group("ast_traversal");
+    group.bench_function("dfs", |b| b.iter(|| black_box(&expression).dfs().count()));
+    group.bench_function("bfs", |b| b.iter(|| black_box(&expression).bfs().count()));
+    group.bench_function("direct_children", |b| {
+        b.iter(|| black_box(&expression).children())
+    });
+    group.bench_function("noop_transform", |b| {
+        b.iter_batched(
+            || expression.clone(),
+            |expression| transform_recursive(expression, &|node| Ok(node)).unwrap(),
+            BatchSize::SmallInput,
+        )
+    });
+    group.finish();
+}
+
+criterion_group!(benches, benchmark_ast_traversal);
+criterion_main!(benches);