Revert "feat(insert): support sql insert simple syntax"

This reverts commit d540169.

Author: KKould

src/binder/create_table.rs src/binder/create.rssrc/binder/create_table.rs renamed to src/binder/create.rs

@@ -1,30 +1,30 @@
 use std::collections::HashSet;
+
 use anyhow::Result;
 use sqlparser::ast::{ColumnDef, ObjectName};
 
 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;
 
 impl Binder {
     pub(crate) fn bind_create_table(
         &mut self,
-        name: &ObjectName,
+        name: ObjectName,
         columns: &[ColumnDef],
     ) -> Result<LogicalCreateTablePlan> {
         let name = lower_case_name(&name);
+
         let (_, table_name) = split_name(&name)?;
 
         // check duplicated column names
         let mut set = HashSet::new();
         for col in columns.iter() {
-            let col_name = &col.name.value;
-            if !set.insert(col_name.clone()) {
+            if !set.insert(col.name.value.clone()) {
                 return Err(anyhow::Error::msg(format!(
                     "bind duplicated column {}",
-                    col_name
+                    col.name.value.clone()
                 )));
             }
         }
@@ -35,10 +35,8 @@ impl Binder {
             .collect();
 
         let plan = LogicalCreateTablePlan {
-            operator: CreateOperator {
-                table_name: table_name.to_string(),
-                columns
-            },
+            table_name: table_name.to_string(),
+            columns,
         };
         Ok(plan)
     }
@@ -48,7 +46,7 @@ impl Binder {
 mod tests {
     use super::*;
     use crate::binder::BinderContext;
-    use crate::catalog::{ColumnCatalog, ColumnDesc, RootCatalog};
+    use crate::catalog::{ColumnDesc, RootCatalog};
     use crate::planner::LogicalPlan;
     use crate::types::LogicalType;
 
@@ -60,21 +58,19 @@ mod tests {
         let plan1 = binder.bind(&stmt[0]).unwrap();
 
         let plan2 = LogicalPlan::CreateTable(LogicalCreateTablePlan {
-            operator: CreateOperator {
-                table_name: "t1".to_string(),
-                columns: vec![
-                    ColumnCatalog::new(
-                        "id".to_string(),
-                        false,
-                        ColumnDesc::new(LogicalType::Integer, false)
-                    ),
-                    ColumnCatalog::new(
-                        "name".to_string(),
-                        false,
-                        ColumnDesc::new(LogicalType::Varchar, false)
-                    )
-                ],
-            },
+            table_name: "t1".to_string(),
+            columns: vec![
+                ColumnCatalog::new(
+                    "id".to_string(),
+                    false,
+                    ColumnDesc::new(LogicalType::Integer, false)
+                ),
+                ColumnCatalog::new(
+                    "name".to_string(),
+                    false,
+                    ColumnDesc::new(LogicalType::Varchar, false)
+                )
+            ],
         });
 
         assert_eq!(plan1, plan2);

src/binder/insert.rs

@@ -1,13 +1,12 @@
 pub mod aggregate;
-mod create_table;
+mod create;
 pub mod expr;
 mod select;
-mod insert;
 
 use std::collections::HashMap;
 
 use anyhow::Result;
-use sqlparser::ast::{Ident, ObjectName, SetExpr, Statement};
+use sqlparser::ast::{Ident, ObjectName, Statement};
 
 use crate::catalog::{RootCatalog, DEFAULT_SCHEMA_NAME, CatalogError};
 use crate::expression::ScalarExpression;
@@ -60,24 +59,15 @@ impl Binder {
     }
 
     pub fn bind(mut self, stmt: &Statement) -> Result<LogicalPlan> {
-        println!("{:#?}", stmt);
         let plan = match stmt {
             Statement::Query(query) => {
                 let plan = self.bind_query(query)?;
                 LogicalPlan::Select(plan)
             }
             Statement::CreateTable { name, columns, .. } => {
-                let plan = self.bind_create_table(name, &columns)?;
+                let plan = self.bind_create_table(name.to_owned(), &columns)?;
                 LogicalPlan::CreateTable(plan)
             }
-            Statement::Insert { table_name, columns, source, .. } => {
-                if let SetExpr::Values(values) = source.body.as_ref() {
-                    let plan = self.bind_insert(table_name.to_owned(), columns, &values.rows)?;
-                    LogicalPlan::Insert(plan)
-                } else {
-                    todo!()
-                }
-            }
             _ => unimplemented!(),
         };
         Ok(plan)

src/binder/mod.rs

@@ -200,7 +200,7 @@ impl Binder {
         let mut exprs = vec![];
         for ref_id in self.context.bind_table.values().cloned().collect_vec() {
             let table = self.context.catalog.get_table(ref_id).unwrap();
-            for (col_id, col) in &table.all_columns() {
+            for (col_id, col) in &table.get_all_columns() {
                 let column_ref_id = ColumnRefId::from_table(ref_id, *col_id);
                 // self.record_regular_table_column(
                 //     &table.name(),

src/binder/select.rs

@@ -75,6 +75,10 @@ impl ColumnDesc {
         }
     }
 
+    pub(crate) fn is_primary(&self) -> bool {
+        self.is_primary
+    }
+
     pub(crate) fn get_datatype(&self) -> LogicalType {
         self.column_datatype.clone()
     }

src/catalog/column.rs

@@ -1,12 +1,10 @@
 use std::collections::HashMap;
-use std::sync::Arc;
-use arrow::datatypes::{Schema, SchemaRef};
 
 use itertools::Itertools;
 
 use crate::catalog::{CatalogError, ColumnCatalog};
 use crate::types::{ColumnIdx, IdGenerator, TableIdx};
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone)]
 pub struct TableCatalog {
     pub id: Option<TableIdx>,
     pub name: String,
@@ -17,10 +15,6 @@ pub struct TableCatalog {
 }
 
 impl TableCatalog {
-    pub(crate) fn columns_len(&self) -> usize {
-        self.columns.len()
-    }
-
     pub(crate) fn get_column_by_id(&self, id: ColumnIdx) -> Option<&ColumnCatalog> {
         self.columns.get(id)
     }
@@ -38,21 +32,13 @@ impl TableCatalog {
         self.column_idxs.contains_key(name)
     }
 
-    pub(crate) fn all_columns(&self) -> Vec<(ColumnIdx, &ColumnCatalog)> {
+    pub(crate) fn get_all_columns(&self) -> Vec<(ColumnIdx, &ColumnCatalog)> {
         self.columns
             .iter()
             .enumerate()
             .collect_vec()
     }
 
-    // TODO: 缓存schema
-    pub(crate) fn schema(&self) -> SchemaRef {
-        let fields = self.columns.iter()
-            .map(ColumnCatalog::to_field)
-            .collect_vec();
-        Arc::new(Schema::new(fields))
-    }
-
     /// Add a column to the table catalog.
     pub(crate) fn add_column(
         &mut self,

src/catalog/table.rs

@@ -123,7 +123,6 @@ pub enum DatabaseError {
 mod test {
     use std::sync::Arc;
     use arrow::array::{BooleanArray, Int32Array};
-    use arrow::compute::concat_batches;
     use arrow::datatypes::Schema;
     use arrow::record_batch::RecordBatch;
     use itertools::Itertools;
@@ -178,14 +177,9 @@ mod test {
         let database = Database::new_on_mem();
 
         tokio_test::block_on(async move {
-            let _ = database.run("create table t1 (a int, b boolean)").await?;
-            let _ = database.run("insert into t1 values (1, true), (2, false)").await?;
-            let vec_batch = database.run("select * from t1").await?;
-
-            let table = database.storage
-                .get_catalog()
-                .get_table(0).unwrap().clone();
-            println!("{:#?}", concat_batches(&table.schema(), &vec_batch));
+            let _batch = database.run("create table t1 (a int, b int)").await?;
+            let batch = database.run("select * from t1").await?;
+            println!("{:#?}", batch);
 
             Ok(())
         })

src/db.rs

@@ -30,7 +30,6 @@ impl PhysicalPlanBuilder {
         match plan {
             LogicalPlan::Select(select) => self.build_select_logical_plan(select),
             LogicalPlan::CreateTable(_) => todo!(),
-            LogicalPlan::Insert(_) => todo!(),
         }
     }
 

src/execution/physical/physical_plan_builder.rs

@@ -1,17 +1,14 @@
 use crate::execution_v1::physical_plan::physical_create_table::PhysicalCreateTable;
-use crate::execution_v1::physical_plan::physical_insert::PhysicalInsert;
 use crate::execution_v1::physical_plan::physical_projection::PhysicalProjection;
 use crate::execution_v1::physical_plan::physical_table_scan::PhysicalTableScan;
 
 pub(crate) mod physical_create_table;
 pub(crate) mod physical_plan_builder;
 pub(crate) mod physical_projection;
 pub(crate) mod physical_table_scan;
-pub(crate) mod physical_insert;
 
 #[derive(Debug)]
 pub enum PhysicalOperator {
-    Insert(PhysicalInsert),
     CreateTable(PhysicalCreateTable),
     TableScan(PhysicalTableScan),
     Projection(PhysicalProjection),