chore: extract protocol error to a separate file

Author: ovr

packages/cubejs-backend-native/Cargo.lock

@@ -11,9 +11,6 @@ use datafusion::arrow::{
     datatypes::{DataType, IntervalUnit, Schema, TimeUnit},
     record_batch::RecordBatch,
 };
-// Type aliases for compatibility - actual implementations are in pg-srv
-pub type IntervalValue = pg_srv::IntervalValue;
-pub type TimestampValue = pg_srv::TimestampValue;
 use rust_decimal::prelude::*;
 use serde::{Serialize, Serializer};
 use std::fmt::Debug;
@@ -78,6 +75,10 @@ impl Row {
     }
 }
 
+// Type aliases for compatibility - actual implementations are in pg-srv
+pub type IntervalValue = pg_srv::IntervalValue;
+pub type TimestampValue = pg_srv::TimestampValue;
+
 #[derive(Debug)]
 pub enum TableValue {
     Null,

rust/cubenativeutils/Cargo.lock

@@ -163,6 +163,36 @@ mod tests {
         assert_text_encode(true, &[0, 0, 0, 1, 116]);
         assert_text_encode(false, &[0, 0, 0, 1, 102]);
         assert_text_encode("str".to_string(), &[0, 0, 0, 3, 115, 116, 114]);
+        assert_text_encode(
+            IntervalValue::new(0, 0, 0, 0, 0, 0),
+            &[
+                0, 0, 0, 46, 48, 32, 121, 101, 97, 114, 115, 32, 48, 32, 109, 111, 110, 115, 32,
+                48, 32, 100, 97, 121, 115, 32, 48, 32, 104, 111, 117, 114, 115, 32, 48, 32, 109,
+                105, 110, 115, 32, 48, 46, 48, 48, 32, 115, 101, 99, 115,
+            ],
+        );
+        assert_text_encode(
+            IntervalValue::new(1, 2, 3, 4, 5, 6),
+            &[
+                0, 0, 0, 50, 48, 32, 121, 101, 97, 114, 115, 32, 49, 32, 109, 111, 110, 115, 32,
+                50, 32, 100, 97, 121, 115, 32, 51, 32, 104, 111, 117, 114, 115, 32, 52, 32, 109,
+                105, 110, 115, 32, 53, 46, 48, 48, 48, 48, 48, 54, 32, 115, 101, 99, 115,
+            ],
+        );
+        assert_text_encode(
+            TimestampValue::new(0, None),
+            &[
+                0, 0, 0, 26, 49, 57, 55, 48, 45, 48, 49, 45, 48, 49, 32, 48, 48, 58, 48, 48, 58,
+                48, 48, 46, 48, 48, 48, 48, 48, 48,
+            ],
+        );
+        assert_text_encode(
+            TimestampValue::new(1650890322000000000, None),
+            &[
+                0, 0, 0, 26, 50, 48, 50, 50, 45, 48, 52, 45, 50, 53, 32, 49, 50, 58, 51, 56, 58,
+                52, 50, 46, 48, 48, 48, 48, 48, 48,
+            ],
+        );
 
         Ok(())
     }
@@ -178,6 +208,24 @@ mod tests {
     fn test_binary_encoders() -> Result<(), ProtocolError> {
         assert_bind_encode(true, &[0, 0, 0, 1, 1]);
         assert_bind_encode(false, &[0, 0, 0, 1, 0]);
+        assert_bind_encode(
+            IntervalValue::new(0, 0, 0, 0, 0, 0),
+            &[0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        );
+        assert_bind_encode(
+            IntervalValue::new(1, 2, 3, 4, 5, 6),
+            &[
+                0, 0, 0, 16, 0, 0, 0, 2, 146, 85, 83, 70, 0, 0, 0, 2, 0, 0, 0, 1,
+            ],
+        );
+        assert_bind_encode(
+            TimestampValue::new(0, None),
+            &[0, 0, 0, 8, 255, 252, 162, 254, 196, 200, 32, 0],
+        );
+        assert_bind_encode(
+            TimestampValue::new(1650890322000000000, None),
+            &[0, 0, 0, 8, 0, 2, 128, 120, 159, 252, 216, 128],
+        );
 
         Ok(())
     }

rust/cubesql/cubesql/src/sql/dataframe.rs

@@ -0,0 +1,68 @@
+//! Protocol error types for PostgreSQL wire protocol
+
+use crate::protocol;
+use std::{backtrace::Backtrace, fmt::Formatter};
+
+/// Protocol error abstract of handled/unhandled errors, it should not handle any kind of business logic errors
+/// TODO: Migrate back to thiserror crate, when Rust will stabilize feature(error_generic_member_access)
+#[derive(Debug)]
+pub enum ProtocolError {
+    IO {
+        source: std::io::Error,
+        backtrace: Backtrace,
+    },
+    ErrorResponse {
+        source: protocol::ErrorResponse,
+        backtrace: Backtrace,
+    },
+}
+
+impl std::fmt::Display for ProtocolError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ProtocolError::IO { source, .. } => f.write_fmt(format_args!("IO error: {}", source)),
+            ProtocolError::ErrorResponse { source, .. } => {
+                f.write_fmt(format_args!("Error: {}", source.message))
+            }
+        }
+    }
+}
+
+impl From<std::io::Error> for ProtocolError {
+    fn from(source: std::io::Error) -> Self {
+        ProtocolError::IO {
+            source,
+            backtrace: Backtrace::capture(),
+        }
+    }
+}
+
+impl From<protocol::ErrorResponse> for ProtocolError {
+    fn from(source: protocol::ErrorResponse) -> Self {
+        ProtocolError::ErrorResponse {
+            source,
+            backtrace: Backtrace::capture(),
+        }
+    }
+}
+
+impl ProtocolError {
+    /// Return Backtrace from any variant of Enum
+    pub fn backtrace(&self) -> Option<&Backtrace> {
+        match &self {
+            ProtocolError::IO { backtrace, .. } => Some(backtrace),
+            ProtocolError::ErrorResponse { backtrace, .. } => Some(backtrace),
+        }
+    }
+
+    /// Converts Error to protocol::ErrorResponse which is usefully for writing response to the client
+    pub fn to_error_response(self) -> protocol::ErrorResponse {
+        match self {
+            ProtocolError::IO { source, .. } => protocol::ErrorResponse::error(
+                protocol::ErrorCode::InternalError,
+                source.to_string(),
+            ),
+            ProtocolError::ErrorResponse { source, .. } => source,
+        }
+    }
+}

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

