diff --git a/doc/user/content/sql/functions/justify-days.md b/doc/user/content/sql/functions/justify-days.md
index 37b0f5cddd833..a761f12a02e15 100644
--- a/doc/user/content/sql/functions/justify-days.md
+++ b/doc/user/content/sql/functions/justify-days.md
@@ -30,5 +30,5 @@ SELECT justify_days(interval '35 days');
 ```nofmt
   justify_days
 ----------------
- 1 month 5 days
+ 1 mon 5 days
 ```
diff --git a/doc/user/content/sql/types/interval.md b/doc/user/content/sql/types/interval.md
index 52a59f6646010..0eeba16e98513 100644
--- a/doc/user/content/sql/types/interval.md
+++ b/doc/user/content/sql/types/interval.md
@@ -19,8 +19,8 @@ Detail | Info
 **Size** | 16 bytes
 **Catalog name** | `pg_catalog.interval`
 **OID** | 1186
-**Min value** | -178956970 years -8 months -2147483648 days -2562047788:00:54.775808
-**Max value** | 178956970 years 7 months 2147483647 days 2562047788:00:54.775807
+**Min value** | -178956970 years -8 mons -2147483648 days -2562047788:00:54.775808
+**Max value** | 178956970 years 7 mons 2147483647 days 2562047788:00:54.775807
 
 ## Syntax
 
@@ -125,7 +125,7 @@ SELECT INTERVAL '1-2 3 4:5:6.7' AS interval_p;
 ```nofmt
             interval_f
 -----------------------------------
- 1 year 2 months 3 days 04:05:06.7
+ 1 year 2 mons 3 days 04:05:06.7
 ```
 
 ### PostgreSQL syntax
@@ -182,7 +182,7 @@ SELECT INTERVAL '1 day 2-3 4' MINUTE AS interval_w;
 ```nofmt
            interval_w
 ---------------------------------
- 2 years 3 months 1 day 00:04:00
+ 2 years 3 mons 1 day 00:04:00
 ```
 
 ### Interaction with timestamps
diff --git a/misc/python/materialize/checks/all_checks/datetime_functions.py b/misc/python/materialize/checks/all_checks/datetime_functions.py
index c954302300618..2150d0cfe974e 100644
--- a/misc/python/materialize/checks/all_checks/datetime_functions.py
+++ b/misc/python/materialize/checks/all_checks/datetime_functions.py
@@ -75,7 +75,13 @@ def validate(self) -> Testdrive:
             3 334 "2024-12-31 23:59:59" "2024-12-31 18:59:59" "2024-12-31 18:59:59"
             4 335 "2025-01-01 00:00:00" "2024-12-31 19:00:00" "2024-12-31 19:00:00"
 
-            > SELECT id, jd::text, jh::text, ji::text FROM datetime_fns_convert1
+            >[version>=2603500] SELECT id, jd::text, jh::text, ji::text FROM datetime_fns_convert1
+            1 "1 mon 5 days" "35 days" "1 mon 5 days"
+            2 27:00:00 "1 day 03:00:00" "1 day 03:00:00"
+            3 "1 mon -01:00:00" "1 mon -01:00:00" "29 days 23:00:00"
+            4 00:00:00 00:00:00 00:00:00
+
+            >[version<2603500] SELECT id, jd::text, jh::text, ji::text FROM datetime_fns_convert1
             1 "1 month 5 days" "35 days" "1 month 5 days"
             2 27:00:00 "1 day 03:00:00" "1 day 03:00:00"
             3 "1 month -01:00:00" "1 month -01:00:00" "29 days 23:00:00"
diff --git a/misc/python/materialize/version_consistency/ignore_filter/version_consistency_ignore_filter.py b/misc/python/materialize/version_consistency/ignore_filter/version_consistency_ignore_filter.py
index 0563ba504df93..f83d0dcdaf99d 100644
--- a/misc/python/materialize/version_consistency/ignore_filter/version_consistency_ignore_filter.py
+++ b/misc/python/materialize/version_consistency/ignore_filter/version_consistency_ignore_filter.py
@@ -43,6 +43,9 @@
 from materialize.output_consistency.input_data.operations.string_operations_provider import (
     TAG_REGEX,
 )
+from materialize.output_consistency.input_data.types.date_time_types_provider import (
+    INTERVAL_TYPE_IDENTIFIER,
+)
 from materialize.output_consistency.input_data.types.number_types_provider import (
     NON_INTEGER_TYPE_IDENTIFIERS,
 )
@@ -66,6 +69,7 @@
 MZ_VERSION_0_117_0 = MzVersion.parse_mz("v0.117.0")
 MZ_VERSION_0_118_0 = MzVersion.parse_mz("v0.118.0")
 MZ_VERSION_0_128_0 = MzVersion.parse_mz("v0.128.0")
+MZ_VERSION_26_35_0 = MzVersion.parse_mz("v26.35.0")
 
 
 class VersionConsistencyIgnoreFilter(GenericInconsistencyIgnoreFilter):
@@ -315,6 +319,20 @@ def _shall_ignore_content_mismatch(
                 "Involvement of unnest changes order with PR#29422 for both DFR and CTF"
             )
 
