polyglot-sql 0.5.5__tar.gz → 0.5.7__tar.gz

{polyglot_sql-0.5.5 → polyglot_sql-0.5.7}/Cargo.lock

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

{polyglot_sql-0.5.5 → polyglot_sql-0.5.7}/Cargo.toml

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

{polyglot_sql-0.5.5 → polyglot_sql-0.5.7}/PKG-INFO

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

{polyglot_sql-0.5.5 → polyglot_sql-0.5.7}/crates/polyglot-sql/Cargo.toml

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

{polyglot_sql-0.5.5 → polyglot_sql-0.5.7}/crates/polyglot-sql/src/dialects/bigquery.rs

@@ -104,6 +104,26 @@ impl DialectImpl for BigQueryDialect {
             // ===== Data Type Mappings =====
             Expression::DataType(dt) => self.transform_data_type(dt),
 
+            Expression::Table(mut table)
+                if table.catalog.is_none()
+                    && table.alias.is_none()
+                    && table.schema.as_ref().map_or(false, |schema| {
+                        schema.quoted && schema.name.contains("INFORMATION_SCHEMA")
+                    }) =>
+            {
+                let schema = table.schema.take().expect("schema checked above");
+                let old_name = table.name.clone();
+                let alias = old_name.name.clone();
+                table.name = Identifier {
+                    name: format!("{}.{}", schema.name, old_name.name),
+                    quoted: true,
+                    trailing_comments: old_name.trailing_comments,
+                    span: old_name.span,
+                };
+                table.alias = Some(Identifier::new(alias));
+                Ok(Expression::Table(table))
+            }
+
             // ===== Null handling =====
             // IFNULL is native to BigQuery - keep as-is for identity
             Expression::IfNull(f) => Ok(Expression::IfNull(f)),

{polyglot_sql-0.5.5 → polyglot_sql-0.5.7}/crates/polyglot-sql/src/dialects/clickhouse.rs

@@ -445,6 +445,17 @@ impl ClickHouseDialect {
                 }
                 self.transform_expr(expr)
             }
+            "XOR" if f.args.len() >= 2 => {
+                let mut iter = f.args.into_iter().map(Self::wrap_nested_xor_arg);
+                let mut expr = iter.next().unwrap();
+                for arg in iter {
+                    expr = Expression::Function(Box::new(Function::new(
+                        f.name.clone(),
+                        vec![expr, arg],
+                    )));
+                }
+                Ok(expr)
+            }
             // TYPEOF -> toTypeName in ClickHouse
             "TYPEOF" => Ok(Expression::Function(Box::new(Function::new(
                 "toTypeName".to_string(),
@@ -668,4 +679,15 @@ impl ClickHouseDialect {
     fn transform_cast(&self, c: Cast) -> Result<Expression> {
         Ok(Expression::Cast(Box::new(c)))
     }
+
+    fn wrap_nested_xor_arg(expr: Expression) -> Expression {
+        if matches!(&expr, Expression::Function(f) if f.name.eq_ignore_ascii_case("XOR")) {
+            Expression::Paren(Box::new(Paren {
+                this: expr,
+                trailing_comments: Vec::new(),
+            }))
+        } else {
+            expr
+        }
+    }
 }

{polyglot_sql-0.5.5 → polyglot_sql-0.5.7}/crates/polyglot-sql/src/dialects/databricks.rs

@@ -10,8 +10,8 @@
 use super::{DialectImpl, DialectType};
 use crate::error::Result;
 use crate::expressions::{
-    AggregateFunction, Cast, DataType, Expression, Function, JSONExtract, Literal, UnaryFunc,
-    VarArgFunc,
+    AggregateFunction, Cast, DataType, DateAddFunc, Expression, Function, IntervalUnit, Literal,
+    UnaryFunc, VarArgFunc,
 };
 #[cfg(feature = "generate")]
 use crate::generator::GeneratorConfig;
@@ -181,6 +181,9 @@ impl DialectImpl for DatabricksDialect {
                 ))))
             }
 
+            // DateAdd -> native Databricks DATE_ADD forms.
+            Expression::DateAdd(f) => Ok(Self::transform_date_add(*f)),
+
             // Pass through everything else
             _ => Ok(expr),
         }
