fix: make all tasks pass test 01-01 (#7)

wangrunji0408 · web-flow · commit e07141696bd8 · 2022-01-25T17:29:58.000+08:00
* update rust toolchain to nightly-2022-01-20

Signed-off-by: Runji Wang &lt;wangrunji0408@163.com&gt;

* 01-03: pass 01-01 test

Signed-off-by: Runji Wang &lt;wangrunji0408@163.com&gt;

* 01-04: pass 01-01 test

Signed-off-by: Runji Wang &lt;wangrunji0408@163.com&gt;

* 01-05: pass 01-01 test

Signed-off-by: Runji Wang &lt;wangrunji0408@163.com&gt;

* 01-06: pass 01-01 test

Signed-off-by: Runji Wang &lt;wangrunji0408@163.com&gt;

* fix cargo clippy

Signed-off-by: Runji Wang &lt;wangrunji0408@163.com&gt;
diff --git a/code/01-03/src/binder/mod.rs b/code/01-03/src/binder/mod.rs
@@ -13,6 +13,7 @@ pub use self::statement::*;
 #[derive(Debug, PartialEq, Clone)]
 pub enum BoundStatement {
     CreateTable(BoundCreateTable),
+    Select(BoundSelect),
 }
 
 /// The error type of bind operations.
@@ -46,10 +47,10 @@ impl Binder {
 
     /// Bind a statement.
     pub fn bind(&mut self, stmt: &Statement) -> Result<BoundStatement, BindError> {
+        use Statement::*;
         match stmt {
-            Statement::CreateTable { .. } => {
-                Ok(BoundStatement::CreateTable(self.bind_create_table(stmt)?))
-            }
+            CreateTable { .. } => Ok(BoundStatement::CreateTable(self.bind_create_table(stmt)?)),
+            Query(query) => Ok(BoundStatement::Select(self.bind_select(query)?)),
             _ => todo!("bind statement: {:#?}", stmt),
         }
     }
diff --git a/code/01-03/src/binder/statement/mod.rs b/code/01-03/src/binder/statement/mod.rs
@@ -1,5 +1,7 @@
 use super::*;
 
 mod create_table;
+mod select;
 
 pub use self::create_table::*;
+pub use self::select::*;
diff --git a/code/01-03/src/binder/statement/select.rs b/code/01-03/src/binder/statement/select.rs
@@ -0,0 +1,26 @@
+use super::*;
+use crate::parser::{Expr, Query, SelectItem, SetExpr, Value};
+
+/// A bound `SELECT` statement.
+#[derive(Debug, PartialEq, Clone)]
+pub struct BoundSelect {
+    pub values: Vec<Value>,
+}
+
+impl Binder {
+    pub fn bind_select(&mut self, query: &Query) -> Result<BoundSelect, BindError> {
+        match &query.body {
+            SetExpr::Select(select) => {
+                let mut values = vec![];
+                for item in &select.projection {
+                    match item {
+                        SelectItem::UnnamedExpr(Expr::Value(v)) => values.push(v.clone()),
+                        _ => todo!("not supported statement: {:#?}", query),
+                    }
+                }
+                Ok(BoundSelect { values })
+            }
+            _ => todo!("not supported statement: {:#?}", query),
+        }
+    }
+}
diff --git a/code/01-03/src/executor/mod.rs b/code/01-03/src/executor/mod.rs
@@ -4,8 +4,10 @@ use crate::binder::BoundStatement;
 use crate::catalog::CatalogRef;
 
 mod create;
+mod select;
 
 use self::create::*;
+use self::select::*;
 
 /// The error type of execution.
 #[derive(thiserror::Error, Debug)]
@@ -36,6 +38,7 @@ impl ExecutorBuilder {
                 stmt,
                 catalog: self.catalog.clone(),
             }),
+            BoundStatement::Select(stmt) => Box::new(SelectExecutor { stmt }),
         }
     }
 }
