[#63] 오류 처리 리팩토링

README.md

@@ -49,7 +49,7 @@ cargo run --bin rrdb run
 #### Client
 
 ```
-psql -U rrdb -p 55555
+psql -U rrdb -p 55555 --host 0.0.0.0
 ```
 
 ---

src/ast/types/function.rs

@@ -1,5 +1,3 @@
-use std::convert::TryFrom;
-
 use serde::{Deserialize, Serialize};
 
 #[derive(Deserialize, Serialize, Clone, Debug, PartialEq, Eq)]

src/errors/execute_error.rs

@@ -1,24 +1,17 @@
-use std::error::Error;
-use std::string::ToString;
+use super::RRDBError;
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Debug)]
 pub struct ExecuteError {
     pub message: String,
+    pub backtrace: std::backtrace::Backtrace,
 }
 
 impl ExecuteError {
-    pub fn new<T: ToString>(message: T) -> Self {
-        Self {
+    pub fn new<T: ToString>(message: T) -> RRDBError {
+        RRDBError::ExecuteError(Self {
             message: message.to_string(),
-        }
-    }
-
-    pub fn boxed<T: ToString>(message: T) -> Box<Self> {
-        Box::new(Self::new(message))
-    }
-
-    pub fn dyn_boxed<T: ToString>(message: T) -> Box<dyn Error + Send> {
-        Box::new(Self::new(message))
+            backtrace: std::backtrace::Backtrace::capture(),
+        })
     }
 }
 

src/errors/into_error.rs

@@ -1,19 +1,17 @@
-use std::string::ToString;
+use super::RRDBError;
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Debug)]
 pub struct IntoError {
     pub message: String,
+    pub backtrace: std::backtrace::Backtrace,
 }
 
 impl IntoError {
-    pub fn new<T: ToString>(message: T) -> Self {
-        Self {
+    pub fn new<T: ToString>(message: T) -> RRDBError {
+        RRDBError::IntoError(Self {
             message: message.to_string(),
-        }
-    }
-
-    pub fn boxed<T: ToString>(message: T) -> Box<Self> {
-        Box::new(Self::new(message))
+            backtrace: std::backtrace::Backtrace::capture(),
+        })
     }
 }
 

src/errors/lexing_error.rs

@@ -1,19 +1,17 @@
-use std::string::ToString;
+use super::RRDBError;
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Debug)]
 pub struct LexingError {
     pub message: String,
+    pub backtrace: std::backtrace::Backtrace,
 }
 
 impl LexingError {
-    pub fn new<T: ToString>(message: T) -> Self {
-        Self {
+    pub fn new<T: ToString>(message: T) -> RRDBError {
+        RRDBError::LexingError(Self {
             message: message.to_string(),
-        }
-    }
-
-    pub fn boxed<T: ToString>(message: T) -> Box<Self> {
-        Box::new(Self::new(message))
+            backtrace: std::backtrace::Backtrace::capture(),
+        })
     }
 }
 

src/errors/mod.rs

@@ -5,3 +5,26 @@ pub mod parsing_error;
 pub mod predule;
 pub mod server_error;
 pub mod type_error;
+
+#[derive(Debug)]
+pub enum RRDBError {
+    ExecuteError(execute_error::ExecuteError),
+    IntoError(into_error::IntoError),
+    LexingError(lexing_error::LexingError),
+    ParsingError(parsing_error::ParsingError),
+    ServerError(server_error::ServerError),
+    TypeError(type_error::TypeError),
+}
+
+impl ToString for RRDBError {
+    fn to_string(&self) -> String {
+        match self {
+            RRDBError::ExecuteError(e) => e.to_string(),
+            RRDBError::IntoError(e) => e.to_string(),
+            RRDBError::LexingError(e) => e.to_string(),
+            RRDBError::ParsingError(e) => e.to_string(),
+            RRDBError::ServerError(e) => e.to_string(),
+            RRDBError::TypeError(e) => e.to_string(),
+        }
+    }
+}

src/errors/parsing_error.rs

@@ -1,19 +1,17 @@
-use std::string::ToString;
+use super::RRDBError;
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Debug)]
 pub struct ParsingError {
     pub message: String,
+    pub backtrace: std::backtrace::Backtrace,
 }
 
 impl ParsingError {
-    pub fn new<T: ToString>(message: T) -> Self {
-        Self {
+    pub fn new<T: ToString>(message: T) -> RRDBError {
+        RRDBError::ParsingError(Self {
             message: message.to_string(),
-        }
-    }
-
-    pub fn boxed<T: ToString>(message: T) -> Box<Self> {
-        Box::new(Self::new(message))
+            backtrace: std::backtrace::Backtrace::capture(),
+        })
     }
 }
 

src/errors/server_error.rs

@@ -1,14 +1,14 @@
-use std::string::ToString;
-
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Debug)]
 pub struct ServerError {
     pub message: String,
+    pub backtrace: std::backtrace::Backtrace,
 }
 
 impl ServerError {
     pub fn new<T: ToString>(message: T) -> Self {
         Self {
             message: message.to_string(),
+            backtrace: std::backtrace::Backtrace::capture(),
         }
     }
 

src/errors/type_error.rs

@@ -1,23 +1,17 @@
-use std::{error::Error, string::ToString};
+use super::RRDBError;
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Debug)]
 pub struct TypeError {
     pub message: String,
+    pub backtrace: std::backtrace::Backtrace,
 }
 
 impl TypeError {
-    pub fn new<T: ToString>(message: T) -> Self {
-        Self {
+    pub fn new<T: ToString>(message: T) -> RRDBError {
+        RRDBError::TypeError(Self {
             message: message.to_string(),
-        }
-    }
-
-    pub fn boxed<T: ToString>(message: T) -> Box<Self> {
-        Box::new(Self::new(message))
-    }
-
-    pub fn dyn_boxed<T: ToString>(message: T) -> Box<dyn Error + Send> {
-        Box::new(Self::new(message))
+            backtrace: std::backtrace::Backtrace::capture(),
+        })
     }
 }
 

src/executor/common.rs

@@ -1,17 +1,14 @@
-use std::error::Error;
 use std::io::ErrorKind;
 
 use super::config::table::TableConfig;
 use super::encoder::storage::StorageEncoder;
 use super::predule::Executor;
 use crate::ast::types::TableName;
 use crate::errors::execute_error::ExecuteError;
+use crate::errors::RRDBError;
 
 impl Executor {
-    pub async fn get_table_config(
-        &self,
-        table_name: TableName,
-    ) -> Result<TableConfig, Box<dyn Error + Send>> {
+    pub async fn get_table_config(&self, table_name: TableName) -> Result<TableConfig, RRDBError> {
         let encoder = StorageEncoder::new();
 
         let base_path = self.get_base_path();
@@ -35,12 +32,12 @@ impl Executor {
 
                 match table_config {
                     Some(table_config) => Ok(table_config),
-                    None => Err(ExecuteError::boxed("invalid config data")),
+                    None => Err(ExecuteError::new("invalid config data")),
                 }
             }
             Err(error) => match error.kind() {
-                ErrorKind::NotFound => Err(ExecuteError::boxed("table not found")),
-                _ => Err(ExecuteError::boxed(format!("{:?}", error))),
+                ErrorKind::NotFound => Err(ExecuteError::new("table not found")),
+                _ => Err(ExecuteError::new(format!("{:?}", error))),
             },
         }
     }

src/executor/config/table.rs

@@ -1,4 +1,4 @@
-use std::{collections::HashMap, iter::FromIterator};
+use std::collections::HashMap;
 
 use serde::{Deserialize, Serialize};
 

src/executor/executor.rs

@@ -1,8 +1,7 @@
-use std::error::Error;
-
 use crate::ast::ddl::create_database::CreateDatabaseQuery;
 use crate::ast::{DDLStatement, DMLStatement, OtherStatement, SQLStatement};
 use crate::errors::execute_error::ExecuteError;
+use crate::errors::RRDBError;
 use crate::executor::predule::ExecuteResult;
 use crate::logger::predule::Logger;
 use crate::utils::path::get_target_basepath;
@@ -23,7 +22,7 @@ impl Executor {
     }
 
     // 기본 설정파일 세팅
-    pub async fn init(&self) -> Result<(), Box<dyn Error + Send>> {
+    pub async fn init(&self) -> Result<(), RRDBError> {
         // 루트 디렉터리 생성 (없다면)
         let base_path = get_target_basepath();
         if let Err(error) = tokio::fs::create_dir(base_path.clone()).await {
@@ -32,7 +31,7 @@ impl Executor {
             } else {
                 println!("path {:?}", base_path.clone());
                 println!("error: {:?}", error.to_string());
-                return Err(ExecuteError::boxed(error.to_string()));
+                return Err(ExecuteError::new(error.to_string()));
             }
         }
 
@@ -43,7 +42,7 @@ impl Executor {
         let global_config = toml::to_string(&global_info).unwrap();
 
         if let Err(error) = tokio::fs::write(global_path, global_config.as_bytes()).await {
-            return Err(ExecuteError::boxed(error.to_string()));
+            return Err(ExecuteError::new(error.to_string()));
         }
 
         self.create_database(CreateDatabaseQuery::builder().set_name("rrdb".into()))
@@ -57,7 +56,7 @@ impl Executor {
         &self,
         statement: SQLStatement,
         _connection_id: String,
-    ) -> Result<ExecuteResult, Box<dyn Error + Send>> {
+    ) -> Result<ExecuteResult, RRDBError> {
         Logger::info(format!("AST echo: {:?}", statement));
 
         // 쿼리 실행
@@ -95,7 +94,7 @@ impl Executor {
 
         match result {
             Ok(result) => Ok(result),
-            Err(error) => Err(ExecuteError::boxed(error.to_string())),
+            Err(error) => Err(ExecuteError::new(error.to_string())),
         }
     }
 }

src/executor/implements/ddl/alter_database.rs

@@ -1,8 +1,8 @@
-use std::error::Error;
 use std::io::ErrorKind;
 
 use crate::ast::ddl::alter_database::{AlterDatabaseAction, AlterDatabaseQuery};
 use crate::errors::predule::ExecuteError;
+use crate::errors::RRDBError;
 use crate::executor::config::database::DatabaseConfig;
 use crate::executor::encoder::storage::StorageEncoder;
 use crate::executor::predule::{ExecuteResult, Executor};
@@ -12,7 +12,7 @@ impl Executor {
     pub async fn alter_database(
         &self,
         query: AlterDatabaseQuery,
-    ) -> Result<ExecuteResult, Box<dyn Error + Send>> {
+    ) -> Result<ExecuteResult, RRDBError> {
         let encoder = StorageEncoder::new();
 
         let base_path = self.get_base_path();
@@ -25,7 +25,7 @@ impl Executor {
                     let from_database_name = query
                         .database_name
                         .clone()
-                        .ok_or_else(|| ExecuteError::dyn_boxed("no database name"))?;
+                        .ok_or_else(|| ExecuteError::new("no database name"))?;
 
                     // 변경할 데이터베이스명
                     let to_database_name = rename.name;
@@ -43,10 +43,10 @@ impl Executor {
                     if let Err(error) = result {
                         match error.kind() {
                             ErrorKind::NotFound => {
-                                return Err(ExecuteError::boxed("database not found"))
+                                return Err(ExecuteError::new("database not found"))
                             }
                             _ => {
-                                return Err(ExecuteError::boxed("database alter failed"));
+                                return Err(ExecuteError::new("database alter failed"));
                             }
                         }
                     }
@@ -69,20 +69,20 @@ impl Executor {
                                     )
                                     .await
                                     {
-                                        return Err(ExecuteError::dyn_boxed("no database name"));
+                                        return Err(ExecuteError::new("no database name"));
                                     }
                                 }
                                 None => {
-                                    return Err(ExecuteError::boxed("invalid config data"));
+                                    return Err(ExecuteError::new("invalid config data"));
                                 }
                             }
                         }
                         Err(error) => match error.kind() {
                             ErrorKind::NotFound => {
-                                return Err(ExecuteError::boxed("database not found"));
+                                return Err(ExecuteError::new("database not found"));
                             }
                             _ => {
-                                return Err(ExecuteError::boxed(format!("{:?}", error)));
+                                return Err(ExecuteError::new(format!("{:?}", error)));
                             }
                         },
                     }