@@ -463,13 +466,29 @@ impl DatabricksDialect {
             // DATE_TRUNC is native in Databricks
             "DATE_TRUNC" => Ok(Expression::Function(Box::new(f))),
 
-            // DATEADD is native in Databricks - uppercase the unit if present
+            // DATEADD normalizes to Databricks DATE_ADD with an uppercased unit.
             "DATEADD" => {
-                let transformed_args = self.uppercase_first_arg_if_identifier(f.args);
-                Ok(Expression::Function(Box::new(Function::new(
-                    "DATEADD".to_string(),
-                    transformed_args,
-                ))))
+                if f.args.len() == 2 {
+                    Ok(Expression::Function(Box::new(Function::new(
+                        "DATE_ADD".to_string(),
+                        f.args,
+                    ))))
+                } else {
+                    let transformed_args = self.uppercase_first_arg_if_identifier(f.args);
+                    let function_name = if matches!(
+                        transformed_args.first(),
+                        Some(Expression::Identifier(unit))
+                            if unit.name.eq_ignore_ascii_case("WEEK")
+                    ) {
+                        "DATEADD"
+                    } else {
+                        "DATE_ADD"
+                    };
+                    Ok(Expression::Function(Box::new(Function::new(
+                        function_name.to_string(),
+                        transformed_args,
+                    ))))
+                }
             }
 
             // DATE_ADD -> DATEADD in Databricks (2-arg form only)
@@ -554,48 +573,16 @@ impl DatabricksDialect {
             // JSON_EXTRACT_SCALAR -> same handling
             "JSON_EXTRACT_SCALAR" => Ok(Expression::Function(Box::new(f))),
 
-            // GET_JSON_OBJECT -> colon syntax in Databricks
-            // GET_JSON_OBJECT(col, '$.path') becomes col:path
+            // GET_JSON_OBJECT is native in Databricks.
             "GET_JSON_OBJECT" if f.args.len() == 2 => {
                 let mut args = f.args;
                 let col = args.remove(0);
                 let path_arg = args.remove(0);
 
-                // Extract and strip the $. prefix from the path
-                let path_expr = match &path_arg {
-                    Expression::Literal(lit)
-                        if matches!(lit.as_ref(), crate::expressions::Literal::String(_)) =>
-                    {
-                        let crate::expressions::Literal::String(s) = lit.as_ref() else {
-                            unreachable!()
-                        };
-                        // Strip leading '$.' if present
-                        let stripped = if s.starts_with("$.") {
-                            &s[2..]
-                        } else if s.starts_with("$") {
-                            &s[1..]
-                        } else {
-                            s.as_str()
-                        };
-                        Expression::Literal(Box::new(crate::expressions::Literal::String(
-                            stripped.to_string(),
-                        )))
-                    }
-                    _ => path_arg,
-                };
-
-                Ok(Expression::JSONExtract(Box::new(JSONExtract {
-                    this: Box::new(col),
-                    expression: Box::new(path_expr),
-                    only_json_types: None,
-                    expressions: Vec::new(),
-                    variant_extract: Some(Box::new(Expression::true_())),
-                    json_query: None,
-                    option: None,
-                    quote: None,
-                    on_condition: None,
-                    requires_json: None,
-                })))
+                Ok(Expression::Function(Box::new(Function::new(
+                    "GET_JSON_OBJECT".to_string(),
+                    vec![col, self.normalize_get_json_object_path(path_arg)],
+                ))))
             }
 
             // FROM_JSON is native in Databricks
@@ -998,6 +985,73 @@ impl DatabricksDialect {
         }
         args
     }
+
+    fn normalize_get_json_object_path(&self, path_arg: Expression) -> Expression {
+        let Expression::Literal(lit) = &path_arg else {
+            return path_arg;
+        };
+        let crate::expressions::Literal::String(path) = lit.as_ref() else {
+            return path_arg;
+        };
+
+        let Some(segment) = path.strip_prefix("$.") else {
+            return path_arg;
+        };
+
+        if segment.is_empty()
+            || segment.contains('.')
+            || segment.contains('[')
+            || segment
+                .chars()
+                .all(|c| c.is_ascii_alphanumeric() || c == '_')
+        {
+            return path_arg;
+        }
+
+        Expression::Literal(Box::new(crate::expressions::Literal::String(format!(
+            "$[\"{}\"]",
+            segment.replace('"', "\\\"")
+        ))))
+    }
+
+    fn transform_date_add(f: DateAddFunc) -> Expression {
+        if f.unit == IntervalUnit::Day {
+            Expression::Function(Box::new(Function::new(
+                "DATE_ADD".to_string(),
+                vec![f.this, f.interval],
+            )))
+        } else {
+            Expression::Function(Box::new(Function::new(
+                "DATE_ADD".to_string(),
+                vec![
+                    Expression::Identifier(crate::expressions::Identifier {
+                        name: Self::interval_unit_name(f.unit).to_string(),
+                        quoted: false,
+                        trailing_comments: Vec::new(),
+                        span: None,
+                    }),
+                    f.interval,
+                    f.this,
+                ],
+            )))
+        }
+    }
+
+    fn interval_unit_name(unit: IntervalUnit) -> &'static str {
+        match unit {
+            IntervalUnit::Year => "YEAR",
+            IntervalUnit::Quarter => "QUARTER",
+            IntervalUnit::Month => "MONTH",
+            IntervalUnit::Week => "WEEK",
+            IntervalUnit::Day => "DAY",
+            IntervalUnit::Hour => "HOUR",
+            IntervalUnit::Minute => "MINUTE",
+            IntervalUnit::Second => "SECOND",
+            IntervalUnit::Millisecond => "MILLISECOND",
+            IntervalUnit::Microsecond => "MICROSECOND",
+            IntervalUnit::Nanosecond => "NANOSECOND",
+        }
+    }
 }
 
 #[cfg(test)]