diff --git a/code/01-03/src/executor/select.rs b/code/01-03/src/executor/select.rs
@@ -0,0 +1,23 @@
+use super::*;
+use crate::binder::BoundSelect;
+use crate::parser::Value;
+
+/// The executor of `SELECT` statement.
+pub struct SelectExecutor {
+    pub stmt: BoundSelect,
+}
+
+impl Executor for SelectExecutor {
+    fn execute(&mut self) -> Result<String, ExecuteError> {
+        let mut output = String::new();
+        for v in &self.stmt.values {
+            output += " ";
+            match v {
+                Value::SingleQuotedString(s) => output += s,
+                Value::Number(s, _) => output += s,
+                _ => todo!("not supported value: {:#?}", v),
+            }
+        }
+        Ok(output.trim().to_string())
+    }
+}
diff --git a/code/01-03/src/test.rs b/code/01-03/src/test.rs
@@ -4,6 +4,7 @@ use test_case::test_case;
 
 use crate::{Database, Error};
 
+#[test_case("01-01.slt")]
 #[test_case("01-03.slt")]
 fn test(name: &str) {
     init_logger();
diff --git a/code/01-04/src/array/mod.rs b/code/01-04/src/array/mod.rs
@@ -232,3 +232,16 @@ impl ArrayImpl {
         self.len() == 0
     }
 }
+
+/// Create a single element array from data value.
+impl From<&DataValue> for ArrayImpl {
+    fn from(val: &DataValue) -> Self {
+        match val {
+            DataValue::Null => Self::Int32([None].into_iter().collect()),
+            &DataValue::Bool(v) => Self::Bool([v].into_iter().collect()),
+            &DataValue::Int32(v) => Self::Int32([v].into_iter().collect()),
+            &DataValue::Float64(v) => Self::Float64([v].into_iter().collect()),
+            DataValue::String(v) => Self::Utf8([Some(v)].into_iter().collect()),
+        }
+    }
+}
diff --git a/code/01-04/src/binder/mod.rs b/code/01-04/src/binder/mod.rs
@@ -13,6 +13,7 @@ pub use self::statement::*;
 #[derive(Debug, PartialEq, Clone)]
 pub enum BoundStatement {
     CreateTable(BoundCreateTable),
+    Select(BoundSelect),
 }
 
 /// The error type of bind operations.
@@ -46,10 +47,10 @@ impl Binder {
 
     /// Bind a statement.
     pub fn bind(&mut self, stmt: &Statement) -> Result<BoundStatement, BindError> {
+        use Statement::*;
         match stmt {
-            Statement::CreateTable { .. } => {
-                Ok(BoundStatement::CreateTable(self.bind_create_table(stmt)?))
-            }
+            CreateTable { .. } => Ok(BoundStatement::CreateTable(self.bind_create_table(stmt)?)),
+            Query(query) => Ok(BoundStatement::Select(self.bind_select(query)?)),
             _ => todo!("bind statement: {:#?}", stmt),
         }
     }
diff --git a/code/01-04/src/binder/statement/mod.rs b/code/01-04/src/binder/statement/mod.rs
@@ -1,5 +1,7 @@
 use super::*;
 
 mod create_table;
+mod select;
 
 pub use self::create_table::*;
+pub use self::select::*;
diff --git a/code/01-04/src/binder/statement/select.rs b/code/01-04/src/binder/statement/select.rs
@@ -0,0 +1,27 @@
+use super::*;
+use crate::parser::{Expr, Query, SelectItem, SetExpr};
+use crate::types::DataValue;
+
+/// A bound `SELECT` statement.
+#[derive(Debug, PartialEq, Clone)]
+pub struct BoundSelect {
+    pub values: Vec<DataValue>,
+}
+
+impl Binder {
+    pub fn bind_select(&mut self, query: &Query) -> Result<BoundSelect, BindError> {
+        match &query.body {
+            SetExpr::Select(select) => {
+                let mut values = vec![];
+                for item in &select.projection {
+                    match item {
+                        SelectItem::UnnamedExpr(Expr::Value(v)) => values.push(v.into()),
+                        _ => todo!("not supported statement: {:#?}", query),
+                    }
+                }
+                Ok(BoundSelect { values })
+            }
+            _ => todo!("not supported statement: {:#?}", query),
+        }
+    }
+}
diff --git a/code/01-04/src/executor/mod.rs b/code/01-04/src/executor/mod.rs
@@ -6,8 +6,10 @@ use crate::catalog::CatalogRef;
 use crate::storage::{StorageError, StorageRef};
 
 mod create;
+mod select;
 
 use self::create::*;
+use self::select::*;
 
 /// The error type of execution.
 #[derive(thiserror::Error, Debug)]
@@ -43,6 +45,7 @@ impl ExecutorBuilder {
                 catalog: self.catalog.clone(),
                 storage: self.storage.clone(),
             }),
