[#63] 메인 서버 및 entrypoint에서 기존 오류 처리 제거

src/errors/mod.rs

@@ -15,3 +15,16 @@ pub enum RRDBError {
     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/type_error.rs

@@ -16,7 +16,7 @@ impl TypeError {
         Box::new(Self::new(message))
     }
 
-    pub fn dyn_boxed<T: ToString>(message: T) -> Box<dyn Error + Send> {
+    pub fn dyn_boxed<T: ToString>(message: T) -> RRDBError {
         Box::new(Self::new(message))
     }
 }

src/executor/common.rs

@@ -6,12 +6,10 @@ 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();

src/executor/executor.rs

@@ -3,6 +3,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 +24,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 {
@@ -57,7 +58,7 @@ impl Executor {
         &self,
         statement: SQLStatement,
         _connection_id: String,
-    ) -> Result<ExecuteResult, Box<dyn Error + Send>> {
+    ) -> Result<ExecuteResult, RRDBError> {
         Logger::info(format!("AST echo: {:?}", statement));
 
         // 쿼리 실행

src/executor/implements/ddl/alter_table.rs

@@ -1,4 +1,3 @@
-use std::error::Error;
 use std::io::ErrorKind;
 
 use crate::ast::ddl::alter_table::{AlterColumnAction, AlterTableAction, AlterTableQuery};

src/executor/implements/ddl/create_database.rs

@@ -1,8 +1,8 @@
-use std::error::Error;
 use std::io::ErrorKind;
 
 use crate::ast::ddl::create_database::CreateDatabaseQuery;
 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 create_database(
         &self,
         query: CreateDatabaseQuery,
-    ) -> Result<ExecuteResult, Box<dyn Error + Send>> {
+    ) -> Result<ExecuteResult, RRDBError> {
         let encoder = StorageEncoder::new();
 
         let base_path = self.get_base_path();

src/executor/implements/ddl/create_table.rs

@@ -1,18 +1,15 @@
-use std::error::Error;
 use std::io::ErrorKind;
 
 use crate::ast::ddl::create_table::CreateTableQuery;
 use crate::errors::predule::ExecuteError;
+use crate::errors::RRDBError;
 use crate::executor::config::table::TableConfig;
 use crate::executor::encoder::storage::StorageEncoder;
 use crate::executor::predule::{ExecuteResult, Executor};
 use crate::executor::result::{ExecuteColumn, ExecuteColumnType, ExecuteField, ExecuteRow};
 
 impl Executor {
-    pub async fn create_table(
-        &self,
-        query: CreateTableQuery,
-    ) -> Result<ExecuteResult, Box<dyn Error + Send>> {
+    pub async fn create_table(&self, query: CreateTableQuery) -> Result<ExecuteResult, RRDBError> {
         let encoder = StorageEncoder::new();
 
         let database_name = query.table.clone().unwrap().database_name.unwrap();

src/executor/implements/ddl/drop_database.rs

@@ -1,16 +1,16 @@
-use std::error::Error;
 use std::io::ErrorKind;
 
 use crate::ast::ddl::drop_database::DropDatabaseQuery;
 use crate::errors::predule::ExecuteError;
+use crate::errors::RRDBError;
 use crate::executor::predule::{ExecuteResult, Executor};
 use crate::executor::result::{ExecuteColumn, ExecuteColumnType, ExecuteField, ExecuteRow};
 
 impl Executor {
     pub async fn drop_database(
         &self,
         query: DropDatabaseQuery,
-    ) -> Result<ExecuteResult, Box<dyn Error + Send>> {
+    ) -> Result<ExecuteResult, RRDBError> {
         let base_path = self.get_base_path();
         let mut database_path = base_path.clone();
 

src/executor/implements/ddl/drop_table.rs

@@ -1,17 +1,14 @@
-use std::error::Error;
 use std::io::ErrorKind;
 
 use crate::ast::ddl::drop_table::DropTableQuery;
 use crate::ast::types::TableName;
 use crate::errors::predule::ExecuteError;
+use crate::errors::RRDBError;
 use crate::executor::predule::{ExecuteResult, Executor};
 use crate::executor::result::{ExecuteColumn, ExecuteColumnType, ExecuteField, ExecuteRow};
 
 impl Executor {
-    pub async fn drop_table(
-        &self,
-        query: DropTableQuery,
-    ) -> Result<ExecuteResult, Box<dyn Error + Send>> {
+    pub async fn drop_table(&self, query: DropTableQuery) -> Result<ExecuteResult, RRDBError> {
         let base_path = self.get_base_path();
 
         let TableName {

src/executor/implements/dml/delete.rs

@@ -1,5 +1,4 @@
 use std::collections::HashMap;
-use std::error::Error;
 
 use futures::future::join_all;
 
@@ -8,6 +7,7 @@ use crate::ast::dml::plan::delete::delete_plan::DeletePlanItem;
 use crate::ast::dml::plan::select::scan::ScanType;
 use crate::errors::predule::ExecuteError;
 use crate::errors::type_error::TypeError;
+use crate::errors::RRDBError;
 use crate::executor::config::row::TableDataFieldType;
 use crate::executor::predule::{
     ExecuteColumn, ExecuteField, ExecuteResult, ExecuteRow, Executor, ReduceContext,
@@ -16,7 +16,7 @@ use crate::executor::result::ExecuteColumnType;
 use crate::optimizer::predule::Optimizer;
 
 impl Executor {
-    pub async fn delete(&self, query: DeleteQuery) -> Result<ExecuteResult, Box<dyn Error + Send>> {
+    pub async fn delete(&self, query: DeleteQuery) -> Result<ExecuteResult, RRDBError> {
         let table = query.from_table.as_ref().unwrap().table.clone();
 
         // 최적화 작업

src/executor/implements/dml/insert.rs

@@ -13,7 +13,7 @@ use crate::executor::predule::{
 };
 
 impl Executor {
-    pub async fn insert(&self, query: InsertQuery) -> Result<ExecuteResult, Box<dyn Error + Send>> {
+    pub async fn insert(&self, query: InsertQuery) -> Result<ExecuteResult, RRDBError> {
         let encoder = StorageEncoder::new();
 
         let into_table = query.into_table.as_ref().unwrap();

src/executor/implements/dml/scan.rs

@@ -14,7 +14,7 @@ impl Executor {
     pub async fn full_scan(
         &self,
         table_name: TableName,
-    ) -> Result<Vec<(PathBuf, TableDataRow)>, Box<dyn Error + Send>> {
+    ) -> Result<Vec<(PathBuf, TableDataRow)>, RRDBError> {
         let encoder = StorageEncoder::new();
 
         let database_name = table_name.database_name.unwrap();

src/executor/implements/dml/select.rs

@@ -18,7 +18,7 @@ use crate::executor::predule::{
 use crate::optimizer::predule::Optimizer;
 
 impl Executor {
-    pub async fn select(&self, query: SelectQuery) -> Result<ExecuteResult, Box<dyn Error + Send>> {
+    pub async fn select(&self, query: SelectQuery) -> Result<ExecuteResult, RRDBError> {
         // 최적화 작업
         let optimizer = Optimizer::new();
 

src/executor/implements/dml/update.rs

@@ -17,7 +17,7 @@ use crate::executor::result::ExecuteColumnType;
 use crate::optimizer::predule::Optimizer;
 
 impl Executor {
-    pub async fn update(&self, query: UpdateQuery) -> Result<ExecuteResult, Box<dyn Error + Send>> {
+    pub async fn update(&self, query: UpdateQuery) -> Result<ExecuteResult, RRDBError> {
         let encoder = StorageEncoder::new();
 
         let table = query.target_table.clone().unwrap().table;

src/executor/implements/other/desc_table.rs

@@ -10,10 +10,7 @@ use crate::executor::predule::{
 };
 
 impl Executor {
-    pub async fn desc_table(
-        &self,
-        query: DescTableQuery,
-    ) -> Result<ExecuteResult, Box<dyn Error + Send>> {
+    pub async fn desc_table(&self, query: DescTableQuery) -> Result<ExecuteResult, RRDBError> {
         let encoder = StorageEncoder::new();
 
         let database_name = query.table_name.database_name.unwrap();

src/executor/implements/other/show_databases.rs

@@ -15,7 +15,7 @@ impl Executor {
     pub async fn show_databases(
         &self,
         _query: ShowDatabasesQuery,
-    ) -> Result<ExecuteResult, Box<dyn Error + Send>> {
+    ) -> Result<ExecuteResult, RRDBError> {
         let encoder = StorageEncoder::new();
 
         let base_path = self.get_base_path();
@@ -70,10 +70,7 @@ impl Executor {
         }
     }
 
-    pub async fn find_database(
-        &self,
-        database_name: String,
-    ) -> Result<bool, Box<dyn Error + Send>> {
+    pub async fn find_database(&self, database_name: String) -> Result<bool, RRDBError> {
         let result = self.show_databases(ShowDatabasesQuery {}).await?;
 
         Ok(result.rows.iter().any(|e| {

src/executor/implements/other/show_tables.rs

@@ -12,10 +12,7 @@ use crate::executor::predule::{
 };
 
 impl Executor {
-    pub async fn show_tables(
-        &self,
-        query: ShowTablesQuery,
-    ) -> Result<ExecuteResult, Box<dyn Error + Send>> {
+    pub async fn show_tables(&self, query: ShowTablesQuery) -> Result<ExecuteResult, RRDBError> {
         let encoder = StorageEncoder::new();
 
         let base_path = self.get_base_path();

src/executor/implements/other/use_database.rs

@@ -8,10 +8,7 @@ use crate::{
 };
 
 impl Executor {
-    pub async fn use_databases(
-        &self,
-        query: UseDatabaseQuery,
-    ) -> Result<ExecuteResult, Box<dyn Error + Send>> {
+    pub async fn use_databases(&self, query: UseDatabaseQuery) -> Result<ExecuteResult, RRDBError> {
         Ok(ExecuteResult {
             columns: (vec![ExecuteColumn {
                 name: "desc".into(),

src/executor/reduce.rs

@@ -27,7 +27,7 @@ impl Executor {
         &self,
         expression: SQLExpression,
         context: ReduceContext
-    ) -> Result<TableDataFieldType, Box<dyn Error + Send>> {
+    ) -> Result<TableDataFieldType, RRDBError> {
         match expression {
             SQLExpression::Integer(value) => Ok(TableDataFieldType::Integer(value)),
             SQLExpression::Boolean(value) => Ok(TableDataFieldType::Boolean(value)),
@@ -568,7 +568,7 @@ impl Executor {
         &self,
         expression: SQLExpression,
         context: ReduceContext
-    ) -> Result<ExecuteColumnType, Box<dyn Error + Send>> {
+    ) -> Result<ExecuteColumnType, RRDBError> {
         match expression {
             SQLExpression::Integer(_) => Ok(ExecuteColumnType::Integer),
             SQLExpression::Boolean(_) => Ok(ExecuteColumnType::Bool),

src/lexer/operator_token.rs

@@ -43,7 +43,7 @@ impl OperatorToken {
 }
 
 impl TryInto<BinaryOperator> for OperatorToken {
-    type Error = Box<dyn Error + Send>;
+    type Error = RRDBError;
 
     fn try_into(self) -> Result<BinaryOperator, Self::Error> {
         match self {
@@ -63,7 +63,7 @@ impl TryInto<BinaryOperator> for OperatorToken {
 }
 
 impl TryInto<UnaryOperator> for OperatorToken {
-    type Error = Box<dyn Error + Send>;
+    type Error = RRDBError;
 
     fn try_into(self) -> Result<UnaryOperator, Self::Error> {
         match self {

src/lexer/tokenizer.rs

@@ -94,7 +94,7 @@ impl Tokenizer {
 
     // 주어진 텍스트에서 토큰을 순서대로 획득해 반환합니다.
     // 끝을 만날 경우 Token::EOF를 반환합니다.
-    pub fn get_token(&mut self) -> Result<Token, Box<dyn Error + Send>> {
+    pub fn get_token(&mut self) -> Result<Token, RRDBError> {
         // 화이트 스페이스 삼킴
         while self.is_whitespace() && !self.is_eof() {
             self.read_char();
@@ -404,7 +404,7 @@ impl Tokenizer {
     }
 
     // Tokenizer 생성 없이 토큰 목록을 가져올 수 있는 유틸 함수입니다.
-    pub fn string_to_tokens(text: String) -> Result<Vec<Token>, Box<dyn Error + Send>> {
+    pub fn string_to_tokens(text: String) -> Result<Vec<Token>, RRDBError> {
         let mut tokenizer = Tokenizer::new(text);
 
         let mut tokens = vec![];

src/lexer/tokens.rs

@@ -138,7 +138,7 @@ impl Token {
     pub fn try_into_multi_token_operator(
         self,
         second_token: Self,
-    ) -> Result<BinaryOperator, Box<dyn Error + Send>> {
+    ) -> Result<BinaryOperator, RRDBError> {
         match self {
             Token::Not => match second_token {
                 Token::Like => Ok(BinaryOperator::NotLike),
@@ -170,9 +170,9 @@ impl Token {
 }
 
 impl TryInto<BinaryOperator> for Token {
-    type Error = Box<dyn Error + Send>;
+    type Error = RRDBError;
 
-    fn try_into(self) -> Result<BinaryOperator, Box<dyn Error + Send>> {
+    fn try_into(self) -> Result<BinaryOperator, RRDBError> {
         match self {
             Token::Operator(operator) => operator.try_into(),
             Token::And => Ok(BinaryOperator::And),

src/main.rs

@@ -1,5 +1,3 @@
-use std::error::Error;
-
 pub mod ast;
 pub mod command;
 pub mod constants;
@@ -14,13 +12,14 @@ pub mod server;
 pub mod utils;
 
 use command::{Command, SubCommand};
+use errors::RRDBError;
 use executor::predule::Executor;
 use server::predule::{Server, ServerOption};
 
 use clap::Parser;
 
 #[tokio::main]
-async fn main() -> Result<(), Box<dyn Error + Send>> {
+async fn main() -> Result<(), RRDBError> {
     let args = Command::parse();
 
     match args.action {

src/optimizer/optimizer.rs

@@ -25,10 +25,7 @@ impl Optimizer {
         Self {}
     }
 
-    pub async fn optimize_select(
-        &self,
-        query: SelectQuery,
-    ) -> Result<SelectPlan, Box<dyn Error + Send>> {
+    pub async fn optimize_select(&self, query: SelectQuery) -> Result<SelectPlan, RRDBError> {
         let mut has_from = false;
         let mut plan = SelectPlan { list: vec![] };
 
@@ -100,10 +97,7 @@ impl Optimizer {
         Ok(plan)
     }
 
-    pub async fn optimize_update(
-        &self,
-        query: UpdateQuery,
-    ) -> Result<UpdatePlan, Box<dyn Error + Send>> {
+    pub async fn optimize_update(&self, query: UpdateQuery) -> Result<UpdatePlan, RRDBError> {
         let mut plan = UpdatePlan { list: vec![] };
 
         let target_table = query.target_table.clone().unwrap();
@@ -129,10 +123,7 @@ impl Optimizer {
         Ok(plan)
     }
 
-    pub async fn optimize_delete(
-        &self,
-        query: DeleteQuery,
-    ) -> Result<DeletePlan, Box<dyn Error + Send>> {
+    pub async fn optimize_delete(&self, query: DeleteQuery) -> Result<DeletePlan, RRDBError> {
         let mut plan = DeletePlan { list: vec![] };
 
         let target_table = query.from_table.clone().unwrap();