{polyglot_sql-0.5.5 → polyglot_sql-0.5.7}/crates/polyglot-sql/src/dialects/exasol.rs

@@ -20,7 +20,9 @@
 
 use super::{DialectImpl, DialectType};
 use crate::error::Result;
-use crate::expressions::{Expression, Function, ListAggFunc, Literal, VarArgFunc};
+use crate::expressions::{
+    BinaryOp, Expression, Function, Identifier, LikeOp, ListAggFunc, Literal, Select, VarArgFunc,
+};
 #[cfg(feature = "generate")]
 use crate::generator::GeneratorConfig;
 use crate::tokens::TokenizerConfig;
@@ -149,6 +151,10 @@ impl DialectImpl for ExasolDialect {
             // Aggregate function transformations
             Expression::AggregateFunction(f) => self.transform_aggregate_function(f),
 
+            Expression::Select(select) => Ok(Expression::Select(Box::new(
+                self.qualify_local_alias_predicates(*select),
+            ))),
+
             // Pass through everything else
             _ => Ok(expr),
         }
@@ -157,6 +163,95 @@ impl DialectImpl for ExasolDialect {
 
 #[cfg(feature = "transpile")]
 impl ExasolDialect {
+    fn qualify_local_alias_predicates(&self, mut select: Select) -> Select {
+        let aliases = Self::select_aliases(&select);
+        if aliases.is_empty() {
+            return select;
+        }
+
+        if let Some(where_clause) = select.where_clause.as_mut() {
+            where_clause.this = Self::qualify_local_alias_expr(where_clause.this.clone(), &aliases);
+        }
+        if let Some(having) = select.having.as_mut() {
+            having.this = Self::qualify_local_alias_expr(having.this.clone(), &aliases);
+        }
+
+        select
+    }
+
+    fn select_aliases(select: &Select) -> std::collections::HashMap<String, Identifier> {
+        let mut aliases = std::collections::HashMap::new();
+        for expression in &select.expressions {
+            if let Expression::Alias(alias) = expression {
+                aliases.insert(alias.alias.name.to_ascii_uppercase(), alias.alias.clone());
+            }
+        }
+        aliases
+    }
+
+    fn qualify_local_alias_expr(
+        expr: Expression,
+        aliases: &std::collections::HashMap<String, Identifier>,
+    ) -> Expression {
+        match expr {
+            Expression::Column(col) if col.table.is_none() => {
+                if let Some(alias) = aliases.get(&col.name.name.to_ascii_uppercase()) {
+                    return Expression::Raw(crate::expressions::Raw {
+                        sql: format!("LOCAL.{}", alias.name),
+                    });
+                }
+                Expression::Column(col)
+            }
+            Expression::Identifier(id) => {
+                if let Some(alias) = aliases.get(&id.name.to_ascii_uppercase()) {
+                    Expression::Raw(crate::expressions::Raw {
+                        sql: format!("LOCAL.{}", alias.name),
+                    })
+                } else {
+                    Expression::Identifier(id)
+                }
+            }
+            Expression::And(op) => Self::qualify_binary(op, aliases, Expression::And),
+            Expression::Or(op) => Self::qualify_binary(op, aliases, Expression::Or),
+            Expression::Eq(op) => Self::qualify_binary(op, aliases, Expression::Eq),
+            Expression::Neq(op) => Self::qualify_binary(op, aliases, Expression::Neq),
+            Expression::Lt(op) => Self::qualify_binary(op, aliases, Expression::Lt),
+            Expression::Lte(op) => Self::qualify_binary(op, aliases, Expression::Lte),
+            Expression::Gt(op) => Self::qualify_binary(op, aliases, Expression::Gt),
+            Expression::Gte(op) => Self::qualify_binary(op, aliases, Expression::Gte),
+            Expression::Like(op) => Self::qualify_like(op, aliases, Expression::Like),
+            Expression::ILike(op) => Self::qualify_like(op, aliases, Expression::ILike),
+            Expression::Not(mut op) => {
+                op.this = Self::qualify_local_alias_expr(op.this, aliases);
+                Expression::Not(op)
+            }
+            other => other,
+        }
+    }
+
+    fn qualify_binary(
+        mut op: Box<BinaryOp>,
+        aliases: &std::collections::HashMap<String, Identifier>,
+        wrap: fn(Box<BinaryOp>) -> Expression,
+    ) -> Expression {
+        op.left = Self::qualify_local_alias_expr(op.left, aliases);
+        op.right = Self::qualify_local_alias_expr(op.right, aliases);
+        wrap(op)
+    }
+
+    fn qualify_like(
+        mut op: Box<LikeOp>,
+        aliases: &std::collections::HashMap<String, Identifier>,
+        wrap: fn(Box<LikeOp>) -> Expression,
+    ) -> Expression {
+        op.left = Self::qualify_local_alias_expr(op.left, aliases);
+        op.right = Self::qualify_local_alias_expr(op.right, aliases);
+        if let Some(escape) = op.escape.take() {
+            op.escape = Some(Self::qualify_local_alias_expr(escape, aliases));
+        }
+        wrap(op)
+    }
+
     fn transform_function(&self, f: Function) -> Result<Expression> {
         let name_upper = f.name.to_uppercase();
         match name_upper.as_str() {

{polyglot_sql-0.5.5 → polyglot_sql-0.5.7}/crates/polyglot-sql/src/dialects/mod.rs

@@ -5524,7 +5524,7 @@ impl Dialect {
             Expression::Min(agg) => rewrite_agg_filter!(Min, agg),
             Expression::Max(agg) => rewrite_agg_filter!(Max, agg),
             Expression::ArrayAgg(agg) => rewrite_agg_filter!(ArrayAgg, agg),
-            Expression::CountIf(agg) => rewrite_agg_filter!(CountIf, agg),
+            Expression::CountIf(agg) => Ok(Expression::CountIf(agg)),
             Expression::Stddev(agg) => rewrite_agg_filter!(Stddev, agg),
             Expression::StddevPop(agg) => rewrite_agg_filter!(StddevPop, agg),
             Expression::StddevSamp(agg) => rewrite_agg_filter!(StddevSamp, agg),
@@ -5610,7 +5610,10 @@ impl Dialect {
             Expression::Min(agg) => push_agg_filter!(Min, agg),
             Expression::Max(agg) => push_agg_filter!(Max, agg),
             Expression::ArrayAgg(agg) => push_agg_filter!(ArrayAgg, agg),
-            Expression::CountIf(agg) => push_agg_filter!(CountIf, agg),
+            Expression::CountIf(mut agg) => {
+                agg.filter = Some(filter);
+                Expression::CountIf(agg)
+            }
             Expression::Stddev(agg) => push_agg_filter!(Stddev, agg),
             Expression::StddevPop(agg) => push_agg_filter!(StddevPop, agg),
             Expression::StddevSamp(agg) => push_agg_filter!(StddevSamp, agg),
@@ -18885,17 +18888,9 @@ impl Dialect {
                                             vec![date, days],
                                         ))))
                                     }
-                                    DialectType::Databricks => {
-                                        // Databricks: DATEADD(DAY, days, date)
-                                        Ok(Expression::Function(Box::new(Function::new(
-                                            "DATEADD".to_string(),
-                                            vec![
-                                                Expression::Identifier(Identifier::new("DAY")),
-                                                days,
-                                                date,
-                                            ],
-                                        ))))
-                                    }
+                                    DialectType::Databricks => Ok(Expression::Function(Box::new(
+                                        Function::new("DATE_ADD".to_string(), vec![date, days]),
+                                    ))),
                                     DialectType::DuckDB => {
                                         // DuckDB: CAST(date AS DATE) + INTERVAL days DAY
                                         let cast_date = Self::ensure_cast_date(date);
@@ -18971,7 +18966,9 @@ impl Dialect {
                                         // But Databricks DATE_ADD doesn't need this wrapping for TSQL
                                         let cast_date = if matches!(
                                             source,
-                                            DialectType::Hive | DialectType::Spark
+                                            DialectType::Hive
+                                                | DialectType::Spark
+                                                | DialectType::Databricks
                                         ) {
                                             if matches!(
                                                 date,

{polyglot_sql-0.5.5 → polyglot_sql-0.5.7}/crates/polyglot-sql/src/dialects/mysql.rs

@@ -10,8 +10,8 @@
 use super::{DialectImpl, DialectType};
 use crate::error::Result;
 use crate::expressions::{
-    BinaryFunc, BinaryOp, Cast, DataType, Expression, Function, JsonExtractFunc, LikeOp, Literal,
-    Paren, UnaryFunc,
+    BinaryFunc, BinaryOp, Cast, DataType, Expression, Function, Interval, IntervalUnit,
+    IntervalUnitSpec, JsonExtractFunc, LikeOp, Literal, MakeInterval, Paren, UnaryFunc,
 };
 #[cfg(feature = "generate")]
 use crate::generator::GeneratorConfig;
@@ -176,6 +176,10 @@ impl DialectImpl for MySQLDialect {
             // MySQL generation renders these as CONCAT(...).
             Expression::Concat(op) => Ok(Expression::Concat(op)),
 
+            // PostgreSQL MAKE_INTERVAL -> MySQL interval arithmetic.
+            Expression::Add(op) => self.transform_make_interval_binary(op, false),
+            Expression::Sub(op) => self.transform_make_interval_binary(op, true),
+
             // RANDOM -> RAND in MySQL
             Expression::Random(_) => Ok(Expression::Rand(Box::new(crate::expressions::Rand {
                 seed: None,
@@ -618,6 +622,159 @@ impl MySQLDialect {
         }
     }
 
+    fn transform_make_interval_binary(
+        &self,
+        op: Box<BinaryOp>,
+        subtract: bool,
+    ) -> Result<Expression> {
+        if let Expression::MakeInterval(make_interval) = &op.right {
+            if let Some(expr) =
+                Self::expand_make_interval_binary(op.left.clone(), make_interval, subtract)
+            {
+                return Ok(expr);
+            }
+        }
+        if let Expression::Function(function) = &op.right {
+            if function.name.eq_ignore_ascii_case("MAKE_INTERVAL") {
+                if let Some(expr) =
+                    Self::expand_make_interval_function_binary(op.left.clone(), function, subtract)
+                {
+                    return Ok(expr);
+                }
+            }
+        }
+
+        if subtract {
+            Ok(Expression::Sub(op))
+        } else {
+            Ok(Expression::Add(op))
+        }
+    }
+
+    fn expand_make_interval_binary(
+        left: Expression,
+        make_interval: &MakeInterval,
+        subtract: bool,
+    ) -> Option<Expression> {
+        let parts = Self::make_interval_parts(make_interval);
+        if parts.is_empty() {
+            return None;
+        }
+
+        let mut expr = left;
+        for (value, unit) in parts {
+            let interval = Expression::Interval(Box::new(Interval {
+                this: Some(value),
+                unit: Some(IntervalUnitSpec::Simple {
+                    unit,
+                    use_plural: false,
+                }),
+            }));
+            expr = if subtract {
+                Expression::Sub(Box::new(BinaryOp::new(expr, interval)))
+            } else {
+                Expression::Add(Box::new(BinaryOp::new(expr, interval)))
+            };
+        }
+
+        Some(expr)
+    }
+
+    fn expand_make_interval_function_binary(
+        left: Expression,
+        function: &Function,
+        subtract: bool,
+    ) -> Option<Expression> {
+        let parts = Self::make_interval_function_parts(function);
+        if parts.is_empty() {
+            return None;
+        }
+
+        let mut expr = left;
+        for (value, unit) in parts {
+            let interval = Expression::Interval(Box::new(Interval {
+                this: Some(value),
+                unit: Some(IntervalUnitSpec::Simple {
+                    unit,
+                    use_plural: false,
+                }),
+            }));
+            expr = if subtract {
+                Expression::Sub(Box::new(BinaryOp::new(expr, interval)))
+            } else {
+                Expression::Add(Box::new(BinaryOp::new(expr, interval)))
+            };
+        }
+
+        Some(expr)
+    }
+
+    fn make_interval_parts(make_interval: &MakeInterval) -> Vec<(Expression, IntervalUnit)> {
+        let mut parts = Vec::new();
+        if let Some(year) = &make_interval.year {
+            parts.push(((**year).clone(), IntervalUnit::Year));
+        }
+        if let Some(month) = &make_interval.month {
+            parts.push(((**month).clone(), IntervalUnit::Month));
+        }
+        if let Some(week) = &make_interval.week {
+            parts.push(((**week).clone(), IntervalUnit::Week));
+        }
+        if let Some(day) = &make_interval.day {
+            parts.push(((**day).clone(), IntervalUnit::Day));
+        }
+        if let Some(hour) = &make_interval.hour {
+            parts.push(((**hour).clone(), IntervalUnit::Hour));
+        }
+        if let Some(minute) = &make_interval.minute {
+            parts.push(((**minute).clone(), IntervalUnit::Minute));
+        }
+        if let Some(second) = &make_interval.second {
+            parts.push(((**second).clone(), IntervalUnit::Second));
+        }
+        parts
+    }
+
+    fn make_interval_function_parts(function: &Function) -> Vec<(Expression, IntervalUnit)> {
+        let positional_units = [
+            IntervalUnit::Year,
+            IntervalUnit::Month,
+            IntervalUnit::Week,
+            IntervalUnit::Day,
+            IntervalUnit::Hour,
+            IntervalUnit::Minute,
+            IntervalUnit::Second,
+        ];
+        let mut positional_index = 0;
+        let mut parts = Vec::new();
+
+        for arg in &function.args {
+            if let Expression::NamedArgument(named) = arg {
+                if let Some(unit) = Self::make_interval_unit_from_name(&named.name.name) {
+                    parts.push((named.value.clone(), unit));
+                }
+            } else if let Some(unit) = positional_units.get(positional_index) {
+                parts.push((arg.clone(), *unit));
+                positional_index += 1;
+            }
+        }
+
+        parts
+    }
+
+    fn make_interval_unit_from_name(name: &str) -> Option<IntervalUnit> {
+        match name.to_ascii_lowercase().as_str() {
+            "year" | "years" => Some(IntervalUnit::Year),
+            "month" | "months" => Some(IntervalUnit::Month),
+            "week" | "weeks" => Some(IntervalUnit::Week),
+            "day" | "days" => Some(IntervalUnit::Day),
+            "hour" | "hours" => Some(IntervalUnit::Hour),
+            "min" | "mins" | "minute" | "minutes" => Some(IntervalUnit::Minute),
+            "sec" | "secs" | "second" | "seconds" => Some(IntervalUnit::Second),
+            _ => None,
+        }
+    }
+
     /// Transform CAST type according to MySQL restrictions
     /// MySQL doesn't support many types in CAST - they get mapped to CHAR or SIGNED
     /// Based on Python sqlglot's CHAR_CAST_MAPPING and SIGNED_CAST_MAPPING