polyglot-sql 0.13.4__tar.gz → 0.13.5__tar.gz

{polyglot_sql-0.13.4 → polyglot_sql-0.13.5}/Cargo.lock

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

{polyglot_sql-0.13.4 → polyglot_sql-0.13.5}/Cargo.toml

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

{polyglot_sql-0.13.4 → polyglot_sql-0.13.5}/PKG-INFO

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

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

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

{polyglot_sql-0.13.4 → polyglot_sql-0.13.5}/crates/polyglot-sql/src/dialects/mod.rs

@@ -757,8 +757,8 @@ fn query_output_width(e: &Expression) -> Option<usize> {
 /// 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.
+/// MySQL additionally checks placement here because a known width alone does
+/// not establish that every generated ordinal can be resolved to an expression.
 #[cfg(feature = "transpile")]
 fn expand_order_by_all(
     order_by: &mut Option<crate::expressions::OrderBy>,
@@ -800,11 +800,8 @@ fn expand_order_by_all(
         .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;
-            }
+            // Keep explicit placement until generation. Clearing it here would
+            // make normalization substitute the source dialect's implicit default.
             o
         })
         .collect();
@@ -3440,6 +3437,7 @@ impl Dialect {
             feature = "dialect-sqlite",
             feature = "dialect-trino",
             feature = "dialect-presto",
+            feature = "dialect-athena",
             feature = "dialect-duckdb",
             feature = "dialect-redshift",
             feature = "dialect-starrocks",
@@ -3583,6 +3581,12 @@ impl Dialect {
                 let expr = transforms::explode_projection_to_unnest(expr, DialectType::Presto)?;
                 Ok(expr)
             }
+            #[cfg(feature = "dialect-athena")]
+            DialectType::Athena => {
+                let expr = transforms::eliminate_qualify(expr)?;
+                let expr = transforms::eliminate_window_clause(expr)?;
+                transforms::explode_projection_to_unnest(expr, DialectType::Athena)
+            }
             // DuckDB supports QUALIFY - no elimination needed
             // Expand POSEXPLODE to GENERATE_SUBSCRIPTS + UNNEST
             // Expand LIKE ANY / ILIKE ANY to OR chains (DuckDB doesn't support quantifiers)
@@ -3592,15 +3596,14 @@ impl Dialect {
                 let expr = transforms::expand_like_any(expr)?;
                 Ok(expr)
             }
-            // Redshift doesn't support QUALIFY, WINDOW clause, or GENERATE_DATE_ARRAY
+            // Redshift supports QUALIFY, but not WINDOW or GENERATE_DATE_ARRAY.
             #[cfg(feature = "dialect-redshift")]
             DialectType::Redshift => {
-                let expr = transforms::eliminate_qualify(expr)?;
                 let expr = transforms::eliminate_window_clause(expr)?;
                 let expr = transforms::unnest_generate_date_array_using_recursive_cte(expr)?;
                 Ok(expr)
             }
-            // StarRocks doesn't support BETWEEN in DELETE statements or QUALIFY
+            // StarRocks supports only restricted QUALIFY forms; lower the general form.
             #[cfg(feature = "dialect-starrocks")]
             DialectType::StarRocks => {
                 let expr = transforms::eliminate_qualify(expr)?;
@@ -4333,6 +4336,11 @@ impl Dialect {
                     normalized
                 };
 
+                let normalized = crate::transforms::lower_set_operations_by_name(
+                    normalized,
+                    self.dialect_type,
+                    target,
+                )?;
                 let transformed =
                     target_dialect.transform_with_guard(normalized, opts.complexity_guard)?;
 

{polyglot_sql-0.13.4 → polyglot_sql-0.13.5}/crates/polyglot-sql/src/dialects/normalization/mod.rs

@@ -2746,33 +2746,13 @@ pub(super) fn normalize(
                 // When nulls_first is not specified, fill in the source dialect's implied
                 // default so the target generator can correctly add/strip NULLS FIRST/LAST.
                 Expression::Ordered(o) => {
-                    // MySQL doesn't support NULLS FIRST/LAST - strip or rewrite
-                    if matches!(target, DialectType::MySQL) && o.nulls_first.is_some() {
-                        Action::Operators(operators::Action::MysqlNullsOrdering)
+                    if o.nulls_first.is_none()
+                        && source != target
+                        && source != DialectType::Vertica
+                    {
+                        Action::Operators(operators::Action::NullsOrdering)
                     } else {
-                        // Skip targets that don't support NULLS FIRST/LAST syntax unless
-                        // the generator can preserve semantics with a CASE sort key.
-                        let target_rewrites_nulls =
-                            matches!(target, DialectType::TSQL | DialectType::Fabric);
-                        let target_supports_nulls = !matches!(
-                            target,
-                            DialectType::MySQL
-                                | DialectType::TSQL
-                                | DialectType::Fabric
-                                | DialectType::StarRocks
-                                | DialectType::Doris
-                        );
-                        // Vertica's implicit NULL placement depends on the sort key's data
-                        // type (NULLS AUTO), so there is no source default to make explicit.
-                        if o.nulls_first.is_none()
-                            && source != target
-                            && source != DialectType::Vertica
-                            && (target_supports_nulls || target_rewrites_nulls)
-                        {
-                            Action::Operators(operators::Action::NullsOrdering)
-                        } else {
-                            Action::None
-                        }
+                        Action::None
                     }
                 }
                 // BigQuery data types: convert INT64, BYTES, NUMERIC etc. to standard types
@@ -3556,7 +3536,6 @@ pub(super) fn normalize(
                     Action::Collections(collections::Action::ArrayIndexConvert)
                 }
                 // ANY_VALUE IGNORE NULLS detection moved to the AnyValue arm above
-                // MysqlNullsOrdering for Ordered is now handled in the Ordered arm above
                 // RESPECT NULLS handling for SQLite (strip it, add NULLS LAST to ORDER BY)
                 // and for MySQL (rewrite ORDER BY with CASE WHEN for null ordering)
                 Expression::WindowFunction(ref wf) => {
@@ -3569,25 +3548,7 @@ pub(super) fn normalize(
                         && wf.over.order_by.iter().any(|o| o.nulls_first.is_some())
                     {
                         Action::Operators(operators::Action::BigQueryNullsOrdering)
-                    // DuckDB -> MySQL: Add CASE WHEN for NULLS LAST simulation in window ORDER BY
-                    // But NOT when frame is RANGE/GROUPS, since adding CASE WHEN would break value-based frames
                     } else {
-                        let source_nulls_last = matches!(source, DialectType::DuckDB);
-                        let has_range_frame = wf.over.frame.as_ref().map_or(false, |f| {
-                            matches!(
-                                f.kind,
-                                crate::expressions::WindowFrameKind::Range
-                                    | crate::expressions::WindowFrameKind::Groups
-                            )
-                        });
-                        if source_nulls_last
-                            && matches!(target, DialectType::MySQL)
-                            && !wf.over.order_by.is_empty()
-                            && wf.over.order_by.iter().any(|o| !o.desc)
-                            && !has_range_frame
-                        {
-                            Action::Scalar(scalar::Action::MysqlNullsLastRewrite)
-                        } else {
                             // Check for Snowflake window frame handling for FIRST_VALUE/LAST_VALUE/NTH_VALUE
                             let is_ranking_window_func = matches!(
                                 &wf.this,
@@ -3639,7 +3600,6 @@ pub(super) fn normalize(
                                     _ => Action::None,
                                 }
                             }
-                        }
                     }
                 }
                 // CREATE TABLE a LIKE b -> dialect-specific transformations

{polyglot_sql-0.13.4 → polyglot_sql-0.13.5}/crates/polyglot-sql/src/dialects/normalization/operators.rs

@@ -20,7 +20,6 @@ pub(super) enum Action {
     DollarParamConvert,
     AnyToExists,
     RespectNullsConvert,
-    MysqlNullsOrdering,
     BigQueryNullsOrdering,
     PipeConcatToConcat,
     PostgresPipeConcatToTsql,
@@ -691,57 +690,6 @@ pub(super) fn rewrite(
                 }
             }
 
-            Action::MysqlNullsOrdering => {
-                // MySQL doesn't support NULLS FIRST/LAST - strip or rewrite
-                if let Expression::Ordered(mut o) = e {
-                    let nulls_last = o.nulls_first == Some(false);
-                    let desc = o.desc;
-                    // MySQL default: ASC -> NULLS LAST, DESC -> NULLS FIRST
-                    // If requested ordering matches default, just strip NULLS clause
-                    let matches_default = if desc {
-                        // DESC default is NULLS FIRST, so nulls_first=true matches
-                        o.nulls_first == Some(true)
-                    } else {
-                        // ASC default is NULLS LAST, so nulls_first=false matches
-                        nulls_last
-                    };
-                    if matches_default {
-                        o.nulls_first = None;
-                        Ok(Expression::Ordered(o))
-                    } else {
-                        // Need CASE WHEN x IS NULL THEN 0/1 ELSE 0/1 END, x
-                        // For ASC NULLS FIRST: ORDER BY CASE WHEN x IS NULL THEN 0 ELSE 1 END, x ASC
-                        // For DESC NULLS LAST: ORDER BY CASE WHEN x IS NULL THEN 1 ELSE 0 END, x DESC
-                        let null_val = if desc { 1 } else { 0 };
-                        let non_null_val = if desc { 0 } else { 1 };
-                        let _case_expr = Expression::Case(Box::new(Case {
-                            operand: None,
-                            whens: vec![(
-                                Expression::IsNull(Box::new(crate::expressions::IsNull {
-                                    this: o.this.clone(),
-                                    not: false,
-                                    postfix_form: false,
-                                })),
-                                Expression::number(null_val),
-                            )],
-                            else_: Some(Expression::number(non_null_val)),
-                            comments: Vec::new(),
-                            inferred_type: None,
-                        }));
-                        o.nulls_first = None;
-                        // Return a tuple of [case_expr, ordered_expr]
-                        // We need to return both as part of the ORDER BY
-                        // But since transform_recursive processes individual expressions,
-                        // we can't easily add extra ORDER BY items here.
-                        // Instead, strip the nulls_first
-                        o.nulls_first = None;
-                        Ok(Expression::Ordered(o))
-                    }
-                } else {
-                    Ok(e)
-                }
-            }
-
             Action::BigQueryNullsOrdering => {
                 // BigQuery doesn't support NULLS FIRST/LAST in window function ORDER BY
                 if let Expression::WindowFunction(mut wf) = e {

{polyglot_sql-0.13.4 → polyglot_sql-0.13.5}/crates/polyglot-sql/src/dialects/normalization/scalar.rs

@@ -73,7 +73,6 @@ pub(super) enum Action {
     CurrentUserParens,
     EscapeStringNormalize,
     SnowflakeIntervalFormat,
-    MysqlNullsLastRewrite,
     FilterToIff,
     StrPositionExpand,
     CurrentUserSparkParens,
@@ -11247,57 +11246,6 @@ pub(super) fn rewrite(
                 }
             }
 
-            Action::MysqlNullsLastRewrite => {
-                // DuckDB -> MySQL: Add CASE WHEN IS NULL THEN 1 ELSE 0 END to ORDER BY
-                // to simulate NULLS LAST for ASC ordering
-                if let Expression::WindowFunction(mut wf) = e {
-                    let mut new_order_by = Vec::new();
-                    for o in wf.over.order_by {
-                        if !o.desc {
-                            // ASC: DuckDB has NULLS LAST, MySQL has NULLS FIRST
-                            // Add CASE WHEN expr IS NULL THEN 1 ELSE 0 END before expr
-                            let case_expr = Expression::Case(Box::new(Case {
-                                operand: None,
-                                whens: vec![(
-                                    Expression::IsNull(Box::new(crate::expressions::IsNull {
-                                        this: o.this.clone(),
-                                        not: false,
-                                        postfix_form: false,
-                                    })),
-                                    Expression::Literal(Box::new(Literal::Number("1".to_string()))),
-                                )],
-                                else_: Some(Expression::Literal(Box::new(Literal::Number(
-                                    "0".to_string(),
-                                )))),
-                                comments: Vec::new(),
-                                inferred_type: None,
-                            }));
-                            new_order_by.push(crate::expressions::Ordered {
-                                nulls_auto: false,
-                                this: case_expr,
-                                desc: false,
-                                nulls_first: None,
-                                explicit_asc: false,
-                                with_fill: None,
-                            });
-                            let mut ordered = o;
-                            ordered.nulls_first = None;
-                            new_order_by.push(ordered);
-                        } else {
-                            // DESC: DuckDB has NULLS LAST, MySQL also has NULLS LAST (NULLs smallest in DESC)
-                            // No change needed
-                            let mut ordered = o;
-                            ordered.nulls_first = None;
-                            new_order_by.push(ordered);
-                        }
-                    }
-                    wf.over.order_by = new_order_by;
-                    Ok(Expression::WindowFunction(wf))
-                } else {
-                    Ok(e)
-                }
-            }
-
             Action::FilterToIff => {
                 // FILTER(WHERE cond) -> rewrite aggregate: AGG(IFF(cond, val, NULL))
                 if let Expression::Filter(f) = e {

{polyglot_sql-0.13.4 → polyglot_sql-0.13.5}/crates/polyglot-sql/src/dialects/starrocks.rs

@@ -50,7 +50,7 @@ impl DialectImpl for StarRocksDialect {
             // StarRocks: PROPERTIES prefix for WITH properties
             with_properties_prefix: "PROPERTIES",
             // StarRocks uses MySQL-style settings
-            null_ordering_supported: false,
+            null_ordering_supported: true,
             limit_only_literals: true,
             semi_anti_join_with_side: false,
             supports_table_alias_columns: false,

{polyglot_sql-0.13.4 → polyglot_sql-0.13.5}/crates/polyglot-sql/src/expressions.rs

@@ -3681,6 +3681,186 @@ pub struct Star {
     pub span: Option<Span>,
 }
 
+impl Star {
+    /// Apply EXCEPT, REPLACE, and RENAME to the expanded `column` named `name`.
+    /// Returns `None` when EXCEPT removes the column.
+    #[cfg(feature = "semantic")]
+    pub(crate) fn expand_column(
+        &self,
+        name: &str,
+        column: Expression,
+        dialect: Option<crate::dialects::DialectType>,
+    ) -> Option<Expression> {
+        if self.excludes(name, dialect) {
+            return None;
+        }
+        let renamed = self.renamed(name, dialect);
+        if let Some(replacement) = self.replacement(name, dialect) {
+            let mut replacement = replacement.clone();
+            if let Some(alias) = renamed {
+                replacement.alias = alias;
+            }
+            return Some(Expression::Alias(Box::new(replacement)));
+        }
+        Some(match renamed {
+            Some(alias) => Expression::Alias(Box::new(Alias::new(column, alias))),
+            None => column,
+        })
+    }
+
+    /// Whether EXCEPT holds a ClickHouse pattern string (`EXCEPT ('re')`).
+    /// The columns it removes are not known, so the star stays unexpanded.
+    #[cfg(any(feature = "semantic", test))]
+    pub(crate) fn has_except_pattern(&self) -> bool {
+        self.except.iter().flatten().any(is_except_pattern)
+    }
+
+    /// Whether EXCEPT / EXCLUDE removes the column `name`.
+    #[cfg(feature = "semantic")]
+    pub(crate) fn excludes(
+        &self,
+        name: &str,
+        dialect: Option<crate::dialects::DialectType>,
+    ) -> bool {
+        self.except
+            .iter()
+            .flatten()
+            .any(|column| star_modifier_matches(column, name, dialect))
+    }
+
+    /// The new name RENAME gives to the column `name`. With a known dialect,
+    /// the name gets the identifier normalization that schema columns get.
+    #[cfg(feature = "semantic")]
+    pub(crate) fn renamed(
+        &self,
+        name: &str,
+        dialect: Option<crate::dialects::DialectType>,
+    ) -> Option<Identifier> {
+        let (_, new) = self
+            .rename
+            .iter()
+            .flatten()
+            .find(|(old, _)| star_modifier_matches(old, name, dialect))?;
+        Some(match dialect {
+            Some(_) => crate::optimizer::normalize_identifiers::normalize_identifier(
+                new.clone(),
+                crate::optimizer::normalize_identifiers::get_normalization_strategy(dialect),
+            ),
+            None => new.clone(),
+        })
+    }
+
+    /// The REPLACE expression for the column `name`.
+    #[cfg(feature = "semantic")]
+    pub(crate) fn replacement(
+        &self,
+        name: &str,
+        dialect: Option<crate::dialects::DialectType>,
+    ) -> Option<&Alias> {
+        self.replace
+            .iter()
+            .flatten()
+            .find(|replacement| star_modifier_matches(&replacement.alias, name, dialect))
+    }
+
+    /// The source column that the star outputs as `output`, after RENAME and
+    /// EXCEPT. Returns `None` when the star does not output `output`.
+    #[cfg(feature = "semantic")]
+    pub(crate) fn source_column(
+        &self,
+        output: &str,
+        dialect: Option<crate::dialects::DialectType>,
+    ) -> Option<String> {
+        let renames = self.rename.iter().flatten();
+        let column = match renames
+            .clone()
+            .find(|(_, new)| star_modifier_matches(new, output, dialect))
+        {
+            Some((old, _)) => old.name.clone(),
+            None if renames
+                .clone()
+                .any(|(old, _)| star_modifier_matches(old, output, dialect)) =>
+            {
+                return None
+            }
+            None => output.to_string(),
+        };
+        (!self.excludes(&column, dialect)).then_some(column)
+    }
+}
+
+/// A pattern string keeps its quotes in the name (see `parse_star_except_name`).
+#[cfg(any(feature = "semantic", test))]
+fn is_except_pattern(identifier: &Identifier) -> bool {
+    !identifier.quoted && identifier.name.starts_with('\'')
+}
+
+/// Match a modifier name to the column `name`. A quoted name matches with
+/// its case, unless the dialect ignores case. An unquoted name ignores case,
+/// unless the dialect is case sensitive. A qualified name such as `t.col`
+/// matches on its column part, as in sqlglot. A pattern string never matches.
+#[cfg(feature = "semantic")]
+fn star_modifier_matches(
+    identifier: &Identifier,
+    name: &str,
+    dialect: Option<crate::dialects::DialectType>,
+) -> bool {
+    use crate::optimizer::normalize_identifiers::{
+        get_normalization_strategy, NormalizationStrategy,
+    };
+    use std::borrow::Cow;
+    if is_except_pattern(identifier) {
+        return false;
+    }
+    let text = identifier.name.as_str();
+    let (column, quoted) = if identifier.quoted {
+        (Cow::Borrowed(text), true)
+    } else if let Some(quote) = text.chars().last().filter(|c| matches!(c, '"' | '`')) {
+        // A qualified name keeps the quotes of its parts: `t."col"`.
+        let body = &text[..text.len() - 1];
+        let mut chars = body.char_indices().rev().peekable();
+        let mut opening = None;
+        while let Some((index, ch)) = chars.next() {
+            if ch == quote {
+                if chars.peek().is_some_and(|(_, next)| *next == quote) {
+                    chars.next(); // Skip an escaped quote inside the identifier.
+                } else {
+                    opening = Some(index);
+                    break;
+                }
+            }
+        }
+        match opening {
+            Some(open) => (
+                Cow::Owned(
+                    body[open + 1..].replace(&format!("{quote}{quote}"), &quote.to_string()),
+                ),
+                true,
+            ),
+            None => (Cow::Borrowed(text), false),
+        }
+    } else {
+        (
+            Cow::Borrowed(text.rsplit_once('.').map_or(text, |(_, column)| column)),
+            false,
+        )
+    };
+    let strategy = dialect.map(|dialect| get_normalization_strategy(Some(dialect)));
+    let exact = match strategy {
+        Some(NormalizationStrategy::CaseSensitive) => true,
+        Some(
+            NormalizationStrategy::CaseInsensitive
+            | NormalizationStrategy::CaseInsensitiveUppercase,
+        ) => false,
+        _ => quoted,
+    };
+    if exact {
+        column == name
+    } else {
+        column.eq_ignore_ascii_case(name)
+    }
+}
+
 /// Represent a complete SELECT statement.
 ///
 /// This is the most feature-rich AST node, covering the full surface area of