chore: extract protocol error to a separate file

Author: ovr

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

@@ -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/cubesql/pg-srv/src/error.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/lib.rs

@@ -6,6 +6,7 @@ mod decoding;
 mod encoding;
 
 pub mod buffer;
+pub mod error;
 pub mod extended;
 pub mod interval;
 pub mod pg_type;
@@ -15,73 +16,8 @@ pub mod timestamp;
 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,
-        }
-    }
-}