initialize from risinglight

Author: wangrunji0408

.github/workflows/ci.yml

@@ -0,0 +1,45 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - 'code/**'
+  pull_request:
+    branches:
+      - main
+    paths:
+      - 'code/**'
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  fmt:
+    runs-on: ubuntu-20.04
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          components: rustfmt, clippy
+      - name: Check code format
+        working-directory: ./code
+        run: cargo fmt --all -- --check
+      - name: Clippy
+        working-directory: ./code
+        run: cargo clippy --all-targets --all-features -- -D warnings
+
+  test:
+    runs-on: ubuntu-20.04
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+      - name: Test
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --manifest-path code/Cargo.toml --release --no-fail-fast --all-features

README.md

@@ -0,0 +1,5 @@
+# RisingLight Tutorial
+
+[![CI](https://github.com/singularity-data/risinglight-tutorial/workflows/CI/badge.svg?branch=main)](https://github.com/singularity-data/risinglight-tutorial/actions)
+
+Let's build an OLAP database from scratch!

code/.gitignore

@@ -0,0 +1,2 @@
+target
+Cargo.lock

code/01-01/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "risinglight-01-01"
+version = "0.1.0"
+edition = "2021"
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+env_logger = "0.9"
+log = "0.4"
+rustyline = "9"
+sqlparser = "0.12"
+thiserror = "1"
+
+[dev-dependencies]
+sqllogictest = "0.1"
+test-case = "1.2"

code/01-01/src/db.rs

@@ -0,0 +1,38 @@
+//! Top-level structure of the database.
+
+use crate::executor::{execute, ExecuteError};
+use crate::parser::{parse, ParserError};
+
+/// The database instance.
+#[derive(Default)]
+pub struct Database {}
+
+impl Database {
+    /// Create a new database instance.
+    pub fn new() -> Self {
+        Database {}
+    }
+
+    /// Run SQL queries and return the outputs.
+    pub fn run(&self, sql: &str) -> Result<Vec<String>, Error> {
+        // parse
+        let stmts = parse(sql)?;
+
+        let mut outputs = vec![];
+        for stmt in stmts {
+            debug!("execute: {:#?}", stmt);
+            let output = execute(&stmt);
+            outputs.extend(output);
+        }
+        Ok(outputs)
+    }
+}
+
+/// The error type of database operations.
+#[derive(thiserror::Error, Debug)]
+pub enum Error {
+    #[error("parse error: {0}")]
+    Parse(#[from] ParserError),
+    #[error("execute error: {0}")]
+    Execute(#[from] ExecuteError),
+}

code/01-01/src/executor.rs

@@ -0,0 +1,33 @@
+//! Execute the queries.
+
+use std::fmt::Write;
+
+use crate::parser::{Expr, SelectItem, SetExpr, Statement, Value};
+
+pub fn execute(stmt: &Statement) -> Result<String, ExecuteError> {
+    match stmt {
+        Statement::Query(query) => match &query.body {
+            SetExpr::Select(select) => {
+                let mut output = String::new();
+                for item in &select.projection {
+                    write!(output, " ").unwrap();
+                    match item {
+                        SelectItem::UnnamedExpr(Expr::Value(v)) => match v {
+                            Value::SingleQuotedString(s) => write!(output, "{}", s).unwrap(),
+                            Value::Number(s, _) => write!(output, "{}", s).unwrap(),
+                            _ => todo!("not supported statement: {:#?}", stmt),
+                        },
+                        _ => todo!("not supported statement: {:#?}", stmt),
+                    }
+                }
+                return Ok(output.trim().to_string());
+            }
+            _ => todo!("not supported statement: {:#?}", stmt),
+        },
+        _ => todo!("not supported statement: {:#?}", stmt),
+    }
+}
+
+/// The error type of execution.
+#[derive(thiserror::Error, Debug)]
+pub enum ExecuteError {}

code/01-01/src/lib.rs

@@ -0,0 +1,21 @@
+//! RisingLight -- an educational OLAP database.
+
+#![deny(unused_must_use)]
+
+// Enable macros for logging.
+#[macro_use]
+extern crate log;
+
+#[cfg(test)]
+mod test;
+
+// Top-level structure of the database.
+pub mod db;
+
+// Stage 1: Parse the SQL string into an Abstract Syntax Tree (AST).
+pub mod parser;
+
+// Stage 2: Execute the queries.
+pub mod executor;
+
+pub use self::db::{Database, Error};

code/01-01/src/main.rs

@@ -0,0 +1,40 @@
+//! A simple interactive shell of the database.
+
+use risinglight_01_01::Database;
+use rustyline::error::ReadlineError;
+use rustyline::Editor;
+
+fn main() {
+    env_logger::init();
+
+    let db = Database::new();
+
+    let mut rl = Editor::<()>::new();
+    loop {
+        match rl.readline("> ") {
+            Ok(line) => {
+                rl.add_history_entry(line.as_str());
+                let ret = db.run(&line);
+                match ret {
+                    Ok(chunks) => {
+                        for chunk in chunks {
+                            println!("{}", chunk);
+                        }
+                    }
+                    Err(err) => println!("{}", err),
+                }
+            }
+            Err(ReadlineError::Interrupted) => {
+                println!("Interrupted");
+            }
+            Err(ReadlineError::Eof) => {
+                println!("Exited");
+                break;
+            }
+            Err(err) => {
+                println!("Error: {:?}", err);
+                break;
+            }
+        }
+    }
+}

code/01-01/src/parser.rs

@@ -0,0 +1,15 @@
+//! Parse the SQL string into an Abstract Syntax Tree (AST).
+//!
+//! The parser module directly uses the [`sqlparser`] crate
+//! and re-exports its AST types.
+
+pub use sqlparser::ast::*;
+use sqlparser::dialect::PostgreSqlDialect;
+use sqlparser::parser::Parser;
+pub use sqlparser::parser::ParserError;
+
+/// Parse the SQL string into a list of ASTs.
+pub fn parse(sql: &str) -> Result<Vec<Statement>, ParserError> {
+    let dialect = PostgreSqlDialect {};
+    Parser::parse_sql(&dialect, sql)
+}

code/01-01/src/test.rs

@@ -0,0 +1,27 @@
+use std::path::Path;
+
+use test_case::test_case;
+
+use crate::{Database, Error};
+
+#[test_case("01-01.slt")]
+fn test(name: &str) {
+    init_logger();
+    let script = std::fs::read_to_string(Path::new("../sql").join(name)).unwrap();
+    let mut tester = sqllogictest::Runner::new(Database::new());
+    tester.run_script(&script);
+}
+
+impl sqllogictest::DB for Database {
+    type Error = Error;
+    fn run(&self, sql: &str) -> Result<String, Self::Error> {
+        let mut outputs = self.run(sql)?;
+        Ok(outputs.remove(0))
+    }
+}
+
+fn init_logger() {
+    use std::sync::Once;
+    static INIT: Once = Once::new();
+    INIT.call_once(env_logger::init);
+}