[#176] 프로젝트 레이아웃 재구성

src/common/command.rs

@@ -0,0 +1,17 @@
+use std::{
+    io,
+    process::{Command, Output},
+};
+
+#[mockall::automock]
+pub trait CommandRunner {
+    fn run(&self, command: &mut Command) -> io::Result<Output>;
+}
+
+pub struct RealCommandRunner;
+
+impl CommandRunner for RealCommandRunner {
+    fn run(&self, command: &mut Command) -> io::Result<Output> {
+        command.output()
+    }
+}

src/executor/mocking.rs → src/common/fs.rs

@@ -1,5 +1,3 @@
-use std::process::{Command, Output};
-
 use futures::io;
 
 #[mockall::automock]
@@ -21,16 +19,3 @@ impl FileSystem for RealFileSystem {
         tokio::fs::write(path, content).await
     }
 }
-
-#[mockall::automock]
-pub trait CommandRunner {
-    fn run(&self, command: &mut Command) -> io::Result<Output>;
-}
-
-pub struct RealCommandRunner;
-
-impl CommandRunner for RealCommandRunner {
-    fn run(&self, command: &mut Command) -> io::Result<Output> {
-        command.output()
-    }
-}

src/common/mod.rs

@@ -0,0 +1,2 @@
+pub mod command;
+pub mod fs;

src/executor/config/global.rs → src/config/launch_config.rs

@@ -8,7 +8,7 @@ use crate::constants::{
 };
 
 #[derive(Deserialize, Serialize, Debug, Clone)]
