From 8126303e645d4d5b2b16050049cfb31d6c48ab22 Mon Sep 17 00:00:00 2001 From: t8y2 <1156263951@qq.com> Date: Tue, 21 Jul 2026 19:45:59 +0800 Subject: [PATCH] fix(sqlserver): recognize datepart function arguments --- crates/dbx-core/src/sql_analysis.rs | 102 +++++++++++- crates/dbx-core/tests/sql_analysis.rs | 216 ++++++++++++++++++++++++++ 2 files changed, 314 insertions(+), 4 deletions(-) diff --git a/crates/dbx-core/src/sql_analysis.rs b/crates/dbx-core/src/sql_analysis.rs index 9a853229b9..8abd8cfc9b 100644 --- a/crates/dbx-core/src/sql_analysis.rs +++ b/crates/dbx-core/src/sql_analysis.rs @@ -80,6 +80,7 @@ struct Analyzer { scopes: Vec, scope_stack: Vec, next_scope_id: usize, + is_sqlserver: bool, } pub fn analyze_sql_references(sql: &str, dialect: Option<&str>) -> Result { @@ -107,7 +108,7 @@ pub fn analyze_sql_references(sql: &str, dialect: Option<&str>) -> Result { self.visit_function_args(&function.parameters); - self.visit_function_args(&function.args); + self.visit_function_call_args(&function.name, &function.args); if let Some(filter) = &function.filter { self.visit_expr(filter); } @@ -483,11 +484,30 @@ impl Analyzer { } fn visit_function_args(&mut self, args: &FunctionArguments) { + self.visit_function_args_skipping(args, |_, _| false); + } + + fn visit_function_call_args(&mut self, name: &ObjectName, args: &FunctionArguments) { + let sqlserver_datepart_function = self.is_sqlserver.then(|| sqlserver_datepart_function_name(name)).flatten(); + self.visit_function_args_skipping(args, |index, arg| { + index == 0 + && sqlserver_datepart_function + .is_some_and(|function_name| is_sqlserver_datepart_argument(function_name, arg)) + }); + } + + fn visit_function_args_skipping( + &mut self, + args: &FunctionArguments, + mut should_skip: impl FnMut(usize, &FunctionArg) -> bool, + ) { match args { FunctionArguments::Subquery(query) => self.visit_child_query(query), FunctionArguments::List(list) => { - for arg in &list.args { - self.visit_function_arg(arg); + for (index, arg) in list.args.iter().enumerate() { + if !should_skip(index, arg) { + self.visit_function_arg(arg); + } } for clause in &list.clauses { if let sqlparser::ast::FunctionArgumentClause::OrderBy(items) = clause { @@ -538,3 +558,77 @@ fn table_reference_from_name( fn object_name_last_ident(name: &ObjectName) -> Option<&Ident> { name.0.iter().rev().find_map(ObjectNamePart::as_ident) } + +fn sqlserver_datepart_function_name(name: &ObjectName) -> Option<&str> { + if name.0.len() != 1 { + return None; + } + + let ident = name.0.first()?.as_ident()?; + ["DATEADD", "DATEDIFF", "DATEDIFF_BIG", "DATEPART", "DATENAME"] + .iter() + .copied() + .find(|function_name| ident.value.eq_ignore_ascii_case(function_name)) +} + +fn is_sqlserver_datepart_argument(function_name: &str, arg: &FunctionArg) -> bool { + let FunctionArg::Unnamed(FunctionArgExpr::Expr(Expr::Identifier(ident))) = arg else { + return false; + }; + if ident.quote_style.is_some() { + return false; + } + + // SQL Server parses datepart tokens as identifiers, but these built-ins treat the first token as grammar, not a column. + let datepart = ident.value.as_str(); + let common_datepart = is_datepart( + datepart, + &[ + "year", + "yy", + "yyyy", + "quarter", + "qq", + "q", + "month", + "mm", + "m", + "dayofyear", + "dy", + "y", + "day", + "dd", + "d", + "week", + "wk", + "ww", + "hour", + "hh", + "minute", + "mi", + "n", + "second", + "ss", + "s", + "millisecond", + "ms", + "microsecond", + "mcs", + "nanosecond", + "ns", + ], + ); + let weekday_datepart = is_datepart(datepart, &["weekday", "dw", "w"]); + let extended_datepart = is_datepart(datepart, &["tzoffset", "tz", "iso_week", "isowk", "isoww"]); + + match function_name { + "DATEADD" | "DATEDIFF" | "DATEDIFF_BIG" => common_datepart || weekday_datepart, + "DATEPART" => common_datepart || weekday_datepart || extended_datepart, + "DATENAME" => common_datepart || weekday_datepart || extended_datepart, + _ => false, + } +} + +fn is_datepart(value: &str, valid_dateparts: &[&str]) -> bool { + valid_dateparts.iter().any(|datepart| value.eq_ignore_ascii_case(datepart)) +} diff --git a/crates/dbx-core/tests/sql_analysis.rs b/crates/dbx-core/tests/sql_analysis.rs index f6beaa8f41..348f219d35 100644 --- a/crates/dbx-core/tests/sql_analysis.rs +++ b/crates/dbx-core/tests/sql_analysis.rs @@ -100,6 +100,222 @@ fn extracts_unqualified_order_by_columns_for_sqlserver_queries() { assert_eq!(columns, vec![(None, "PDReceiveDatePartInfo")]); } +#[test] +fn sqlserver_date_functions_do_not_treat_legal_dateparts_as_columns() { + let dateadd_and_datediff = [ + "year", + "yy", + "yyyy", + "quarter", + "qq", + "q", + "month", + "mm", + "m", + "dayofyear", + "dy", + "y", + "day", + "dd", + "d", + "week", + "wk", + "ww", + "weekday", + "dw", + "w", + "hour", + "hh", + "minute", + "mi", + "n", + "second", + "ss", + "s", + "millisecond", + "ms", + "microsecond", + "mcs", + "nanosecond", + "ns", + ]; + let datediff_big = [ + "year", + "yy", + "yyyy", + "quarter", + "qq", + "q", + "month", + "mm", + "m", + "dayofyear", + "dy", + "y", + "day", + "dd", + "d", + "week", + "wk", + "ww", + "weekday", + "dw", + "w", + "hour", + "hh", + "minute", + "mi", + "n", + "second", + "ss", + "s", + "millisecond", + "ms", + "microsecond", + "mcs", + "nanosecond", + "ns", + ]; + let datepart = [ + "year", + "yy", + "yyyy", + "quarter", + "qq", + "q", + "month", + "mm", + "m", + "dayofyear", + "dy", + "y", + "day", + "dd", + "d", + "week", + "wk", + "ww", + "weekday", + "dw", + "w", + "hour", + "hh", + "minute", + "mi", + "n", + "second", + "ss", + "s", + "millisecond", + "ms", + "microsecond", + "mcs", + "nanosecond", + "ns", + "tzoffset", + "tz", + "iso_week", + "isowk", + "isoww", + ]; + let datename = [ + "year", + "yy", + "yyyy", + "quarter", + "qq", + "q", + "month", + "mm", + "m", + "dayofyear", + "dy", + "y", + "day", + "dd", + "d", + "week", + "wk", + "ww", + "weekday", + "dw", + "w", + "hour", + "hh", + "minute", + "mi", + "n", + "second", + "ss", + "s", + "millisecond", + "ms", + "microsecond", + "mcs", + "nanosecond", + "ns", + "tzoffset", + "tz", + "iso_week", + "isowk", + "isoww", + ]; + + for (function, dateparts) in [ + ("DATEADD", dateadd_and_datediff.as_slice()), + ("DATEDIFF", dateadd_and_datediff.as_slice()), + ("DATEDIFF_BIG", datediff_big.as_slice()), + ("DATEPART", datepart.as_slice()), + ("DATENAME", datename.as_slice()), + ] { + for (index, datepart) in dateparts.iter().enumerate() { + let datepart = if index % 2 == 0 { datepart.to_ascii_uppercase() } else { datepart.to_string() }; + let sql = match function { + "DATEADD" => format!("SELECT DATEADD({datepart}, amount, occurred_at) FROM events"), + "DATEDIFF" | "DATEDIFF_BIG" => { + format!("SELECT {function}({datepart}, started_at, ended_at) FROM events") + } + "DATEPART" | "DATENAME" => format!("SELECT {function}({datepart}, occurred_at) FROM events"), + _ => unreachable!(), + }; + let analysis = analyze_sql_references(&sql, Some("sqlserver")) + .unwrap_or_else(|error| panic!("{function}({datepart}, ...) should analyze: {error}")); + let columns: Vec<_> = analysis.columns.iter().map(|column| column.name.as_str()).collect(); + let expected = match function { + "DATEADD" => vec!["amount", "occurred_at"], + "DATEDIFF" | "DATEDIFF_BIG" => vec!["started_at", "ended_at"], + "DATEPART" | "DATENAME" => vec!["occurred_at"], + _ => unreachable!(), + }; + assert_eq!(columns, expected, "{function} must ignore the legal {datepart} datepart only"); + } + } +} + +#[test] +fn sqlserver_datepart_suppression_is_limited_to_unqualified_builtins() { + let sql = "SELECT dAtEaDd(SeCoNd, amount, occurred_at), dbo.DATEADD(SECOND, amount, occurred_at), custom_fn(MONTH, occurred_at), DATEADD(datepart_column, amount, occurred_at), SECOND FROM events"; + let analysis = analyze_sql_references(sql, Some("sqlserver")).unwrap(); + + let columns: Vec<_> = analysis.columns.iter().map(|column| column.name.as_str()).collect(); + assert_eq!( + columns, + vec![ + "amount", + "occurred_at", + "SECOND", + "amount", + "occurred_at", + "MONTH", + "occurred_at", + "datepart_column", + "amount", + "occurred_at", + "SECOND", + ] + ); +} + #[test] fn sqlserver_create_proc_and_procedure_are_equivalent() { for sql in ["CREATE PROC test\nAS\n", "CREATE PROCEDURE test\nAS\n", "CREATE PROC test AS SELECT 1;"] {