add a template for startup

Signed-off-by: Runji Wang <[email protected]>

Author: wangrunji0408

src/agg.rs

@@ -0,0 +1,31 @@
+use egg::Language;
+
+use super::*;
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum Error {
+    // #[error("aggregate function calls cannot be nested")]
+    NestedAgg(String),
+    // #[error("WHERE clause cannot contain aggregates")]
+    AggInWhere,
+    // #[error("GROUP BY clause cannot contain aggregates")]
+    AggInGroupBy,
+    // #[error("column {0} must appear in the GROUP BY clause or be used in an aggregate function")]
+    ColumnNotInAgg(String),
+}
+
+/// Converts the SELECT statement into a plan tree.
+///
+/// The nodes of all clauses have been added to the `egraph`.
+/// `from`, `where_`... are the ids of their root node.
+pub fn plan_select(
+    egraph: &mut EGraph,
+    from: Id,
+    where_: Id,
+    having: Id,
+    groupby: Id,
+    orderby: Id,
+    projection: Id,
+) -> Result<Id, Error> {
+    todo!()
+}

src/expr.rs

@@ -0,0 +1,13 @@
+//! Expression simplification rules and constant folding.
+
+use egg::rewrite as rw;
+
+use super::*;
+
+/// Returns all rules of expression simplification.
+#[rustfmt::skip]
+pub fn rules() -> Vec<Rewrite> { vec![
+    rw!("add-zero";  "(+ ?a 0)" => "?a"),
+
+    // TODO: add more rules
+]}

src/lib.rs

@@ -0,0 +1,57 @@
+#![allow(unused)]
+
+use std::hash::Hash;
+
+use egg::{define_language, Analysis, DidMerge, Id};
+
+pub mod agg;
+pub mod expr;
+pub mod plan;
+mod value;
+
+pub use value::*;
+
+pub type RecExpr = egg::RecExpr<Expr>;
+pub type EGraph = egg::EGraph<Expr, ExprAnalysis>;
+pub type Rewrite = egg::Rewrite<Expr, ExprAnalysis>;
+
+define_language! {
+    pub enum Expr {
+        // values
+        Constant(Value),            // null, true, 1, 'hello'
+        Column(Column),             // t.a, b, c
+
+        // TODO: add more nodes
+    }
+}
+
+/// The unified analysis for all rules.
+#[derive(Default)]
+pub struct ExprAnalysis;
+
+/// The analysis data associated with each eclass.
+///
+/// See [`egg::Analysis`] for how data is being processed.
+#[derive(Debug)]
+pub struct Data {
+    // TODO: add analysis data
+}
+
+impl Analysis<Expr> for ExprAnalysis {
+    type Data = Data;
+
+    /// Analyze a node and give the result.
+    fn make(egraph: &EGraph, enode: &Expr) -> Self::Data {
+        todo!()
+    }
+
+    /// Merge the analysis data with previous one.
+    fn merge(&mut self, to: &mut Self::Data, from: Self::Data) -> DidMerge {
+        todo!()
+    }
+
+    /// Modify the graph after analyzing a node.
+    fn modify(egraph: &mut EGraph, id: Id) {
+        todo!()
+    }
+}

src/plan.rs

@@ -0,0 +1,26 @@
+//! Plan optimization rules.
+
+use std::collections::HashSet;
+
+use super::*;
+use egg::rewrite as rw;
+
+/// Returns the rules that always improve the plan.
+pub fn rules() -> Vec<Rewrite> {
+    let mut rules = vec![];
+    rules.extend(projection_pushdown_rules());
+    rules.extend(join_rules());
+    // TODO: add rules
+    rules
+}
+
+#[rustfmt::skip]
+pub fn join_rules() -> Vec<Rewrite> { vec![
+    // TODO: add rules
+]}
+
+/// Pushdown projections and prune unused columns.
+#[rustfmt::skip]
+pub fn projection_pushdown_rules() -> Vec<Rewrite> { vec![
+    // TODO: add rules
+]}

src/value.rs

@@ -0,0 +1,47 @@
+use std::{fmt::Display, str::FromStr};
+
+/// SQL value.
+///
+/// # Display and Parse Format
+///
+/// - Null: `null`
+/// - Bool: `false`
+/// - Integer: `1`
+/// - String: `'string'`
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum Value {
+    Null,
+    Bool(bool),
+    Int(i32),
+    String(String),
+}
+
+impl Display for Value {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Value::Null => write!(f, "null"),
+            Value::Bool(b) => write!(f, "{b}"),
+            Value::Int(i) => write!(f, "{i}"),
+            Value::String(s) => write!(f, "'{s}'"),
+        }
+    }
+}
+
+impl FromStr for Value {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if s == "null" {
+            return Ok(Value::Null);
+        } else if let Ok(i) = s.parse() {
+            return Ok(Value::Bool(i));
+        } else if let Ok(i) = s.parse() {
+            return Ok(Value::Int(i));
+        } else if s.starts_with('\'') && s.ends_with('\'') {
+            return Ok(Value::String(s[1..s.len() - 1].to_string()));
+        }
+        Err(s.to_string())
+    }
+}
+
+pub type Column = egg::Symbol;