+            BoundStatement::Select(stmt) => Box::new(SelectExecutor { stmt }),
         }
     }
 }
diff --git a/code/01-04/src/executor/select.rs b/code/01-04/src/executor/select.rs
@@ -0,0 +1,15 @@
+use super::*;
+use crate::array::ArrayImpl;
+use crate::binder::BoundSelect;
+
+/// The executor of `SELECT` statement.
+pub struct SelectExecutor {
+    pub stmt: BoundSelect,
+}
+
+impl Executor for SelectExecutor {
+    fn execute(&mut self) -> Result<DataChunk, ExecuteError> {
+        let chunk = self.stmt.values.iter().map(ArrayImpl::from).collect();
+        Ok(chunk)
+    }
+}
diff --git a/code/01-04/src/test.rs b/code/01-04/src/test.rs
@@ -6,6 +6,7 @@ use crate::array::DataChunk;
 use crate::types::DataValue;
 use crate::{Database, Error};
 
+#[test_case("01-01.slt")]
 #[test_case("01-03.slt")]
 fn test(name: &str) {
     init_logger();
diff --git a/code/01-04/src/types.rs b/code/01-04/src/types.rs
@@ -1,6 +1,7 @@
 //! Defination of data types.
 
 pub use sqlparser::ast::DataType as DataTypeKind;
+use sqlparser::ast::Value;
 
 /// Data type with nullable.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -64,3 +65,24 @@ impl ToString for DataValue {
         }
     }
 }
+
+impl From<&Value> for DataValue {
+    fn from(v: &Value) -> Self {
+        match v {
+            Value::Number(n, _) => {
+                if let Ok(int) = n.parse::<i32>() {
+                    Self::Int32(int)
+                } else if let Ok(float) = n.parse::<f64>() {
+                    Self::Float64(float)
+                } else {
+                    panic!("invalid digit: {}", n);
+                }
+            }
+            Value::SingleQuotedString(s) => Self::String(s.clone()),
+            Value::DoubleQuotedString(s) => Self::String(s.clone()),
+            Value::Boolean(b) => Self::Bool(*b),
+            Value::Null => Self::Null,
+            _ => todo!("parse value: {:?}", v),
+        }
+    }
+}
diff --git a/code/01-05/src/array/mod.rs b/code/01-05/src/array/mod.rs
@@ -232,3 +232,16 @@ impl ArrayImpl {
         self.len() == 0
     }
 }
+
+/// Create a single element array from data value.
+impl From<&DataValue> for ArrayImpl {
+    fn from(val: &DataValue) -> Self {
+        match val {
+            DataValue::Null => Self::Int32([None].into_iter().collect()),
+            &DataValue::Bool(v) => Self::Bool([v].into_iter().collect()),
+            &DataValue::Int32(v) => Self::Int32([v].into_iter().collect()),
+            &DataValue::Float64(v) => Self::Float64([v].into_iter().collect()),
+            DataValue::String(v) => Self::Utf8([Some(v)].into_iter().collect()),
+        }
+    }
+}
diff --git a/code/01-05/src/binder/mod.rs b/code/01-05/src/binder/mod.rs
@@ -16,6 +16,7 @@ pub use self::statement::*;
 pub enum BoundStatement {
     CreateTable(BoundCreateTable),
     Insert(BoundInsert),
+    Select(BoundSelect),
 }
 
 /// The error type of bind operations.
