polyglot-sql 0.3.5__tar.gz → 0.3.6__tar.gz

{polyglot_sql-0.3.5 → polyglot_sql-0.3.6}/Cargo.lock

@@ -605,7 +605,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql"
-version = "0.3.5"
+version = "0.3.6"
 dependencies = [
  "criterion",
  "once_cell",
@@ -621,7 +621,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-ffi"
-version = "0.3.5"
+version = "0.3.6"
 dependencies = [
  "cbindgen",
  "polyglot-sql",
@@ -631,11 +631,11 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-function-catalogs"
-version = "0.3.5"
+version = "0.3.6"
 
 [[package]]
 name = "polyglot-sql-python"
-version = "0.3.5"
+version = "0.3.6"
 dependencies = [
  "polyglot-sql",
  "pyo3",
@@ -646,7 +646,7 @@ dependencies = [
 
 [[package]]
 name = "polyglot-sql-wasm"
-version = "0.3.5"
+version = "0.3.6"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",

{polyglot_sql-0.3.5 → polyglot_sql-0.3.6}/Cargo.toml

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

{polyglot_sql-0.3.5 → polyglot_sql-0.3.6}/PKG-INFO

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

{polyglot_sql-0.3.5 → polyglot_sql-0.3.6}/crates/polyglot-sql/Cargo.toml

@@ -83,7 +83,7 @@ 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.3.5", optional = true, default-features = false }
+polyglot-sql-function-catalogs = { path = "../polyglot-sql-function-catalogs", version = "0.3.6", optional = true, default-features = false }
 
 [dev-dependencies]
 pretty_assertions = "1.4"

{polyglot_sql-0.3.5 → polyglot_sql-0.3.6}/crates/polyglot-sql/src/dialects/databricks.rs

@@ -213,6 +213,37 @@ impl DatabricksDialect {
                 f.args,
             )))),
 
+            // NAMED_STRUCT('a', 1) -> STRUCT(1 AS a) for SQLGlot Databricks outputs
+            "NAMED_STRUCT" if f.args.len() % 2 == 0 => {
+                let original_args = f.args.clone();
+                let mut struct_args = Vec::new();
+                for pair in f.args.chunks(2) {
+                    if let Expression::Literal(lit) = &pair[0] {
+                        if let Literal::String(field_name) = lit.as_ref() {
+                            struct_args.push(Expression::Alias(Box::new(
+                                crate::expressions::Alias {
+                                    this: pair[1].clone(),
+                                    alias: crate::expressions::Identifier::new(field_name),
+                                    column_aliases: Vec::new(),
+                                    pre_alias_comments: Vec::new(),
+                                    trailing_comments: Vec::new(),
+                                    inferred_type: None,
+                                },
+                            )));
+                            continue;
+                        }
+                    }
+                    return Ok(Expression::Function(Box::new(Function::new(
+                        "NAMED_STRUCT".to_string(),
+                        original_args,
+                    ))));
+                }
+                Ok(Expression::Function(Box::new(Function::new(
+                    "STRUCT".to_string(),
+                    struct_args,
+                ))))
+            }
+
             // GETDATE -> CURRENT_TIMESTAMP
             "GETDATE" => Ok(Expression::CurrentTimestamp(
                 crate::expressions::CurrentTimestamp {

{polyglot_sql-0.3.5 → polyglot_sql-0.3.6}/crates/polyglot-sql/src/dialects/duckdb.rs

@@ -3466,10 +3466,27 @@ impl DuckDBDialect {
                     vec![arg, Expression::number(2)],
                 ))))
             }
