feat(cubesql): Support timestamp parameter binding

Author: ovr

rust/cubesql/cubesql/e2e/main.rs

@@ -22,7 +22,7 @@ impl TestsRunner {
 
     pub fn register_suite(&mut self, result: AsyncTestConstructorResult) {
         match result {
-            AsyncTestConstructorResult::Sucess(suite) => self.suites.push(suite),
+            AsyncTestConstructorResult::Success(suite) => self.suites.push(suite),
             AsyncTestConstructorResult::Skipped(message) => {
                 println!("Skipped: {}", message)
             }

rust/cubesql/cubesql/e2e/tests/basic.rs

@@ -23,6 +23,6 @@ pub trait AsyncTestSuite: Debug {
 }
 
 pub enum AsyncTestConstructorResult {
-    Sucess(Box<dyn AsyncTestSuite>),
+    Success(Box<dyn AsyncTestSuite>),
     Skipped(String),
 }

rust/cubesql/cubesql/e2e/tests/postgres.rs

@@ -92,7 +92,7 @@ impl PostgresIntegrationTestSuite {
         )
         .await;
 
-        AsyncTestConstructorResult::Sucess(Box::new(PostgresIntegrationTestSuite { client, port }))
+        AsyncTestConstructorResult::Success(Box::new(PostgresIntegrationTestSuite { client, port }))
     }
 
     async fn create_client(config: tokio_postgres::Config) -> Client {

rust/cubesql/cubesql/src/sql/statement.rs

@@ -624,6 +624,10 @@ impl<'ast> Visitor<'ast, ConnectionError> for PostgresStatementParamsBinder {
                     BindValue::Float64(v) => {
                         *value = ast::Value::Number(v.to_string(), *v < 0_f64);
                     }
+                    BindValue::Timestamp(v) => {
+                        // Format timestamp as string literal for SQL processing
+                        *value = ast::Value::SingleQuotedString(v.format("%Y-%m-%d %H:%M:%S%.6f").to_string());
+                    }
                     BindValue::Null => {
                         *value = ast::Value::Null;
                     }

rust/cubesql/pg-srv/src/decoding.rs

@@ -5,6 +5,8 @@ use crate::{
     ProtocolError,
 };
 use byteorder::{BigEndian, ByteOrder};
+#[cfg(feature = "with-chrono")]
+use chrono::{NaiveDate, NaiveDateTime};
 use std::backtrace::Backtrace;
 
 /// This trait explains how to decode values from the protocol
@@ -122,6 +124,81 @@ impl FromProtocolValue for f64 {
     }
 }
 
+#[cfg(feature = "with-chrono")]
+impl FromProtocolValue for NaiveDateTime {
+    fn from_text(raw: &[u8]) -> Result<Self, ProtocolError> {
+        let as_str = std::str::from_utf8(raw).map_err(|err| ProtocolError::ErrorResponse {
+            source: ErrorResponse::error(ErrorCode::ProtocolViolation, err.to_string()),
+            backtrace: Backtrace::capture(),
+        })?;
+
+        // Parse timestamp strings in various common formats
+        // Try PostgreSQL format first: "2022-04-25 16:25:01.164774"
+        if let Ok(dt) = NaiveDateTime::parse_from_str(as_str, "%Y-%m-%d %H:%M:%S%.f") {
+            return Ok(dt);
+        }
+
+        // Try without microseconds: "2022-04-25 16:25:01"
+        if let Ok(dt) = NaiveDateTime::parse_from_str(as_str, "%Y-%m-%d %H:%M:%S") {
+            return Ok(dt);
+        }
+
+        // Try ISO format: "2022-04-25T16:25:01.164774"
+        if let Ok(dt) = NaiveDateTime::parse_from_str(as_str, "%Y-%m-%dT%H:%M:%S%.f") {
+            return Ok(dt);
+        }
+
+        // Try ISO format without microseconds: "2022-04-25T16:25:01"
+        if let Ok(dt) = NaiveDateTime::parse_from_str(as_str, "%Y-%m-%dT%H:%M:%S") {
+            return Ok(dt);
+        }
+
+        Err(ProtocolError::ErrorResponse {
+            source: ErrorResponse::error(
+                ErrorCode::ProtocolViolation,
+                format!("Unable to parse timestamp from text: {}", as_str),
+            ),
+            backtrace: Backtrace::capture(),
+        })
+    }
+
+    fn from_binary(raw: &[u8]) -> Result<Self, ProtocolError> {
+        if raw.len() != 8 {
+            return Err(ProtocolError::ErrorResponse {
+                source: ErrorResponse::error(
+                    ErrorCode::ProtocolViolation,
+                    format!(
+                        "Invalid binary timestamp length: expected 8, got {}",
+                        raw.len()
+                    ),
+                ),
+                backtrace: Backtrace::capture(),
+            });
+        }
+
+        // PostgreSQL timestamp is microseconds since 2000-01-01 00:00:00 UTC
+        let microseconds = BigEndian::read_i64(raw);
+        let base_time = NaiveDate::from_ymd_opt(2000, 1, 1)
+            .unwrap()
+            .and_hms_opt(0, 0, 0)
+            .unwrap();
+
+        let duration = chrono::Duration::microseconds(microseconds);
+        base_time
+            .checked_add_signed(duration)
+            .ok_or_else(|| ProtocolError::ErrorResponse {
+                source: ErrorResponse::error(
+                    ErrorCode::ProtocolViolation,
+                    format!(
+                        "Timestamp overflow: {} microseconds from epoch",
+                        microseconds
+                    ),
+                ),
+                backtrace: Backtrace::capture(),
+            })
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::*;
@@ -156,6 +233,16 @@ mod tests {
         assert_test_decode(-std::f64::consts::E, Format::Text)?;
         assert_test_decode(0.0_f64, Format::Text)?;
 
+        #[cfg(feature = "with-chrono")]
+        {
+            use chrono::NaiveDate;
+            let timestamp = NaiveDate::from_ymd_opt(2022, 4, 25)
+                .unwrap()
+                .and_hms_micro_opt(16, 25, 1, 164774)
+                .unwrap();
+            assert_test_decode(timestamp, Format::Text)?;
+        }
+
         Ok(())
     }
 
@@ -170,6 +257,16 @@ mod tests {
         assert_test_decode(-std::f64::consts::E, Format::Binary)?;
         assert_test_decode(0.0_f64, Format::Binary)?;
 
+        #[cfg(feature = "with-chrono")]
+        {
+            use chrono::NaiveDate;
+            let timestamp = NaiveDate::from_ymd_opt(2022, 4, 25)
+                .unwrap()
+                .and_hms_micro_opt(16, 25, 1, 164774)
+                .unwrap();
+            assert_test_decode(timestamp, Format::Binary)?;
+        }
+
         Ok(())
     }
 }

rust/cubesql/pg-srv/src/encoding.rs

@@ -1,6 +1,9 @@
 //! Encoding native values to the Protocol representation
 
-use crate::{protocol::Format, ProtocolError};
+use crate::{
+    protocol::{ErrorCode, ErrorResponse, Format},
+    ProtocolError,
+};
 use bytes::{BufMut, BytesMut};
 #[cfg(feature = "with-chrono")]
 use chrono::{NaiveDate, NaiveDateTime};
@@ -149,6 +152,39 @@ impl ToProtocolValue for NaiveDate {
     }
 }
 
+#[cfg(feature = "with-chrono")]
+impl ToProtocolValue for NaiveDateTime {
+    // timestamp_out - https://github.com/postgres/postgres/blob/REL_14_4/src/backend/utils/adt/timestamp.c#L242
+    fn to_text(&self, buf: &mut BytesMut) -> Result<(), ProtocolError> {
+        // Format as PostgreSQL timestamp string
+        let formatted = self.format("%Y-%m-%d %H:%M:%S%.6f").to_string();
+        formatted.to_text(buf)
+    }
+
+    // timestamp_send - https://github.com/postgres/postgres/blob/REL_14_4/src/backend/utils/adt/timestamp.c#L280
+    fn to_binary(&self, buf: &mut BytesMut) -> Result<(), ProtocolError> {
+        // PostgreSQL timestamp is microseconds since 2000-01-01 00:00:00 UTC
+        let base_time = pg_base_date_epoch();
+        let duration = self.signed_duration_since(base_time);
+
+        let microseconds =
+            duration
+                .num_microseconds()
+                .ok_or_else(|| ProtocolError::ErrorResponse {
+                    source: ErrorResponse::error(
+                        ErrorCode::ProtocolViolation,
+                        "Timestamp duration overflow when converting to microseconds".to_string(),
+                    ),
+                    backtrace: std::backtrace::Backtrace::capture(),
+                })?;
+
+        buf.put_i32(8); // timestamp is 8 bytes
+        buf.put_i64(microseconds);
+
+        Ok(())
+    }
+}
+
 #[derive(Debug, Clone, Default)]
 pub struct IntervalValue {
     pub months: i32,
@@ -307,6 +343,23 @@ mod tests {
         assert_text_encode(false, &[0, 0, 0, 1, 102]);
         assert_text_encode("str".to_string(), &[0, 0, 0, 3, 115, 116, 114]);
 
+        #[cfg(feature = "with-chrono")]
+        {
+            use chrono::NaiveDate;
+            let timestamp = NaiveDate::from_ymd_opt(2022, 4, 25)
+                .unwrap()
+                .and_hms_micro_opt(16, 25, 1, 164774)
+                .unwrap();
+
+            let mut buf = BytesMut::new();
+            timestamp.to_text(&mut buf).unwrap();
+
+            // Check that it encoded correctly - should start with length
+            assert!(buf.len() > 4);
+            let length = u32::from_be_bytes([buf[0], buf[1], buf[2], buf[3]]) as usize;
+            assert_eq!(length + 4, buf.len());
+        }
+
         Ok(())
     }
 
@@ -322,6 +375,22 @@ mod tests {
         assert_bind_encode(true, &[0, 0, 0, 1, 1]);
         assert_bind_encode(false, &[0, 0, 0, 1, 0]);
 
+        #[cfg(feature = "with-chrono")]
+        {
+            use chrono::NaiveDate;
+            let timestamp = NaiveDate::from_ymd_opt(2022, 4, 25)
+                .unwrap()
+                .and_hms_micro_opt(16, 25, 1, 164774)
+                .unwrap();
+
+            let mut buf = BytesMut::new();
+            timestamp.to_binary(&mut buf).unwrap();
+
+            // Check that it encoded correctly - should be 12 bytes total (4 bytes length + 8 bytes timestamp)
+            assert_eq!(buf.len(), 12);
+            assert_eq!(&buf[0..4], &[0, 0, 0, 8]); // length = 8
+        }
+
         Ok(())
     }
 

rust/cubesql/pg-srv/src/extended.rs

@@ -1,10 +1,15 @@
 //! Implementation for Extended Query
 
+#[cfg(feature = "with-chrono")]
+use chrono::NaiveDateTime;
+
 #[derive(Debug, PartialEq)]
 pub enum BindValue {
     String(String),
     Int64(i64),
     Float64(f64),
     Bool(bool),
+    #[cfg(feature = "with-chrono")]
+    Timestamp(NaiveDateTime),
     Null,
 }

rust/cubesql/pg-srv/src/protocol.rs

@@ -18,6 +18,9 @@ use tokio::io::AsyncReadExt;
 
 use crate::{buffer, BindValue, FromProtocolValue, PgType, PgTypeId, ProtocolError};
 
+#[cfg(feature = "with-chrono")]
+use chrono;
+
 const DEFAULT_CAPACITY: usize = 64;
 
 #[derive(Debug, PartialEq, Clone)]
@@ -786,6 +789,10 @@ impl Bind {
                     PgTypeId::FLOAT8 => {
                         BindValue::Float64(f64::from_protocol(raw_value, param_format)?)
                     }
+                    #[cfg(feature = "with-chrono")]
+                    PgTypeId::TIMESTAMP => {
+                        BindValue::Timestamp(chrono::NaiveDateTime::from_protocol(raw_value, param_format)?)
+                    }
                     _ => {
                         return Err(ErrorResponse::error(
                             ErrorCode::FeatureNotSupported,