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

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

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

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

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

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

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

{polyglot_sql-0.13.1 → polyglot_sql-0.13.2}/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.1" }
+polyglot-sql-ast-derive = { path = "../polyglot-sql-ast-derive", version = "0.13.2" }
 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.1", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.13.2", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql-0.13.1 → polyglot_sql-0.13.2}/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.1", default-features = false }
+polyglot-sql = { version = "0.13.2", default-features = false }
 ```
 
 ```toml
 polyglot-sql = {
-    version = "0.13.1",
+    version = "0.13.2",
     default-features = false,
     features = ["dialect-clickhouse"],
 }
@@ -44,14 +44,14 @@ Examples:
 ```toml
 # Parse and generate SQL for one dialect.
 polyglot-sql = {
-    version = "0.13.1",
+    version = "0.13.2",
     default-features = false,
     features = ["generate", "dialect-clickhouse"],
 }
 
 # Cross-dialect transpilation.
 polyglot-sql = {
-    version = "0.13.1",
+    version = "0.13.2",
     default-features = false,
     features = ["transpile", "dialect-clickhouse", "dialect-postgresql"],
 }

{polyglot_sql-0.13.1 → polyglot_sql-0.13.2}/crates/polyglot-sql/src/dialects/duckdb.rs

@@ -103,6 +103,8 @@ impl DialectImpl for DuckDBDialect {
         config.nested_comments = true;
         // DuckDB allows underscores as digit separators in numeric literals
         config.numbers_can_be_underscore_separated = true;
+        // `//` is integer division (same tokenizer-level recognition as Vertica)
+        config.double_slash_int_div = true;
         config
     }
 

{polyglot_sql-0.13.1 → polyglot_sql-0.13.2}/crates/polyglot-sql/src/dialects/mod.rs

@@ -298,6 +298,20 @@ impl DialectType {
             DialectType::TSQL | DialectType::Fabric | DialectType::MySQL | DialectType::SQLite
         ) || (matches!(self, DialectType::DuckDB) && explicit_as)
     }
