postgres: Handle incoming ISO-8601 timestamps

Postgres' standard base representation of timestamps is "<date>
<time>", with a space as separator: "2025-10-13 16:09:06"; PG takes
that base format as input and returns as output.

Additionally, there is a Note on the same page that states:

  ISO 8601 specifies the use of uppercase letter T to separate the date
  and time. PostgreSQL accepts that format on input, but on output it
  uses a space rather than T, as shown above. This is for readability
  and for consistency with RFC 3339 as well as some other database
  systems.

Some drivers (node-js, psychopg2) will, by default, send the ISO-8601
flavored string representation.

Readyset is currently not accepting the T separator variant in either
the simple query protocol (string -> `DfValue`), nor in the text
transfer format of the extended protocol path, a/k/a bound parameters
to prepared statements (`psql-srv::codec::decoder`).

This CL fixes both paths by performing the existing space-separator
parsing first, then trying the `T`-separator parse on error.

[0] www.postgresql.org/docs/current/datatype-datetime.html

Fixes: REA-6104
Release-Note-Core: Accept IS0-8601 string timestamp separator in
  postgres (both simple and extended query protocols).
Change-Id: I096bb650540784f897210f19e00f8f8f0cbfbbac
Reviewed-on: https://gerrit.readyset.name/c/readyset/+/10678
Tested-by: Buildkite CI
Reviewed-by: Johnathan Davis <jcd@readyset.io>

Author: jasobrown-rs

psql-srv/src/codec/decoder.rs

@@ -50,8 +50,18 @@ const STARTUP_MESSAGE_APPLICATION_NAME_PARAMETER: &str = "application_name";
 const HEADER_LENGTH: usize = 5;
 const LENGTH_NULL_SENTINEL: i32 = -1;
 const NUL_BYTE: u8 = b'\0';
+
+/// The standard postgres representation of a timestamp, as per [0].
+///
+/// [0] www.postgresql.org/docs/current/datatype-datetime.html
 const TIMESTAMP_FORMAT: &str = "%Y-%m-%d %H:%M:%S%.f";
 
+/// Postgres also supports the standard ISO-8601 format, the the `T` separator
+/// between the date and the time. See note in pg docs: [0].
+///
+/// https://www.postgresql.org/docs/current/datatype-datetime.html#DATATYPE-DATETIME-INPUT
+const ISO_TIMESTAMP_FORMAT: &str = "%Y-%m-%dT%H:%M:%S%.f";
+
 impl Decoder for Codec {
     type Item = FrontendMessage;
     type Error = Error;
@@ -455,7 +465,9 @@ fn get_text_value(src: &mut Bytes, t: &Type) -> Result<PsqlValue, Error> {
             // TODO: Does not correctly handle all valid timestamp representations. For example,
             // 8601/SQL timestamp format is assumed; infinity/-infinity are not supported.
             let (datetime, timezone_tag) =
-                NaiveDateTime::parse_and_remainder(text_str, TIMESTAMP_FORMAT)?;
+                NaiveDateTime::parse_and_remainder(text_str, TIMESTAMP_FORMAT).or_else(|_| {
+                    NaiveDateTime::parse_and_remainder(text_str, ISO_TIMESTAMP_FORMAT)
+                })?;
             if timezone_tag.is_empty() {
                 return Ok(PsqlValue::Timestamp(datetime));
             }
@@ -1482,6 +1494,19 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_decode_text_timestamp_separator() {
+        let mut buf = BytesMut::new();
+        buf.put_i32(22); // size
+        buf.extend_from_slice(b"2020-01-02T03:04:05.66"); // value
+        assert_eq!(
+            get_text_value(&mut buf.freeze(), &Type::TIMESTAMP).unwrap(),
+            PsqlValue::Timestamp(
+                NaiveDateTime::parse_from_str("2020-01-02 03:04:05.66", TIMESTAMP_FORMAT).unwrap()
+            )
+        );
+    }
+
     #[test]
     fn test_decode_text_timestamp() {
         let mut buf = BytesMut::new();
@@ -1494,7 +1519,6 @@ mod tests {
             )
         );
     }
-
     #[test]
     fn test_decode_text_timestamp_with_offset() {
         let expected =

readyset-data/src/timestamp.rs

@@ -15,6 +15,9 @@ use crate::{DfType, DfValue};
 /// The format for timestamps when parsed as text
 pub const TIMESTAMP_PARSE_FORMAT: &str = "%Y-%m-%d %H:%M:%S%.f";
 
+/// The ISO-8601 format for timestamps with T separator
+pub const ISO_TIMESTAMP_PARSE_FORMAT: &str = "%Y-%m-%dT%H:%M:%S%.f";
+
 /// The format for timestamps when presented as text
 pub const TIMESTAMP_FORMAT: &str = "%Y-%m-%d %H:%M:%S";
 
@@ -388,6 +391,7 @@ impl TimestampTz {
         Ok(
             if let Ok((naive_date_time, offset_tag)) =
                 NaiveDateTime::parse_and_remainder(ts, TIMESTAMP_PARSE_FORMAT)
+                    .or_else(|_| NaiveDateTime::parse_and_remainder(ts, ISO_TIMESTAMP_PARSE_FORMAT))
             {
                 if let Some(offset) = parse_timestamp_tag(offset_tag) {
                     offset?
@@ -398,8 +402,6 @@ impl TimestampTz {
                 } else {
                     naive_date_time.into()
                 }
-            } else if let Ok(dt) = NaiveDateTime::parse_from_str(ts, TIMESTAMP_PARSE_FORMAT) {
-                dt.into()
             } else if let Ok(dt) = NaiveDate::parse_from_str(ts, DATE_FORMAT) {
                 // Make TimestampTz object with time portion 00:00:00
                 dt.and_hms_opt(0, 0, 0)
@@ -838,6 +840,18 @@ mod tests {
                 .unwrap()
         );
 
+        // Test ISO-8601 format with T separator
+        assert_eq!(
+            TimestampTz::from_str("2012-02-09T12:12:12")
+                .unwrap()
+                .to_chrono()
+                .naive_local(),
+            chrono::NaiveDate::from_ymd_opt(2012, 2, 9)
+                .unwrap()
+                .and_hms_opt(12, 12, 12)
+                .unwrap()
+        );
+
         assert_eq!(
             TimestampTz::from_str("2004-10-19 10:23:54+02")
                 .unwrap()
@@ -849,6 +863,18 @@ mod tests {
                 .unwrap()
         );
 
+        // Test ISO-8601 format with T separator and timezone
+        assert_eq!(
+            TimestampTz::from_str("2004-10-19T10:23:54+02")
+                .unwrap()
+                .to_chrono(),
+            chrono::FixedOffset::east_opt(2 * 60 * 60)
+                .unwrap()
+                .with_ymd_and_hms(2004, 10, 19, 10, 23, 54)
+                .single()
+                .unwrap()
+        );
+
         assert_eq!(
             TimestampTz::from_str("2004-10-19 10:23:54.1234+02")
                 .unwrap()