Merge pull request #29 from KKould/main

feat(insert): support sql insert simple syntax

Author: KKould

src/binder/create.rs src/binder/create_table.rssrc/binder/create.rs renamed to src/binder/create_table.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::CreateTableOperator;
 
 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() {
-            if !set.insert(col.name.value.clone()) {
+            let col_name = &col.name.value;
+            if !set.insert(col_name.clone()) {
                 return Err(anyhow::Error::msg(format!(
                     "bind duplicated column {}",
-                    col.name.value.clone()
+                    col_name
                 )));
             }
         }
@@ -35,8 +35,10 @@ impl Binder {
             .collect();
 
         let plan = LogicalCreateTablePlan {
-            table_name: table_name.to_string(),
-            columns,
+            operator: CreateTableOperator {
+                table_name: table_name.to_string(),
+                columns
+            },
         };
         Ok(plan)
     }
@@ -46,7 +48,7 @@ impl Binder {
 mod tests {
     use super::*;
     use crate::binder::BinderContext;
-    use crate::catalog::{ColumnDesc, RootCatalog};
+    use crate::catalog::{ColumnCatalog, ColumnDesc, RootCatalog};
     use crate::planner::LogicalPlan;
     use crate::types::LogicalType;
 
@@ -58,19 +60,21 @@ mod tests {
         let plan1 = binder.bind(&stmt[0]).unwrap();
 
         let plan2 = LogicalPlan::CreateTable(LogicalCreateTablePlan {
-            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)
-                )
-            ],
+            operator: CreateTableOperator {
+                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

@@ -0,0 +1,90 @@
+use std::slice;
+use std::sync::Arc;
+use sqlparser::ast::{Expr, Ident, ObjectName};
+use anyhow::{Error, Result};
+use itertools::Itertools;
+use crate::binder::{Binder, lower_case_name, split_name};
+use crate::catalog::ColumnCatalog;
+use crate::expression::ScalarExpression;
+use crate::planner::logical_insert_plan::LogicalInsertPlan;
+use crate::planner::operator::insert::InsertOperator;
+use crate::planner::operator::Operator;
+use crate::planner::operator::values::ValuesOperator;
+use crate::types::value::DataValue;
+
+impl Binder {
+
+    // TODO: 支持Project
+    // TODO: 检测多行Values对齐
+    pub(crate) fn bind_insert(
+        &mut self,
+        name: ObjectName,
+        idents: &[Ident],
+        rows: &Vec<Vec<Expr>>
+    ) -> Result<LogicalInsertPlan> {
+        let name = lower_case_name(&name);
+        let (_, table_name) = split_name(&name)?;
+
+        if let Some(table) = self.context.catalog.get_table_by_name(table_name) {
+            let mut col_catalogs = Vec::new();
+
+            if idents.is_empty() {
+                col_catalogs = table.all_columns()
+                    .into_iter()
+                    .map(|(_, catalog)| catalog.clone())
+                    .collect_vec();
+            } else {
+                for ident in idents {
+                    match self.bind_column_ref_from_identifiers(slice::from_ref(ident))? {
+                        ScalarExpression::ColumnRef(catalog) => col_catalogs.push(catalog),
+                        _ => unreachable!()
+                    }
+                }
+            }
+
+            let rows = rows
+                .into_iter()
+                .map(|row| {
+                    row.into_iter()
+                        .map(|expr| match self.bind_expr(expr)? {
+                            ScalarExpression::Constant(value) => Ok::<DataValue, Error>(value),
+                            _ => unreachable!(),
+                        })
+                        .try_collect()
+                })
+                .try_collect()?;
+
+            let values_plan = self.bind_values(rows, col_catalogs.clone());
+
+            Ok(LogicalInsertPlan {
+                operator: Arc::new(
+                    Operator::Insert(
+                        InsertOperator {
+                            table: table_name.to_string(),
+                        }
+                    )
+                ),
+                children: vec![Arc::new(values_plan)],
+            })
+        } else {
+            Err(anyhow::Error::msg(format!(
+                "not found table {}",
+                table_name
+            )))
+        }
+    }
+
+    fn bind_values(
+        &mut self,
+        rows: Vec<Vec<DataValue>>,
+        col_catalogs: Vec<ColumnCatalog>
+    ) -> LogicalInsertPlan {
+        LogicalInsertPlan {
+            operator: Arc::new(Operator::Values(ValuesOperator {
+                rows,
+                col_catalogs,
+            })),
+            children: vec![],
+        }
+    }
+}

src/binder/mod.rs

@@ -1,12 +1,13 @@
 pub mod aggregate;
-mod create;
+mod create_table;
 pub mod expr;
 mod select;
+mod insert;
 
 use std::collections::HashMap;
 
 use anyhow::Result;
-use sqlparser::ast::{Ident, ObjectName, Statement};
+use sqlparser::ast::{Ident, ObjectName, SetExpr, Statement};
 
 use crate::catalog::{RootCatalog, DEFAULT_SCHEMA_NAME, CatalogError};
 use crate::expression::ScalarExpression;
@@ -65,9 +66,17 @@ impl Binder {
                 LogicalPlan::Select(plan)
             }
             Statement::CreateTable { name, columns, .. } => {
-                let plan = self.bind_create_table(name.to_owned(), &columns)?;
+                let plan = self.bind_create_table(name, &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)