Skip to main content

uqa_sql/semantics/parameters/
datestyle.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! `DateStyle` input order and canonical assignments, including partial settings and reset defaults.
8
9use super::{definition::ParameterDefinition, identifier_list::split_identifier_list};
10use crate::SQLError;
11use uqa_core::{TemporalDateOrder, TemporalDateStyle as Style};
12
13#[derive(Clone, Copy, Default)]
14struct DateStyle {
15    style: Style,
16    order: TemporalDateOrder,
17}
18
19impl DateStyle {
20    fn canonical(setting: &str) -> Self {
21        let mut value = Self::default();
22        for token in setting.split(',').map(str::trim) {
23            match token {
24                "ISO" => value.style = Style::Iso,
25                "SQL" => value.style = Style::Sql,
26                "Postgres" => value.style = Style::Postgres,
27                "German" => value.style = Style::German,
28                "MDY" => value.order = TemporalDateOrder::MonthDayYear,
29                "DMY" => value.order = TemporalDateOrder::DayMonthYear,
30                "YMD" => value.order = TemporalDateOrder::YearMonthDay,
31                _ => {}
32            }
33        }
34        value
35    }
36
37    fn display(self) -> String {
38        let style = match self.style {
39            Style::Iso => "ISO",
40            Style::Sql => "SQL",
41            Style::Postgres => "Postgres",
42            Style::German => "German",
43        };
44        let order = match self.order {
45            TemporalDateOrder::MonthDayYear => "MDY",
46            TemporalDateOrder::DayMonthYear => "DMY",
47            TemporalDateOrder::YearMonthDay => "YMD",
48        };
49        format!("{style}, {order}")
50    }
51}
52
53/// The date order in a validated, canonical session setting.
54#[must_use]
55pub fn date_order(setting: &str) -> TemporalDateOrder {
56    DateStyle::canonical(setting).order
57}
58
59/// The output style in a validated, canonical session setting.
60#[must_use]
61pub fn date_style(setting: &str) -> Style {
62    DateStyle::canonical(setting).style
63}
64
65pub(super) fn parse_setting(
66    definition: &ParameterDefinition,
67    raw: &str,
68    current: &str,
69    reset: &str,
70) -> Result<String, SQLError> {
71    let error = |detail: String| SQLError::Diagnostic {
72        sqlstate: "22023".into(),
73        message: super::value::invalid_value_message(definition, raw),
74        detail: Some(detail),
75        hint: None,
76    };
77    let tokens =
78        split_identifier_list(raw, b',').ok_or_else(|| error("List syntax is invalid.".into()))?;
79    let mut value = DateStyle::canonical(current);
80    let reset = DateStyle::canonical(reset);
81    let mut have_style = false;
82    let mut have_order = false;
83    let mut conflict = false;
84    for token in tokens {
85        let lowered = token.to_ascii_lowercase();
86        let style = match lowered.as_str() {
87            "iso" => Some(Style::Iso),
88            "sql" => Some(Style::Sql),
89            "german" => Some(Style::German),
90            token if token.starts_with("postgres") => Some(Style::Postgres),
91            _ => None,
92        };
93        if let Some(style) = style {
94            conflict |= have_style && value.style != style;
95            value.style = style;
96            have_style = true;
97            if style == Style::German && !have_order {
98                value.order = TemporalDateOrder::DayMonthYear;
99            }
100            continue;
101        }
102        let order = match lowered.as_str() {
103            "ymd" => Some(TemporalDateOrder::YearMonthDay),
104            "dmy" => Some(TemporalDateOrder::DayMonthYear),
105            "mdy" | "us" => Some(TemporalDateOrder::MonthDayYear),
106            token if token.starts_with("euro") => Some(TemporalDateOrder::DayMonthYear),
107            token if token.starts_with("noneuro") => Some(TemporalDateOrder::MonthDayYear),
108            _ => None,
109        };
110        if let Some(order) = order {
111            conflict |= have_order && value.order != order;
112            value.order = order;
113            have_order = true;
114        } else if lowered == "default" {
115            if !have_style {
116                value.style = reset.style;
117            }
118            if !have_order {
119                value.order = reset.order;
120            }
121        } else {
122            return Err(error(format!("Unrecognized key word: \"{token}\".")));
123        }
124    }
125    if conflict {
126        return Err(error("Conflicting \"DateStyle\" specifications.".into()));
127    }
128    Ok(value.display())
129}
130
131#[cfg(test)]
132mod tests {
133    use super::*;
134
135    #[test]
136    fn assignments_preserve_unspecified_fields_and_use_reset_defaults() {
137        let definition = super::super::catalog::find_parameter("DateStyle").unwrap();
138        for (raw, current, reset, expected) in [
139            ("ISO", "SQL, YMD", "ISO, MDY", "ISO, YMD"),
140            ("German", "ISO, MDY", "ISO, MDY", "German, DMY"),
141            ("US, German", "ISO, YMD", "ISO, MDY", "German, MDY"),
142            ("DEFAULT, YMD", "SQL, MDY", "German, DMY", "German, YMD"),
143            ("SQL, DEFAULT", "ISO, MDY", "German, DMY", "SQL, DMY"),
144            ("european", "ISO, MDY", "ISO, MDY", "ISO, DMY"),
145            ("", "ISO, YMD", "ISO, MDY", "ISO, YMD"),
146        ] {
147            assert_eq!(
148                parse_setting(definition, raw, current, reset).unwrap(),
149                expected
150            );
151        }
152        for (raw, detail) in [
153            ("MDY,DMY", "Conflicting \"DateStyle\" specifications."),
154            ("ISO,", "List syntax is invalid."),
155            ("bogus", "Unrecognized key word: \"bogus\"."),
156        ] {
157            let error = parse_setting(definition, raw, "ISO, MDY", "ISO, MDY").unwrap_err();
158            assert_eq!(error.sqlstate(), Some("22023"));
159            assert_eq!(error.detail(), Some(detail));
160        }
161    }
162}