@@ -57,11 +58,11 @@ impl Binder {
 
     /// Bind a statement.
     pub fn bind(&mut self, stmt: &Statement) -> Result<BoundStatement, BindError> {
+        use Statement::*;
         match stmt {
-            Statement::CreateTable { .. } => {
-                Ok(BoundStatement::CreateTable(self.bind_create_table(stmt)?))
-            }
-            Statement::Insert { .. } => Ok(BoundStatement::Insert(self.bind_insert(stmt)?)),
+            CreateTable { .. } => Ok(BoundStatement::CreateTable(self.bind_create_table(stmt)?)),
+            Insert { .. } => Ok(BoundStatement::Insert(self.bind_insert(stmt)?)),
+            Query(query) => Ok(BoundStatement::Select(self.bind_select(query)?)),
             _ => todo!("bind statement: {:#?}", stmt),
         }
     }
diff --git a/code/01-05/src/binder/statement/mod.rs b/code/01-05/src/binder/statement/mod.rs
@@ -2,6 +2,8 @@ use super::*;
 
 mod create_table;
 mod insert;
+mod select;
 
 pub use self::create_table::*;
 pub use self::insert::*;
+pub use self::select::*;
diff --git a/code/01-05/src/binder/statement/select.rs b/code/01-05/src/binder/statement/select.rs
@@ -0,0 +1,26 @@
+use super::*;
+use crate::parser::{Query, SelectItem, SetExpr};
+
+/// A bound `SELECT` statement.
+#[derive(Debug, PartialEq, Clone)]
+pub struct BoundSelect {
+    pub values: Vec<BoundExpr>,
+}
+
+impl Binder {
+    pub fn bind_select(&mut self, query: &Query) -> Result<BoundSelect, BindError> {
+        match &query.body {
+            SetExpr::Select(select) => {
+                let mut values = vec![];
+                for item in &select.projection {
+                    match item {
+                        SelectItem::UnnamedExpr(expr) => values.push(self.bind_expr(expr)?),
+                        _ => todo!("not supported statement: {:#?}", query),
+                    }
+                }
+                Ok(BoundSelect { values })
+            }
+            _ => todo!("not supported statement: {:#?}", query),
+        }
+    }
+}
diff --git a/code/01-05/src/executor/mod.rs b/code/01-05/src/executor/mod.rs
@@ -7,10 +7,12 @@ use crate::storage::{StorageError, StorageRef};
 
 mod create;
 mod insert;
+mod select;
 mod values;
 
 use self::create::*;
 use self::insert::*;
+use self::select::*;
 use self::values::*;
 
 /// The error type of execution.
@@ -57,6 +59,7 @@ impl ExecutorBuilder {
                     values: stmt.values,
                 }),
             }),
+            BoundStatement::Select(stmt) => Box::new(SelectExecutor { stmt }),
         }
     }
 }
diff --git a/code/01-05/src/executor/select.rs b/code/01-05/src/executor/select.rs
@@ -0,0 +1,17 @@
+use super::*;
+use crate::array::ArrayImpl;
+use crate::binder::{BoundExpr, BoundSelect};
+
+/// The executor of `SELECT` statement.
+pub struct SelectExecutor {
+    pub stmt: BoundSelect,
+}
+
+impl Executor for SelectExecutor {
+    fn execute(&mut self) -> Result<DataChunk, ExecuteError> {
+        let chunk = (self.stmt.values.iter())
+            .map(|BoundExpr::Constant(v)| ArrayImpl::from(v))
+            .collect();
+        Ok(chunk)
+    }
+}
diff --git a/code/01-05/src/test.rs b/code/01-05/src/test.rs
@@ -6,6 +6,7 @@ use crate::array::DataChunk;
 use crate::types::DataValue;
 use crate::{Database, Error};
 