+        if (
+            self.lower_version <= MZ_VERSION_26_35_0 <= self.higher_version
+            and query_template.matches_any_expression(
+                partial(
+                    is_known_to_involve_exact_data_types,
+                    internal_data_type_identifiers={INTERVAL_TYPE_IDENTIFIER},
+                ),
+                True,
+            )
+        ):
+            return YesIgnore(
+                "Interval text output changed from 'month(s)' to 'mon(s)' with SQL-463"
+            )
+
         return super()._shall_ignore_content_mismatch(
             error,
             query_template,
diff --git a/src/expr/src/scalar/func/impls/date.rs b/src/expr/src/scalar/func/impls/date.rs
index f36c887df72e1..8da16e5721e6c 100644
--- a/src/expr/src/scalar/func/impls/date.rs
+++ b/src/expr/src/scalar/func/impls/date.rs
@@ -139,7 +139,7 @@ pub fn extract_date_inner(units: DateTimeUnits, date: NaiveDate) -> Result<Numer
         DateTimeUnits::Millennium => Ok(Numeric::from(date.millennium())),
         DateTimeUnits::Century => Ok(Numeric::from(date.century())),
         DateTimeUnits::Decade => Ok(Numeric::from(date.decade())),
-        DateTimeUnits::Year => Ok(Numeric::from(date.year())),
+        DateTimeUnits::Year => Ok(Numeric::from(date.extract_year())),
         DateTimeUnits::Quarter => Ok(Numeric::from(date.quarter())),
         DateTimeUnits::Week => Ok(Numeric::from(date.iso_week_number())),
         DateTimeUnits::Month => Ok(Numeric::from(date.month())),
diff --git a/src/expr/src/scalar/func/impls/timestamp.rs b/src/expr/src/scalar/func/impls/timestamp.rs
index 5648020899542..38084ba147568 100644
--- a/src/expr/src/scalar/func/impls/timestamp.rs
+++ b/src/expr/src/scalar/func/impls/timestamp.rs
@@ -417,7 +417,7 @@ where
         DateTimeUnits::Millennium => Ok(D::from(ts.millennium())),
         DateTimeUnits::Century => Ok(D::from(ts.century())),
         DateTimeUnits::Decade => Ok(D::from(ts.decade())),
-        DateTimeUnits::Year => Ok(D::from(ts.year())),
+        DateTimeUnits::Year => Ok(D::from(ts.extract_year())),
         DateTimeUnits::Quarter => Ok(D::from(ts.quarter())),
         DateTimeUnits::Week => Ok(D::from(ts.iso_week_number())),
         DateTimeUnits::Month => Ok(D::from(ts.month())),
diff --git a/src/expr/src/scalar/func/variadic.rs b/src/expr/src/scalar/func/variadic.rs
index 125784661cc36..1f1164272ad9d 100644
--- a/src/expr/src/scalar/func/variadic.rs
+++ b/src/expr/src/scalar/func/variadic.rs
@@ -1056,7 +1056,6 @@ fn make_mz_acl_item(
 }
 
 #[sqlfunc(sqlname = "makets")]
-// TODO(benesch): remove potentially dangerous usage of `as`.
 #[allow(clippy::as_conversions)]
 fn make_timestamp(
     year: i64,
@@ -1066,36 +1065,37 @@ fn make_timestamp(
     minute: i64,
     second_float: f64,
 ) -> Result<Option<CheckedTimestamp<NaiveDateTime>>, EvalError> {
-    let year: i32 = match year.try_into() {
-        Ok(year) => year,
-        Err(_) => return Ok(None),
-    };
-    let month: u32 = match month.try_into() {
-        Ok(month) => month,
-        Err(_) => return Ok(None),
-    };
-    let day: u32 = match day.try_into() {
-        Ok(day) => day,
-        Err(_) => return Ok(None),
-    };
-    let hour: u32 = match hour.try_into() {
-        Ok(hour) => hour,
-        Err(_) => return Ok(None),
-    };
-    let minute: u32 = match minute.try_into() {
-        Ok(minute) => minute,
-        Err(_) => return Ok(None),
-    };
-    let second = second_float as u32;
-    let micros = ((second_float - second as f64) * 1_000_000.0) as u32;
-    let date = match NaiveDate::from_ymd_opt(year, month, day) {
-        Some(date) => date,
-        None => return Ok(None),
-    };
-    let timestamp = match date.and_hms_micro_opt(hour, minute, second, micros) {
-        Some(timestamp) => timestamp,
-        None => return Ok(None),
-    };
+    // NOTE: This function never returns `Ok(None)`. The `Option` stays so
+    // that the derived `introduces_nulls` (and with it the nullability of
+    // existing objects planned with this function) does not change.
+
+    // Negative years are BC and there is no year 0. Chrono's astronomical
+    // numbering has 1 BC as year 0, so BC years shift by one.
+    if year == 0 {
+        return Err(EvalError::DateOutOfRange);
+    }
+    let year = if year < 0 { year + 1 } else { year };
+    let year: i32 = year.try_into().map_err(|_| EvalError::DateOutOfRange)?;
+    let month: u32 = month.try_into().map_err(|_| EvalError::DateOutOfRange)?;
+    let day: u32 = day.try_into().map_err(|_| EvalError::DateOutOfRange)?;
+    let date = NaiveDate::from_ymd_opt(year, month, day).ok_or(EvalError::DateOutOfRange)?;
+    // Allow exactly 24:00:00 (rolls over to midnight of the next day) and
+    // 60 seconds (rolls over into the next minute).
+    if !(0..=24).contains(&hour)
+        || !(0..=59).contains(&minute)
+        || !(0.0..=60.0).contains(&second_float)
+        || (hour == 24 && (minute > 0 || second_float > 0.0))
+    {
+        return Err(EvalError::TimestampOutOfRange);
+    }
+    // The cast is exact: second_float is in [0, 60].
+    let micros = (second_float * 1_000_000.0).round() as i64;
+    let time = chrono::Duration::microseconds((hour * 60 + minute) * 60 * 1_000_000 + micros);
+    let timestamp = date
+        .and_hms_opt(0, 0, 0)
+        .unwrap()
+        .checked_add_signed(time)
+        .ok_or(EvalError::TimestampOutOfRange)?;
     Ok(Some(timestamp.try_into()?))
 }
 
diff --git a/src/repr/src/adt/datetime.rs b/src/repr/src/adt/datetime.rs
index 12232874f325e..72aea07e75dcd 100644
--- a/src/repr/src/adt/datetime.rs
+++ b/src/repr/src/adt/datetime.rs
@@ -735,7 +735,10 @@ impl ParsedDateTime {
             if fmt.is_none() {
                 fmt = match value_parts.pop_front() {
                     Some(next_part) => {
-                        match determine_format_w_datetimefield(next_part.clone(), None)? {
+                        match determine_format_w_datetimefield(
+                            next_part.clone(),
+                            leading_time_precision,
+                        )? {
                             Some(TimePartFormat::SqlStandard(f)) => {
                                 match f {
                                     // Do not capture this token because expression
@@ -813,12 +816,13 @@ impl ParsedDateTime {
     pub fn build_parsed_datetime_timestamp(
         value: &str,
         era: CalendarEra,
+        order: DateOrder,
     ) -> Result<ParsedDateTime, String> {
         let mut pdt = ParsedDateTime::default();
 
         let mut ts_actual = tokenize_time_str(value)?;
 
-        fill_pdt_date(&mut pdt, &mut ts_actual)?;
+        fill_pdt_date(&mut pdt, &mut ts_actual, order, era)?;
 
         if let CalendarEra::BC = era {
             pdt.year = pdt.year.map(|mut y| {
@@ -1080,6 +1084,8 @@ impl ParsedDateTime {
 fn fill_pdt_date(
     pdt: &mut ParsedDateTime,
     actual: &mut VecDeque<TimeStrToken>,
+    order: DateOrder,
+    era: CalendarEra,
 ) -> Result<(), String> {
     use TimeStrToken::*;
 
@@ -1124,6 +1130,26 @@ fn fill_pdt_date(
         _ => (),
     }
 
+    // PostgreSQL under the pinned `DateStyle = ISO, MDY` reads a separated
+    // date whose leading field has one or two digits as month-day-year, and
+    // only a leading field of three or more digits as year-month-day. The
+    // formats below fill fields positionally as year-month-day, so record the
+    // digit counts up front and reorder the fields after a successful fill.
+    let mdy = match (order, actual.front()) {
+        (DateOrder::Mdy, Some(&Num(_, digits))) => digits <= 2,
+        _ => false,
+    };
+    // Digit count of the third numeric field, the year in a month-day-year
+    // date, which decides two-digit-year windowing.
+    let year_digits = actual
+        .iter()
+        .take_while(|t| matches!(t, Num(..) | Dash | Delim))
+        .filter_map(|t| match t {
+            Num(_, digits) => Some(*digits),
+            _ => None,
+        })
+        .nth(2);
+
     let valid_formats = [
         [
             Num(0, 1), // year
@@ -1153,6 +1179,22 @@ fn fill_pdt_date(
     for expected in valid_formats {
         match fill_pdt_from_tokens(pdt, actual, &expected, DateTimeField::Year, 1) {
             Ok(()) => {
+                // In a month-day-year date the positional fill above put the
+                // month in `year`, the day in `month`, and the year in `day`.
+                if mdy {
+                    if let (Some(month), Some(day), Some(mut year)) = (pdt.year, pdt.month, pdt.day)
+                    {
+                        // Window two-digit years into 1970..=2069, as
+                        // PostgreSQL does. Explicit BC years are never
+                        // windowed.
+                        if era == CalendarEra::AD && year_digits.is_some_and(|d| d <= 2) {
+                            year.unit += if year.unit < 70 { 2000 } else { 1900 };
+                        }
+                        pdt.year = Some(year);
+                        pdt.month = Some(month);
+                        pdt.day = Some(day);
+                    }
+                }
                 return Ok(());
             }
             Err(_) => {
@@ -1810,12 +1852,25 @@ pub(crate) fn tokenize_time_str(value: &str) -> Result<VecDeque<TimeStrToken>, S
     Ok(toks)
 }
 
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum CalendarEra {
     BC,
     AD,
 }
 
+/// Determines how ambiguous all-numeric dates like `01/02/03` are interpreted.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum DateOrder {
+    /// PostgreSQL semantics under the pinned `DateStyle = ISO, MDY`: a date
+    /// whose leading field has one or two digits is month-day-year, and a
+    /// two-digit year is windowed into 1970..=2069.
+    Mdy,
+    /// Always year-month-day, with no year windowing. Frozen behavior for
+    /// storage source casts, which must not change across releases (see the
+    /// stability contract in `mz_storage_types::sources::casts`).
+    LegacyYmd,
+}
+
 /// Takes a 'date timezone' 'date time timezone' string and splits it into 'date
 /// {time}' and 'timezone' components then checks for a 'CalenderEra' defaulting
 /// to 'AD'.
@@ -2839,10 +2894,79 @@ mod tests {
                 ..Default::default()
             },
         );
+        // A one- or two-digit leading field starts a month-day-year date, and
+        // a two-digit year is windowed into 1970..=2069.
+        run_test_build_parsed_datetime_timestamp(
+            "01/02/03",
+            ParsedDateTime {
+                year: Some(DateTimeFieldValue::new(2003, 0)),
+                month: Some(DateTimeFieldValue::new(1, 0)),
+                day: Some(DateTimeFieldValue::new(2, 0)),
+                ..Default::default()
+            },
+        );
+        run_test_build_parsed_datetime_timestamp(
+            "01-02-70 3:4:5.6",
+            ParsedDateTime {
+                year: Some(DateTimeFieldValue::new(1970, 0)),
+                month: Some(DateTimeFieldValue::new(1, 0)),
+                day: Some(DateTimeFieldValue::new(2, 0)),
+                hour: Some(DateTimeFieldValue::new(3, 0)),
+                minute: Some(DateTimeFieldValue::new(4, 0)),
+                second: Some(DateTimeFieldValue::new(5, 600_000_000)),
+                ..Default::default()
+            },
+        );
+        // A four-digit year in month-day-year position is not windowed.
+        run_test_build_parsed_datetime_timestamp(
+            "1/2/1999",
+            ParsedDateTime {
+                year: Some(DateTimeFieldValue::new(1999, 0)),
+                month: Some(DateTimeFieldValue::new(1, 0)),
+                day: Some(DateTimeFieldValue::new(2, 0)),
+                ..Default::default()
+            },
+        );
+        // BC years are never windowed.
+        assert_eq!(
+            ParsedDateTime::build_parsed_datetime_timestamp(
+                "01/02/03",
+                CalendarEra::BC,
+                DateOrder::Mdy,
+            )
+            .unwrap(),
+            ParsedDateTime {
+                year: Some(DateTimeFieldValue::new(-3, 0)),
+                month: Some(DateTimeFieldValue::new(1, 0)),
+                day: Some(DateTimeFieldValue::new(2, 0)),
+                ..Default::default()
+            },
+        );
+        // The legacy order keeps the frozen year-month-day interpretation
+        // with no windowing.
+        assert_eq!(
+            ParsedDateTime::build_parsed_datetime_timestamp(
+                "01/02/03",
+                CalendarEra::AD,
+                DateOrder::LegacyYmd,
+            )
+            .unwrap(),
+            ParsedDateTime {
+                year: Some(DateTimeFieldValue::new(1, 0)),
+                month: Some(DateTimeFieldValue::new(2, 0)),
+                day: Some(DateTimeFieldValue::new(3, 0)),
+                ..Default::default()
+            },
+        );
 
         fn run_test_build_parsed_datetime_timestamp(test: &str, res: ParsedDateTime) {
             assert_eq!(
-                ParsedDateTime::build_parsed_datetime_timestamp(test, CalendarEra::AD).unwrap(),
+                ParsedDateTime::build_parsed_datetime_timestamp(
+                    test,
+                    CalendarEra::AD,
+                    DateOrder::Mdy
+                )
+                .unwrap(),
                 res
             );
         }
diff --git a/src/repr/src/adt/interval.rs b/src/repr/src/adt/interval.rs
index 65e775b5914d4..a61d64b1253e5 100644
--- a/src/repr/src/adt/interval.rs
+++ b/src/repr/src/adt/interval.rs
@@ -448,27 +448,6 @@ impl Interval {
         Ok(Duration::from_micros(micros))
     }
 
-    /// Truncate the "head" of the interval, removing all time units greater than `f`.
-    pub fn truncate_high_fields(&mut self, f: DateTimeField) {
-        match f {
-            DateTimeField::Year => {}
-            DateTimeField::Month => self.months %= 12,
-            DateTimeField::Day => self.months = 0,
-            DateTimeField::Hour | DateTimeField::Minute | DateTimeField::Second => {
-                self.months = 0;
-                self.days = 0;
-                self.micros %= f.next_largest().micros_multiplier()
-            }
-            DateTimeField::Millennium
-            | DateTimeField::Century
-            | DateTimeField::Decade
-            | DateTimeField::Milliseconds
-            | DateTimeField::Microseconds => {
-                unreachable!("Cannot truncate interval by {f}");
-            }
-        }
-    }
-
     /// Truncate the "tail" of the interval, removing all time units less than `f`.
     /// # Arguments
     /// - `f`: Round the interval down to the specified time unit.
@@ -753,7 +732,7 @@ impl Interval {
 ///
 /// Example outputs:
 ///
-/// * 1 year 2 months 5 days 03:04:00
+/// * 1 year 2 mons 5 days 03:04:00
 /// * -1 year +5 days +18:59:29.3
 /// * 00:00:00
 impl fmt::Display for Interval {
@@ -793,7 +772,7 @@ impl fmt::Display for Interval {
             if neg_months {
                 f.write_char('-')?;
             }
-            write!(f, "{} month", months)?;
+            write!(f, "{} mon", months)?;
             if months > 1 || neg_months {
                 f.write_char('s')?;
             }
@@ -943,12 +922,12 @@ mod test {
             .to_string()
         }
 
-        assert_eq!(mon(1), "1 month");
+        assert_eq!(mon(1), "1 mon");
         assert_eq!(mon(12), "1 year");
-        assert_eq!(mon(13), "1 year 1 month");
+        assert_eq!(mon(13), "1 year 1 mon");
         assert_eq!(mon(24), "2 years");
-        assert_eq!(mon(25), "2 years 1 month");
-        assert_eq!(mon(26), "2 years 2 months");
+        assert_eq!(mon(25), "2 years 1 mon");
+        assert_eq!(mon(26), "2 years 2 mons");
 
         fn dur(days: i32, micros: i64) -> String {
             Interval::new(0, days, micros).to_string()
@@ -1022,14 +1001,14 @@ mod test {
         fn mon_dur(mon: i32, days: i32, micros: i64) -> String {
             Interval::new(mon, days, micros).to_string()
         }
-        assert_eq!(&mon_dur(1, 2, 6 * 1_000_000), "1 month 2 days 00:00:06");
+        assert_eq!(&mon_dur(1, 2, 6 * 1_000_000), "1 mon 2 days 00:00:06");
         assert_eq!(
             &mon_dur(1, 2, (45 * 60 * 1_000_000) + (6 * 1_000_000)),
-            "1 month 2 days 00:45:06"
+            "1 mon 2 days 00:45:06"
         );
         assert_eq!(
             &mon_dur(1, 2, (3 * 60 * 60 * 1_000_000) + (6 * 1_000_000)),
-            "1 month 2 days 03:00:06"
+            "1 mon 2 days 03:00:06"
         );
         assert_eq!(
             &mon_dur(
@@ -1037,37 +1016,37 @@ mod test {
                 0,
                 (3 * 60 * 60 * 1_000_000) + (45 * 60 * 1_000_000) + (6 * 1_000_000)
             ),
-            "2 years 2 months 03:45:06"
+            "2 years 2 mons 03:45:06"
         );
         assert_eq!(
             &mon_dur(26, 0, (3 * 60 * 60 * 1_000_000) + (6 * 1_000_000)),
-            "2 years 2 months 03:00:06"
+            "2 years 2 mons 03:00:06"
         );
         assert_eq!(
             &mon_dur(26, 0, 3 * 60 * 60 * 1_000_000),
-            "2 years 2 months 03:00:00"
+            "2 years 2 mons 03:00:00"
         );
         assert_eq!(
             &mon_dur(26, 0, (45 * 60 * 1_000_000) + (6 * 1_000_000)),
-            "2 years 2 months 00:45:06"
+            "2 years 2 mons 00:45:06"
         );
         assert_eq!(
             &mon_dur(26, 0, 45 * 60 * 1_000_000),
-            "2 years 2 months 00:45:00"
+            "2 years 2 mons 00:45:00"
         );
-        assert_eq!(&mon_dur(26, 0, 6 * 1_000_000), "2 years 2 months 00:00:06");
+        assert_eq!(&mon_dur(26, 0, 6 * 1_000_000), "2 years 2 mons 00:00:06");
 
         assert_eq!(
             &mon_dur(26, -2, -6 * 1_000_000),
-            "2 years 2 months -2 days -00:00:06"
+            "2 years 2 mons -2 days -00:00:06"
         );
         assert_eq!(
             &mon_dur(26, -2, (-45 * 60 * 1_000_000) + (-6 * 1_000_000)),
-            "2 years 2 months -2 days -00:45:06"
+            "2 years 2 mons -2 days -00:45:06"
         );
         assert_eq!(
             &mon_dur(26, -2, (-3 * 60 * 60 * 1_000_000) + (-6 * 1_000_000)),
-            "2 years 2 months -2 days -03:00:06"
+            "2 years 2 mons -2 days -03:00:06"
         );
         assert_eq!(
             &mon_dur(
@@ -1075,37 +1054,34 @@ mod test {
                 0,
                 (-3 * 60 * 60 * 1_000_000) + (-45 * 60 * 1_000_000) + (-6 * 1_000_000)
             ),
-            "2 years 2 months -03:45:06"
+            "2 years 2 mons -03:45:06"
         );
         assert_eq!(
             &mon_dur(26, 0, (-3 * 60 * 60 * 1_000_000) + (-6 * 1_000_000)),
-            "2 years 2 months -03:00:06"
+            "2 years 2 mons -03:00:06"
         );
         assert_eq!(
             &mon_dur(26, 0, -3 * 60 * 60 * 1_000_000),
-            "2 years 2 months -03:00:00"
+            "2 years 2 mons -03:00:00"
         );
         assert_eq!(
             &mon_dur(26, 0, (-45 * 60 * 1_000_000) + (-6 * 1_000_000)),
-            "2 years 2 months -00:45:06"
+            "2 years 2 mons -00:45:06"
         );
         assert_eq!(
             &mon_dur(26, 0, -45 * 60 * 1_000_000),
-            "2 years 2 months -00:45:00"
-        );
-        assert_eq!(
-            &mon_dur(26, 0, -6 * 1_000_000),
-            "2 years 2 months -00:00:06"
+            "2 years 2 mons -00:45:00"
         );
+        assert_eq!(&mon_dur(26, 0, -6 * 1_000_000), "2 years 2 mons -00:00:06");
 
-        assert_eq!(&mon_dur(-1, 2, 6 * 1_000_000), "-1 months +2 days 00:00:06");
+        assert_eq!(&mon_dur(-1, 2, 6 * 1_000_000), "-1 mons +2 days 00:00:06");
         assert_eq!(
             &mon_dur(-1, 2, (45 * 60 * 1_000_000) + (6 * 1_000_000)),
-            "-1 months +2 days 00:45:06"
+            "-1 mons +2 days 00:45:06"
         );
         assert_eq!(
             &mon_dur(-1, 2, (3 * 60 * 60 * 1_000_000) + (6 * 1_000_000)),
-            "-1 months +2 days 03:00:06"
+            "-1 mons +2 days 03:00:06"
         );
         assert_eq!(
             &mon_dur(
@@ -1113,40 +1089,40 @@ mod test {
                 0,
                 (3 * 60 * 60 * 1_000_000) + (45 * 60 * 1_000_000) + (6 * 1_000_000)
             ),
-            "-2 years -2 months +03:45:06"
+            "-2 years -2 mons +03:45:06"
         );
         assert_eq!(
             &mon_dur(-26, 0, (3 * 60 * 60 * 1_000_000) + (6 * 1_000_000)),
-            "-2 years -2 months +03:00:06"
+            "-2 years -2 mons +03:00:06"
         );
         assert_eq!(
             &mon_dur(-26, 0, 3 * 60 * 60 * 1_000_000),
-            "-2 years -2 months +03:00:00"
+            "-2 years -2 mons +03:00:00"
         );
         assert_eq!(
             &mon_dur(-26, 0, (45 * 60 * 1_000_000) + (6 * 1_000_000)),
-            "-2 years -2 months +00:45:06"
+            "-2 years -2 mons +00:45:06"
         );
         assert_eq!(
             &mon_dur(-26, 0, 45 * 60 * 1_000_000),
-            "-2 years -2 months +00:45:00"
+            "-2 years -2 mons +00:45:00"
         );
         assert_eq!(
             &mon_dur(-26, 0, 6 * 1_000_000),
-            "-2 years -2 months +00:00:06"
+            "-2 years -2 mons +00:00:06"
         );
 
         assert_eq!(
             &mon_dur(-26, -2, -6 * 1_000_000),
-            "-2 years -2 months -2 days -00:00:06"
+            "-2 years -2 mons -2 days -00:00:06"
         );
         assert_eq!(
             &mon_dur(-26, -2, (-45 * 60 * 1_000_000) + (-6 * 1_000_000)),
-            "-2 years -2 months -2 days -00:45:06"
+            "-2 years -2 mons -2 days -00:45:06"
         );
         assert_eq!(
             &mon_dur(-26, -2, (-3 * 60 * 60 * 1_000_000) + (-6 * 1_000_000)),
-            "-2 years -2 months -2 days -03:00:06"
+            "-2 years -2 mons -2 days -03:00:06"
         );
         assert_eq!(
             &mon_dur(
@@ -1154,27 +1130,27 @@ mod test {
                 0,
                 (-3 * 60 * 60 * 1_000_000) + (-45 * 60 * 1_000_000) + (-6 * 1_000_000)
             ),
-            "-2 years -2 months -03:45:06"
+            "-2 years -2 mons -03:45:06"
         );
         assert_eq!(
             &mon_dur(-26, 0, (-3 * 60 * 60 * 1_000_000) + (-6 * 1_000_000)),
-            "-2 years -2 months -03:00:06"
+            "-2 years -2 mons -03:00:06"
         );
         assert_eq!(
             &mon_dur(-26, 0, -3 * 60 * 60 * 1_000_000),
-            "-2 years -2 months -03:00:00"
+            "-2 years -2 mons -03:00:00"
         );
         assert_eq!(
             &mon_dur(-26, 0, (-45 * 60 * 1_000_000) + (-6 * 1_000_000)),
-            "-2 years -2 months -00:45:06"
+            "-2 years -2 mons -00:45:06"
         );
         assert_eq!(
             &mon_dur(-26, 0, -45 * 60 * 1_000_000),
-            "-2 years -2 months -00:45:00"
+            "-2 years -2 mons -00:45:00"
         );
         assert_eq!(
             &mon_dur(-26, 0, -6 * 1_000_000),
-            "-2 years -2 months -00:00:06"
+            "-2 years -2 mons -00:00:06"
         );
     }
 
@@ -1293,99 +1269,6 @@ mod test {
         }
     }
 
-    #[mz_ore::test]
-    fn test_interval_value_truncate_high_fields() {
-        use DateTimeField::*;
-
-        // (month, day, microsecond) tuples
-        let mut test_cases = [
-            (
-                Year,
-                (
-                    321,
-                    7,
-                    (13 * 60 * 60 * 1_000_000) + (45 * 60 * 1_000_000) + (21 * 1_000_000),
-                ),
-                (
-                    321,
-                    7,
-                    (13 * 60 * 60 * 1_000_000) + (45 * 60 * 1_000_000) + (21 * 1_000_000),
-                ),
-            ),
-            (
-                Month,
-                (
-                    321,
-                    7,
-                    (13 * 60 * 60 * 1_000_000) + (45 * 60 * 1_000_000) + (21 * 1_000_000),
-                ),
-                (
-                    9,
-                    7,
-                    (13 * 60 * 60 * 1_000_000) + (45 * 60 * 1_000_000) + (21 * 1_000_000),
-                ),
-            ),
-            (
-                Day,
-                (
-                    321,
-                    7,
-                    (13 * 60 * 60 * 1_000_000) + (45 * 60 * 1_000_000) + (21 * 1_000_000),
-                ),
-                (
-                    0,
-                    7,
-                    (13 * 60 * 60 * 1_000_000) + (45 * 60 * 1_000_000) + (21 * 1_000_000),
-                ),
-            ),
-            (
-                Hour,
-                (
-                    321,
-                    7,
-                    (13 * 60 * 60 * 1_000_000) + (45 * 60 * 1_000_000) + (21 * 1_000_000),
-                ),
-                (
-                    0,
-                    0,
-                    (13 * 60 * 60 * 1_000_000) + (45 * 60 * 1_000_000) + (21 * 1_000_000),
-                ),
-            ),
-            (
-                Minute,
-                (
-                    321,
-                    7,
-                    (13 * 60 * 60 * 1_000_000) + (45 * 60 * 1_000_000) + (21 * 1_000_000),
-                ),
-                (0, 0, (45 * 60 * 1_000_000) + (21 * 1_000_000)),
-            ),
-            (
-                Second,
-                (
-                    321,
-                    7,
-                    (13 * 60 * 60 * 1_000_000) + (45 * 60 * 1_000_000) + (21 * 1_000_000),
-                ),
-                (0, 0, 21 * 1_000_000),
-            ),
-        ];
-
-        for test in test_cases.iter_mut() {
-            let mut i = Interval::new((test.1).0, (test.1).1, (test.1).2);
-            let j = Interval::new((test.2).0, (test.2).1, (test.2).2);
-
-            i.truncate_high_fields(test.0);
-
-            if i != j {
-                panic!(
-                    "test_interval_value_truncate_high_fields failed on {} \n actual: {:?} \n expected: {:?}",
-                    test.0, i, j
-                );
-            }
-        }
-    }
-
     #[mz_ore::test]
     fn test_convert_date_time_unit() {
         assert_eq!(
diff --git a/src/repr/src/adt/timestamp.rs b/src/repr/src/adt/timestamp.rs
index a3b0853db29c3..8ea0b3c8d6ff2 100644
--- a/src/repr/src/adt/timestamp.rs
+++ b/src/repr/src/adt/timestamp.rs
@@ -184,6 +184,14 @@ pub trait DateLike: chrono::Datelike {
         naive_date.and_utc().timestamp()
     }
 
+    /// The year in SQL's numbering, where 1 BC is year -1 and there is no
+    /// year 0. Chrono's `year` uses astronomical numbering, where 1 BC is
+    /// year 0.
+    fn extract_year(&self) -> i32 {
+        let year = self.year();
+        if year <= 0 { year - 1 } else { year }
+    }
+
     fn millennium(&self) -> i32 {
         (self.year() + if self.year() > 0 { 999 } else { -1_000 }) / 1_000
     }
diff --git a/src/repr/src/strconv.rs b/src/repr/src/strconv.rs
index 84023a9a9fa36..b09784f58f0bb 100644
--- a/src/repr/src/strconv.rs
+++ b/src/repr/src/strconv.rs
@@ -52,7 +52,7 @@ use uuid::Uuid;
 
 use crate::adt::array::ArrayDimension;
 use crate::adt::date::Date;
-use crate::adt::datetime::{self, DateTimeField, ParsedDateTime};
+use crate::adt::datetime::{self, DateOrder, DateTimeField, ParsedDateTime};
 use crate::adt::interval::Interval;
 use crate::adt::jsonb::{Jsonb, JsonbRef};
 use crate::adt::mz_acl_item::{AclItem, MzAclItem};
@@ -225,6 +225,18 @@ pub fn parse_mz_timestamp(s: &str) -> Result<crate::Timestamp, ParseError> {
         .map_err(|e| ParseError::invalid_input_syntax("mz_timestamp", s).with_details(e))
 }
 
+/// Parses an `mz_timestamp` from `s` with the frozen legacy date parsing in
+/// its timestamp fallback.
+///
+/// NOTE: This exists solely to keep the storage source cast
+/// `CastStringToMzTimestamp` evaluation-stable across releases (see the
+/// stability contract in `mz_storage_types::sources::casts`). Use
+/// [`parse_mz_timestamp`] everywhere else.
+pub fn parse_mz_timestamp_legacy(s: &str) -> Result<crate::Timestamp, ParseError> {
+    crate::Timestamp::from_str_legacy(s.trim())
+        .map_err(|e| ParseError::invalid_input_syntax("mz_timestamp", s).with_details(e))
+}
+
 /// Writes an `mz_timestamp` to `buf`.
 pub fn format_mz_timestamp<F>(buf: &mut F, u: crate::Timestamp) -> Nestable
 where
@@ -399,7 +411,10 @@ where
 /// <time zone interval> ::=
 ///     <sign> <hours value> <colon> <minutes value>
 /// ```
-fn parse_timestamp_string(s: &str) -> Result<(NaiveDate, NaiveTime, Timezone), String> {
+fn parse_timestamp_string(
+    s: &str,
+    order: DateOrder,
+) -> Result<(NaiveDate, NaiveTime, Timezone), String> {
     if s.is_empty() {
         return Err("timestamp string is empty".into());
     }
@@ -418,7 +433,7 @@ fn parse_timestamp_string(s: &str) -> Result<(NaiveDate, NaiveTime, Timezone), S
 
     let (ts_string, tz_string, era) = datetime::split_timestamp_string(s);
 
-    let pdt = ParsedDateTime::build_parsed_datetime_timestamp(ts_string, era)?;
+    let pdt = ParsedDateTime::build_parsed_datetime_timestamp(ts_string, era, order)?;
     let d: NaiveDate = pdt.compute_date()?;
     let t: NaiveTime = pdt.compute_time()?;
 
@@ -433,7 +448,21 @@ fn parse_timestamp_string(s: &str) -> Result<(NaiveDate, NaiveTime, Timezone), S
 
 /// Parses a [`Date`] from `s`.
 pub fn parse_date(s: &str) -> Result<Date, ParseError> {
-    match parse_timestamp_string(s) {
+    parse_date_inner(s, DateOrder::Mdy)
+}
+
+/// Parses a [`Date`] from `s` with the frozen legacy year-month-day
+/// interpretation of ambiguous dates.
+///
+/// NOTE: This exists solely to keep the storage source cast `CastStringToDate`
+/// evaluation-stable across releases (see the stability contract in
+/// `mz_storage_types::sources::casts`). Use [`parse_date`] everywhere else.
+pub fn parse_date_legacy(s: &str) -> Result<Date, ParseError> {
+    parse_date_inner(s, DateOrder::LegacyYmd)
+}
+
+fn parse_date_inner(s: &str, order: DateOrder) -> Result<Date, ParseError> {
+    match parse_timestamp_string(s, order) {
         Ok((date, _, _)) => Date::try_from(date).map_err(|_| ParseError::out_of_range("date", s)),
         Err(e) => Err(ParseError::invalid_input_syntax("date", s).with_details(e)),
     }
@@ -478,7 +507,25 @@ where
 
 /// Parses a `NaiveDateTime` from `s`.
 pub fn parse_timestamp(s: &str) -> Result<CheckedTimestamp<NaiveDateTime>, ParseError> {
-    match parse_timestamp_string(s) {
+    parse_timestamp_inner(s, DateOrder::Mdy)
+}
+
+/// Parses a `NaiveDateTime` from `s` with the frozen legacy year-month-day
+/// interpretation of ambiguous dates.
+///
+/// NOTE: This exists solely to keep the storage source cast
+/// `CastStringToTimestamp` evaluation-stable across releases (see the
+/// stability contract in `mz_storage_types::sources::casts`). Use
+/// [`parse_timestamp`] everywhere else.
+pub fn parse_timestamp_legacy(s: &str) -> Result<CheckedTimestamp<NaiveDateTime>, ParseError> {
+    parse_timestamp_inner(s, DateOrder::LegacyYmd)
+}
+
+fn parse_timestamp_inner(
+    s: &str,
+    order: DateOrder,
+) -> Result<CheckedTimestamp<NaiveDateTime>, ParseError> {
+    match parse_timestamp_string(s, order) {
         Ok((date, time, _)) => CheckedTimestamp::from_timestamplike(date.and_time(time))
             .map_err(|_| ParseError::out_of_range("timestamp", s)),
         Err(e) => Err(ParseError::invalid_input_syntax("timestamp", s).with_details(e)),
@@ -502,7 +549,25 @@ where
 
 /// Parses a `DateTime<Utc>` from `s`. See `mz_expr::scalar::func::timezone_timestamp` for timezone anomaly considerations.
 pub fn parse_timestamptz(s: &str) -> Result<CheckedTimestamp<DateTime<Utc>>, ParseError> {
-    parse_timestamp_string(s)
+    parse_timestamptz_inner(s, DateOrder::Mdy)
+}
+
+/// Parses a `DateTime<Utc>` from `s` with the frozen legacy year-month-day
+/// interpretation of ambiguous dates.
+///
+/// NOTE: This exists solely to keep the storage source cast
+/// `CastStringToTimestampTz` evaluation-stable across releases (see the
+/// stability contract in `mz_storage_types::sources::casts`). Use
+/// [`parse_timestamptz`] everywhere else.
+pub fn parse_timestamptz_legacy(s: &str) -> Result<CheckedTimestamp<DateTime<Utc>>, ParseError> {
+    parse_timestamptz_inner(s, DateOrder::LegacyYmd)
+}
+
+fn parse_timestamptz_inner(
+    s: &str,
+    order: DateOrder,
+) -> Result<CheckedTimestamp<DateTime<Utc>>, ParseError> {
+    parse_timestamp_string(s, order)
         .and_then(|(date, time, timezone)| {
             use Timezone::*;
             let mut dt = date.and_time(time);
@@ -1778,8 +1843,10 @@ struct ListElementEscaper;
 
 impl ElementEscaper for ListElementEscaper {
     fn needs_escaping(elem: &[u8]) -> bool {
+        // The parser treats any case variant of unquoted "NULL" as null, so
+        // any such element must be quoted to round-trip.
         elem.is_empty()
-            || elem == b"NULL"
+            || elem.eq_ignore_ascii_case(b"NULL")
             || elem
                 .iter()
                 .any(|c| matches!(c, b'{' | b'}' | b',' | b'"' | b'\\') || c.is_ascii_whitespace())
@@ -1795,7 +1862,7 @@ struct MapElementEscaper;
 impl ElementEscaper for MapElementEscaper {
     fn needs_escaping(elem: &[u8]) -> bool {
         elem.is_empty()
-            || elem == b"NULL"
+            || elem.eq_ignore_ascii_case(b"NULL")
             || elem.iter().any(|c| {
                 matches!(c, b'{' | b'}' | b',' | b'"' | b'=' | b'>' | b'\\')
                     || c.is_ascii_whitespace()
@@ -2267,4 +2334,61 @@ mod tests {
         assert!(parse_oid_legacy("4294967295").is_err());
         assert!(parse_oid_legacy("nope").is_err());
     }
+
+    fn date(y: i32, m: u32, d: u32) -> Date {
+        Date::try_from(NaiveDate::from_ymd_opt(y, m, d).unwrap()).unwrap()
+    }
+
+    #[mz_ore::test]
+    fn test_parse_date_mdy() {
+        // Pinned `DateStyle = ISO, MDY`: a one- or two-digit leading field
+        // starts a month-day-year date, and a two-digit year is windowed
+        // into 1970..=2069.
+        assert_eq!(parse_date("01/02/03").unwrap(), date(2003, 1, 2));
+        assert_eq!(parse_date("1-2-3").unwrap(), date(2003, 1, 2));
+        assert_eq!(parse_date("01/02/69").unwrap(), date(2069, 1, 2));
+        assert_eq!(parse_date("01/02/70").unwrap(), date(1970, 1, 2));
+        assert_eq!(parse_date("01/02/1999").unwrap(), date(1999, 1, 2));
+        // A leading field of three or more digits is a year, with no
+        // windowing.
+        assert_eq!(parse_date("0099-01-08").unwrap(), date(99, 1, 8));
+        assert_eq!(parse_date("2003-01-02").unwrap(), date(2003, 1, 2));
+        // BC years are never windowed. Year 3 BC is year -2 in chrono.
+        assert_eq!(parse_date("01/02/03 BC").unwrap(), date(-2, 1, 2));
+        // A two-digit leading field is a month, so these are out of range.
+        assert!(parse_date("99-01-08").is_err());
+        assert!(parse_date("13/01/08").is_err());
+
+        assert_eq!(
+            parse_timestamp("01/02/03 04:05:06").unwrap().to_string(),
+            "2003-01-02 04:05:06"
+        );
+        assert_eq!(
+            parse_mz_timestamp("01/02/03").unwrap(),
+            parse_mz_timestamp("2003-01-02").unwrap()
+        );
+    }
+
+    #[mz_ore::test]
+    fn test_parse_date_legacy() {
+        // The frozen behavior keeps year-month-day for ambiguous dates, with
+        // no windowing. This divergence from `parse_date` must not change
+        // (storage stability).
+        assert_eq!(parse_date_legacy("01/02/03").unwrap(), date(1, 2, 3));
+        assert_eq!(parse_date_legacy("99-01-08").unwrap(), date(99, 1, 8));
+        assert!(parse_date_legacy("01/02/1999").is_err());
+        assert_eq!(
+            parse_timestamp_legacy("01/02/03 04:05:06")
+                .unwrap()
+                .to_string(),
+            "0001-02-03 04:05:06"
+        );
+        // The mz_timestamp fallback keeps the frozen interpretation, under
+        // which 0001-02-03 is out of range.
+        assert!(parse_mz_timestamp_legacy("01/02/03").is_err());
+        assert_eq!(
+            parse_mz_timestamp_legacy("2003-01-02").unwrap(),
+            parse_mz_timestamp("2003-01-02").unwrap()
+        );
+    }
 }
diff --git a/src/repr/src/timestamp.rs b/src/repr/src/timestamp.rs
index ac07e38a4cf19..2f5d46412f5dd 100644
--- a/src/repr/src/timestamp.rs
+++ b/src/repr/src/timestamp.rs
@@ -18,9 +18,12 @@ use mz_timely_util::temporal::BucketTimestamp;
 use proptest_derive::Arbitrary;
 use serde::{Deserialize, Serialize, Serializer};
 
+use chrono::{DateTime, Utc};
+
 use crate::adt::numeric::Numeric;
+use crate::adt::timestamp::CheckedTimestamp;
 use crate::refresh_schedule::RefreshSchedule;
-use crate::strconv::parse_timestamptz;
+use crate::strconv::{ParseError, parse_timestamptz, parse_timestamptz_legacy};
 
 include!(concat!(env!("OUT_DIR"), "/mz_repr.timestamp.rs"));
 
@@ -536,12 +539,29 @@ impl std::str::FromStr for Timestamp {
     type Err = String;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Self::parse_with(s, parse_timestamptz)
+    }
+}
+
+impl Timestamp {
+    /// Like the [`std::str::FromStr`] impl, but the timestamp fallback uses
+    /// the frozen legacy date parsing. Solely for the storage source cast
+    /// `CastStringToMzTimestamp` (see the stability contract in
+    /// `mz_storage_types::sources::casts`).
+    pub fn from_str_legacy(s: &str) -> Result<Self, String> {
+        Self::parse_with(s, parse_timestamptz_legacy)
+    }
+
+    fn parse_with(
+        s: &str,
+        parse_fallback: fn(&str) -> Result<CheckedTimestamp<DateTime<Utc>>, ParseError>,
+    ) -> Result<Self, String> {
         Ok(Self {
             internal: s
                 .parse::<u64>()
                 .map_err(|_| "could not parse as number of milliseconds since epoch".to_string())
                 .or_else(|err_num_of_millis| {
-                    parse_timestamptz(s)
+                    parse_fallback(s)
                         .map_err(|parse_error| {
                             format!(
                                 "{}; could not parse as date and time: {}",
diff --git a/src/repr/tests/strconv.rs b/src/repr/tests/strconv.rs
index 41679837cc2c4..58364213a2ea1 100644
--- a/src/repr/tests/strconv.rs
+++ b/src/repr/tests/strconv.rs
@@ -523,7 +523,7 @@ fn miri_test_format_list() {
     .unwrap();
     assert_eq!(
         out,
-        r#"{a,"a\"b","",NULL,"NULL",nUlL,"  spaces ","a,b","\\","a\\b\"c\\d\""}"#
+        r#"{a,"a\"b","",NULL,"NULL","nUlL","  spaces ","a,b","\\","a\\b\"c\\d\""}"#
     );
 }
 
diff --git a/src/sql-parser/src/ast/defs/value.rs b/src/sql-parser/src/ast/defs/value.rs
index 348ebb7ae0826..2556d7b14c56b 100644
--- a/src/sql-parser/src/ast/defs/value.rs
+++ b/src/sql-parser/src/ast/defs/value.rs
@@ -249,8 +249,9 @@ impl FromStr for DateTimeField {
 pub struct IntervalValue {
     /// The raw `[value]` that was present in `INTERVAL '[value]'`
     pub value: String,
-    /// The most significant DateTimeField to propagate to Interval in
-    /// compute_interval.
+    /// The high end of the range qualifier, e.g. HOUR in `INTERVAL '...'
+    /// HOUR TO MINUTE`. Only disambiguates parsing of ambiguous time-like
+    /// parts of `value`. Fields above it are kept, as in PostgreSQL.
     pub precision_high: DateTimeField,
     /// The least significant DateTimeField to propagate to Interval in
     /// compute_interval.
diff --git a/src/sql/src/plan/literal.rs b/src/sql/src/plan/literal.rs
index 25eab9c41c8fa..50e8dc9327281 100644
--- a/src/sql/src/plan/literal.rs
+++ b/src/sql/src/plan/literal.rs
@@ -27,7 +27,9 @@ pub fn plan_interval(iv: &IntervalValue) -> Result<Interval, PlanError> {
         },
         parser_datetimefield_to_adt(iv.precision_low),
     )?;
-    i.truncate_high_fields(parser_datetimefield_to_adt(iv.precision_high));
+    // Like PostgreSQL, the range qualifier only disambiguates parsing and
+    // discards fields below precision_low. Fields above precision_high are
+    // kept as written.
     i.truncate_low_fields(
         parser_datetimefield_to_adt(iv.precision_low),
         iv.fsec_max_precision,
diff --git a/src/storage-types/src/sources/casts.rs b/src/storage-types/src/sources/casts.rs
index ec6df50cc4420..5813a22ca80e2 100644
--- a/src/storage-types/src/sources/casts.rs
+++ b/src/storage-types/src/sources/casts.rs
@@ -220,9 +220,9 @@ impl CastFunc {
             CastFunc::CastStringToUint64 => {
                 Ok(Datum::UInt64(strconv::parse_uint64(a).map_err(parse_err)?))
             }
-            CastFunc::CastStringToDate => {
-                Ok(Datum::Date(strconv::parse_date(a).map_err(parse_err)?))
-            }
+            CastFunc::CastStringToDate => Ok(Datum::Date(
+                strconv::parse_date_legacy(a).map_err(parse_err)?,
+            )),
             CastFunc::CastStringToTime => {
                 Ok(Datum::Time(strconv::parse_time(a).map_err(parse_err)?))
             }
@@ -239,7 +239,7 @@ impl CastFunc {
                 Ok(arena.push_unary_row(jsonb.into_row()))
             }
             CastFunc::CastStringToMzTimestamp => Ok(Datum::MzTimestamp(
-                strconv::parse_mz_timestamp(a).map_err(parse_err)?,
+                strconv::parse_mz_timestamp_legacy(a).map_err(parse_err)?,
             )),
 
             // Parameterized eager casts.
@@ -253,12 +253,12 @@ impl CastFunc {
                 Ok(Datum::from(d.into_inner()))
             }
             CastFunc::CastStringToTimestamp(precision) => {
-                let out = strconv::parse_timestamp(a)?;
+                let out = strconv::parse_timestamp_legacy(a)?;
                 let updated = out.round_to_precision(*precision)?;
                 Ok(Datum::Timestamp(updated))
             }
             CastFunc::CastStringToTimestampTz(precision) => {
-                let out = strconv::parse_timestamptz(a)?;
+                let out = strconv::parse_timestamptz_legacy(a)?;
                 let updated = out.round_to_precision(*precision)?;
                 Ok(Datum::TimestampTz(updated))
             }
@@ -498,6 +498,25 @@ mod tests {
         assert!(matches!(result, Datum::Date(_)));
     }
 
+    #[mz_ore::test]
+    fn test_cast_string_to_date_frozen_ambiguous() {
+        // Ambiguous dates keep the frozen year-month-day interpretation with
+        // no two-digit-year windowing, diverging from the SQL layer's
+        // `DateStyle = ISO, MDY` semantics. This must not change (see the
+        // stability contract above).
+        let arena = RowArena::new();
+        let expr = cast_col0(CastFunc::CastStringToDate);
+        for (input, expected) in [("01/02/03", "0001-02-03"), ("99-01-08", "0099-01-08")] {
+            let result = expr.eval(&[Datum::String(input)], &arena).unwrap();
+            let Datum::Date(d) = result else {
+                panic!("expected Date, got {:?}", result);
+            };
+            let mut buf = String::new();
+            strconv::format_date(&mut buf, d);
+            assert_eq!(buf, expected, "for input {input:?}");
+        }
+    }
+
     #[mz_ore::test]
     fn test_cast_string_to_uuid() {
         let arena = RowArena::new();
diff --git a/test/iceberg/catalog.td b/test/iceberg/catalog.td
index e84c3ecbd0da8..25c3b2d4ed208 100644
--- a/test/iceberg/catalog.td
+++ b/test/iceberg/catalog.td
@@ -216,7 +216,7 @@ $ duckdb-query name=iceberg
 SELECT id, dur FROM iceberg_scan('s3://test-bucket/default_namespace/interval_table') ORDER BY id
 1 1 day
 2 02:30:00
-3 1 year 3 months
+3 1 year 3 mons
 4 00:00:00
 
 # Test updating interval values
@@ -228,7 +228,7 @@ $ duckdb-query name=iceberg
 SELECT id, dur FROM iceberg_scan('s3://test-bucket/default_namespace/interval_table') ORDER BY id
 1 5 days 12:00:00
 2 02:30:00
-3 1 year 3 months
+3 1 year 3 mons
 4 00:00:00
 
 # Test range types (int4range)
diff --git a/test/legacy-upgrade/check-from-v0.27.0-interval-literals.td b/test/legacy-upgrade/check-from-v0.27.0-interval-literals.td
index 9ac50bcbd95c4..b72322f8c8eb2 100644
--- a/test/legacy-upgrade/check-from-v0.27.0-interval-literals.td
+++ b/test/legacy-upgrade/check-from-v0.27.0-interval-literals.td
@@ -9,10 +9,10 @@
 
 
 > SELECT * FROM postgres_interval1;
-"1 year 2 months 3 days 14:42:07.8"
+"1 year 2 mons 3 days 14:42:07.8"
 
 > SELECT * FROM postgres_interval2;
-"1 year 2 months 3 days 14:42:07.8"
+"1 year 2 mons 3 days 14:42:07.8"
 
 > SELECT * FROM interval_second;
 00:02:03
@@ -27,7 +27,7 @@
 "123 days"
 
 > SELECT * FROM interval_month;
-"10 years 3 months"
+"10 years 3 mons"
 
 > SELECT * FROM interval_year;
 "123 years"
diff --git a/test/legacy-upgrade/check-from-v0.27.0-time-literals.td b/test/legacy-upgrade/check-from-v0.27.0-time-literals.td
index 4dc1f6c99c918..7d84c84a82440 100644
--- a/test/legacy-upgrade/check-from-v0.27.0-time-literals.td
+++ b/test/legacy-upgrade/check-from-v0.27.0-time-literals.td
@@ -8,4 +8,4 @@
 # by the Apache License, Version 2.0.
 
 > SELECT * FROM time_literals;
-"2007-02-01" "1 year 2 months 3 days 04:05:06.7" "01:23:45" "2007-02-01 15:04:05.123456" "2007-02-01 09:04:05.123456 UTC"
+"2007-02-01" "1 year 2 mons 3 days 04:05:06.7" "01:23:45" "2007-02-01 15:04:05.123456" "2007-02-01 09:04:05.123456 UTC"
diff --git a/test/pg-cdc-old-syntax/types-interval.td b/test/pg-cdc-old-syntax/types-interval.td
index b763d71a1ad61..c29ee953522c8 100644
--- a/test/pg-cdc-old-syntax/types-interval.td
+++ b/test/pg-cdc-old-syntax/types-interval.td
@@ -48,6 +48,10 @@ INSERT INTO t1 SELECT * FROM t1;
 > SELECT pg_typeof(f1) FROM t1 LIMIT 1;
 interval
 
-> SELECT * FROM t1;
+>[version>=2603500] SELECT * FROM t1;
+"1 year 2 mons 3 days 04:05:06.789123"
+"1 year 2 mons 3 days 04:05:06.789123"
+
+>[version<2603500] SELECT * FROM t1;
 "1 year 2 months 3 days 04:05:06.789123"
 "1 year 2 months 3 days 04:05:06.789123"
diff --git a/test/pg-cdc/types-interval.td b/test/pg-cdc/types-interval.td
index 6a372e3d3bc5d..b6c00fad6ca84 100644
--- a/test/pg-cdc/types-interval.td
+++ b/test/pg-cdc/types-interval.td
@@ -52,6 +52,10 @@ INSERT INTO t1 SELECT * FROM t1;
 > SELECT pg_typeof(f1) FROM t1 LIMIT 1;
 interval
 
-> SELECT * FROM t1;
+>[version>=2603500] SELECT * FROM t1;
+"1 year 2 mons 3 days 04:05:06.789123"
+"1 year 2 mons 3 days 04:05:06.789123"
+
+>[version<2603500] SELECT * FROM t1;
 "1 year 2 months 3 days 04:05:06.789123"
 "1 year 2 months 3 days 04:05:06.789123"
diff --git a/test/pgtest-mz/datums.pt b/test/pgtest-mz/datums.pt
index 17f8839028d4f..5b6eef6f1f89e 100644
--- a/test/pgtest-mz/datums.pt
+++ b/test/pgtest-mz/datums.pt
@@ -24,18 +24,18 @@ CommandComplete {"tag":"CREATE TABLE"}
 ReadyForQuery {"status":"I"}
 RowDescription {"fields":[{"name":"rowid"},{"name":"_bool"},{"name":"_int16"},{"name":"_int32"},{"name":"_int64"},{"name":"_uint16"},{"name":"_uint32"},{"name":"_uint64"},{"name":"_float32"},{"name":"_float64"},{"name":"_numeric"},{"name":"_date"},{"name":"_time"},{"name":"_timestamp"},{"name":"_timestamp_"},{"name":"_timestamp__"},{"name":"_timestamptz"},{"name":"_timestamptz_"},{"name":"_timestamptz__"},{"name":"_interval"},{"name":"_pglegacychar"},{"name":"_bytes"},{"name":"_string"},{"name":"_char"},{"name":"_varchar"},{"name":"_jsonb"},{"name":"_uuid"},{"name":"_oid"},{"name":"_regproc"},{"name":"_regtype"},{"name":"_regclass"},{"name":"_int2vector"},{"name":"_mztimestamp"},{"name":"_mzaclitem"}]}
 DataRow {"fields":["1","t","0","0","0","0","0","0","0","0","0","2000-01-01","00:00:00","1970-01-01 00:00:00","1970-01-01 00:00:00","1970-01-01 00:00:00","1970-01-01 00:00:00+00","1970-01-01 00:00:00+00","1970-01-01 00:00:00+00","00:00:00","\u0000","\\x",""," ","","true","00000000-0000-0000-0000-000000000000","0","0","0","0","NULL","0","=/p"]}
-DataRow {"fields":["2","f","1","1","1","1","1","1","1","1","1","4714-11-24 BC","23:59:59.999999","4714-12-31 00:00:00 BC","4714-12-31 00:00:00 BC","4714-12-31 00:00:00 BC","4714-12-31 00:00:00+00 BC","4714-12-31 00:00:00+00 BC","4714-12-31 00:00:00+00 BC","1 month 1 day 00:00:00.000001","[255]","\\x00"," ","'"," ","false","ffffffff-ffff-ffff-ffff-ffffffffffff","4294967295","4294967295","4294967295","4294967295","NULL","18446744073709551615","=arwdUCRBNP/p"]}
-DataRow {"fields":["3","NULL","-1","-1","-1","65535","4294967295","18446744073709551615","-1","-1","-1","262142-12-31","NULL","262142-12-31 23:59:59","262142-12-31 23:59:59","262142-12-31 23:59:59","262142-12-31 23:59:59+00","262142-12-31 23:59:59+00","262142-12-31 23:59:59+00","-1 months -1 days -00:00:00.000001","NULL","\\xff","'","\"","'","null","NULL","NULL","NULL","NULL","NULL","NULL","NULL","u42=/p"]}
-DataRow {"fields":["4","NULL","-32768","-2147483648","-9223372036854775808","255","32767","2147483647","-3.4028235e+38","-1.7976931348623157e+308","-Infinity","NULL","NULL","1970-01-01 00:00:00.123457","1970-01-01 00:00:00.123457","1970-01-01 00:00:00.123457","1970-01-01 00:00:00.123457+00","1970-01-01 00:00:00.123457+00","1970-01-01 00:00:00.123457+00","1 month","NULL","NULL","\"",".","\"","\"\"","NULL","NULL","NULL","NULL","NULL","NULL","NULL","u42=arwdUCRBNP/p"]}
+DataRow {"fields":["2","f","1","1","1","1","1","1","1","1","1","4714-11-24 BC","23:59:59.999999","4714-12-31 00:00:00 BC","4714-12-31 00:00:00 BC","4714-12-31 00:00:00 BC","4714-12-31 00:00:00+00 BC","4714-12-31 00:00:00+00 BC","4714-12-31 00:00:00+00 BC","1 mon 1 day 00:00:00.000001","[255]","\\x00"," ","'"," ","false","ffffffff-ffff-ffff-ffff-ffffffffffff","4294967295","4294967295","4294967295","4294967295","NULL","18446744073709551615","=arwdUCRBNP/p"]}
+DataRow {"fields":["3","NULL","-1","-1","-1","65535","4294967295","18446744073709551615","-1","-1","-1","262142-12-31","NULL","262142-12-31 23:59:59","262142-12-31 23:59:59","262142-12-31 23:59:59","262142-12-31 23:59:59+00","262142-12-31 23:59:59+00","262142-12-31 23:59:59+00","-1 mons -1 days -00:00:00.000001","NULL","\\xff","'","\"","'","null","NULL","NULL","NULL","NULL","NULL","NULL","NULL","u42=/p"]}
+DataRow {"fields":["4","NULL","-32768","-2147483648","-9223372036854775808","255","32767","2147483647","-3.4028235e+38","-1.7976931348623157e+308","-Infinity","NULL","NULL","1970-01-01 00:00:00.123457","1970-01-01 00:00:00.123457","1970-01-01 00:00:00.123457","1970-01-01 00:00:00.123457+00","1970-01-01 00:00:00.123457+00","1970-01-01 00:00:00.123457+00","1 mon","NULL","NULL","\"",".","\"","\"\"","NULL","NULL","NULL","NULL","NULL","NULL","NULL","u42=arwdUCRBNP/p"]}
 DataRow {"fields":["5","NULL","-32767","-2147483647","-9223372036854775807","256","32768","2147483648","1.1754944e-38","2.2250738585072014e-308","0","NULL","NULL","2019-07-24 23:59:60.1234","2019-07-24 23:59:60.1234","2019-07-24 23:59:60.1234","NULL","NULL","NULL","1 day","NULL","NULL",".",",",".","\" \"","NULL","NULL","NULL","NULL","NULL","NULL","NULL","=/u42"]}
 DataRow {"fields":["6","NULL","32767","2147483647","9223372036854775807","NULL","NULL","NULL","3.4028235e+38","1.7976931348623157e+308","Infinity","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","00:00:00.000001","NULL","NULL","2015-09-18T23:56:04.123Z","\t","2015-09-18T23:56:04.123Z","\"'\"","NULL","NULL","NULL","NULL","NULL","NULL","NULL","=arwdUCRBNP/u42"]}
-DataRow {"fields":["7","NULL","127","32767","2147483647","NULL","NULL","NULL","1.1920929e-7","2.220446049250313e-16","0.0000000000000002220446049250313","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","-1 months","NULL","NULL","xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","\n","xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","\"\\\"\"","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL"]}
+DataRow {"fields":["7","NULL","127","32767","2147483647","NULL","NULL","NULL","1.1920929e-7","2.220446049250313e-16","0.0000000000000002220446049250313","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","-1 mons","NULL","NULL","xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","\n","xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","\"\\\"\"","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL"]}
 DataRow {"fields":["8","NULL","128","32768","2147483648","NULL","NULL","NULL","NaN","NaN","NaN","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","-1 days","NULL","NULL","JAPAN","\r","JAPAN","\".\"","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL"]}
 DataRow {"fields":["9","NULL","NULL","NULL","NULL","NULL","NULL","NULL","Infinity","Infinity","Infinity","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","-00:00:00.000001","NULL","NULL","1,2,3","\\","1,2,3","\"2015-09-18T23:56:04.123Z\"","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL"]}
-DataRow {"fields":["10","NULL","NULL","NULL","NULL","NULL","NULL","NULL","-Infinity","-Infinity","-Infinity","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","-178956970 years -8 months -2147483648 days -2562047788:00:54.775808","NULL","NULL","\r\n","\u0000","\r\n","\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL"]}
-DataRow {"fields":["11","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","178956970 years 7 months 2147483647 days 2562047788:00:54.775807","NULL","NULL","\"\"","\u0002","\"\"","\"JAPAN\"","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL"]}
-DataRow {"fields":["12","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","-178956970 years -8 months","NULL","NULL"," ","\u0003"," ","\"1,2,3\"","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL"]}
-DataRow {"fields":["13","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","178956970 years 7 months","NULL","NULL","'","\b","'","\"\\r\\n\"","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL"]}
+DataRow {"fields":["10","NULL","NULL","NULL","NULL","NULL","NULL","NULL","-Infinity","-Infinity","-Infinity","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","-178956970 years -8 mons -2147483648 days -2562047788:00:54.775808","NULL","NULL","\r\n","\u0000","\r\n","\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL"]}
+DataRow {"fields":["11","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","178956970 years 7 mons 2147483647 days 2562047788:00:54.775807","NULL","NULL","\"\"","\u0002","\"\"","\"JAPAN\"","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL"]}
+DataRow {"fields":["12","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","-178956970 years -8 mons","NULL","NULL"," ","\u0003"," ","\"1,2,3\"","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL"]}
+DataRow {"fields":["13","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","178956970 years 7 mons","NULL","NULL","'","\b","'","\"\\r\\n\"","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL"]}
 DataRow {"fields":["14","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","-2147483648 days","NULL","NULL","\"","\u001b","\"","\"\\\"\\\"\"","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL"]}
 DataRow {"fields":["15","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","2147483647 days","NULL","NULL",".","",".","0","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL"]}
 DataRow {"fields":["16","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL","-2562047788:00:54.775808","NULL","NULL",",","NULL",",","1","NULL","NULL","NULL","NULL","NULL","NULL","NULL","NULL"]}
diff --git a/test/sqllogictest/arrays.slt b/test/sqllogictest/arrays.slt
index 308c15b8001cf..60ee06a60458c 100644
--- a/test/sqllogictest/arrays.slt
+++ b/test/sqllogictest/arrays.slt
@@ -1179,7 +1179,7 @@ end
 {{c,d},{c,d},{c,d}}	3	2	c	end
 {{{NULL}},{{NULL}}}	2	1	1	end
 {{{b},{b}},{{b},{b}}}	2	2	1	b	end
-{{c,NULL},{NULL,d},{null,NULL}}	3	2	c	end
+{{c,NULL},{NULL,d},{"null",NULL}}	3	2	c	end
 {{{{b},{b}}},{{{b},{b}}},{{{b},{b}}}}	3	1	2	1	b	end
 
 # Test that whitespace produces same results
@@ -1489,3 +1489,16 @@ SELECT ARRAY[NULL::BIGINT[], ARRAY[]::BIGINT[], NULL::BIGINT[]];
 
 query error number of array elements \(3\) does not match declared cardinality \(2\)
 SELECT ARRAY[ARRAY[1, 2], ARRAY[3, 4, 5], ARRAY[6]];
+
+# Regression test for SQL-466: string elements matching "NULL" in any case
+# must be quoted in text output, so that they round-trip.
+
+query TT
+SELECT ARRAY['null']::text, (ARRAY['null']::text)::text[] = ARRAY['null'];
+----
+{"null"}  true
+
+query T
+SELECT ARRAY['null', 'NuLl', NULL, 'nullish']::text;
+----
+{"null","NuLl",NULL,nullish}
diff --git a/test/sqllogictest/cockroach/interval.slt b/test/sqllogictest/cockroach/interval.slt
index b88b9aeb90939..044b5e1db4249 100644
--- a/test/sqllogictest/cockroach/interval.slt
+++ b/test/sqllogictest/cockroach/interval.slt
@@ -104,7 +104,7 @@ SELECT interval '999' day
 query T
 SELECT interval '999' month
 ----
-83 years 3 months
+83 years 3 mons
 
 # test SQL-spec syntaxes for restricted field sets
 
@@ -116,7 +116,7 @@ SELECT interval '1' year
 query T
 SELECT interval '2' month
 ----
-2 months
+2 mons
 
 query T
 SELECT interval '3' day
@@ -141,12 +141,12 @@ SELECT interval '6' second
 query T
 SELECT interval '1' year to month
 ----
-1 month
+1 mon
 
 query T
 SELECT interval '1-2' year to month
 ----
-1 year 2 months
+1 year 2 mons
 
 # Not supported by Materialize.
 onlyif cockroach
@@ -194,77 +194,61 @@ SELECT interval '1 2:03:04' day to second
 query error invalid input syntax for type interval: Cannot determine format of all parts\. Add explicit time components, e\.g\. INTERVAL '1 day' or INTERVAL '1' DAY: "1 2"
 SELECT interval '1 2' hour to minute
 
-# SQL-474 (https://linear.app/materializeinc/issue/SQL-474): Materialize drops
-# interval fields to the left of the range qualifier's leading unit, even when
-# they were written explicitly. PG and CockroachDB keep every explicitly-written
-# field and only use the qualifier to resolve ambiguity. Some inputs also change
-# magnitude. The commented "PG/CRDB:" lines are the outputs to restore on fix.
-
-# SQL-474 PG/CRDB: 1 day 02:03:00
 query T
 SELECT interval '1 2:03' hour to minute
 ----
-02:03:00
+1 day 02:03:00
 
-# SQL-474 PG/CRDB: 1 day 02:03:00
 query T
 SELECT interval '1 2:03:04' hour to minute
 ----
-02:03:00
+1 day 02:03:00
 
 query error invalid input syntax for type interval: Cannot determine format of all parts\. Add explicit time components, e\.g\. INTERVAL '1 day' or INTERVAL '1' DAY: "1 2"
 SELECT interval '1 2' hour to second
 
-# SQL-474 PG/CRDB: 1 day 02:03:00
 query T
 SELECT interval '1 2:03' hour to second
 ----
-02:03:00
+1 day 02:03:00
 
-# SQL-474 PG/CRDB: 1 day 02:03:04
 query T
 SELECT interval '1 2:03:04' hour to second
 ----
-02:03:04
+1 day 02:03:04
 
 query error invalid input syntax for type interval: Cannot determine format of all parts\. Add explicit time components, e\.g\. INTERVAL '1 day' or INTERVAL '1' DAY: "1 2"
 SELECT interval '1 2' minute to second
 
-# SQL-474 PG/CRDB: 1 day 00:02:03 (MZ also mis-scales "2:03" as MM instead of MM:SS)
 query T
 SELECT interval '1 2:03' minute to second
 ----
-00:03:00
+1 day 00:02:03
 
-# SQL-474 PG/CRDB: 1 day 02:03:04
 query T
 SELECT interval '1 2:03:04' minute to second
 ----
-00:03:04
+1 day 02:03:04
 
-# SQL-474 PG/CRDB: 1 day 00:02:03
 query T
 SELECT interval '1 +2:03' minute to second
 ----
-00:03:00
+1 day 00:02:03
 
-# SQL-474 PG/CRDB: 1 day 02:03:04
 query T
 SELECT interval '1 +2:03:04' minute to second
 ----
-00:03:04
+1 day 02:03:04
 
-# SQL-474 PG/CRDB: 1 day -00:02:03
 query T
 SELECT interval '1 -2:03' minute to second
 ----
--00:03:00
+1 day -00:02:03
 
-# SQL-474 PG/CRDB: 1 day -02:03:04
 query T
 SELECT interval '1 -2:03:04' minute to second
 ----
--00:03:04
+1 day -02:03:04
 
 # Not supported by Materialize.
 onlyif cockroach
@@ -334,32 +318,28 @@ SELECT interval '1 2:03:04.5678' day to second(2)
 query error invalid input syntax for type interval: Cannot determine format of all parts\. Add explicit time components, e\.g\. INTERVAL '1 day' or INTERVAL '1' DAY: "1 2\.345"
 SELECT interval '1 2.345' hour to second(2)
 
-# SQL-474 PG/CRDB: 1 day 00:02:03.46
 query T
 SELECT interval '1 2:03.45678' hour to second(2)
 ----
-00:02:03.46
+1 day 00:02:03.46
 
-# SQL-474 PG/CRDB: 1 day 02:03:04.57
 query T
 SELECT interval '1 2:03:04.5678' hour to second(2)
 ----
-02:03:04.57
+1 day 02:03:04.57
 
 query error invalid input syntax for type interval: Cannot determine format of all parts\. Add explicit time components, e\.g\. INTERVAL '1 day' or INTERVAL '1' DAY: "1 2\.3456"
 SELECT interval '1 2.3456' minute to second(2)
 
-# SQL-474 PG/CRDB: 1 day 00:02:03.57
 query T
 SELECT interval '1 2:03.5678' minute to second(2)
 ----
-00:02:03.57
+1 day 00:02:03.57
 
-# SQL-474 PG/CRDB: 1 day 02:03:04.57
 query T
 SELECT interval '1 2:03:04.5678' minute to second(2)
 ----
-00:03:04.57
+1 day 02:03:04.57
 
 # Extra regression tests found when fixing this bug.
 subtest regression_43074
@@ -390,7 +370,7 @@ SELECT interval '1-2 3' year
 query T
 SELECT interval '1-2 3' day
 ----
-1 year 2 months 3 days
+1 year 2 mons 3 days
 
 query T
 SELECT interval '2.1 00:'
@@ -513,7 +493,7 @@ INSERT INTO intervals VALUES
 query T
 SELECT '-2 years 11 months 1 day 01:02:03'::interval
 ----
--1 years -1 months +1 day 01:02:03
+-1 years -1 mons +1 day 01:02:03
 
 statement ok
 create table interval_parsing ( pk INT PRIMARY KEY, i TEXT )
@@ -528,9 +508,9 @@ INSERT INTO interval_parsing VALUES
 query T
 SELECT i FROM intervals ORDER BY pk
 ----
--2 years -11 months +1 day 04:05:06.123
+-2 years -11 mons +1 day 04:05:06.123
 1 day 04:06:08.123
-2 years 11 months -2 days +03:25:45.678
+2 years 11 mons -2 days +03:25:45.678
 
 # Not supported by Materialize.
 onlyif cockroach
@@ -564,19 +544,19 @@ ORDER BY pk
 query T
 SELECT array_to_string(array_agg(i ORDER BY pk), ' ') FROM intervals
 ----
--2 years -11 months +1 day 04:05:06.123 1 day 04:06:08.123 2 years 11 months -2 days +03:25:45.678
+-2 years -11 mons +1 day 04:05:06.123 1 day 04:06:08.123 2 years 11 mons -2 days +03:25:45.678
 
 query T
 SELECT (array_agg(i ORDER BY pk))::string FROM intervals
 ----
-{"-2 years -11 months +1 day 04:05:06.123","1 day 04:06:08.123","2 years 11 months -2 days +03:25:45.678"}
+{"-2 years -11 mons +1 day 04:05:06.123","1 day 04:06:08.123","2 years 11 mons -2 days +03:25:45.678"}
 
 query T
 SELECT i::string FROM intervals ORDER BY pk
 ----
--2 years -11 months +1 day 04:05:06.123
+-2 years -11 mons +1 day 04:05:06.123
 1 day 04:06:08.123
-2 years 11 months -2 days +03:25:45.678
+2 years 11 mons -2 days +03:25:45.678
 
 # Not supported by Materialize.
 onlyif cockroach
@@ -599,10 +579,10 @@ SELECT row_to_json(intervals) FROM intervals ORDER BY pk
 query TT
 SELECT i, i::INTERVAL FROM interval_parsing ORDER BY pk
 ----
--10␠years␠22␠months␠1␠day␠01:02:03  -8␠years␠-2␠months␠+1␠day␠01:02:03
--10␠years␠-22␠months␠1␠day␠01:02:03  -11␠years␠-10␠months␠+1␠day␠01:02:03
--10␠years␠22␠months␠-1␠day␠01:02:03  -8␠years␠-2␠months␠-1␠days␠+01:02:03
--10␠years␠22␠months␠-1␠day␠-01:02:03  -8␠years␠-2␠months␠-1␠days␠-01:02:03
+-10␠years␠22␠months␠1␠day␠01:02:03  -8␠years␠-2␠mons␠+1␠day␠01:02:03
+-10␠years␠-22␠months␠1␠day␠01:02:03  -11␠years␠-10␠mons␠+1␠day␠01:02:03
+-10␠years␠22␠months␠-1␠day␠01:02:03  -8␠years␠-2␠mons␠-1␠days␠+01:02:03
+-10␠years␠22␠months␠-1␠day␠-01:02:03  -8␠years␠-2␠mons␠-1␠days␠-01:02:03
 
 # Not supported by Materialize.
 onlyif cockroach
@@ -612,31 +592,31 @@ SET intervalstyle = 'iso_8601'
 query T
 SELECT '-2 years 11 months 1 day 01:02:03'::interval
 ----
--1 years -1 months +1 day 01:02:03
+-1 years -1 mons +1 day 01:02:03
 
 query T
 SELECT i FROM intervals ORDER BY pk
 ----
--2 years -11 months +1 day 04:05:06.123
+-2 years -11 mons +1 day 04:05:06.123
 1 day 04:06:08.123
-2 years 11 months -2 days +03:25:45.678
+2 years 11 mons -2 days +03:25:45.678
 
 query T
 SELECT array_to_string(array_agg(i ORDER BY pk), ' ') FROM intervals
 ----
--2 years -11 months +1 day 04:05:06.123 1 day 04:06:08.123 2 years 11 months -2 days +03:25:45.678
+-2 years -11 mons +1 day 04:05:06.123 1 day 04:06:08.123 2 years 11 mons -2 days +03:25:45.678
 
 query T
 SELECT (array_agg(i ORDER BY pk))::string FROM intervals
 ----
-{"-2 years -11 months +1 day 04:05:06.123","1 day 04:06:08.123","2 years 11 months -2 days +03:25:45.678"}
+{"-2 years -11 mons +1 day 04:05:06.123","1 day 04:06:08.123","2 years 11 mons -2 days +03:25:45.678"}
 
 query T
 SELECT i::string FROM intervals ORDER BY pk
 ----
--2 years -11 months +1 day 04:05:06.123
+-2 years -11 mons +1 day 04:05:06.123
 1 day 04:06:08.123
-2 years 11 months -2 days +03:25:45.678
+2 years 11 mons -2 days +03:25:45.678
 
 # Not supported by Materialize.
 onlyif cockroach
@@ -659,10 +639,10 @@ SELECT row_to_json(intervals) FROM intervals ORDER BY pk
 query TT
 SELECT i, i::INTERVAL FROM interval_parsing ORDER BY pk
 ----
--10␠years␠22␠months␠1␠day␠01:02:03  -8␠years␠-2␠months␠+1␠day␠01:02:03
--10␠years␠-22␠months␠1␠day␠01:02:03  -11␠years␠-10␠months␠+1␠day␠01:02:03
--10␠years␠22␠months␠-1␠day␠01:02:03  -8␠years␠-2␠months␠-1␠days␠+01:02:03
--10␠years␠22␠months␠-1␠day␠-01:02:03  -8␠years␠-2␠months␠-1␠days␠-01:02:03
+-10␠years␠22␠months␠1␠day␠01:02:03  -8␠years␠-2␠mons␠+1␠day␠01:02:03
+-10␠years␠-22␠months␠1␠day␠01:02:03  -11␠years␠-10␠mons␠+1␠day␠01:02:03
+-10␠years␠22␠months␠-1␠day␠01:02:03  -8␠years␠-2␠mons␠-1␠days␠+01:02:03
+-10␠years␠22␠months␠-1␠day␠-01:02:03  -8␠years␠-2␠mons␠-1␠days␠-01:02:03
 
 # Not supported by Materialize.
 onlyif cockroach
@@ -672,31 +652,31 @@ SET intervalstyle = 'sql_standard'
 query T
 SELECT '-2 years 11 months 1 day 01:02:03'::interval
 ----
--1 years -1 months +1 day 01:02:03
+-1 years -1 mons +1 day 01:02:03
 
 query T
 SELECT i FROM intervals ORDER BY pk
 ----
--2 years -11 months +1 day 04:05:06.123
+-2 years -11 mons +1 day 04:05:06.123
 1 day 04:06:08.123
-2 years 11 months -2 days +03:25:45.678
+2 years 11 mons -2 days +03:25:45.678
 
 query T
 SELECT array_to_string(array_agg(i ORDER BY pk), ' ') FROM intervals
 ----
--2 years -11 months +1 day 04:05:06.123 1 day 04:06:08.123 2 years 11 months -2 days +03:25:45.678
+-2 years -11 mons +1 day 04:05:06.123 1 day 04:06:08.123 2 years 11 mons -2 days +03:25:45.678
 
 query T
 SELECT (array_agg(i ORDER BY pk))::string FROM intervals
 ----
-{"-2 years -11 months +1 day 04:05:06.123","1 day 04:06:08.123","2 years 11 months -2 days +03:25:45.678"}
+{"-2 years -11 mons +1 day 04:05:06.123","1 day 04:06:08.123","2 years 11 mons -2 days +03:25:45.678"}
 
 query T
 SELECT i::string FROM intervals ORDER BY pk
 ----
--2 years -11 months +1 day 04:05:06.123
+-2 years -11 mons +1 day 04:05:06.123
 1 day 04:06:08.123
-2 years 11 months -2 days +03:25:45.678
+2 years 11 mons -2 days +03:25:45.678
 
 # Not supported by Materialize.
 onlyif cockroach
@@ -719,10 +699,10 @@ SELECT row_to_json(intervals) FROM intervals ORDER BY pk
 query TT
 SELECT i, i::INTERVAL FROM interval_parsing ORDER BY pk
 ----
--10␠years␠22␠months␠1␠day␠01:02:03  -8␠years␠-2␠months␠+1␠day␠01:02:03
--10␠years␠-22␠months␠1␠day␠01:02:03  -11␠years␠-10␠months␠+1␠day␠01:02:03
--10␠years␠22␠months␠-1␠day␠01:02:03  -8␠years␠-2␠months␠-1␠days␠+01:02:03
--10␠years␠22␠months␠-1␠day␠-01:02:03  -8␠years␠-2␠months␠-1␠days␠-01:02:03
+-10␠years␠22␠months␠1␠day␠01:02:03  -8␠years␠-2␠mons␠+1␠day␠01:02:03
+-10␠years␠-22␠months␠1␠day␠01:02:03  -11␠years␠-10␠mons␠+1␠day␠01:02:03
+-10␠years␠22␠months␠-1␠day␠01:02:03  -8␠years␠-2␠mons␠-1␠days␠+01:02:03
+-10␠years␠22␠months␠-1␠day␠-01:02:03  -8␠years␠-2␠mons␠-1␠days␠-01:02:03
 
 # Not supported by Materialize.
 onlyif cockroach
diff --git a/test/sqllogictest/dates-times.slt b/test/sqllogictest/dates-times.slt
index 2596594079e11..ed301a8f1ea22 100644
--- a/test/sqllogictest/dates-times.slt
+++ b/test/sqllogictest/dates-times.slt
@@ -94,7 +94,7 @@ SELECT min(b) FROM timeish
 query T
 SELECT INTERVAL '1' MONTH
 ----
-1 month
+1 mon
 
 query T
 SELECT INTERVAL '1' YEAR
@@ -104,7 +104,7 @@ SELECT INTERVAL '1' YEAR
 query T
 SELECT INTERVAL '1-3' YEAR TO MONTH
 ----
-1 year 3 months
+1 year 3 mons
 
 query T
 SELECT INTERVAL '1' MINUTE
@@ -826,7 +826,7 @@ SELECT (TIMESTAMPTZ '2000-01-01 00:00:00-6')::text
 query T
 SELECT (INTERVAL '1-3' YEAR TO MONTH)::text
 ----
-1 year 3 months
+1 year 3 mons
 
 query RRRRR
 SELECT EXTRACT(HOUR from TIME '11:12:42.666'),
@@ -1136,7 +1136,7 @@ SELECT '2007-02-01'::date
 query T
 SELECT '-1-2 3 -4:5:6.7'::interval;
 ----
--1 years -2 months +3 days -04:05:06.7
+-1 years -2 mons +3 days -04:05:06.7
 
 query T
 SELECT '01:23:45'::time;
@@ -1163,7 +1163,7 @@ SELECT (date '2007-02-01')::text
 query T
 SELECT (interval '-1-2 3 -4:5:6.7')::text;
 ----
--1 years -2 months +3 days -04:05:06.7
+-1 years -2 mons +3 days -04:05:06.7
 
 query T
 SELECT (time '01:23:45')::text;
@@ -1396,10 +1396,10 @@ select '0001-02-24 03:04:05.6789 +00:00'::timestamptz - interval '1 YEAR'
 ----
 0001-02-24 03:04:05.6789+00 BC
 
-query error "-178956970 years -8 months" interval out of range
+query error "\-178956970 years \-8 mons" interval out of range
 select '0001-02-24 03:04:05.6789'::timestamp - interval '-2147483648 MONTHS'
 
-query error "-178956970 years -8 months" interval out of range
+query error "\-178956970 years \-8 mons" interval out of range
 select '0001-02-24 03:04:05.6789 +00:00'::timestamptz - interval '-2147483648 MONTHS'
 
 # Infinity dates not supported.
@@ -1752,3 +1752,108 @@ query T
 SELECT timestamp::timestamp from t ORDER BY t.timestamp;
 ----
 2012-03-05 00:00:00
+
+# Regression tests for SQL-467.
+
+# BC years in extract are numbered with 1 BC as year -1, there is no year 0.
+query RRR
+SELECT extract(year FROM DATE '2020-08-11 BC'),
+       extract(year FROM TIMESTAMP '2020-08-11 12:00:00 BC'),
+       extract(year FROM TIMESTAMPTZ '2020-08-11 12:00:00+00 BC')
+----
+-2020  -2020  -2020
+
+query RR
+SELECT extract(year FROM DATE '0001-08-11 BC'), extract(year FROM DATE '0001-08-11')
+----
+-1  1
+
+# make_timestamp rejects year 0 and treats negative years as BC.
+query error date out of range
+SELECT make_timestamp(0, 7, 15, 12, 30, 15)
+
+query T
+SELECT make_timestamp(-1, 7, 15, 12, 30, 15)
+----
+0001-07-15 12:30:15 BC
+
+query T
+SELECT make_timestamp(-2020, 8, 11, 12, 30, 15)
+----
+2020-08-11 12:30:15 BC
+
+# make_timestamp allows exactly 24:00:00 and 60 seconds, which roll over.
+query T
+SELECT make_timestamp(1999, 12, 31, 24, 0, 0)
+----
+2000-01-01 00:00:00
+
+query T
+SELECT make_timestamp(2013, 7, 15, 12, 30, 60)
+----
+2013-07-15 12:31:00
+
+query error timestamp out of range
+SELECT make_timestamp(1999, 12, 31, 24, 0, 1)
+
+# Invalid fields are errors, not NULL.
+query error date out of range
+SELECT make_timestamp(2020, 13, 1, 0, 0, 0)
+
+query error timestamp out of range
+SELECT make_timestamp(2020, 1, 1, 12, 60, 0)
+
+# Ambiguous all-numeric dates follow the pinned DateStyle 'ISO, MDY': a one- or
+# two-digit leading field starts a month-day-year date, and a two-digit year is
+# windowed into 1970..=2069 (SQL-461).
+
+query T
+SELECT DATE '01/02/03'
+----
+2003-01-02
+
+query T
+SELECT DATE '1-2-3'
+----
+2003-01-02
+
+query T
+SELECT DATE '01/02/1999'
+----
+1999-01-02
+
+query T
+SELECT DATE '01/02/69'
+----
+2069-01-02
+
+query T
+SELECT DATE '01/02/70'
+----
+1970-01-02
+
+# A leading field of three or more digits is a year, with no windowing.
+query T
+SELECT DATE '0099-01-08'
+----
+0099-01-08
+
+query error invalid input syntax for type date: MONTH must be \[1, 12\], got 99: "99\-01\-08"
+SELECT DATE '99-01-08'
+
+# BC years are never windowed.
+query T
+SELECT DATE '01/02/03 BC'
+----
+0003-01-02 BC
+
+# Timestamps interpret the date part the same way.
+query T
+SELECT TIMESTAMP '01/02/03 04:05:06'
+----
+2003-01-02 04:05:06
+
+query T
+SELECT TIMESTAMP WITH TIME ZONE '01/02/03 04:05:06+00'
+----
+2003-01-02 04:05:06+00
diff --git a/test/sqllogictest/filter-pushdown.slt b/test/sqllogictest/filter-pushdown.slt
index ae1328911f221..de5cf9419c4da 100644
--- a/test/sqllogictest/filter-pushdown.slt
+++ b/test/sqllogictest/filter-pushdown.slt
@@ -401,12 +401,12 @@ EXPLAIN OPTIMIZED PLAN WITH(filter pushdown, humanized expressions) AS VERBOSE T
 ----
 materialize.public.mv10:
   Project (#0{id}, #1{ship_time})
-    Filter (mz_now() <= timestamp_to_mz_timestamp(date_trunc_month_ts((#1{ship_time} - (1 month * numeric_to_double((case when (#2 < 6) then (extract_month_ts(#1{ship_time}) + 6) else 0 end + case when (#2 >= 6) then (extract_month_ts(#1{ship_time}) - 6) else 0 end)))))))
+    Filter (mz_now() <= timestamp_to_mz_timestamp(date_trunc_month_ts((#1{ship_time} - (1 mon * numeric_to_double((case when (#2 < 6) then (extract_month_ts(#1{ship_time}) + 6) else 0 end + case when (#2 >= 6) then (extract_month_ts(#1{ship_time}) - 6) else 0 end)))))))
       Map (extract_month_ts(#1{ship_time}))
         ReadStorage materialize.public.items
 
 Source materialize.public.items
-  filter=((mz_now() <= timestamp_to_mz_timestamp(date_trunc_month_ts((#1{ship_time} - (1 month * numeric_to_double((case when (#2 < 6) then (extract_month_ts(#1{ship_time}) + 6) else 0 end + case when (#2 >= 6) then (extract_month_ts(#1{ship_time}) - 6) else 0 end))))))))
+  filter=((mz_now() <= timestamp_to_mz_timestamp(date_trunc_month_ts((#1{ship_time} - (1 mon * numeric_to_double((case when (#2 < 6) then (extract_month_ts(#1{ship_time}) + 6) else 0 end + case when (#2 >= 6) then (extract_month_ts(#1{ship_time}) - 6) else 0 end))))))))
   map=(extract_month_ts(#1{ship_time}))
 
 Target cluster: quickstart
diff --git a/test/sqllogictest/funcs.slt b/test/sqllogictest/funcs.slt
index 17c1c0fc5509d..96cd26a74403d 100644
--- a/test/sqllogictest/funcs.slt
+++ b/test/sqllogictest/funcs.slt
@@ -167,37 +167,37 @@ SELECT date_trunc(field, TIMESTAMP '2019-11-26 15:56:46.241150') FROM date_trunc
 query T
 SELECT date_trunc('microseconds',  INTERVAL '1234 years 11 months 23 days 23:59:12.123456789') AS t;
 ----
-1234 years 11 months 23 days 23:59:12.123457
+1234 years 11 mons 23 days 23:59:12.123457
 
 query T
 SELECT date_trunc('milliseconds',  INTERVAL '1234 years 11 months 23 days 23:59:12.123456789') AS t;
 ----
-1234 years 11 months 23 days 23:59:12.123
+1234 years 11 mons 23 days 23:59:12.123
 
 query T
 SELECT date_trunc('milliseconds',  INTERVAL '1234 years 11 months 23 days 23:59:12.123456789') AS t;
 ----
-1234 years 11 months 23 days 23:59:12.123
+1234 years 11 mons 23 days 23:59:12.123
 
 query T
 SELECT date_trunc('seconds',  INTERVAL '1234 years 11 months 23 days 23:59:12.123456789') AS t;
 ----
-1234 years 11 months 23 days 23:59:12
+1234 years 11 mons 23 days 23:59:12
 
 query T
 SELECT date_trunc('minutes',  INTERVAL '1234 years 11 months 23 days 23:59:12.123456789') AS t;
 ----
-1234 years 11 months 23 days 23:59:00
+1234 years 11 mons 23 days 23:59:00
 
 query T
 SELECT date_trunc('hours',  INTERVAL '1234 years 11 months 23 days 23:59:12.123456789') AS t;
 ----
-1234 years 11 months 23 days 23:00:00
+1234 years 11 mons 23 days 23:00:00
 
 query T
 SELECT date_trunc('days',  INTERVAL '1234 years 11 months 23 days 23:59:12.123456789') AS t;
 ----
-1234 years 11 months 23 days
+1234 years 11 mons 23 days
 
 query error unit 'weeks' not recognized
 SELECT date_trunc('weeks',  INTERVAL '1234 years 11 months 23 days 23:59:12.123456789') AS t;
@@ -205,7 +205,7 @@ SELECT date_trunc('weeks',  INTERVAL '1234 years 11 months 23 days 23:59:12.1234
 query T
 SELECT date_trunc('months',  INTERVAL '1234 years 11 months 23 days 23:59:12.123456789') AS t;
 ----
-1234 years 11 months
+1234 years 11 mons
 
 query T
 SELECT date_trunc('years',  INTERVAL '1234 years 11 months 23 days 23:59:12.123456789') AS t;
diff --git a/test/sqllogictest/interval.slt b/test/sqllogictest/interval.slt
index 0e1805f845267..159f35163aa4e 100644
--- a/test/sqllogictest/interval.slt
+++ b/test/sqllogictest/interval.slt
@@ -35,13 +35,13 @@ SELECT INTERVAL '1 2:';
 query T
 SELECT INTERVAL '1-2 3:4';
 ----
-1 year 2 months 03:04:00
+1 year 2 mons 03:04:00
 
 # Parse Y-M D H:M.
 query T
 SELECT INTERVAL '1-2 3 4:5';
 ----
-1 year 2 months 3 days 04:05:00
+1 year 2 mons 3 days 04:05:00
 
 # Parse Y- D H:
 query T
@@ -53,19 +53,19 @@ SELECT INTERVAL '1- 2 3:';
 query T
 SELECT INTERVAL '1:2:3.4 5-6';
 ----
-5 years 6 months 01:02:03.4
+5 years 6 mons 01:02:03.4
 
 # Implicit SECOND for ambiguous part.
 query T
 SELECT INTERVAL '1-2 3';
 ----
-1 year 2 months 00:00:03
+1 year 2 mons 00:00:03
 
 # Explicitly set ambiguous part.
 query T
 SELECT INTERVAL '1-2 3' HOUR;
 ----
-1 year 2 months 03:00:00
+1 year 2 mons 03:00:00
 
 # Disallow components to be set twice.
 statement error invalid input syntax for type interval: YEAR field set twice: "1 year 2 years"
@@ -94,38 +94,39 @@ SELECT INTERVAL '1-2 3 4:5:6.7' YEAR;
 query T
 SELECT INTERVAL '1-2 3 4:5:6.7' MONTH;
 ----
-1 year 2 months
+1 year 2 mons
 
 query T
 SELECT INTERVAL '1-2 3 4:5:6.7' DAY;
 ----
-1 year 2 months 3 days
+1 year 2 mons 3 days
 
 query T
 SELECT INTERVAL '1-2 3 4:5:6.7' HOUR;
 ----
-1 year 2 months 3 days 04:00:00
+1 year 2 mons 3 days 04:00:00
 
 query T
 SELECT INTERVAL '1-2 3 4:5:6.7' MINUTE;
 ----
-1 year 2 months 3 days 04:05:00
+1 year 2 mons 3 days 04:05:00
 
 query T
 SELECT INTERVAL '1-2 3 4:5:6.7' SECOND;
 ----
-1 year 2 months 3 days 04:05:06.7
+1 year 2 mons 3 days 04:05:06.7
 
-# Treat trailing DateTimeFields as range of components to process.
+# Range qualifiers discard fields less significant than the range's low end,
+# but keep more significant fields, matching PostgreSQL.
 query T
 SELECT INTERVAL '1-2 3 4:5:6.7' MONTH TO MINUTE;
 ----
-2 months 3 days 04:05:00
+1 year 2 mons 3 days 04:05:00
 
 query T
 SELECT INTERVAL '1-2 3 4:5:6.7' DAY TO HOUR;
 ----
-3 days 04:00:00
+1 year 2 mons 3 days 04:00:00
 
 query T
 SELECT INTERVAL '12:34';
@@ -195,7 +196,7 @@ SELECT INTERVAL '12:34:56' HOUR TO SECOND;
 query T
 SELECT INTERVAL '12:34:56' MINUTE TO SECOND;
 ----
-00:34:56
+12:34:56
 
 query T
 SELECT INTERVAL '12:34' DAY TO SECOND;
@@ -207,6 +208,18 @@ SELECT INTERVAL '12:34' MONTH TO SECOND;
 ----
 12:34:00
 
+# Regression tests for SQL-474: fields above the range qualifier are kept, and
+# MINUTE TO SECOND reads ambiguous a:b values as minutes:seconds.
+query T
+SELECT INTERVAL '1 2:03' HOUR TO MINUTE;
+----
+1 day 02:03:00
+
+query T
+SELECT INTERVAL '1 2:03' MINUTE TO SECOND;
+----
+1 day 00:02:03
+
 # Disallow ranges where trailing element is greater than lead.
 statement error
 SELECT INTERVAL '1-2 3 4:5:6.7' MINUTE TO MONTH;
@@ -219,7 +232,7 @@ SELECT INTERVAL '1-2 3 4:5:6.7' SECOND TO SECOND;
 query T
 SELECT INTERVAL '1:2:3.4 5-6 7' DAY;
 ----
-5 years 6 months 7 days
+5 years 6 mons 7 days
 
 # Disambiguate component (YEAR), but disallow because
 # the group it's in has been closed.
@@ -230,30 +243,30 @@ SELECT INTERVAL '1:2:3.4 5-6 7' YEAR;
 query T
 SELECT INTERVAL '-1-2 -3 -4:5:6.7';
 ----
--1 years -2 months -3 days -04:05:06.7
+-1 years -2 mons -3 days -04:05:06.7
 
 # Mixed signs
 query T
 SELECT INTERVAL '-1-2 3 -4:5:6.7';
 ----
--1 years -2 months +3 days -04:05:06.7
+-1 years -2 mons +3 days -04:05:06.7
 
 # Allow skipping components.
 query T
 SELECT INTERVAL '1-2 3 4::.5';
 ----
-1 year 2 months 3 days 04:00:00.5
+1 year 2 mons 3 days 04:00:00.5
 
 # Mix negatives and missing components.
 query T
 SELECT INTERVAL '-1-2 -3 4::.5';
 ----
--1 years -2 months -3 days +04:00:00.5
+-1 years -2 mons -3 days +04:00:00.5
 
 query T
 SELECT INTERVAL '-1-2 -3 -4::.5';
 ----
--1 years -2 months -3 days -04:00:00.5
+-1 years -2 mons -3 days -04:00:00.5
 
 # Parse - and infer second value.
 query T
@@ -325,37 +338,37 @@ SELECT INTERVAL '1x2:3.4';
 query T
 SELECT INTERVAL '1 year 2 month 3 day 4 hour 5 minute 6.7 second';
 ----
-1 year 2 months 3 days 04:05:06.7
+1 year 2 mons 3 days 04:05:06.7
 
 # Plural TimeUnits.
 query T
 SELECT INTERVAL '1 years 2 months 3 days 4 hours 5 minutes 6.7 seconds';
 ----
-1 year 2 months 3 days 04:05:06.7
+1 year 2 mons 3 days 04:05:06.7
 
 # Shorthand.
 query T
 SELECT INTERVAL '1y 2mon 3d 4h 5m 6.7s';
 ----
-1 year 2 months 3 days 04:05:06.7
+1 year 2 mons 3 days 04:05:06.7
 
 # Commutative expressions.
 query T
 SELECT INTERVAL '6.7 seconds 5 minutes 3 days 4 hours 1 year 2 month';
 ----
-1 year 2 months 3 days 04:05:06.7
+1 year 2 mons 3 days 04:05:06.7
 
 # Allow mix of positive and negative components.
 query T
 SELECT INTERVAL '-6.7 seconds 5 minutes -3 days 4 hours -1 year 2 month';
 ----
--10 months -3 days +04:04:53.3
+-10 mons -3 days +04:04:53.3
 
 # Allow fractional components.
 query T
 SELECT INTERVAL '1y 2.3mon 4.5d';
 ----
-1 year 2 months 13 days 12:00:00
+1 year 2 mons 13 days 12:00:00
 
 query T
 SELECT INTERVAL '-6.7 seconds 5.6 minutes -3.4 days 4.5 hours -1.2 year 2.3 month';
@@ -378,7 +391,7 @@ SELECT INTERVAL '-1 day 0.27 seconds';
 query T
 SELECT INTERVAL '10.333 years';
 ----
-10 years 3 months
+10 years 3 mons
 
 # Fractional part with ambiguity and range.
 query T
@@ -390,7 +403,7 @@ SELECT INTERVAL '10.333' years;
 query T
 SELECT INTERVAL '1.5555555 month';
 ----
-1 month 16 days 15:59:59.856
+1 mon 16 days 15:59:59.856
 
 # Fractional day, includes nanoseconds.
 query T
@@ -420,7 +433,7 @@ SELECT INTERVAL '.33333 minute .1 second';
 query T
 SELECT INTERVAL '1year 2months 3.4days';
 ----
-1 year 2 months 3 days 09:36:00
+1 year 2 mons 3 days 09:36:00
 
 # Zero values.
 query T
@@ -437,7 +450,7 @@ SELECT INTERVAL '0 foo';
 query T
 SELECT INTERVAL '1-2 3:4 5 day';
 ----
-1 year 2 months 5 days 03:04:00
+1 year 2 mons 5 days 03:04:00
 
 # Parse + signs.
 query T
@@ -466,34 +479,34 @@ SELECT INTERVAL '01:02:03minute hour day year';
 query T
 SELECT INTERVAL '-13-10 15 -16::.27';
 ----
--13 years -10 months +15 days -16:00:00.27
+-13 years -10 mons +15 days -16:00:00.27
 
 query T
 SELECT INTERVAL '-13-10 -15 -16::.27';
 ----
--13 years -10 months -15 days -16:00:00.27
+-13 years -10 mons -15 days -16:00:00.27
 
 # Parsing output as input.
 query T
 SELECT INTERVAL '-13 years -10 months -15 days -16:00:00.27';
 ----
--13 years -10 months -15 days -16:00:00.27
+-13 years -10 mons -15 days -16:00:00.27
 
 query T
 SELECT INTERVAL '-13 years -10 months +14 days +07:59:59.73';
 ----
--13 years -10 months +14 days 07:59:59.73
+-13 years -10 mons +14 days 07:59:59.73
 
 # Commutative mixed expressions.
 query T
 SELECT INTERVAL '5 day 3:4 1-2';
 ----
-1 year 2 months 5 days 03:04:00
+1 year 2 mons 5 days 03:04:00
 
 query T
 SELECT INTERVAL '1-2 3:4 5 day';
 ----
-1 year 2 months 5 days 03:04:00
+1 year 2 mons 5 days 03:04:00
 
 # Mix style allowed, but cannot assigning to closed group.
 statement error invalid input syntax for type interval: SECOND field set twice: "1-2 3:4 5 second"
@@ -507,14 +520,14 @@ SELECT INTERVAL '1-2 5 second 3:4';
 query T
 SELECT INTERVAL '1.5555 month 2 3:4:5.6';
 ----
-1 month 18 days 19:01:41.6
+1 mon 18 days 19:01:41.6
 
 # Fractional month with terminating range. Truncation should
 # only happen after computation.
 query T
 SELECT INTERVAL '1.5555 month 2 3:4:5.6' HOUR;
 ----
-1 month 18 days 19:00:00
+1 mon 18 days 19:00:00
 
 # Fractional month with leading and terminating range.
 # Again, truncation should only happen after
@@ -522,7 +535,7 @@ SELECT INTERVAL '1.5555 month 2 3:4:5.6' HOUR;
 query T
 SELECT INTERVAL '1.5555 month 2 3:4:5.6' DAY TO HOUR;
 ----
-18 days 19:00:00
+1 mon 18 days 19:00:00
 
 # Only allow disambiguation if ambiguous element
 # is final element of interval string.
@@ -595,14 +608,14 @@ SELECT INTERVAL '0.00000001 min 0.0006 millisecond 3.5 microsecond' SECOND(5);
 query T
 SELECT INTERVAL '-1.555555555 years 2.555555555 months -3.555555555 days 4.555555555 hours -5.555555555 minutes 6.555555555 seconds';
 ----
--1 years -4 months +13 days 07:07:53.220829
+-1 years -4 mons +13 days 07:07:53.220829
 
 
 # Allow precision as second element in range.
 query T
 SELECT INTERVAL '1:2:31.23456789' MINUTE TO SECOND(2);
 ----
-00:02:31.23
+01:02:31.23
 
 # Do not allow more than 9 places of precision
 query T
@@ -637,7 +650,7 @@ SELECT INTERVAL '1 day 2-3 4' SECOND(-1);
 query T
 SELECT interval '02-01!1~01:02:03';
 ----
-2 years 1 month 1 day 01:02:03
+2 years 1 mon 1 day 01:02:03
 
 query T
 SELECT interval '1! hour';
@@ -653,48 +666,48 @@ SELECT interval '02!01!1~01:02:03';
 query T
 SELECT - INTERVAL '1-2 3 4:5:6.7';
 ----
--1 years -2 months -3 days -04:05:06.7
+-1 years -2 mons -3 days -04:05:06.7
 
 query T
 SELECT - INTERVAL '-1 year -2 months -3 days -04:05:06.7';
 ----
-1 year 2 months 3 days 04:05:06.7
+1 year 2 mons 3 days 04:05:06.7
 
 query T
 SELECT - INTERVAL '1 year 2 months -3 days -04:05:06.7';
 ----
--1 years -2 months +3 days 04:05:06.7
+-1 years -2 mons +3 days 04:05:06.7
 
 query T
 SELECT - INTERVAL '-1 year -2 months 3 days 04:05:06.7';
 ----
-1 year 2 months -3 days -04:05:06.7
+1 year 2 mons -3 days -04:05:06.7
 
 # Add, sub intervals
 query T
 SELECT INTERVAL '1-2 3 4:5:6.7' + INTERVAL '1-2 3 4:5:6.7';
 ----
-2 years 4 months 6 days 08:10:13.4
+2 years 4 mons 6 days 08:10:13.4
 
 query T
 SELECT INTERVAL '1-2 3 4:5:6.7' - INTERVAL '7-6 5 4:3:2.1';
 ----
--6 years -4 months -2 days +00:02:04.6
+-6 years -4 mons -2 days +00:02:04.6
 
 query T
 SELECT INTERVAL '1-2 3 4:5:6.7' + - INTERVAL '7-6 5 4:3:2.1';
 ----
--6 years -4 months -2 days +00:02:04.6
+-6 years -4 mons -2 days +00:02:04.6
 
 query T
 SELECT INTERVAL '1-2 3 4:5:6.7' + INTERVAL '-7-6 -5 -4:3:2.1';
 ----
--6 years -4 months -2 days +00:02:04.6
+-6 years -4 mons -2 days +00:02:04.6
 
 query T
 SELECT INTERVAL '1-2 3 4:5:6.7' - INTERVAL '-7-6 -5 -4:3:2.1';
 ----
-8 years 8 months 8 days 08:08:08.8
+8 years 8 mons 8 days 08:08:08.8
 
 query T
 SELECT INTERVAL '1-2 3 4:5:6.7' - INTERVAL '1-2 3 4:5:6.7'
@@ -725,7 +738,7 @@ SELECT INTERVAL '1' MONTH / 30
 query T
 SELECT INTERVAL '1' YEAR * 13/12
 ----
-1 year 1 month
+1 year 1 mon
 
 query error "10 years \* 10000000000" interval out of range
 SELECT INTERVAL '10 years' *  9999999999.999999999;
@@ -744,12 +757,12 @@ SELECT INTERVAL '1' YEAR / 360
 query T
 SELECT INTERVAL '1' YEAR * 0.9999999
 ----
-11 months 29 days 23:59:56.8896
+11 mons 29 days 23:59:56.8896
 
 query T
 SELECT INTERVAL '-1-2 -3 -4:5:6.7' * 999
 ----
--1165 years -6 months -2997 days -4081:06:33.3
+-1165 years -6 mons -2997 days -4081:06:33.3
 
 # Division by zero
 statement error division by zero
@@ -785,12 +798,12 @@ SELECT INTERVAL '-2147483648 days -2562047787 hours -59 minutes -59.999999 secon
 query T
 SELECT INTERVAL '2147483647 months 2147483647 days 9223372036854775807 us'
 ----
-178956970 years 7 months 2147483647 days 2562047788:00:54.775807
+178956970 years 7 mons 2147483647 days 2562047788:00:54.775807
 
 query T
 SELECT INTERVAL '-2147483648 months -2147483648 days -9223372036854775808 us'
 ----
--178956970 years -8 months -2147483648 days -2562047788:00:54.775808
+-178956970 years -8 mons -2147483648 days -2562047788:00:54.775808
 
 statement error Overflows maximum microseconds;
 SELECT INTERVAL '2147483647 days 2562047789 hours';
@@ -810,10 +823,10 @@ SELECT INTERVAL '2147483647 days 2562047788 hours 54 seconds' + INTERVAL '1'
 statement error "-2147483648 days -2562047788:00:54 - 00:00:01" interval out of range
 SELECT INTERVAL '-2147483648 days -2562047788 hours -54 seconds' - INTERVAL '1'
 
-statement error "178956970 years 7 months / 0.99" interval out of range
+statement error "178956970 years 7 mons / 0\.99" interval out of range
 SELECT INTERVAL '2147483647' MONTH / 0.99
 
-statement error "-178956970 years -7 months \* 1.01" interval out of range
+statement error "\-178956970 years \-7 mons \* 1\.01" interval out of range
 SELECT INTERVAL '-2147483647' MONTH * 1.01
 
 # Largest number of cumulative nanoseconds
@@ -1215,7 +1228,7 @@ SELECT INTERVAL '1 millenniums 2 centuries 3 decades 4 years'
 ----
 1234 years
 
-query error "-178956970 years -8 months" interval out of range
+query error "\-178956970 years \-8 mons" interval out of range
 SELECT -INTERVAL '-2147483648 months';
 
 query error "-2147483648 days" interval out of range
@@ -1224,7 +1237,7 @@ SELECT -INTERVAL '-2147483648 days';
 query error "-2562047788:00:54.775808" interval out of range
 SELECT -INTERVAL '-9223372036854775808 microseconds';
 
-query error "-1 months - -178956970 years -8 months" interval out of range
+query error "\-1 mons \- \-178956970 years \-8 mons" interval out of range
 SELECT INTERVAL '-1 months' - INTERVAL '-2147483648 months';
 
 query error "-1 days - -2147483648 days" interval out of range
@@ -1376,7 +1389,7 @@ true
 query T
 SELECT justify_hours(interval '6 months 3 days 52 hours 3 minutes 2 seconds');
 ----
-6 months 5 days 04:03:02
+6 mons 5 days 04:03:02
 
 query T
 SELECT justify_hours(interval '27 hours');
@@ -1386,12 +1399,12 @@ SELECT justify_hours(interval '27 hours');
 query T
 SELECT justify_days(interval '6 months 36 days 5 hours 4 minutes 3 seconds');
 ----
-7 months 6 days 05:04:03
+7 mons 6 days 05:04:03
 
 query T
 SELECT justify_days(interval '35 days');
 ----
-1 month 5 days
+1 mon 5 days
 
 query T
 SELECT justify_interval(interval '1 month -1 hour');
@@ -1401,39 +1414,39 @@ SELECT justify_interval(interval '1 month -1 hour');
 query error "2147483647 days 24:00:00" interval out of range
 SELECT justify_hours(interval '2147483647 days 24 hrs');
 
-query error "178956970 years 7 months 30 days" interval out of range
+query error "178956970 years 7 mons 30 days" interval out of range
 SELECT justify_days(interval '2147483647 months 30 days');
 
 query T
 SELECT justify_interval(interval '2147483647 days 24 hrs');
 ----
-5965232 years 4 months 8 days
+5965232 years 4 mons 8 days
 
 query T
 SELECT justify_interval(interval '-2147483648 days -24 hrs');
 ----
--5965232 years -4 months -9 days
+-5965232 years -4 mons -9 days
 
-query error "178956970 years 7 months 30 days" interval out of range
+query error "178956970 years 7 mons 30 days" interval out of range
 SELECT justify_interval(interval '2147483647 months 30 days');
 
-query error "-178956970 years -8 months -30 days" interval out of range
+query error "\-178956970 years \-8 mons \-30 days" interval out of range
 SELECT justify_interval(interval '-2147483648 months -30 days');
 
 query T
 SELECT justify_interval(interval '2147483647 months 30 days -24 hrs');
 ----
-178956970 years 7 months 29 days
+178956970 years 7 mons 29 days
 
 query T
 SELECT justify_interval(interval '-2147483648 months -30 days 24 hrs');
 ----
--178956970 years -8 months -29 days
+-178956970 years -8 mons -29 days
 
-query error "178956970 years 7 months -30 days \+1440:00:00" interval out of range
+query error "178956970 years 7 mons \-30 days \+1440:00:00" interval out of range
 SELECT justify_interval(interval '2147483647 months -30 days 1440 hrs');
 
-query error "-178956970 years -8 months \+30 days -1440:00:00" interval out of range
+query error "\-178956970 years \-8 mons \+30 days \-1440:00:00" interval out of range
 SELECT justify_interval(interval '-2147483648 months 30 days -1440 hrs');
 
 # TIMESTAMP/DATE builtins.
@@ -1441,7 +1454,7 @@ SELECT justify_interval(interval '-2147483648 months 30 days -1440 hrs');
 query T
 SELECT age('2001-04-10 22:06:45', '1957-06-13')
 ----
-43 years 9 months 27 days 22:06:45
+43 years 9 mons 27 days 22:06:45
 
 query T
 SELECT age('2017-12-10'::timestamptz, '2017-12-01'::timestamptz)
@@ -1456,7 +1469,7 @@ SELECT age('2017-12-10 04:05:01.555'::timestamp, '2017-12-10 04:05:01.550'::time
 query T
 SELECT age('0001-06-01 08:10:56.555'::timestamp, '9999-12-10 04:05:01.550'::timestamp);
 ----
--9998 years -6 months -8 days -19:54:04.995
+-9998 years -6 mons -8 days -19:54:04.995
 
 query B
 SELECT age('2020-04-05'::date + '03:00'::time, '2020-04-05'::date + '02:00'::time) = '1 hour'::interval;
@@ -1466,19 +1479,19 @@ true
 query T
 SELECT age(to_timestamp(-210833720368), to_timestamp(8200000000000));
 ----
--266528 years -8 months -17 days -12:06:08
+-266528 years -8 mons -17 days -12:06:08
 
 query T
 SELECT age(to_timestamp(8200000000000), to_timestamp(-210833720368));
 ----
-266528 years 8 months 17 days 12:06:08
+266528 years 8 mons 17 days 12:06:08
 
 # Aggregation
 
 query T
 SELECT MAX(unnest) FROM (SELECT UNNEST(ARRAY[INTERVAL '1-2 3 4:5:6.7' MONTH, INTERVAL '1-2 3 4:5:6.7' YEAR]));
 ----
-1 year 2 months
+1 year 2 mons
 
 query T
 SELECT MAX(unnest) FROM (SELECT UNNEST(ARRAY[INTERVAL '2' SECOND, INTERVAL '1' SECOND]));
@@ -1489,3 +1502,18 @@ query T
 SELECT MIN(unnest) FROM (SELECT UNNEST(ARRAY[INTERVAL '2' SECOND, INTERVAL '1' SECOND]));
 ----
 00:00:01
+
+# Regression test for SQL-463: the text encoding must spell the months field
+# "mon"/"mons" like PostgreSQL's IntervalStyle=postgres. Drivers that parse
+# that style (e.g. psycopg) silently dropped all fields following a "months"
+# spelling, corrupting results.
+simple
+SELECT '1 month 10 days'::interval, '-1 year -2 months +3 days'::interval;
+----
+1 mon 10 days,-1 years -2 mons +3 days
+COMPLETE 1
+
+query T
+SELECT ('1 month 10 days'::interval)::text;
+----
+1 mon 10 days
diff --git a/test/sqllogictest/list.slt b/test/sqllogictest/list.slt
index 00d6585b4545c..4158a8bd6ae84 100644
--- a/test/sqllogictest/list.slt
+++ b/test/sqllogictest/list.slt
@@ -92,7 +92,7 @@ SELECT (LIST[1, null] :: TEXT LIST)::text
 query T
 SELECT (LIST['foo', 'f}o', '"\', null, 'null', 'NULL'])::text
 ----
-{foo,"f}o","\"\\",NULL,null,"NULL"}
+{foo,"f}o","\"\\",NULL,"null","NULL"}
 
 query T
 SELECT (list[list[list['"']]])::text
diff --git a/test/sqllogictest/map.slt b/test/sqllogictest/map.slt
index e8ea6500ef77b..4b2f093d95f72 100644
--- a/test/sqllogictest/map.slt
+++ b/test/sqllogictest/map.slt
@@ -984,3 +984,11 @@ query T
 SELECT unnest('{a=>NULL}'::map[text=>int4]);
 ----
 (a,)
+
+# Regression test for SQL-466: string values matching "NULL" in any case
+# must be quoted in text output, so that they round-trip.
+
+query T
+SELECT MAP['k' => 'null']::text;
+----
+{k=>"null"}
diff --git a/test/sqllogictest/not-null-propagation.slt b/test/sqllogictest/not-null-propagation.slt
index ecfb92af890cb..72f7b4ca6e92d 100644
--- a/test/sqllogictest/not-null-propagation.slt
+++ b/test/sqllogictest/not-null-propagation.slt
@@ -421,10 +421,27 @@ EOF
 
 # VARIADIC FUNCTIONS that introduce nulls
 
-query BBBBBBB
-SELECT COALESCE(NULLIF('a', 'a')) IS NULL, GREATEST(NULLIF('a', 'a')) IS NULL, LEAST(NULLIF('a', 'a')) IS NULL, MAKE_TIMESTAMP(2023, 1, 1, 0, 0, 11111) IS NULL, (ARRAY[1, 2])[3] IS NULL, (LIST[1, 2])[3] IS NULL, REGEXP_MATCH('a', 'b')  IS NULL;
+query BBBBBB
+SELECT COALESCE(NULLIF('a', 'a')) IS NULL, GREATEST(NULLIF('a', 'a')) IS NULL, LEAST(NULLIF('a', 'a')) IS NULL, (ARRAY[1, 2])[3] IS NULL, (LIST[1, 2])[3] IS NULL, REGEXP_MATCH('a', 'b')  IS NULL;
 ----
-true  true  true  true  true  true  true
+true  true  true  true  true  true
+
+# MAKE_TIMESTAMP errors on invalid fields rather than returning NULL, but its
+# return type stays nullable, so it still propagates as NULL-able.
+
+query T multiline
+EXPLAIN OPTIMIZED PLAN WITH(types, no fast path, humanized expressions) AS VERBOSE TEXT FOR SELECT MAKE_TIMESTAMP(col_not_null, 1, 1, 0, 0, 0) FROM int_table;
+----
+Explained Query:
+  Project (#2) // { types: "(r_timestamp?)" }
+    Map (makets(integer_to_bigint(#1{col_not_null}), 1, 1, 0, 0, 0)) // { types: "(r_int32?, r_int32, r_timestamp?)" }
+      ReadStorage materialize.public.int_table // { types: "(r_int32?, r_int32)" }
+
+Source materialize.public.int_table
+
+Target cluster: quickstart
+
+EOF
 
 # BINARY FUNCTIONS that introduce nulls
 # MapGetValue and ListLengthMax not covered
diff --git a/test/sqllogictest/timestamptz.slt b/test/sqllogictest/timestamptz.slt
index d0cfb9681bbb5..2e0c62762eac5 100644
--- a/test/sqllogictest/timestamptz.slt
+++ b/test/sqllogictest/timestamptz.slt
@@ -182,7 +182,7 @@ FROM (
 1␠hour␠30␠minutes true
 
 query error timestamp out of range
-select timezone('1 day'::interval, '1-12-31'::timestamptz+'262141 years'::interval)
+select timezone('1 day'::interval, '0001-12-31'::timestamptz+'262141 years'::interval)
 
 # Regression test for database-issues#CLU-92: a leap-second timestamptz combined
 # with a fixed offset that shifts the seconds off `:59` previously panicked
diff --git a/test/sqllogictest/transform/join_fusion.slt b/test/sqllogictest/transform/join_fusion.slt
index b1f0e3f31992e..a1a0f99423ef4 100644
--- a/test/sqllogictest/transform/join_fusion.slt
+++ b/test/sqllogictest/transform/join_fusion.slt
@@ -118,12 +118,12 @@ EXPLAIN OPTIMIZED PLAN WITH(humanized expressions, arity, join implementations)
 Explained Query:
   Project (#0{l_orderkey}..=#7{l_receiptdate}, #0{l_orderkey}, #9{o_custkey}..=#14{c_acctbal}) // { arity: 15 }
     Filter (#5{l_shipdate} != #11{o_orderdate}) AND (#14{c_acctbal} >= #10{o_totalprice}) // { arity: 15 }
-      Join on=(#0{l_orderkey} = #8{o_orderkey} AND date_to_timestamp(#11{o_orderdate}) = (#5{l_shipdate} - 9 months)) type=delta // { arity: 15 }
+      Join on=(#0{l_orderkey} = #8{o_orderkey} AND date_to_timestamp(#11{o_orderdate}) = (#5{l_shipdate} - 9 mons)) type=delta // { arity: 15 }
         implementation
           %0:lineitem » %1:orders[#0{o_orderkey}, date_to_timestamp(#3{o_orderdate})]KK » %2:customer[×]
-          %1:orders » %0:lineitem[#0{l_orderkey}, (#5{l_shipdate} - 9 months)]KK » %2:customer[×]
+          %1:orders » %0:lineitem[#0{l_orderkey}, (#5{l_shipdate} - 9 mons)]KK » %2:customer[×]
           %2:customer » %0:lineitem[×] » %1:orders[#0{o_orderkey}, date_to_timestamp(#3{o_orderdate})]KK
-        ArrangeBy keys=[[], [#0{l_orderkey}, (#5{l_shipdate} - 9 months)]] // { arity: 8 }
+        ArrangeBy keys=[[], [#0{l_orderkey}, (#5{l_shipdate} - 9 mons)]] // { arity: 8 }
           ReadIndex on=lineitem pk_lineitem_orderkey_linenumber=[*** full scan ***] // { arity: 8 }
         ArrangeBy keys=[[#0{o_orderkey}, date_to_timestamp(#3{o_orderdate})]] // { arity: 4 }
           Filter (#0{o_orderkey}) IS NOT NULL // { arity: 4 }
diff --git a/test/sqllogictest/types.slt b/test/sqllogictest/types.slt
index 2c92116f0a440..2ecceecb7361d 100644
--- a/test/sqllogictest/types.slt
+++ b/test/sqllogictest/types.slt
@@ -249,24 +249,24 @@ bigint
 query T
 SELECT '1-2 3 4:5:6.7'::interval
 ----
-1 year 2 months 3 days 04:05:06.7
+1 year 2 mons 3 days 04:05:06.7
 
 query T
 SELECT '1-2 3 4:5:6.7'::pg_catalog.interval
 ----
-1 year 2 months 3 days 04:05:06.7
+1 year 2 mons 3 days 04:05:06.7
 
 # 🔬🔬🔬 interval prefix
 
 query T
 SELECT interval '1-2 3 4:5:6.7'
 ----
-1 year 2 months 3 days 04:05:06.7
+1 year 2 mons 3 days 04:05:06.7
 
 query T
 SELECT pg_catalog.interval '1-2 3 4:5:6.7'
 ----
-1 year 2 months 3 days 04:05:06.7
+1 year 2 mons 3 days 04:05:06.7
 
 # Special interval literal syntax doesn't apply to qualified interval
 query error Expected end of statement, found DAY
diff --git a/test/testdrive-old-kafka-src-syntax/dates-times.td b/test/testdrive-old-kafka-src-syntax/dates-times.td
index d14223a9ebbc4..11ae4b88b1b62 100644
--- a/test/testdrive-old-kafka-src-syntax/dates-times.td
+++ b/test/testdrive-old-kafka-src-syntax/dates-times.td
@@ -133,7 +133,7 @@ contains:precision for type timestamp or timestamptz must be between 0 and 6
 "1 day"
 
 > SELECT INTERVAL '6' MONTH
-"6 months"
+"6 mons"
 
 > SELECT INTERVAL '10' YEAR
 "10 years"
diff --git a/test/testdrive/cluster-controller.td b/test/testdrive/cluster-controller.td
index a84a0d5c69e80..8a50999d7c2dd 100644
--- a/test/testdrive/cluster-controller.td
+++ b/test/testdrive/cluster-controller.td
@@ -330,6 +330,73 @@ scale=1,workers=4
 
 > DROP CLUSTER cc_forced CASCADE
 
+# A second ALTER to the same target can force an in-flight reconfiguration to
+# cut over without replacing the target replica.
+> CREATE CLUSTER cc_force_existing (SIZE 'scale=1,workers=1', REPLICATION FACTOR 1)
+
+> CREATE TABLE cc_force_existing_t (id int)
+
+> INSERT INTO cc_force_existing_t VALUES (1)
+
+> CREATE MATERIALIZED VIEW cc_force_existing_slow IN CLUSTER cc_force_existing AS
+  SELECT mz_unsafe.mz_sleep(id * 3600) AS s FROM cc_force_existing_t
+
+> ALTER CLUSTER cc_force_existing SET (SIZE 'scale=1,workers=4') WITH (WAIT UNTIL READY (TIMEOUT '600s', ON TIMEOUT 'ROLLBACK'))
+
+# The long deadline leaves both the realized and un-hydrated target replicas
+# online while the reconfiguration remains in progress.
+> SELECT r.size, bool_and(status.status = 'online')
+  FROM mz_cluster_replicas r
+  JOIN mz_clusters c ON c.id = r.cluster_id
+  JOIN mz_internal.mz_cluster_replica_statuses status ON status.replica_id = r.id
+  WHERE c.name = 'cc_force_existing'
+  GROUP BY r.size
+scale=1,workers=1 true
+scale=1,workers=4 true
+
+> SELECT recon.status
+  FROM mz_internal.mz_cluster_reconfigurations recon
+  JOIN mz_clusters c ON c.id = recon.cluster_id
+  WHERE c.name = 'cc_force_existing'
+in-progress
+
+$ set-from-sql var=cc_force_existing_target_id
+SELECT r.id::text
+FROM mz_cluster_replicas r
+JOIN mz_clusters c ON c.id = r.cluster_id
+WHERE c.name = 'cc_force_existing' AND r.size = 'scale=1,workers=4'
+
+# Replace only the deadline and timeout action. The existing target shape and
+# replica are reused, and the elapsed deadline forces cut-over on the next tick.
+> ALTER CLUSTER cc_force_existing SET (SIZE 'scale=1,workers=4') WITH (WAIT UNTIL READY (TIMEOUT '0s', ON TIMEOUT 'COMMIT'))
+
+> SELECT r.id::text = '${cc_force_existing_target_id}', r.size
+  FROM mz_cluster_replicas r
+  JOIN mz_clusters c ON c.id = r.cluster_id
+  WHERE c.name = 'cc_force_existing'
+true scale=1,workers=4
+
+> SELECT row_number() OVER (ORDER BY id), details->>'transition', details->>'forced'
+  FROM mz_catalog.mz_audit_events
+  WHERE event_type = 'alter'
+    AND object_type = 'cluster'
+    AND details->>'cluster_name' = 'cc_force_existing'
+    AND details->>'transition' IS NOT NULL
+1 started <null>
+2 started <null>
+3 finalized true
+
+# Only the first ALTER created a target replica.
+> SELECT count(*)
+  FROM mz_catalog.mz_audit_events
+  WHERE event_type = 'create'
+    AND object_type = 'cluster-replica'
+    AND details->>'cluster_name' = 'cc_force_existing'
+    AND details->>'reason' = 'reconfiguration'
+1
+
+> DROP CLUSTER cc_force_existing CASCADE
+
 $ postgres-execute connection=postgres://mz_system@${testdrive.materialize-internal-sql-addr}
 ALTER SYSTEM SET unsafe_enable_unstable_dependencies = false
 
diff --git a/test/testdrive/copy-from-s3-minio-parquet.td b/test/testdrive/copy-from-s3-minio-parquet.td
index 5c921fab1149d..4baad39ba049a 100644
--- a/test/testdrive/copy-from-s3-minio-parquet.td
+++ b/test/testdrive/copy-from-s3-minio-parquet.td
@@ -79,9 +79,9 @@ SlimJim
 Taco
 
 > SELECT interval_ym_col FROM types ORDER BY int8_col DESC;
-"-2 months"
-"1 year 1 month"
-"1 month"
+"-2 mons"
+"1 year 1 mon"
+"1 mon"
 
 > SELECT interval_dt_col FROM types ORDER BY int8_col DESC;
 "-1 days -00:00:01"
@@ -114,9 +114,9 @@ SlimJim
 Taco
 
 > SELECT interval_ym_col FROM types ORDER BY int8_col DESC;
-"-2 months"
-"1 year 1 month"
-"1 month"
+"-2 mons"
+"1 year 1 mon"
+"1 mon"
 
 > SELECT interval_dt_col FROM types ORDER BY int8_col DESC;
 "-1 days -00:00:01"
@@ -148,9 +148,9 @@ SlimJim
 Taco
 
 > SELECT interval_ym_col FROM types ORDER BY int8_col DESC;
-"-2 months"
-"1 year 1 month"
-"1 month"
+"-2 mons"
+"1 year 1 mon"
+"1 mon"
 
 > SELECT interval_dt_col FROM types ORDER BY int8_col DESC;
 "-1 days -00:00:01"
@@ -182,9 +182,9 @@ SlimJim
 Taco
 
 > SELECT interval_ym_col FROM types ORDER BY int8_col DESC;
-"-2 months"
-"1 year 1 month"
-"1 month"
+"-2 mons"
+"1 year 1 mon"
+"1 mon"
 
 > SELECT interval_dt_col FROM types ORDER BY int8_col DESC;
 "-1 days -00:00:01"
@@ -216,9 +216,9 @@ SlimJim
 Taco
 
 > SELECT interval_ym_col FROM types ORDER BY int8_col DESC;
-"-2 months"
-"1 year 1 month"
-"1 month"
+"-2 mons"
+"1 year 1 mon"
+"1 mon"
 
 > SELECT interval_dt_col FROM types ORDER BY int8_col DESC;
 "-1 days -00:00:01"
@@ -250,9 +250,9 @@ SlimJim
 Taco
 
 > SELECT interval_ym_col FROM types ORDER BY int8_col DESC;
-"-2 months"
-"1 year 1 month"
-"1 month"
+"-2 mons"
+"1 year 1 mon"
+"1 mon"
 
 > SELECT interval_dt_col FROM types ORDER BY int8_col DESC;
 "-1 days -00:00:01"
@@ -335,24 +335,24 @@ Taco
 Taco
 
 > SELECT interval_ym_col FROM types ORDER BY int8_col DESC;
-"-2 months"
-"-2 months"
-"-2 months"
-"-2 months"
-"-2 months"
-"-2 months"
-"1 year 1 month"
-"1 year 1 month"
-"1 year 1 month"
-"1 year 1 month"
-"1 year 1 month"
-"1 year 1 month"
-"1 month"
-"1 month"
-"1 month"
-"1 month"
-"1 month"
-"1 month"
+"-2 mons"
+"-2 mons"
+"-2 mons"
+"-2 mons"
+"-2 mons"
+"-2 mons"
+"1 year 1 mon"
+"1 year 1 mon"
+"1 year 1 mon"
+"1 year 1 mon"
+"1 year 1 mon"
+"1 year 1 mon"
+"1 mon"
+"1 mon"
+"1 mon"
+"1 mon"
+"1 mon"
+"1 mon"
 
 > SELECT interval_dt_col FROM types ORDER BY int8_col DESC;
 "-1 days -00:00:01"
diff --git a/test/testdrive/dates-times.td b/test/testdrive/dates-times.td
index 2ce8c2b4985b6..97cc04fbd75bf 100644
--- a/test/testdrive/dates-times.td
+++ b/test/testdrive/dates-times.td
@@ -137,7 +137,7 @@ contains:precision for type timestamp or timestamptz must be between 0 and 6
 "1 day"
 
 > SELECT INTERVAL '6' MONTH
-"6 months"
+"6 mons"
 
 > SELECT INTERVAL '10' YEAR
 "10 years"