+
+    /// Whether this dialect natively accepts DuckDB-style `ORDER BY ALL`
+    /// (a bare `ALL` keyword meaning "every projected column, in order").
+    /// Other targets need it rewritten to positional `ORDER BY 1, 2, ...`.
+    pub(crate) const fn supports_order_by_all(self) -> bool {
+        matches!(
+            self,
+            DialectType::DuckDB
+                | DialectType::Snowflake
+                | DialectType::ClickHouse
+                | DialectType::Databricks
+                | DialectType::Spark
+        )
+    }
 }
 
 impl Default for DialectType {
@@ -648,6 +662,189 @@ fn is_default_presto_date_format(fmt: &str) -> bool {
     fmt == "%Y-%m-%d" || fmt == "%F"
 }
 
+/// The parser marks the ORDER BY ALL keyword as a Var, never an identifier.
+#[cfg(feature = "generate")]
+pub(crate) fn is_order_by_all_marker(e: &Expression) -> bool {
+    matches!(e, Expression::Var(v) if v.this.eq_ignore_ascii_case("all"))
+}
+
+#[cfg(feature = "transpile")]
+fn is_order_by_all(order_by: &Option<crate::expressions::OrderBy>) -> bool {
+    order_by.as_ref().is_some_and(|ob| {
+        ob.expressions.len() == 1 && is_order_by_all_marker(&ob.expressions[0].this)
+    })
+}
+
+/// Whether `e` is a projection item that can produce more or fewer than one
+/// output column (`*`, or DuckDB's `COLUMNS(...)` macro), making the output
+/// column count unknowable from the AST alone.
+#[cfg(feature = "transpile")]
+fn has_unknown_column_count(e: &Expression) -> bool {
+    use crate::expressions::Expression as E;
+    let mut inner = e;
+    loop {
+        inner = match inner {
+            E::Alias(a) => &a.this,
+            E::Paren(p) => &p.this,
+            _ => break,
+        };
+    }
+    if matches!(inner, E::Star(_)) {
+        return true;
+    }
+    // COLUMNS still expands inside arithmetic, casts and aggregate/function
+    // arguments. COUNT(*) and scalar subqueries, however, produce one column.
+    contains_in_projection(inner, |node| match node {
+        E::Columns(_) => true,
+        E::Function(f) => {
+            !f.quoted && f.qualified_name.is_empty() && f.name.eq_ignore_ascii_case("COLUMNS")
+        }
+        E::MethodCall(m) => m.method.name.eq_ignore_ascii_case("COLUMNS"),
+        _ => false,
+    })
+}
+
+#[cfg(feature = "transpile")]
+pub(crate) fn contains_in_projection(
+    e: &Expression,
+    predicate: impl Fn(&Expression) -> bool,
+) -> bool {
+    let mut pending = vec![e];
+    while let Some(node) = pending.pop() {
+        if matches!(
+            node,
+            Expression::Subquery(_) | Expression::Select(_) | Expression::Exists(_)
+        ) {
+            continue;
+        }
+        if predicate(node) {
+            return true;
+        }
+        crate::ast_children::for_each_child_untracked(node, |child| pending.push(child));
+    }
+    false
+}
+
+/// The number of columns a query block projects, when that count is known
+/// statically from the AST. Compound queries (UNION/INTERSECT/EXCEPT) take
+/// their width from the left-hand operand, per standard SQL set-operation
+/// rules (both sides must already agree on column count).
+#[cfg(feature = "transpile")]
+fn query_output_width(e: &Expression) -> Option<usize> {
+    use crate::expressions::Expression as E;
+    match e {
+        E::Select(sel) => {
+            if sel.expressions.is_empty() || sel.expressions.iter().any(has_unknown_column_count) {
+                None
+            } else {
+                Some(sel.expressions.len())
+            }
+        }
+        E::Paren(p) => query_output_width(&p.this),
+        E::Subquery(s) => query_output_width(&s.this),
+        E::Union(u) if !u.by_name => query_output_width(&u.left),
+        E::Intersect(i) => query_output_width(&i.left),
+        E::Except(ex) => query_output_width(&ex.left),
+        _ => None,
+    }
+}
+
+/// Rewrite an `ORDER BY ALL` clause into positional `ORDER BY 1..n` over
+/// `width` columns, in place. No-op if `order_by` isn't the ALL marker.
+/// Errors if the marker is present but `width` is unknown (e.g. a `*` or
+/// `COLUMNS(...)` projection, where positional ordinals can't be derived).
+///
+/// The source's explicit direction and NULL order (if any) carry over to each
+/// positional entry unchanged; the later cross-dialect NULL-ordering pass
+/// fills in the source dialect's implied default where the target's differs.
+/// MySQL is the exception: it has no NULLS FIRST/LAST syntax and is skipped by
+/// that pass, so compare every supported source's default against MySQL here.
+#[cfg(feature = "transpile")]
+fn expand_order_by_all(
+    order_by: &mut Option<crate::expressions::OrderBy>,
+    width: Option<usize>,
+    source: DialectType,
+    target: DialectType,
+) -> Result<()> {
+    use crate::expressions::Expression as E;
+    if !is_order_by_all(order_by) {
+        return Ok(());
+    }
+    let Some(n) = width else {
+        return Err(crate::error::Error::unsupported(
+            "ORDER BY ALL over a projection with an unknown column count (*, COLUMNS(...), or UNION BY NAME) cannot be expanded to positional ORDER BY",
+            target.to_string(),
+        ));
+    };
+    let ob = order_by.as_mut().unwrap();
+    let (desc, nulls_first) = (ob.expressions[0].desc, ob.expressions[0].nulls_first);
+
+    // An ordinal cannot be used inside a CASE expression to emulate NULL
+    // placement: it would become a constant instead of a column reference.
+    if matches!(target, DialectType::MySQL) {
+        let required_nulls_first = nulls_first.unwrap_or(match source {
+            DialectType::DuckDB | DialectType::ClickHouse => false,
+            DialectType::Snowflake => desc,
+            DialectType::Spark | DialectType::Databricks => !desc,
+            _ => unreachable!("ORDER BY ALL source capability must be checked"),
+        });
+        if required_nulls_first != !desc {
+            return Err(crate::error::Error::unsupported(
+                "ORDER BY ALL's NULL ordering (MySQL's default NULL placement does not match and cannot be emulated with positional ordering)",
+                target.to_string(),
+            ));
+        }
+    }
+
+    ob.expressions = (1..=n as i64)
+        .map(|i| {
+            let mut o = ob.expressions[0].clone();
+            o.this = E::number(i);
+            if target == DialectType::MySQL {
+                // Matching explicit NULL placement is redundant and MySQL
+                // cannot print the NULLS FIRST/LAST syntax.
+                o.nulls_first = None;
+            }
+            o
+        })
+        .collect();
+    Ok(())
+}
+
+/// Expand when the target lacks ALL, or when a native target cannot use it
+/// for this query (aggregate projections in Snowflake, DISTINCT ON emulation).
+#[cfg(feature = "transpile")]
+fn expand_select_order_by_all(
+    mut sel: Box<crate::expressions::Select>,
+    source: DialectType,
+    target: DialectType,
+) -> Result<Box<crate::expressions::Select>> {
+    if !is_order_by_all(&sel.order_by) {
+        return Ok(sel);
+    }
+    let emulate_distinct = sel
+        .distinct_on
+        .as_ref()
+        .is_some_and(|cols| !cols.is_empty())
+        && !Dialect::target_supports_distinct_on(target);
+    let snowflake_aggregate = target == DialectType::Snowflake
+        && sel
+            .expressions
+            .iter()
+            .any(|e| contains_in_projection(e, crate::traversal::is_aggregate));
+    if target.supports_order_by_all() && !emulate_distinct && !snowflake_aggregate {
+        return Ok(sel);
+    }
+    let width =
+        if sel.expressions.is_empty() || sel.expressions.iter().any(has_unknown_column_count) {
+            None
+        } else {
+            Some(sel.expressions.len())
+        };
+    expand_order_by_all(&mut sel.order_by, width, source, target)?;
+    Ok(sel)
+}
+
 /// Applies a dialect transform bottom-up through selected syntax children.
 ///
 /// The public entrypoint uses an explicit task stack for the recursion-heavy shapes
@@ -708,6 +905,7 @@ where
             Expression::Union(set_op) => set_op.with.is_none() && set_op.order_by.is_none(),
             Expression::Intersect(set_op) => set_op.with.is_none() && set_op.order_by.is_none(),
             Expression::Except(set_op) => set_op.with.is_none() && set_op.order_by.is_none(),
+            Expression::Subquery(subquery) => subquery.order_by.is_none(),
             Expression::Vertica(_)
             | Expression::Literal(_)
             | Expression::Boolean(_)
@@ -725,7 +923,6 @@ where
             | Expression::IsNull(_)
             | Expression::IsTrue(_)
             | Expression::IsFalse(_)
-            | Expression::Subquery(_)
             | Expression::Exists(_)
             | Expression::Any(_)
             | Expression::All(_)
@@ -736,6 +933,7 @@ where
             | Expression::Sub(_)
             | Expression::Mul(_)
             | Expression::Div(_)
+            | Expression::IntDiv(_)
             | Expression::Eq(_)
             | Expression::NullSafeEq(_)
             | Expression::NullSafeNeq(_)
@@ -1596,6 +1794,9 @@ where
         // ===== Subquery expressions =====
         Expression::Subquery(mut s) => {
             s.this = transform_recursive(s.this, transform_fn)?;
+            if let Some(order_by) = s.order_by.take() {
+                s.order_by = Some(transform_order_by_recursive(order_by, transform_fn)?);
+            }
             Expression::Subquery(s)
         }
         Expression::Exists(mut e) => {
@@ -3515,16 +3716,57 @@ impl Dialect {
                 let expr =
                     normalization::vertica::prepare_conversion(expr, self.dialect_type, target)?;
                 normalization::vertica::validate_conversion(&expr, self.dialect_type, target)?;
+                let expr = normalization::duckdb::prepare_integer_division(
+                    expr,
+                    self.dialect_type,
+                    target,
+                )?;
                 // DuckDB source: normalize VARCHAR/CHAR to TEXT (DuckDB doesn't support
                 // VARCHAR length constraints). This emulates Python sqlglot's DuckDB parser
                 // where VARCHAR_LENGTH = None and VARCHAR maps to TEXT.
-                let expr = if matches!(self.dialect_type, DialectType::DuckDB) {
+                //
+                // Any source with native `ORDER BY ALL`: expand it to positional
+                // `ORDER BY 1..n` for targets without it, on both plain SELECTs and
+                // compound queries (whose ORDER BY lives on the set-op node).
+                let source = self.dialect_type;
+                let is_duckdb = matches!(source, DialectType::DuckDB);
+                let expand_all = source.supports_order_by_all() && !target.supports_order_by_all();
+                let expr = if source.supports_order_by_all() {
                     use crate::expressions::DataType as DT;
                     transform_recursive(expr, &|e| match e {
-                        Expression::DataType(DT::VarChar { .. }) => {
+                        Expression::DataType(DT::VarChar { .. }) if is_duckdb => {
+                            Ok(Expression::DataType(DT::Text))
+                        }
+                        Expression::DataType(DT::Char { .. }) if is_duckdb => {
                             Ok(Expression::DataType(DT::Text))
                         }
-                        Expression::DataType(DT::Char { .. }) => Ok(Expression::DataType(DT::Text)),
+                        Expression::Select(sel) => {
+                            expand_select_order_by_all(sel, source, target).map(Expression::Select)
+                        }
+                        Expression::Subquery(mut subquery) if expand_all => {
+                            let width = query_output_width(&subquery.this);
+                            expand_order_by_all(&mut subquery.order_by, width, source, target)?;
+                            Ok(Expression::Subquery(subquery))
+                        }
+                        Expression::Union(mut u) if expand_all => {
+                            let width = if u.by_name {
+                                None
+                            } else {
+                                query_output_width(&u.left)
+                            };
+                            expand_order_by_all(&mut u.order_by, width, source, target)?;
+                            Ok(Expression::Union(u))
+                        }
+                        Expression::Intersect(mut i) if expand_all => {
+                            let width = query_output_width(&i.left);
+                            expand_order_by_all(&mut i.order_by, width, source, target)?;
+                            Ok(Expression::Intersect(i))
+                        }
+                        Expression::Except(mut ex) if expand_all => {
+                            let width = query_output_width(&ex.left);
+                            expand_order_by_all(&mut ex.order_by, width, source, target)?;
+                            Ok(Expression::Except(ex))
+                        }
                         _ => Ok(e),
                     })?
                 } else {

polyglot_sql-0.13.2/crates/polyglot-sql/src/dialects/normalization/duckdb.rs

@@ -0,0 +1,107 @@
+//! Preserve DuckDB's type-dependent `//` semantics before target rewrites.
+
+use super::scalar::{expression_numeric_kind, NumericKind};
+use super::*;
+
+fn combine(left: NumericKind, right: NumericKind) -> NumericKind {
+    use NumericKind::*;
+    match (left, right) {
+        (Unknown, _) | (_, Unknown) => Unknown,
+        (Float, _) | (_, Float) => Float,
+        (Decimal, _) | (_, Decimal) => Decimal,
+        (Integer, Integer) => Integer,
+    }
+}
+
+fn numeric_kind(expr: &Expression) -> NumericKind {
+    match expr {
+        Expression::Paren(p) => numeric_kind(&p.this),
+        Expression::Neg(n) => numeric_kind(&n.this),
+        Expression::Alias(a) => numeric_kind(&a.this),
+        Expression::Add(b) | Expression::Sub(b) | Expression::Mul(b) | Expression::Mod(b) => {
+            combine(numeric_kind(&b.left), numeric_kind(&b.right))
+        }
+        // The complete bottom-up source pass has already lowered fractional
+        // children to Div. Remaining IntDiv children have integer operands.
+        Expression::IntDiv(_) => NumericKind::Integer,
+        Expression::Div(_) => NumericKind::Float,
+        Expression::Function(f) if f.name.eq_ignore_ascii_case("NULLIF") && f.args.len() == 2 => {
+            numeric_kind(&f.args[0])
+        }
+        Expression::NullIf(f) => numeric_kind(&f.this),
+        _ => expression_numeric_kind(expr),
+    }
+}
+
+pub(in crate::dialects) fn prepare_integer_division(
+    expr: Expression,
+    source: DialectType,
+    target: DialectType,
+) -> Result<Expression> {
+    if source != DialectType::DuckDB || target == DialectType::DuckDB {
+        return Ok(expr);
+    }
+
+    // Visit every physical child, including typed function arguments and both
+    // operands of nested IntDiv nodes, before lowering the enclosing operator.
+    crate::traversal::transform_all(expr, &|expr| {
+        let Expression::IntDiv(mut division) = expr else {
+            return Ok(expr);
+        };
+        let left_kind = numeric_kind(&division.this);
+        let right_kind = numeric_kind(&division.expression);
+        let kind = combine(left_kind, right_kind);
+        if kind == NumericKind::Unknown {
+            return Err(crate::error::Error::unsupported(
+                "DuckDB // with unresolved operand types; use explicit numeric casts",
+                target.to_string(),
+            ));
+        }
+
+        // NULLIF evaluates the divisor once and preserves NULL on zero for
+        // literals, casts, computed expressions, and values only known at runtime.
+        division.expression = Expression::Function(Box::new(Function::new(
+            "NULLIF".to_string(),
+            vec![division.expression, Expression::number(0)],
+        )));
+
+        if kind != NumericKind::Integer {
+            // DuckDB decimal division produces DOUBLE, whereas some targets
+            // keep decimal arithmetic (and SQLite may treat DECIMAL as INTEGER).
+            // An explicitly floating operand already establishes float division.
+            if kind == NumericKind::Decimal {
+                division.this = super::operators::cast_expr(
+                    division.this,
+                    DataType::Double {
+                        precision: None,
+                        scale: None,
+                    },
+                );
+            }
+            return Ok(Expression::Div(Box::new(BinaryOp::new(
+                division.this,
+                division.expression,
+            ))));
+        }
+
+        // Only use IntDiv where generation has a native or exact lowering.
+        // A generic DIV(...) call is invalid in several other targets.
+        if !matches!(
+            target,
+            DialectType::PostgreSQL
+                | DialectType::BigQuery
+                | DialectType::ClickHouse
+                | DialectType::SQLite
+                | DialectType::Vertica
+                | DialectType::Hive
+                | DialectType::Spark
+                | DialectType::Databricks
+        ) {
+            return Err(crate::error::Error::unsupported(
+                "DuckDB integer // conversion",
+                target.to_string(),
+            ));
+        }
+        Ok(Expression::IntDiv(division))
+    })
+}

{polyglot_sql-0.13.1 → polyglot_sql-0.13.2}/crates/polyglot-sql/src/dialects/normalization/mod.rs

@@ -8,6 +8,7 @@ use super::*;
 
 mod aggregates;
 mod collections;
+pub(in crate::dialects) mod duckdb;
 mod hana;
 mod json;
 mod operators;

{polyglot_sql-0.13.1 → polyglot_sql-0.13.2}/crates/polyglot-sql/src/generator.rs

@@ -3448,17 +3448,33 @@ impl Generator {
             Expression::Div(op) => self.generate_precedence_binary_op(op, "/", InfixOperator::Div),
             Expression::IntDiv(f) => {
                 use crate::dialects::DialectType;
-                if matches!(self.config.dialect, Some(DialectType::ClickHouse)) {
+                let is_native_slash_op = matches!(
+                    self.config.dialect,
+                    Some(DialectType::DuckDB) | Some(DialectType::Vertica)
+                );
+                if matches!(self.config.dialect, Some(DialectType::SQLite)) {
+                    // Keep native integer arithmetic exact above 2^53. The
+                    // outer cast truncates floating operands for other sources
+                    // whose IntDiv always truncates (e.g. MySQL and Vertica).
+                    self.write_keyword("CAST");
+                    self.write("(");
+                    self.generate_infix_operand(InfixOperator::Div, &f.this, OperandSide::Left)?;
+                    self.write(" / ");
+                    self.generate_infix_operand(
+                        InfixOperator::Div,
+                        &f.expression,
+                        OperandSide::Right,
+                    )?;
+                    self.write(" AS INTEGER)");
+                    Ok(())
+                } else if matches!(self.config.dialect, Some(DialectType::ClickHouse)) {
                     self.write("intDiv(");
                     self.generate_expression(&f.this)?;
                     self.write(", ");
                     self.generate_expression(&f.expression)?;
                     self.write(")");
                     Ok(())
-                } else if matches!(
-                    self.config.dialect,
-                    Some(DialectType::DuckDB) | Some(DialectType::Vertica)
-                ) {
+                } else if is_native_slash_op {
                     // DuckDB and Vertica use // operator for integer division
                     self.generate_expression(&f.this)?;
                     self.write(" // ");
@@ -27118,7 +27134,22 @@ impl Generator {
             }
         }
 
-        self.generate_expression(&ordered.this)?;
+        // Only a parser-marked keyword bypasses ordinary identifier quoting.
+        if crate::dialects::is_order_by_all_marker(&ordered.this) {
+            if !self
+                .config
+                .dialect
+                .is_some_and(|d| d.supports_order_by_all())
+            {
+                return Err(crate::error::Error::unsupported(
+                    "ORDER BY ALL must be expanded before generation",
+                    format!("{:?}", self.config.dialect),
+                ));
+            }
+            self.write_keyword("ALL");
+        } else {
+            self.generate_expression(&ordered.this)?;
+        }
         if ordered.desc {
             self.write_space();
             self.write_keyword("DESC");

{polyglot_sql-0.13.1 → polyglot_sql-0.13.2}/crates/polyglot-sql/src/parser.rs

@@ -8962,6 +8962,7 @@ impl Parser {
             }
         }
 
+        self.mark_order_by_all(&mut expressions);
         Ok(OrderBy {
             expressions,
             siblings,
@@ -8969,6 +8970,26 @@ impl Parser {
         })
     }
 
+    /// Keep the query-level ALL keyword separate from identifiers, including
+    /// columns subsequently created by builders or rename_columns. Var is the
+    /// AST's unquoted keyword representation (also used for LIMIT ALL).
+    fn mark_order_by_all(&self, expressions: &mut [Ordered]) {
+        if !self
+            .config
+            .dialect
+            .is_some_and(|d| d.supports_order_by_all())
+        {
+            return;
+        }
+        if let [ordered] = expressions {
+            if matches!(&ordered.this, Expression::Column(c)
+                if c.table.is_none() && !c.name.quoted && c.name.name.eq_ignore_ascii_case("all"))
+            {
+                ordered.this = Expression::Var(Box::new(Var { this: "ALL".into() }));
+            }
+        }
+    }
+
     /// Parse a LIMIT count without mistaking a trailing percent sign for modulo.
     fn parse_limit_value(&mut self) -> Result<(Expression, bool)> {
         let saved_pos = self.current;
@@ -58458,6 +58479,7 @@ impl Parser {
             }
         }
 
+        self.mark_order_by_all(&mut expressions);
         Ok(Some(Expression::OrderBy(Box::new(OrderBy {
             expressions,
             siblings: false,