+#[test_case("01-01.slt")]
 #[test_case("01-03.slt")]
 #[test_case("01-05.slt")]
 fn test(name: &str) {
diff --git a/code/01-06/src/array/mod.rs b/code/01-06/src/array/mod.rs
@@ -232,3 +232,16 @@ impl ArrayImpl {
         self.len() == 0
     }
 }
+
+/// Create a single element array from data value.
+impl From<&DataValue> for ArrayImpl {
+    fn from(val: &DataValue) -> Self {
+        match val {
+            DataValue::Null => Self::Int32([None].into_iter().collect()),
+            &DataValue::Bool(v) => Self::Bool([v].into_iter().collect()),
+            &DataValue::Int32(v) => Self::Int32([v].into_iter().collect()),
+            &DataValue::Float64(v) => Self::Float64([v].into_iter().collect()),
+            DataValue::String(v) => Self::Utf8([Some(v)].into_iter().collect()),
+        }
+    }
+}
diff --git a/code/01-06/src/binder/mod.rs b/code/01-06/src/binder/mod.rs
diff --git a/code/01-06/src/binder/statement/mod.rs b/code/01-06/src/binder/statement/mod.rs
diff --git a/code/01-06/src/binder/statement/select.rs b/code/01-06/src/binder/statement/select.rs
diff --git a/code/01-06/src/logical_planner/mod.rs b/code/01-06/src/logical_planner/mod.rs
diff --git a/code/01-06/src/logical_planner/select.rs b/code/01-06/src/logical_planner/select.rs
diff --git a/code/01-06/src/test.rs b/code/01-06/src/test.rs
diff --git a/rust-toolchain b/rust-toolchain

Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,7 @@ pub use self::statement::*;`
`13`	`13`	`#[derive(Debug, PartialEq, Clone)]`
`14`	`14`	`pub enum BoundStatement {`
`15`	`15`	`CreateTable(BoundCreateTable),`
	`16`	`+ Select(BoundSelect),`
`16`	`17`	`}`
`17`	`18`
`18`	`19`	`/// The error type of bind operations.`
`@@ -46,10 +47,10 @@ impl Binder {`
`46`	`47`
`47`	`48`	`/// Bind a statement.`
`48`	`49`	`pub fn bind(&mut self, stmt: &Statement) -> Result<BoundStatement, BindError> {`
	`50`	`+ use Statement::*;`
`49`	`51`	`match stmt {`
`50`		`- Statement::CreateTable { .. } => {`
`51`		`- Ok(BoundStatement::CreateTable(self.bind_create_table(stmt)?))`
`52`		`- }`
	`52`	`+ CreateTable { .. } => Ok(BoundStatement::CreateTable(self.bind_create_table(stmt)?)),`
	`53`	`+ Query(query) => Ok(BoundStatement::Select(self.bind_select(query)?)),`
`53`	`54`	`_ => todo!("bind statement: {:#?}", stmt),`
`54`	`55`	`}`
`55`	`56`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,8 +4,10 @@ use crate::binder::BoundStatement;`
`4`	`4`	`use crate::catalog::CatalogRef;`
`5`	`5`
`6`	`6`	`mod create;`
	`7`	`+mod select;`
`7`	`8`
`8`	`9`	`use self::create::*;`
	`10`	`+use self::select::*;`
`9`	`11`
`10`	`12`	`/// The error type of execution.`
`11`	`13`	`#[derive(thiserror::Error, Debug)]`
`@@ -36,6 +38,7 @@ impl ExecutorBuilder {`
`36`	`38`	`stmt,`
`37`	`39`	`catalog: self.catalog.clone(),`
`38`	`40`	`}),`
	`41`	`+ BoundStatement::Select(stmt) => Box::new(SelectExecutor { stmt }),`
`39`	`42`	`}`
`40`	`43`	`}`
`41`	`44`	`}`