-pub struct GlobalConfig {
+pub struct LaunchConfig {
     pub port: u32,
     pub host: String,
     pub data_directory: String,
@@ -20,7 +20,7 @@ pub struct GlobalConfig {
 }
 
 #[allow(clippy::derivable_impls)]
-impl std::default::Default for GlobalConfig {
+impl std::default::Default for LaunchConfig {
     fn default() -> Self {
         let base_path = PathBuf::from(DEFAULT_CONFIG_BASEPATH);
 
@@ -44,7 +44,7 @@ impl std::default::Default for GlobalConfig {
     }
 }
 
-impl GlobalConfig {
+impl LaunchConfig {
     pub fn default_config_path() -> PathBuf {
         let base_path = PathBuf::from(DEFAULT_CONFIG_BASEPATH);
         base_path.join(DEFAULT_CONFIG_FILENAME)

src/config/mod.rs

@@ -0,0 +1 @@
+pub mod launch_config;

src/executor/implements/ddl/alter_database.rs → src/engine/actions/ddl/alter_database.rs

@@ -1,14 +1,17 @@
 use std::io::ErrorKind;
 
-use crate::ast::ddl::alter_database::{AlterDatabaseAction, AlterDatabaseQuery};
-use crate::errors::predule::ExecuteError;
+use crate::engine::DBEngine;
+use crate::engine::ast::ddl::alter_database::{AlterDatabaseAction, AlterDatabaseQuery};
+
+use crate::engine::encoder::schema_encoder::StorageEncoder;
+use crate::engine::schema::database::DatabaseSchema;
+use crate::engine::types::{
+    ExecuteColumn, ExecuteColumnType, ExecuteField, ExecuteResult, ExecuteRow,
+};
 use crate::errors::RRDBError;
-use crate::executor::config::database::DatabaseConfig;
-use crate::executor::encoder::storage::StorageEncoder;
-use crate::executor::predule::{ExecuteResult, Executor};
-use crate::executor::result::{ExecuteColumn, ExecuteColumnType, ExecuteField, ExecuteRow};
+use crate::errors::predule::ExecuteError;
 
-impl Executor {
+impl DBEngine {
     pub async fn alter_database(
         &self,
         query: AlterDatabaseQuery,
@@ -43,7 +46,7 @@ impl Executor {
                     if let Err(error) = result {
                         match error.kind() {
                             ErrorKind::NotFound => {
-                                return Err(ExecuteError::wrap("database not found"))
+                                return Err(ExecuteError::wrap("database not found"));
                             }
                             _ => {
                                 return Err(ExecuteError::wrap("database alter failed"));
@@ -57,7 +60,7 @@ impl Executor {
 
                     match tokio::fs::read(&config_path).await {
                         Ok(data) => {
-                            let database_config: Option<DatabaseConfig> =
+                            let database_config: Option<DatabaseSchema> =
                                 encoder.decode(data.as_slice());
 
                             match database_config {

src/executor/implements/ddl/alter_table.rs → src/engine/actions/ddl/alter_table.rs

@@ -1,16 +1,17 @@
 use std::io::ErrorKind;
 
-use crate::ast::ddl::alter_table::{AlterColumnAction, AlterTableAction, AlterTableQuery};
-use crate::ast::types::TableName;
-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::{
-    ExecuteColumn, ExecuteColumnType, ExecuteField, ExecuteResult, ExecuteRow, Executor,
+use crate::engine::DBEngine;
+use crate::engine::ast::ddl::alter_table::{AlterColumnAction, AlterTableAction, AlterTableQuery};
+use crate::engine::ast::types::TableName;
+use crate::engine::encoder::schema_encoder::StorageEncoder;
+use crate::engine::schema::table::TableSchema;
+use crate::engine::types::{
+    ExecuteColumn, ExecuteColumnType, ExecuteField, ExecuteResult, ExecuteRow,
 };
+use crate::errors::RRDBError;
+use crate::errors::predule::ExecuteError;
 
-impl Executor {
+impl DBEngine {
     pub async fn alter_table(&self, query: AlterTableQuery) -> Result<ExecuteResult, RRDBError> {
         let encoder = StorageEncoder::new();
 
@@ -117,7 +118,7 @@ impl Executor {
 
                         match tokio::fs::read(&config_path).await {
                             Ok(data) => {
-                                let table_config: Option<TableConfig> =
+                                let table_config: Option<TableSchema> =
                                     encoder.decode(data.as_slice());
 
                                 match table_config {
@@ -169,7 +170,7 @@ impl Executor {
 
                         match tokio::fs::read(&config_path).await {
                             Ok(data) => {
-                                let table_config: Option<TableConfig> =
+                                let table_config: Option<TableSchema> =
                                     encoder.decode(data.as_slice());
 
                                 match table_config {
@@ -221,7 +222,7 @@ impl Executor {
 
                         match tokio::fs::read(&config_path).await {
                             Ok(data) => {
-                                let table_config: Option<TableConfig> =
+                                let table_config: Option<TableSchema> =
                                     encoder.decode(data.as_slice());
 
                                 match table_config {
@@ -272,7 +273,7 @@ impl Executor {
 
                         match tokio::fs::read(&config_path).await {
                             Ok(data) => {
-                                let table_config: Option<TableConfig> =
+                                let table_config: Option<TableSchema> =
                                     encoder.decode(data.as_slice());
 
                                 match table_config {

src/executor/implements/ddl/create_database.rs → src/engine/actions/ddl/create_database.rs

@@ -1,14 +1,17 @@
 use std::io::ErrorKind;
 
-use crate::ast::ddl::create_database::CreateDatabaseQuery;
-use crate::errors::predule::ExecuteError;
+use crate::engine::DBEngine;
+use crate::engine::ast::ddl::create_database::CreateDatabaseQuery;
+use crate::engine::encoder::schema_encoder::StorageEncoder;
+use crate::engine::schema::database::DatabaseSchema;
+
+use crate::engine::types::{
+    ExecuteColumn, ExecuteColumnType, ExecuteField, ExecuteResult, ExecuteRow,
+};
 use crate::errors::RRDBError;
-use crate::executor::config::database::DatabaseConfig;
-use crate::executor::encoder::storage::StorageEncoder;
-use crate::executor::predule::{ExecuteResult, Executor};
-use crate::executor::result::{ExecuteColumn, ExecuteColumnType, ExecuteField, ExecuteRow};
+use crate::errors::predule::ExecuteError;
 
-impl Executor {
+impl DBEngine {
     pub async fn create_database(
         &self,
         query: CreateDatabaseQuery,
@@ -55,7 +58,7 @@ impl Executor {
         if let Err(error) = tokio::fs::create_dir(&tables_path).await {
             match error.kind() {
                 ErrorKind::AlreadyExists => {
-                    return Err(ExecuteError::wrap("already exists tables"))
+                    return Err(ExecuteError::wrap("already exists tables"));
                 }
                 _ => {
                     return Err(ExecuteError::wrap("tables create failed"));
@@ -65,7 +68,7 @@ impl Executor {
 
         // 각 데이터베이스 단위 설정파일 생성
         let config_path = database_path.clone().join("database.config");
-        let database_info = DatabaseConfig {
+        let database_info = DatabaseSchema {
             database_name: database_name.clone(),
         };
 

src/executor/implements/ddl/create_table.rs → src/engine/actions/ddl/create_table.rs

@@ -1,14 +1,16 @@
 use std::io::ErrorKind;
 
-use crate::ast::ddl::create_table::CreateTableQuery;
-use crate::errors::predule::ExecuteError;
+use crate::engine::DBEngine;
+use crate::engine::ast::ddl::create_table::CreateTableQuery;
+use crate::engine::encoder::schema_encoder::StorageEncoder;
+use crate::engine::schema::table::TableSchema;
+use crate::engine::types::{
+    ExecuteColumn, ExecuteColumnType, ExecuteField, ExecuteResult, ExecuteRow,
+};
 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};
+use crate::errors::predule::ExecuteError;
 
-impl Executor {
+impl DBEngine {
     pub async fn create_table(&self, query: CreateTableQuery) -> Result<ExecuteResult, RRDBError> {
         let encoder = StorageEncoder::new();
 
@@ -31,7 +33,7 @@ impl Executor {
 
         // 각 데이터베이스 단위 설정파일 생성
         let config_path = table_path.clone().join("table.config");
-        let table_info: TableConfig = query.into();
+        let table_info: TableSchema = query.into();
 
         if let Err(error) = tokio::fs::write(&config_path, encoder.encode(table_info)).await {
             return Err(ExecuteError::wrap(error.to_string()));

src/executor/implements/ddl/drop_database.rs → src/engine/actions/ddl/drop_database.rs

@@ -1,12 +1,15 @@
 use std::io::ErrorKind;
 
-use crate::ast::ddl::drop_database::DropDatabaseQuery;
-use crate::errors::predule::ExecuteError;
+use crate::engine::DBEngine;
+
+use crate::engine::ast::ddl::drop_database::DropDatabaseQuery;
+use crate::engine::types::{
+    ExecuteColumn, ExecuteColumnType, ExecuteField, ExecuteResult, ExecuteRow,
+};
 use crate::errors::RRDBError;
-use crate::executor::predule::{ExecuteResult, Executor};
-use crate::executor::result::{ExecuteColumn, ExecuteColumnType, ExecuteField, ExecuteRow};
+use crate::errors::predule::ExecuteError;
 
-impl Executor {
+impl DBEngine {
     pub async fn drop_database(
         &self,
         query: DropDatabaseQuery,

src/executor/implements/ddl/drop_table.rs → src/engine/actions/ddl/drop_table.rs

@@ -1,13 +1,15 @@
 use std::io::ErrorKind;
 
-use crate::ast::ddl::drop_table::DropTableQuery;
-use crate::ast::types::TableName;
-use crate::errors::predule::ExecuteError;
+use crate::engine::DBEngine;
+use crate::engine::ast::ddl::drop_table::DropTableQuery;
+use crate::engine::ast::types::TableName;
+use crate::engine::types::{
+    ExecuteColumn, ExecuteColumnType, ExecuteField, ExecuteResult, ExecuteRow,
+};
 use crate::errors::RRDBError;
-use crate::executor::predule::{ExecuteResult, Executor};
-use crate::executor::result::{ExecuteColumn, ExecuteColumnType, ExecuteField, ExecuteRow};
+use crate::errors::predule::ExecuteError;
 
-impl Executor {
+impl DBEngine {
     pub async fn drop_table(&self, query: DropTableQuery) -> Result<ExecuteResult, RRDBError> {
         let base_path = self.get_data_directory();
 

src/executor/implements/dml/delete.rs → src/engine/actions/dml/delete.rs

@@ -2,20 +2,19 @@ use std::collections::HashMap;
 
 use futures::future::join_all;
 
-use crate::ast::dml::delete::DeleteQuery;
-use crate::ast::dml::plan::delete::delete_plan::DeletePlanItem;
-use crate::ast::dml::plan::select::scan::ScanType;
+use crate::engine::DBEngine;
+use crate::engine::ast::dml::delete::DeleteQuery;
+use crate::engine::ast::dml::plan::delete::delete_plan::DeletePlanItem;
+use crate::engine::ast::dml::plan::select::scan::ScanType;
+use crate::engine::optimizer::predule::Optimizer;
+use crate::engine::schema::row::TableDataFieldType;
+use crate::engine::types::{ExecuteResult, ExecuteColumn, ExecuteColumnType, ExecuteField, ExecuteRow};
+use crate::engine::expression::ReduceContext;
+use crate::errors::RRDBError;
 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,
-};
-use crate::executor::result::ExecuteColumnType;
-use crate::optimizer::predule::Optimizer;
-
-impl Executor {
+
+impl DBEngine {
     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 → src/engine/actions/dml/insert.rs

@@ -1,18 +1,17 @@
 use std::collections::HashSet;
 use std::io::ErrorKind;
 
-use crate::ast::dml::insert::{InsertData, InsertQuery};
-use crate::ast::types::SQLExpression;
-use crate::errors::predule::ExecuteError;
+use crate::engine::DBEngine;
+use crate::engine::ast::dml::insert::{InsertData, InsertQuery};
+use crate::engine::ast::types::SQLExpression;
+use crate::engine::schema::row::{TableDataField, TableDataRow};
+use crate::engine::schema::table::TableSchema;
+use crate::engine::encoder::schema_encoder::StorageEncoder;
+use crate::engine::types::{ExecuteColumn, ExecuteColumnType, ExecuteField, ExecuteResult, ExecuteRow};
 use crate::errors::RRDBError;
-use crate::executor::config::row::{TableDataField, TableDataRow};
-use crate::executor::config::table::TableConfig;
-use crate::executor::encoder::storage::StorageEncoder;
-use crate::executor::predule::{
-    ExecuteColumn, ExecuteColumnType, ExecuteField, ExecuteResult, ExecuteRow, Executor,
-};
-
-impl Executor {
+use crate::errors::predule::ExecuteError;
+
+impl DBEngine {
     pub async fn insert(&self, query: InsertQuery) -> Result<ExecuteResult, RRDBError> {
         let encoder = StorageEncoder::new();
 
@@ -35,7 +34,7 @@ impl Executor {
 
         let table_config = match tokio::fs::read(&config_path).await {
             Ok(data) => {
-                let table_config: Option<TableConfig> = encoder.decode(data.as_slice());
+                let table_config: Option<TableSchema> = encoder.decode(data.as_slice());
 
                 match table_config {
                     Some(table_config) => table_config,
@@ -123,7 +122,7 @@ impl Executor {
                                 return Err(ExecuteError::wrap(format!(
                                     "column '{}' not exists",
                                     column_name
-                                )))
+                                )));
                             }
                         }
 
@@ -175,7 +174,7 @@ impl Executor {
                                 return Err(ExecuteError::wrap(format!(
                                     "column '{}' not exists",
                                     column_name
-                                )))
+                                )));
                             }
                         }