style: remove field redundancy of create_table and insert

Author: KKould

src/binder/create_table.rs

@@ -6,7 +6,7 @@ use super::Binder;
 use crate::binder::{lower_case_name, split_name};
 use crate::catalog::ColumnCatalog;
 use crate::planner::logical_create_table_plan::LogicalCreateTablePlan;
-use crate::planner::operator::create_table::CreateOperator;
+use crate::planner::operator::create_table::CreateTableOperator;
 
 impl Binder {
     pub(crate) fn bind_create_table(
@@ -35,7 +35,7 @@ impl Binder {
             .collect();
 
         let plan = LogicalCreateTablePlan {
-            operator: CreateOperator {
+            operator: CreateTableOperator {
                 table_name: table_name.to_string(),
                 columns
             },
@@ -60,7 +60,7 @@ mod tests {
         let plan1 = binder.bind(&stmt[0]).unwrap();
 
         let plan2 = LogicalPlan::CreateTable(LogicalCreateTablePlan {
-            operator: CreateOperator {
+            operator: CreateTableOperator {
                 table_name: "t1".to_string(),
                 columns: vec![
                     ColumnCatalog::new(

src/db.rs

@@ -174,7 +174,7 @@ mod test {
         })
     }
     #[test]
-    fn test_sql() -> anyhow::Result<()> {
+    fn test_crud_sql() -> anyhow::Result<()> {
         let database = Database::new_on_mem();
 
         tokio_test::block_on(async move {

src/execution_v1/physical_plan/physical_create_table.rs

@@ -1,9 +1,6 @@
-use crate::catalog::ColumnCatalog;
+use crate::planner::operator::create_table::CreateTableOperator;
 
 #[derive(Debug)]
 pub struct PhysicalCreateTable {
-    /// Table name to insert to
-    pub table_name: String,
-    /// List of columns of the table
-    pub columns: Vec<ColumnCatalog>,
+    pub op: CreateTableOperator
 }

src/execution_v1/physical_plan/physical_insert.rs

@@ -1,12 +1,6 @@
-use crate::expression::ScalarExpression;
-use crate::types::ColumnIdx;
+use crate::planner::operator::insert::InsertOperator;
 
 #[derive(Debug)]
 pub struct PhysicalInsert {
-    /// Table name to insert to
-    pub table_name: String,
-
-    pub col_idxs: Vec<ColumnIdx>,
-    /// List of columns of the table
-    pub cols: Vec<Vec<ScalarExpression>>
+    pub op: InsertOperator
 }

src/execution_v1/physical_plan/physical_plan_builder.rs

@@ -11,7 +11,6 @@ use anyhow::anyhow;
 use anyhow::Result;
 use crate::execution_v1::physical_plan::physical_insert::PhysicalInsert;
 use crate::planner::logical_insert_plan::LogicalInsertPlan;
-use crate::planner::operator::insert::InsertOperator;
 use crate::planner::operator::project::ProjectOperator;
 
 pub struct PhysicalPlanBuilder {
@@ -44,13 +43,9 @@ impl PhysicalPlanBuilder {
         &mut self,
         plan: &LogicalInsertPlan,
     ) -> PhysicalOperator {
-        let InsertOperator { table, col_idxs, cols: rows } = plan.operator.clone();
-
         PhysicalOperator::Insert(
             PhysicalInsert {
-                table_name: table,
-                col_idxs,
-                cols: rows,
+                op: plan.operator.clone()
             }
         )
     }
@@ -59,12 +54,9 @@ impl PhysicalPlanBuilder {
         &mut self,
         plan: &LogicalCreateTablePlan,
     ) -> PhysicalOperator {
-        let operator = &plan.operator;
-
         PhysicalOperator::CreateTable(
             PhysicalCreateTable {
-                table_name: operator.table_name.to_string(),
-                columns: operator.columns.clone(),
+                op: plan.operator.clone(),
             }
         )
     }

src/execution_v1/volcano_executor/create_table.rs

@@ -3,8 +3,8 @@ use crate::execution_v1::ExecutorError;
 use crate::storage::Storage;
 use crate::catalog::ColumnCatalog;
 use std::sync::Arc;
-use itertools::Itertools;
 use arrow::datatypes::Schema;
+use itertools::Itertools;
 use arrow::record_batch::RecordBatch;
 use futures_async_stream::try_stream;
 
@@ -13,14 +13,14 @@ pub struct CreateTable {}
 impl CreateTable {
     #[try_stream(boxed, ok = RecordBatch, error = ExecutorError)]
     pub async fn execute(plan: PhysicalCreateTable, storage: impl Storage) {
-        let fields = plan.columns
+        let fields = plan.op.columns
             .iter()
             .map(ColumnCatalog::to_field)
             .collect_vec();
         let schema = Arc::new(Schema::new(fields));
 
         let _ = storage.create_table(
-            plan.table_name.as_str(),
+            plan.op.table_name.as_str(),
             vec![RecordBatch::new_empty(schema)]
         );
     }

src/execution_v1/volcano_executor/mod.rs

@@ -13,8 +13,8 @@ use crate::storage::StorageImpl;
 use arrow::record_batch::RecordBatch;
 use futures::stream::BoxStream;
 use futures::TryStreamExt;
-use crate::execution_v1::physical_plan::physical_insert::PhysicalInsert;
 use crate::execution_v1::volcano_executor::insert::Insert;
+use crate::planner::operator::insert::InsertOperator;
 
 pub type BoxedExecutor = BoxStream<'static, Result<RecordBatch, ExecutorError>>;
 
@@ -41,10 +41,12 @@ impl VolcanoExecutor {
             PhysicalOperator::CreateTable(op) => match &self.storage {
                 StorageImpl::InMemoryStorage(storage) => CreateTable::execute(op, storage.clone()),
             },
-            PhysicalOperator::Insert(PhysicalInsert { table_name, col_idxs, cols, }) => {
+            PhysicalOperator::Insert(op) => {
+                let InsertOperator { table, col_idxs, cols } = op.op;
+
                 match &self.storage {
                     StorageImpl::InMemoryStorage(storage) =>
-                        Insert::execute(table_name, col_idxs, cols, storage.clone()),
+                        Insert::execute(table, col_idxs, cols, storage.clone()),
                 }
             }
         }

src/planner/logical_create_table_plan.rs

@@ -1,8 +1,8 @@
-use crate::planner::operator::create_table::CreateOperator;
+use crate::planner::operator::create_table::CreateTableOperator;
 
 #[derive(Debug, PartialEq, Clone)]
 pub struct LogicalCreateTablePlan {
-    pub operator: CreateOperator
+    pub operator: CreateTableOperator
 }
 
 // use sqlparser::ast::{ColumnDef, ColumnOption, Statement};

src/planner/operator/create_table.rs

@@ -1,7 +1,7 @@
 use crate::catalog::ColumnCatalog;
 
 #[derive(Debug, PartialEq, Clone)]
-pub struct CreateOperator {
+pub struct CreateTableOperator {
     /// Table name to insert to
     pub table_name: String,
     /// List of columns of the table