@@ -6,82 +6,16 @@ mod decoding;
 mod encoding;
 
 pub mod buffer;
+pub mod error;
 pub mod extended;
-pub mod interval;
 pub mod pg_type;
 pub mod protocol;
-pub mod timestamp;
+pub mod values;
 
 pub use buffer::*;
 pub use decoding::*;
 pub use encoding::*;
+pub use error::*;
 pub use extended::*;
-pub use interval::*;
 pub use pg_type::*;
-pub use timestamp::*;
-
-use std::{backtrace::Backtrace, fmt::Formatter};
-
-/// Protocol error abstract of handled/unhandled errors, it should not handle any kind of business logic errors
-/// TODO: Migrate back to thiserror crate, when Rust will stabilize feature(error_generic_member_access)
-#[derive(Debug)]
-pub enum ProtocolError {
-    IO {
-        source: std::io::Error,
-        backtrace: Backtrace,
-    },
-    ErrorResponse {
-        source: protocol::ErrorResponse,
-        backtrace: Backtrace,
-    },
-}
-
-impl std::fmt::Display for ProtocolError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match self {
-            ProtocolError::IO { source, .. } => f.write_fmt(format_args!("IO error: {}", source)),
-            ProtocolError::ErrorResponse { source, .. } => {
-                f.write_fmt(format_args!("Error: {}", source.message))
-            }
-        }
-    }
-}
-
-impl From<std::io::Error> for ProtocolError {
-    fn from(source: std::io::Error) -> Self {
-        ProtocolError::IO {
-            source,
-            backtrace: Backtrace::capture(),
-        }
-    }
-}
-
-impl From<protocol::ErrorResponse> for ProtocolError {
-    fn from(source: protocol::ErrorResponse) -> Self {
-        ProtocolError::ErrorResponse {
-            source,
-            backtrace: Backtrace::capture(),
-        }
-    }
-}
-
-impl ProtocolError {
-    /// Return Backtrace from any variant of Enum
-    pub fn backtrace(&self) -> Option<&Backtrace> {
-        match &self {
-            ProtocolError::IO { backtrace, .. } => Some(backtrace),
-            ProtocolError::ErrorResponse { backtrace, .. } => Some(backtrace),
-        }
-    }
-
-    /// Converts Error to protocol::ErrorResponse which is usefully for writing response to the client
-    pub fn to_error_response(self) -> protocol::ErrorResponse {
-        match self {
-            ProtocolError::IO { source, .. } => protocol::ErrorResponse::error(
-                protocol::ErrorCode::InternalError,
-                source.to_string(),
-            ),
-            ProtocolError::ErrorResponse { source, .. } => source,
-        }
-    }
-}
+pub use values::*;

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

@@ -0,0 +1,9 @@
+//! PostgreSQL value types for wire protocol
+
+pub mod interval;
+#[cfg(feature = "with-chrono")]
+pub mod timestamp;
+
+pub use interval::*;
+#[cfg(feature = "with-chrono")]
+pub use timestamp::*;