polyglot-sql 0.12.1__tar.gz → 0.13.1__tar.gz

{polyglot_sql-0.12.1 → polyglot_sql-0.13.1}/Cargo.lock

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

{polyglot_sql-0.12.1 → polyglot_sql-0.13.1}/Cargo.toml

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

{polyglot_sql-0.12.1 → polyglot_sql-0.13.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyglot-sql
-Version: 0.12.1
+Version: 0.13.1
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -356,7 +356,7 @@ All functions are exported from `polyglot_sql`.
 
 Current dialect names returned by `polyglot_sql.dialects()`:
 
-`athena`, `bigquery`, `clickhouse`, `cockroachdb`, `datafusion`, `databricks`, `doris`, `dremio`, `drill`, `druid`, `duckdb`, `dune`, `exasol`, `fabric`, `generic`, `hive`, `materialize`, `mysql`, `oracle`, `postgres`, `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`, `hana`, `hive`, `materialize`, `mysql`, `oracle`, `postgres`, `presto`, `redshift`, `risingwave`, `singlestore`, `snowflake`, `solr`, `spark`, `sqlite`, `starrocks`, `tableau`, `teradata`, `tidb`, `trino`, `tsql`, `vertica`.
 
 ## Error Handling
 

{polyglot_sql-0.12.1/crates/polyglot-sql-python → polyglot_sql-0.13.1}/README.md

@@ -329,7 +329,7 @@ All functions are exported from `polyglot_sql`.
 
 Current dialect names returned by `polyglot_sql.dialects()`:
 
-`athena`, `bigquery`, `clickhouse`, `cockroachdb`, `datafusion`, `databricks`, `doris`, `dremio`, `drill`, `druid`, `duckdb`, `dune`, `exasol`, `fabric`, `generic`, `hive`, `materialize`, `mysql`, `oracle`, `postgres`, `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`, `hana`, `hive`, `materialize`, `mysql`, `oracle`, `postgres`, `presto`, `redshift`, `risingwave`, `singlestore`, `snowflake`, `solr`, `spark`, `sqlite`, `starrocks`, `tableau`, `teradata`, `tidb`, `trino`, `tsql`, `vertica`.
 
 ## Error Handling
 

{polyglot_sql-0.12.1 → polyglot_sql-0.13.1}/crates/polyglot-sql/Cargo.toml

@@ -48,7 +48,8 @@ all-dialects = [
     "dialect-singlestore", "dialect-cockroachdb", "dialect-tidb",
     "dialect-druid", "dialect-solr", "dialect-tableau",
     "dialect-dune", "dialect-fabric", "dialect-drill",
-    "dialect-dremio", "dialect-exasol", "dialect-datafusion",
+    "dialect-dremio", "dialect-exasol", "dialect-datafusion", "dialect-hana",
+    "dialect-vertica",
 ]
 dialect-postgresql = []
 dialect-mysql = []
@@ -83,6 +84,8 @@ dialect-drill = []
 dialect-dremio = []
 dialect-exasol = []
 dialect-datafusion = []
+dialect-hana = []
+dialect-vertica = []
 function-catalog-clickhouse = [
     "semantic",
     "dep:polyglot-sql-function-catalogs",
@@ -100,14 +103,14 @@ function-catalog-all-dialects = [
 ]
 
 [dependencies]
-polyglot-sql-ast-derive = { path = "../polyglot-sql-ast-derive", version = "0.12.1" }
+polyglot-sql-ast-derive = { path = "../polyglot-sql-ast-derive", version = "0.13.1" }
 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.12.1", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.13.1", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql-0.12.1 → polyglot_sql-0.13.1}/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.12.1", default-features = false }
+polyglot-sql = { version = "0.13.1", default-features = false }
 ```
 
 ```toml
 polyglot-sql = {
-    version = "0.12.1",
+    version = "0.13.1",
     default-features = false,
     features = ["dialect-clickhouse"],
 }
@@ -44,14 +44,14 @@ Examples:
 ```toml
 # Parse and generate SQL for one dialect.
 polyglot-sql = {
-    version = "0.12.1",
+    version = "0.13.1",
     default-features = false,
     features = ["generate", "dialect-clickhouse"],
 }
 
 # Cross-dialect transpilation.
 polyglot-sql = {
-    version = "0.12.1",
+    version = "0.13.1",
     default-features = false,
     features = ["transpile", "dialect-clickhouse", "dialect-postgresql"],
 }
@@ -488,7 +488,7 @@ assert_eq!(err.line(), None);
 
 ## Supported Dialects
 
-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
+Athena, BigQuery, ClickHouse, CockroachDB, DataFusion, Databricks, Doris, Dremio, Drill, Druid, DuckDB, Dune, Exasol, Fabric, Generic SQL, SAP HANA, Hive, Materialize, MySQL, Oracle, PostgreSQL, Presto, Redshift, RisingWave, SingleStore, Snowflake, Solr, Spark, SQLite, StarRocks, Tableau, Teradata, TiDB, Trino, TSQL, Vertica
 
 ## Feature Flags
 

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

@@ -0,0 +1,167 @@
+use polyglot_sql::dialects::{Dialect, DialectType};
+use stats_alloc::{Region, Stats, StatsAlloc, INSTRUMENTED_SYSTEM};
+use std::alloc::System;
+use std::hint::black_box;
+
+mod common;
+
+use common::{
+    large_strings, large_token_list, many_columns, many_numbers, nested_functions,
+    COMMENT_AND_STRING_HEAVY, SHORT_ASCII, UNICODE,
+};
+
+#[global_allocator]
+static GLOBAL: &StatsAlloc<System> = &INSTRUMENTED_SYSTEM;
+
+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 compound_row_limits() {
+    for branches in [1, 10, 100] {
+        let body = vec!["SELECT a FROM t"; branches].join(" UNION ALL ");
+        for (name, source, target, tail) in [
+            (
+                "count",
+                DialectType::PostgreSQL,
+                DialectType::Oracle,
+                "LIMIT 5 OFFSET 2",
+            ),
+            (
+                "percent",
+                DialectType::DuckDB,
+                DialectType::Oracle,
+                "LIMIT 10 PERCENT",
+            ),
+            (
+                "fetch",
+                DialectType::Oracle,
+                DialectType::DuckDB,
+                "OFFSET 2 ROWS FETCH NEXT 5 ROWS ONLY",
+            ),
+        ] {
+            let sql = format!("{body} ORDER BY a {tail}");
+            let dialect = Dialect::get(source);
+            let writer = Dialect::get(target);
+            let ast = dialect.parse(&sql).unwrap();
+            let case = format!("compound/{name}/{branches}");
+            print_stats(
+                &case,
+                "parse",
+                sql.len(),
+                measure(|| dialect.parse(&sql).unwrap()),
+            );
+            print_stats(
+                &case,
+                "generate",
+                sql.len(),
+                measure(|| writer.generate(&ast[0]).unwrap()),
+            );
+            print_stats(
+                &case,
+                "transpile",
+                sql.len(),
+                measure(|| dialect.transpile(&sql, target).unwrap()),
+            );
+        }
+    }
+}
+
+fn main() {
+    compound_row_limits();
+    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 generic_functions = format!(
+        "SELECT {} FROM t",
+        (0..1_000)
+            .map(|i| format!("my_udf(c{i}) AS v{i}"))
+            .collect::<Vec<_>>()
+            .join(", ")
+    );
+    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()),
+        ("generic_functions", generic_functions.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)),
+    );
+
+    for depth in [10, 20, 40, 80] {
+        let mut sql = "SELECT 1".to_owned();
+        for _ in 0..depth {
+            sql = format!("SELECT ({sql})");
+        }
+        for kind in [DialectType::PostgreSQL, DialectType::HANA] {
+            let dialect = Dialect::get(kind);
+            black_box(dialect.parse(&sql).unwrap());
+            print_stats(
+                &format!("nested_{depth}_{kind}"),
+                "parse",
+                sql.len(),
+                measure(|| dialect.parse(&sql).unwrap()),
+            );
+        }
+    }
+
+    #[cfg(feature = "transpile")]
+    {
+        let options = polyglot_sql::TranspileOptions::strict();
+        for (name, sql) in common::transpilation_queries() {
+            let run =
+                || polyglot_sql::transpile_with_by_name(&sql, "hana", "duckdb", &options).unwrap();
+            black_box(run());
+            print_stats(
+                &format!("hana_{name}"),
+                "transpile",
+                sql.len(),
+                measure(run),
+            );
+        }
+    }
+}

polyglot_sql-0.13.1/crates/polyglot-sql/benches/common/mod.rs

@@ -0,0 +1,93 @@
+//! SQL inputs shared by the latency and allocation hotspot benchmarks.
+//! Dialect selection stays in the callers, so both suites use identical fixtures.
+
+pub(super) const SHORT_ASCII: &str =
+    "SELECT a, b, SUM(c) AS total FROM events WHERE created_at >= '2025-01-01' GROUP BY a, b";
+
+pub(super) 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'";
+
+pub(super) 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
+"#;
+
+pub(super) 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})")
+}
+
+pub(super) fn many_columns() -> String {
+    format!(
+        "SELECT {} FROM t",
+        (0..1_000)
+            .map(|index| format!("c{index}"))
+            .collect::<Vec<_>>()
+            .join(", ")
+    )
+}
+
+pub(super) fn nested_functions() -> String {
+    format!(
+        "SELECT {}x{} FROM t",
+        "COALESCE(".repeat(20),
+        ", NULL)".repeat(20)
+    )
+}
+
+pub(super) fn large_strings() -> String {
+    format!(
+        "SELECT {} FROM t",
+        vec![format!("'{}'", "x".repeat(100)); 500].join(", ")
+    )
+}
+
+pub(super) fn many_numbers() -> String {
+    format!(
+        "SELECT {} FROM t",
+        (0..10_000)
+            .map(|value| value.to_string())
+            .collect::<Vec<_>>()
+            .join(", ")
+    )
+}
+
+#[cfg(feature = "transpile")]
+pub(super) fn transpilation_queries() -> Vec<(&'static str, String)> {
+    vec![
+        ("short", "SELECT COALESCE(x, 0) FROM t".to_owned()),
+        (
+            "wide",
+            format!(
+                "SELECT {} FROM t",
+                (0..100)
+                    .map(|i| format!("COALESCE(c{i}, 0) AS v{i}"))
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            ),
+        ),
+        (
+            "nested",
+            format!(
+                "SELECT {}x{} FROM t",
+                "COALESCE(".repeat(20),
+                ", 0)".repeat(20)
+            ),
+        ),
+        (
+            "casts",
+            format!(
+                "SELECT {}",
+                (0..100)
+                    .map(|i| format!("CAST({i}.123 AS DECIMAL(10, 2)) AS v{i}"))
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            ),
+        ),
+    ]
+}

{polyglot_sql-0.12.1 → polyglot_sql-0.13.1}/crates/polyglot-sql/benches/performance_hotspots.rs

@@ -4,18 +4,12 @@ use polyglot_sql::parser::{Parser, ParserConfig};
 use polyglot_sql::ComplexityGuardOptions;
 use std::time::Duration;
 
-const SHORT_ASCII: &str =
-    "SELECT a, b, SUM(c) AS total FROM events WHERE created_at >= '2025-01-01' GROUP BY a, b";
+mod common;
 
-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
-"#;
+use common::{
+    large_strings, large_token_list, many_columns, many_numbers, nested_functions,
+    COMMENT_AND_STRING_HEAVY, SHORT_ASCII, UNICODE,
+};
 
 const TPCH_STYLE: &str = r#"
 WITH regional_sales AS (
@@ -36,49 +30,6 @@ WHERE ranked.position <= 10
 ORDER BY ranked.revenue DESC
 "#;
 
-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 disabled_guards() -> ComplexityGuardOptions {
     ComplexityGuardOptions {
         max_parser_depth: None,
@@ -269,11 +220,49 @@ fn bench_validation_and_analysis(c: &mut Criterion) {
     let _ = c;
 }
 
+fn bench_hana_nested_queries(c: &mut Criterion) {
+    let mut group = c.benchmark_group("nested_query_dialects");
+    for depth in [10, 20, 40, 80] {
+        let mut sql = "SELECT 1".to_owned();
+        for _ in 0..depth {
+            sql = format!("SELECT ({sql})");
+        }
+        for kind in [DialectType::PostgreSQL, DialectType::HANA] {
+            let dialect = Dialect::get(kind);
+            group.bench_with_input(BenchmarkId::new(kind.to_string(), depth), &sql, |b, sql| {
+                b.iter(|| dialect.parse(black_box(sql)).unwrap());
+            });
+        }
+    }
+    group.finish();
+}
+
+fn bench_hana_source_validation(c: &mut Criterion) {
+    #[cfg(feature = "transpile")]
+    {
+        let options = polyglot_sql::TranspileOptions::strict();
+        let mut group = c.benchmark_group("hana_source_validation");
+        for (name, sql) in common::transpilation_queries() {
+            group.bench_with_input(BenchmarkId::from_parameter(name), &sql, |b, sql| {
+                b.iter(|| {
+                    polyglot_sql::transpile_with_by_name(black_box(sql), "hana", "duckdb", &options)
+                        .unwrap()
+                });
+            });
+        }
+        group.finish();
+    }
+    #[cfg(not(feature = "transpile"))]
+    let _ = c;
+}
+
 criterion_group!(
     benches,
     bench_dialect_construction,
     bench_fresh_vs_reused_dialect,
     bench_tokenize_and_parse,
-    bench_validation_and_analysis
+    bench_validation_and_analysis,
+    bench_hana_nested_queries,
+    bench_hana_source_validation
 );
 criterion_main!(benches);

{polyglot_sql-0.12.1 → polyglot_sql-0.13.1}/crates/polyglot-sql/benches/transpile.rs

@@ -167,10 +167,54 @@ fn bench_roundtrip(c: &mut Criterion) {
     group.finish();
 }
 
+fn bench_compound_row_limits(c: &mut Criterion) {
+    use polyglot_sql::dialects::Dialect;
+    use std::time::Duration;
+
+    let mut group = c.benchmark_group("compound_row_limits");
+    group.sample_size(30);
+    group.warm_up_time(Duration::from_millis(500));
+    group.measurement_time(Duration::from_secs(2));
+    for branches in [1, 10, 100] {
+        let body = vec!["SELECT a FROM t"; branches].join(" UNION ALL ");
+        for (name, source, target, tail) in [
+            (
+                "count",
+                DialectType::PostgreSQL,
+                DialectType::Oracle,
+                "LIMIT 5 OFFSET 2",
+            ),
+            (
+                "percent",
+                DialectType::DuckDB,
+                DialectType::Oracle,
+                "LIMIT 10 PERCENT",
+            ),
+            (
+                "fetch",
+                DialectType::Oracle,
+                DialectType::DuckDB,
+                "OFFSET 2 ROWS FETCH NEXT 5 ROWS ONLY",
+            ),
+        ] {
+            let sql = format!("{body} ORDER BY a {tail}");
+            let dialect = Dialect::get(source);
+            group.bench_function(format!("parse/{name}/{branches}"), |b| {
+                b.iter(|| dialect.parse(black_box(&sql)).unwrap())
+            });
+            group.bench_function(format!("transpile/{name}/{branches}"), |b| {
+                b.iter(|| transpile(black_box(&sql), source, target).unwrap())
+            });
+        }
+    }
+    group.finish();
+}
+
 criterion_group!(
     benches,
     bench_transpile_by_query_size,
     bench_transpile_dialect_pairs,
-    bench_roundtrip
+    bench_roundtrip,
+    bench_compound_row_limits
 );
 criterion_main!(benches);