-            "UUID_STRING" => Ok(Expression::Function(Box::new(Function::new(
-                "UUID".to_string(),
-                vec![],
-            )))),
+            "LIST"
+                if f.args.len() == 1 && !matches!(f.args.first(), Some(Expression::Select(_))) =>
+            {
+                Ok(Expression::Function(Box::new(Function::new(
+                    "ARRAY_AGG".to_string(),
+                    f.args,
+                ))))
+            }
+            "UUID_STRING" => {
+                if f.args.is_empty() {
+                    Ok(Expression::Function(Box::new(Function::new(
+                        "UUID".to_string(),
+                        vec![],
+                    ))))
+                } else {
+                    Ok(Expression::Function(Box::new(Function::new(
+                        "UUID_STRING".to_string(),
+                        f.args,
+                    ))))
+                }
+            }
             "ENDSWITH" => Ok(Expression::Function(Box::new(Function::new(
                 "ENDS_WITH".to_string(),
                 f.args,

{polyglot_sql-0.3.5 → polyglot_sql-0.3.6}/crates/polyglot-sql/src/dialects/mod.rs

@@ -17530,7 +17530,13 @@ impl Dialect {
                                 let mut args = f.args;
                                 let date = args.remove(0);
                                 let interval_expr = args.remove(0);
-                                let (val, unit) = Self::extract_interval_parts(&interval_expr);
+                                let (val, unit) = Self::extract_interval_parts(&interval_expr)
+                                    .unwrap_or_else(|| {
+                                        (
+                                            interval_expr.clone(),
+                                            crate::expressions::IntervalUnit::Day,
+                                        )
+                                    });
                                 let unit_str = Self::interval_unit_to_string(&unit);
                                 let is_literal = matches!(&val,
                                     Expression::Literal(lit) if matches!(lit.as_ref(), Literal::Number(_) | Literal::String(_))
@@ -20841,37 +20847,13 @@ impl Dialect {
                                     _ => Ok(Expression::Function(f)),
                                 }
                             }
-                            // CONCAT_WS('-', args...) -> CONCAT_WS('-', CAST(arg AS VARCHAR), ...) for Presto/Trino
-                            "CONCAT_WS" if f.args.len() >= 2 => match target {
-                                DialectType::Presto | DialectType::Trino | DialectType::Athena => {
-                                    let mut args = f.args;
-                                    let sep = args.remove(0);
-                                    let cast_args: Vec<Expression> = args
-                                        .into_iter()
-                                        .map(|a| {
-                                            Expression::Cast(Box::new(Cast {
-                                                this: a,
-                                                to: DataType::VarChar {
-                                                    length: None,
-                                                    parenthesized_length: false,
-                                                },
-                                                double_colon_syntax: false,
-                                                trailing_comments: Vec::new(),
-                                                format: None,
-                                                default: None,
-                                                inferred_type: None,
-                                            }))
-                                        })
-                                        .collect();
-                                    let mut new_args = vec![sep];
-                                    new_args.extend(cast_args);
-                                    Ok(Expression::Function(Box::new(Function::new(
-                                        "CONCAT_WS".to_string(),
-                                        new_args,
-                                    ))))
-                                }
-                                DialectType::DuckDB => {
-                                    let args = f.args;
+                            // CONCAT_WS from Generic is null-propagating in SQLGlot fixtures.
+                            // Trino also requires non-separator arguments cast to VARCHAR.
+                            "CONCAT_WS" if f.args.len() >= 2 => {
+                                fn concat_ws_null_case(
+                                    args: Vec<Expression>,
+                                    else_expr: Expression,
+                                ) -> Expression {
                                     let mut null_checks = args.iter().cloned().map(|arg| {
                                         Expression::IsNull(Box::new(crate::expressions::IsNull {
                                             this: arg,
@@ -20893,19 +20875,89 @@ impl Dialect {
                                                 inferred_type: None,
                                             }))
                                         });
-                                    Ok(Expression::Case(Box::new(Case {
+                                    Expression::Case(Box::new(Case {
                                         operand: None,
                                         whens: vec![(null_check, Expression::Null(Null))],
-                                        else_: Some(Expression::Function(Box::new(Function::new(
-                                            "CONCAT_WS".to_string(),
-                                            args,
-                                        )))),
+                                        else_: Some(else_expr),
                                         comments: vec![],
                                         inferred_type: None,
-                                    })))
+                                    }))
                                 }
-                                _ => Ok(Expression::Function(f)),
-                            },
+
+                                match target {
+                                    DialectType::Trino
+                                        if matches!(source, DialectType::Generic) =>
+                                    {
+                                        let original_args = f.args.clone();
+                                        let mut args = f.args;
+                                        let sep = args.remove(0);
+                                        let cast_args: Vec<Expression> = args
+                                            .into_iter()
+                                            .map(|a| {
+                                                Expression::Cast(Box::new(Cast {
+                                                    this: a,
+                                                    to: DataType::VarChar {
+                                                        length: None,
+                                                        parenthesized_length: false,
+                                                    },
+                                                    double_colon_syntax: false,
+                                                    trailing_comments: Vec::new(),
+                                                    format: None,
+                                                    default: None,
+                                                    inferred_type: None,
+                                                }))
+                                            })
+                                            .collect();
+                                        let mut new_args = vec![sep];
+                                        new_args.extend(cast_args);
+                                        let else_expr = Expression::Function(Box::new(
+                                            Function::new("CONCAT_WS".to_string(), new_args),
+                                        ));
+                                        Ok(concat_ws_null_case(original_args, else_expr))
+                                    }
+                                    DialectType::Presto
+                                    | DialectType::Trino
+                                    | DialectType::Athena => {
+                                        let mut args = f.args;
+                                        let sep = args.remove(0);
+                                        let cast_args: Vec<Expression> = args
+                                            .into_iter()
+                                            .map(|a| {
+                                                Expression::Cast(Box::new(Cast {
+                                                    this: a,
+                                                    to: DataType::VarChar {
+                                                        length: None,
+                                                        parenthesized_length: false,
+                                                    },
+                                                    double_colon_syntax: false,
+                                                    trailing_comments: Vec::new(),
+                                                    format: None,
+                                                    default: None,
+                                                    inferred_type: None,
+                                                }))
+                                            })
+                                            .collect();
+                                        let mut new_args = vec![sep];
+                                        new_args.extend(cast_args);
+                                        Ok(Expression::Function(Box::new(Function::new(
+                                            "CONCAT_WS".to_string(),
+                                            new_args,
+                                        ))))
+                                    }
+                                    DialectType::Spark
+                                    | DialectType::Hive
+                                    | DialectType::DuckDB
+                                        if matches!(source, DialectType::Generic) =>
+                                    {
+                                        let args = f.args;
+                                        let else_expr = Expression::Function(Box::new(
+                                            Function::new("CONCAT_WS".to_string(), args.clone()),
+                                        ));
+                                        Ok(concat_ws_null_case(args, else_expr))
+                                    }
+                                    _ => Ok(Expression::Function(f)),
+                                }
+                            }
                             // ARRAY_SLICE(x, start, end) -> SLICE(x, start, end) for Presto/Trino/Databricks, arraySlice for ClickHouse
                             "ARRAY_SLICE" if f.args.len() >= 2 => match target {
                                 DialectType::DuckDB
@@ -31957,66 +32009,93 @@ impl Dialect {
     /// Returns (value_expression, IntervalUnit)
     fn extract_interval_parts(
         interval_expr: &Expression,
-    ) -> (Expression, crate::expressions::IntervalUnit) {
-        use crate::expressions::{IntervalUnit, IntervalUnitSpec};
-
-        if let Expression::Interval(iv) = interval_expr {
-            let val = iv.this.clone().unwrap_or(Expression::number(0));
-            let unit = match &iv.unit {
-                Some(IntervalUnitSpec::Simple { unit, .. }) => *unit,
-                None => {
-                    // Unit might be embedded in the string value (Snowflake format: '5 DAY')
-                    if let Expression::Literal(lit) = &val {
-                        if let crate::expressions::Literal::String(s) = lit.as_ref() {
-                            let parts: Vec<&str> = s.trim().splitn(2, ' ').collect();
-                            if parts.len() == 2 {
-                                let unit_str = parts[1].trim().to_ascii_uppercase();
-                                let parsed_unit = match unit_str.as_str() {
-                                    "YEAR" | "YEARS" => IntervalUnit::Year,
-                                    "QUARTER" | "QUARTERS" => IntervalUnit::Quarter,
-                                    "MONTH" | "MONTHS" => IntervalUnit::Month,
-                                    "WEEK" | "WEEKS" | "ISOWEEK" => IntervalUnit::Week,
-                                    "DAY" | "DAYS" => IntervalUnit::Day,
-                                    "HOUR" | "HOURS" => IntervalUnit::Hour,
-                                    "MINUTE" | "MINUTES" => IntervalUnit::Minute,
-                                    "SECOND" | "SECONDS" => IntervalUnit::Second,
-                                    "MILLISECOND" | "MILLISECONDS" => IntervalUnit::Millisecond,
-                                    "MICROSECOND" | "MICROSECONDS" => IntervalUnit::Microsecond,
-                                    _ => IntervalUnit::Day,
-                                };
-                                // Return just the numeric part as value and parsed unit
-                                return (
-                                    Expression::Literal(Box::new(
-                                        crate::expressions::Literal::String(
-                                            parts[0].trim().to_string(),
-                                        ),
-                                    )),
-                                    parsed_unit,
-                                );
-                            }
-                            IntervalUnit::Day
-                        } else {
-                            IntervalUnit::Day
+    ) -> Option<(Expression, crate::expressions::IntervalUnit)> {
+        use crate::expressions::{DataType, IntervalUnit, IntervalUnitSpec, Literal};
+
+        fn unit_from_str(unit: &str) -> Option<IntervalUnit> {
+            match unit.trim().to_ascii_uppercase().as_str() {
+                "YEAR" | "YEARS" => Some(IntervalUnit::Year),
+                "QUARTER" | "QUARTERS" => Some(IntervalUnit::Quarter),
+                "MONTH" | "MONTHS" => Some(IntervalUnit::Month),
+                "WEEK" | "WEEKS" | "ISOWEEK" => Some(IntervalUnit::Week),
+                "DAY" | "DAYS" => Some(IntervalUnit::Day),
+                "HOUR" | "HOURS" => Some(IntervalUnit::Hour),
+                "MINUTE" | "MINUTES" => Some(IntervalUnit::Minute),
+                "SECOND" | "SECONDS" => Some(IntervalUnit::Second),
+                "MILLISECOND" | "MILLISECONDS" => Some(IntervalUnit::Millisecond),
+                "MICROSECOND" | "MICROSECONDS" => Some(IntervalUnit::Microsecond),
+                "NANOSECOND" | "NANOSECONDS" => Some(IntervalUnit::Nanosecond),
+                _ => None,
+            }
+        }
+
+        fn parts_from_literal_string(s: &str) -> Option<(Expression, IntervalUnit)> {
+            let mut parts = s.split_whitespace();
+            let value = parts.next()?;
+            let unit = unit_from_str(parts.next()?)?;
+            Some((
+                Expression::Literal(Box::new(Literal::String(value.to_string()))),
+                unit,
+            ))
+        }
+
+        fn unit_from_spec(unit: &IntervalUnitSpec) -> Option<IntervalUnit> {
+            match unit {
+                IntervalUnitSpec::Simple { unit, .. } => Some(*unit),
+                IntervalUnitSpec::Expr(expr) => match expr.as_ref() {
+                    Expression::Day(_) => Some(IntervalUnit::Day),
+                    Expression::Month(_) => Some(IntervalUnit::Month),
+                    Expression::Year(_) => Some(IntervalUnit::Year),
+                    Expression::Identifier(id) => unit_from_str(&id.name),
+                    Expression::Var(v) => unit_from_str(&v.this),
+                    Expression::Column(col) => unit_from_str(&col.name.name),
+                    _ => None,
+                },
+                _ => None,
+            }
+        }
+
+        match interval_expr {
+            Expression::Interval(iv) => {
+                let val = iv.this.clone().unwrap_or(Expression::number(0));
+                if let Expression::Literal(lit) = &val {
+                    if let Literal::String(s) = lit.as_ref() {
+                        if let Some(parts) = parts_from_literal_string(s) {
+                            return Some(parts);
                         }
-                    } else {
-                        IntervalUnit::Day
                     }
                 }
-                _ => IntervalUnit::Day,
-            };
-            (val, unit)
-        } else {
-            // Not an interval - pass through
-            (interval_expr.clone(), crate::expressions::IntervalUnit::Day)
+                let unit = iv
+                    .unit
+                    .as_ref()
+                    .and_then(unit_from_spec)
+                    .unwrap_or(IntervalUnit::Day);
+                Some((val, unit))
+            }
+            Expression::Cast(cast) if matches!(cast.to, DataType::Interval { .. }) => {
+                if let Expression::Literal(lit) = &cast.this {
+                    if let Literal::String(s) = lit.as_ref() {
+                        if let Some(parts) = parts_from_literal_string(s) {
+                            return Some(parts);
+                        }
+                    }
+                }
+                let unit = match &cast.to {
+                    DataType::Interval {
+                        unit: Some(unit), ..
+                    } => unit_from_str(unit).unwrap_or(IntervalUnit::Day),
+                    _ => IntervalUnit::Day,
+                };
+                Some((cast.this.clone(), unit))
+            }
+            _ => None,
         }
     }
 
     fn rewrite_tsql_interval_arithmetic(expr: &Expression) -> Option<Expression> {
         match expr {
             Expression::Add(op) => {
-                let Expression::Interval(_) = &op.right else {
-                    return None;
-                };
+                Self::extract_interval_parts(&op.right)?;
                 Some(Self::build_tsql_dateadd_from_interval(
                     op.left.clone(),
                     &op.right,
@@ -32024,9 +32103,7 @@ impl Dialect {
                 ))
             }
             Expression::Sub(op) => {
-                let Expression::Interval(_) = &op.right else {
-                    return None;
-                };
+                Self::extract_interval_parts(&op.right)?;
                 Some(Self::build_tsql_dateadd_from_interval(
                     op.left.clone(),
                     &op.right,
@@ -32042,7 +32119,8 @@ impl Dialect {
         interval: &Expression,
         subtract: bool,
     ) -> Expression {
-        let (value, unit) = Self::extract_interval_parts(interval);
+        let (value, unit) = Self::extract_interval_parts(interval)
+            .unwrap_or_else(|| (interval.clone(), crate::expressions::IntervalUnit::Day));
         let unit = Self::interval_unit_to_string(&unit);
         let amount = Self::tsql_dateadd_amount(value, subtract);
 
@@ -32053,7 +32131,7 @@ impl Dialect {
     }
 
     fn tsql_dateadd_amount(value: Expression, negate: bool) -> Expression {
-        use crate::expressions::UnaryOp;
+        use crate::expressions::{Parameter, ParameterStyle, UnaryOp};
 
         fn numeric_literal_value(value: &Expression) -> Option<&str> {
             match value {
@@ -32066,6 +32144,38 @@ impl Dialect {
             }
         }
 
+        fn colon_parameter(value: &Expression) -> Option<Expression> {
+            let Expression::Literal(lit) = value else {
+                return None;
+            };
+            let crate::expressions::Literal::String(s) = lit.as_ref() else {
+                return None;
+            };
+            let name = s.strip_prefix(':')?;
+            if name.is_empty()
+                || !name
+                    .chars()
+                    .all(|ch| ch.is_ascii_alphanumeric() || ch == '_')
+            {
+                return None;
+            }
+
+            Some(Expression::Parameter(Box::new(Parameter {
+                name: if name.chars().all(|ch| ch.is_ascii_digit()) {
+                    None
+                } else {
+                    Some(name.to_string())
+                },
+                index: name.parse::<u32>().ok(),
+                style: ParameterStyle::Colon,
+                quoted: false,
+                string_quoted: false,
+                expression: None,
+            })))
+        }
+
+        let value = colon_parameter(&value).unwrap_or(value);
+
         if let Some(n) = numeric_literal_value(&value) {
             if let Ok(parsed) = n.parse::<f64>() {
                 let normalized = if negate { -parsed } else { parsed };
@@ -32527,7 +32637,10 @@ impl Dialect {
             "TIMESTAMP_ADD" | "DATETIME_ADD" | "TIME_ADD" if args.len() == 2 => {
                 let ts = args.remove(0);
                 let interval_expr = args.remove(0);
-                let (val, unit) = Self::extract_interval_parts(&interval_expr);
+                let (val, unit) =
+                    Self::extract_interval_parts(&interval_expr).unwrap_or_else(|| {
+                        (interval_expr.clone(), crate::expressions::IntervalUnit::Day)
+                    });
 
                 match target {
                     DialectType::Snowflake => {
@@ -32657,7 +32770,10 @@ impl Dialect {
             "TIMESTAMP_SUB" | "DATETIME_SUB" | "TIME_SUB" if args.len() == 2 => {
                 let ts = args.remove(0);
                 let interval_expr = args.remove(0);
-                let (val, unit) = Self::extract_interval_parts(&interval_expr);
+                let (val, unit) =
+                    Self::extract_interval_parts(&interval_expr).unwrap_or_else(|| {
+                        (interval_expr.clone(), crate::expressions::IntervalUnit::Day)
+                    });
 
                 match target {
                     DialectType::Snowflake => {
@@ -32789,7 +32905,10 @@ impl Dialect {
             "DATE_SUB" if args.len() == 2 => {
                 let date = args.remove(0);
                 let interval_expr = args.remove(0);
-                let (val, unit) = Self::extract_interval_parts(&interval_expr);
+                let (val, unit) =
+                    Self::extract_interval_parts(&interval_expr).unwrap_or_else(|| {
+                        (interval_expr.clone(), crate::expressions::IntervalUnit::Day)
+                    });
 
                 match target {
                     DialectType::Databricks | DialectType::Spark => {
@@ -33144,7 +33263,10 @@ impl Dialect {
             "DATE_ADD" if args.len() == 2 => {
                 let date = args.remove(0);
                 let interval_expr = args.remove(0);
-                let (val, unit) = Self::extract_interval_parts(&interval_expr);
+                let (val, unit) =
+                    Self::extract_interval_parts(&interval_expr).unwrap_or_else(|| {
+                        (interval_expr.clone(), crate::expressions::IntervalUnit::Day)
+                    });
                 let unit_str = Self::interval_unit_to_string(&unit);
 
                 match target {

{polyglot_sql-0.3.5 → polyglot_sql-0.3.6}/crates/polyglot-sql/src/dialects/mysql.rs

@@ -83,6 +83,7 @@ impl DialectImpl for MySQLDialect {
         config.escape_follow_chars = vec!['0', 'b', 'n', 'r', 't', 'Z', '%', '_'];
         // MySQL allows identifiers to start with digits (e.g., 1a, 1_a)
         config.identifiers_can_start_with_digit = true;
+        config.hex_number_strings = true;
         config
     }
 

{polyglot_sql-0.3.5 → polyglot_sql-0.3.6}/crates/polyglot-sql/src/dialects/redshift.rs

@@ -42,6 +42,7 @@ impl DialectImpl for RedshiftDialect {
             supports_column_join_marks: true,
             locking_reads_supported: false,
             tz_to_with_time_zone: true,
+            single_string_interval: true,
             ..Default::default()
         }
     }

{polyglot_sql-0.3.5 → polyglot_sql-0.3.6}/crates/polyglot-sql/src/dialects/snowflake.rs

@@ -2392,6 +2392,15 @@ impl SnowflakeDialect {
                 ))))
             }
 
+            "STRTOK_TO_ARRAY" if f.args.len() == 1 => {
+                let mut args = f.args;
+                args.push(Expression::string(" ".to_string()));
+                Ok(Expression::Function(Box::new(Function::new(
+                    "STRTOK_TO_ARRAY".to_string(),
+                    args,
+                ))))
+            }
+
             // WEEKOFYEAR -> WEEK
             "WEEKOFYEAR" => Ok(Expression::Function(Box::new(Function::new(
                 "WEEK".to_string(),