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

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

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

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyglot-sql
-Version: 0.13.0
+Version: 0.13.1
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

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

@@ -103,14 +103,14 @@ function-catalog-all-dialects = [
 ]
 
 [dependencies]
-polyglot-sql-ast-derive = { path = "../polyglot-sql-ast-derive", version = "0.13.0" }
+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.13.0", 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.13.0 → 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.13.0", default-features = false }
+polyglot-sql = { version = "0.13.1", default-features = false }
 ```
 
 ```toml
 polyglot-sql = {
-    version = "0.13.0",
+    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.13.0",
+    version = "0.13.1",
     default-features = false,
     features = ["generate", "dialect-clickhouse"],
 }
 
 # Cross-dialect transpilation.
 polyglot-sql = {
-    version = "0.13.0",
+    version = "0.13.1",
     default-features = false,
     features = ["transpile", "dialect-clickhouse", "dialect-postgresql"],
 }

{polyglot_sql-0.13.0 → polyglot_sql-0.13.1}/crates/polyglot-sql/benches/allocation_hotspots.rs

@@ -29,7 +29,58 @@ fn print_stats(case: &str, operation: &str, input_bytes: usize, stats: Stats) {
     );
 }
 
+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();

{polyglot_sql-0.13.0 → 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);

{polyglot_sql-0.13.0 → polyglot_sql-0.13.1}/crates/polyglot-sql/src/dialects/normalization/statements.rs

@@ -119,30 +119,8 @@ pub(super) fn normalize_root(expression: Expression, context: &NormalizationCont
         expr
     };
 
-    // Oracle: LIMIT -> FETCH FIRST, OFFSET -> OFFSET ROWS
-    let expr = if matches!(target, DialectType::Oracle) {
-        if let Expression::Select(mut select) = expr {
-            if let Some(limit) = select.limit.take() {
-                // Convert LIMIT to FETCH FIRST n ROWS ONLY
-                select.fetch = Some(crate::expressions::Fetch {
-                    direction: "FIRST".to_string(),
-                    count: Some(limit.this),
-                    percent: false,
-                    rows: true,
-                    with_ties: false,
-                });
-            }
-            // Add ROWS to OFFSET if present
-            if let Some(ref mut offset) = select.offset {
-                offset.rows = Some(true);
-            }
-            Expression::Select(select)
-        } else {
-            expr
-        }
-    } else {
-        expr
-    };
+    // Oracle LIMIT/OFFSET -> OFFSET n ROWS FETCH FIRST m ROWS ONLY is rendered by the
+    // generator (`LimitFetchStyle::FetchFirst`), so it also applies to nested queries.
 
     // Handle CreateTable WITH properties transformation before recursive transforms
     let expr = if let Expression::CreateTable(mut ct) = expr {

{polyglot_sql-0.13.0 → polyglot_sql-0.13.1}/crates/polyglot-sql/src/dialects/oracle.rs

@@ -56,6 +56,8 @@ impl DialectImpl for OracleDialect {
             tz_to_with_time_zone: true,
             // Oracle UNPIVOT aliases retain literal aliases as literals.
             unpivot_aliases_are_identifiers: false,
+            // Oracle has no LIMIT: use OFFSET n ROWS FETCH FIRST m ROWS ONLY
+            limit_fetch_style: crate::generator::LimitFetchStyle::FetchFirst,
             ..Default::default()
         }
     }

{polyglot_sql-0.13.0 → polyglot_sql-0.13.1}/crates/polyglot-sql/src/dialects/tsql.rs

@@ -62,8 +62,8 @@ impl DialectImpl for TSQLDialect {
             identifier_quote_style: IdentifierQuoteStyle::BRACKET,
             dialect: Some(DialectType::TSQL),
             // T-SQL specific settings from Python sqlglot
-            // SQL Server uses TOP/FETCH instead of LIMIT
-            limit_fetch_style: crate::generator::LimitFetchStyle::FetchFirst,
+            // SQL Server uses TOP (or OFFSET/FETCH, handled by the generator) instead of LIMIT
+            limit_fetch_style: crate::generator::LimitFetchStyle::Top,
             // NULLS FIRST/LAST not supported in SQL Server
             null_ordering_supported: false,
             // SQL Server does not support SQL:2003 aggregate FILTER clauses.

{polyglot_sql-0.13.0 → polyglot_sql-0.13.1}/crates/polyglot-sql/src/expressions.rs

@@ -3935,7 +3935,8 @@ pub struct Union {
     pub with: Option<With>,
     /// ORDER BY applied to entire UNION result
     pub order_by: Option<OrderBy>,
-    /// LIMIT applied to entire UNION result
+    /// Row limit applied to the entire UNION result: a legacy count expression,
+    /// or a complete `Expression::Limit` / `Expression::Fetch` with clause options.
     pub limit: Option<Box<Expression>>,
     /// OFFSET applied to entire UNION result
     pub offset: Option<Box<Expression>>,
@@ -4004,7 +4005,8 @@ pub struct Intersect {
     pub with: Option<With>,
     /// ORDER BY applied to entire INTERSECT result
     pub order_by: Option<OrderBy>,
-    /// LIMIT applied to entire INTERSECT result
+    /// Row limit applied to the entire INTERSECT result: a legacy count expression,
+    /// or a complete `Expression::Limit` / `Expression::Fetch` with clause options.
     pub limit: Option<Box<Expression>>,
     /// OFFSET applied to entire INTERSECT result
     pub offset: Option<Box<Expression>>,
@@ -4071,7 +4073,8 @@ pub struct Except {
     pub with: Option<With>,
     /// ORDER BY applied to entire EXCEPT result
     pub order_by: Option<OrderBy>,
-    /// LIMIT applied to entire EXCEPT result
+    /// Row limit applied to the entire EXCEPT result: a legacy count expression,
+    /// or a complete `Expression::Limit` / `Expression::Fetch` with clause options.
     pub limit: Option<Box<Expression>>,
     /// OFFSET applied to entire EXCEPT result
     pub offset: Option<Box<Expression>>,
@@ -5807,6 +5810,35 @@ pub struct Limit {
     pub comments: Vec<String>,
 }
 
+impl Limit {
+    /// Preserve the legacy count-only set-operation AST when no metadata is needed.
+    pub(crate) fn into_set_limit(self) -> Box<Expression> {
+        if self.percent || !self.comments.is_empty() {
+            Box::new(Expression::Limit(Box::new(self)))
+        } else {
+            Box::new(self.this)
+        }
+    }
+}
+
+/// Move a compound query's row limit onto a SELECT without losing clause options.
+/// Bare expressions remain supported for existing builders and serialized ASTs.
+pub(crate) fn split_set_limit(limit: Option<Box<Expression>>) -> (Option<Limit>, Option<Fetch>) {
+    match limit.map(|limit| *limit) {
+        Some(Expression::Limit(limit)) => (Some(*limit), None),
+        Some(Expression::Fetch(fetch)) => (None, Some(*fetch)),
+        Some(this) => (
+            Some(Limit {
+                this,
+                percent: false,
+                comments: Vec::new(),
+            }),
+            None,
+        ),
+        None => (None, None),
+    }
+}
+
 /// OFFSET clause
 #[derive(polyglot_sql_ast_derive::AstNode, Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[cfg_attr(feature = "bindings", derive(TS))]