fix: handle negative timezone offsets in timestamptz text-format decode

The text-format decoder for NaiveDateTime used s.contains('+') to detect
timezone offsets in PostgreSQL's text output. This missed negative offsets
(e.g. -05 for America/New_York), causing the parse to fail and silently
return the Unix epoch (1970-01-01T00:00:00+00:00).

This affects any query using the simple query protocol (no bind parameters)
that returns a TIMESTAMPTZ column when the session timezone is west of UTC.

Fix: try parsing with timezone offset first (%#z), then fall back to
parsing without timezone. Added tests for positive, negative, and missing
timezone offsets.

Author: lovasoa

sqlx-core/src/postgres/types/chrono/datetime.rs

@@ -68,17 +68,11 @@ impl<'r> Decode<'r, Postgres> for NaiveDateTime {
 
             PgValueFormat::Text => {
                 let s = value.as_str()?;
-                NaiveDateTime::parse_from_str(
-                    s,
-                    if s.contains('+') {
-                        // Contains a time-zone specifier
-                        // This is given for timestamptz for some reason
-                        // Postgres already guarantees this to always be UTC
-                        "%Y-%m-%d %H:%M:%S%.f%#z"
-                    } else {
-                        "%Y-%m-%d %H:%M:%S%.f"
-                    },
-                )?
+                // Try with timezone offset first (handles both positive and
+                // negative offsets like +05 or -05), then fall back to parsing
+                // without timezone for plain timestamps.
+                NaiveDateTime::parse_from_str(s, "%Y-%m-%d %H:%M:%S%.f%#z")
+                    .or_else(|_| NaiveDateTime::parse_from_str(s, "%Y-%m-%d %H:%M:%S%.f"))?
             }
         })
     }
@@ -114,3 +108,68 @@ impl<'r> Decode<'r, Postgres> for DateTime<FixedOffset> {
         Ok(Utc.fix().from_utc_datetime(&naive))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::postgres::PgValueFormat;
+
+    fn text_decode_naive(s: &str) -> Result<NaiveDateTime, BoxDynError> {
+        let value = PgValueRef {
+            value: Some(s.as_bytes()),
+            row: None,
+            type_info: PgTypeInfo::TIMESTAMPTZ,
+            format: PgValueFormat::Text,
+        };
+        <NaiveDateTime as Decode<Postgres>>::decode(value)
+    }
+
+    #[test]
+    fn test_decode_timestamptz_negative_offset() {
+        // PostgreSQL returns this text format when session timezone is America/New_York (UTC-5)
+        let dt = text_decode_naive("2020-12-31 19:00:00-05").unwrap();
+        assert_eq!(
+            dt,
+            NaiveDate::from_ymd_opt(2020, 12, 31)
+                .unwrap()
+                .and_hms_opt(19, 0, 0)
+                .unwrap()
+        );
+    }
+
+    #[test]
+    fn test_decode_timestamptz_positive_offset() {
+        let dt = text_decode_naive("2021-01-01 05:00:00+05").unwrap();
+        assert_eq!(
+            dt,
+            NaiveDate::from_ymd_opt(2021, 1, 1)
+                .unwrap()
+                .and_hms_opt(5, 0, 0)
+                .unwrap()
+        );
+    }
+
+    #[test]
+    fn test_decode_timestamp_no_offset() {
+        let dt = text_decode_naive("2021-01-01 00:00:00").unwrap();
+        assert_eq!(
+            dt,
+            NaiveDate::from_ymd_opt(2021, 1, 1)
+                .unwrap()
+                .and_hms_opt(0, 0, 0)
+                .unwrap()
+        );
+    }
+
+    #[test]
+    fn test_decode_timestamptz_with_fractional_seconds() {
+        let dt = text_decode_naive("2021-01-01 00:00:00.123456-05").unwrap();
+        assert_eq!(
+            dt,
+            NaiveDate::from_ymd_opt(2021, 1, 1)
+                .unwrap()
+                .and_hms_micro_opt(0, 0, 0, 123456)
+                .unwrap()
+        );
+    }
+}