sql-parser: select ast (2)

Author: Almaz-KG

README.md

@@ -58,16 +58,18 @@ The items were taken from the official SQLite documentation
 
 ### Advanced statements
 
-#### SELECT Statement ![progress](https://progress-bar.xyz/0/?scale=8&suffix=%%%20(0%20of%208)&width=140)
+#### SELECT Statement ![progress](https://progress-bar.xyz/0/?scale=9&suffix=%%%20(0%20of%209)&width=140)
 
 1. [result-columns](https://www.sqlite.org/syntax/result-column.html)
 1. [table-or-subquery](https://www.sqlite.org/lang_select.html#tablename)
 1. [join-clauses](https://www.sqlite.org/syntax/join-clause.html)
 1. [where-group-by-having-clause](https://www.sqlite.org/lang_select.html#where)
-1. [window-functions-part](https://www.sqlite.org/syntax/window-defn.html)
+1. [window-functions](https://www.sqlite.org/syntax/window-defn.html)
+1. [select-core-stmt](https://www.sqlite.org/syntax/select-core.html)
+1. [values-stmt](https://www.sqlite.org/syntax/select-core.html)
+1. [with-compound-stmt](https://www.sqlite.org/syntax/factored-select-stmt.html)
 1. [order-by-and-limit-clause](https://www.sqlite.org/lang_select.html#orderby)
 1. [common-table-expressions](https://www.sqlite.org/syntax/common-table-expression.html)
-1. [select-stmt](https://www.sqlite.org/syntax/select-stmt.html)
 
 #### DELETE Statements ![progress](https://progress-bar.xyz/0/?scale=2&suffix=%%%20(0%20of%202)&width=140)
 1. [delete-stmt](https://www.sqlite.org/syntax/delete-stmt.html)

src/ast/cte.rs

@@ -0,0 +1,27 @@
+use super::{Identifier, SelectStatement, Statement};
+
+/// An AST for [WITH](https://www.sqlite.org/lang_with.html) SQL statement.
+/// The WITH statement is used in SELECT, INSERT, UPDATE, and DELETE
+/// statements to define Common Table Expressions (CTEs).
+#[derive(Debug, PartialEq)]
+pub struct WithCteStatement {
+    pub cte_name: String,
+
+    pub recursive: bool,
+
+    pub cte_expressions: Vec<CteExpression>,
+
+    pub statement: Statement,
+}
+
+/// An AST for a single CTE expression.
+#[derive(Debug, PartialEq)]
+pub struct CteExpression {
+    pub name: Identifier,
+
+    pub column_names: Vec<Identifier>,
+
+    pub materialized: Option<bool>,
+
+    pub select: Vec<SelectStatement>,
+}

src/ast/expression.rs

@@ -2,7 +2,7 @@ use std::fmt::Display;
 
 use crate::{ParsingError, TokenType};
 
-use super::{Ordering, SelectStatement};
+use super::{OrderingTerm, SelectStatementType};
 
 /// An SQLite3 [expr](https://www.sqlite.org/lang_expr.html) expression
 #[derive(Debug, PartialEq, Clone)]
@@ -206,7 +206,7 @@ pub struct Function {
     /// The filter clause of the function
     pub filter_clause: Option<Box<Expression>>,
     /// The over clause of the function
-    pub over_clause: Option<OverClause>,
+    pub over_clause: Option<WindowDefinition>,
 }
 
 /// A function argument
@@ -231,7 +231,7 @@ pub enum FunctionArgType {
 
 /// An over clause
 #[derive(Debug, PartialEq, Clone, Default)]
-pub struct OverClause {
+pub struct WindowDefinition {
     /// The window name
     pub window_name: Option<String>,
     /// The partition by clause
@@ -242,19 +242,6 @@ pub struct OverClause {
     pub frame_spec: Option<FrameSpec>,
 }
 
-/// An ordering term
-/// Possible collation name will be parsed, and will be stored in the
-/// expression field
-#[derive(Debug, PartialEq, Clone)]
-pub struct OrderingTerm {
-    /// The expression to order by
-    pub expression: Box<Expression>,
-    /// The ordering
-    pub ordering: Option<Ordering>,
-    /// The nulls ordering
-    pub nulls_ordering: Option<NullsOrdering>,
-}
-
 /// Nulls ordering
 #[derive(Debug, PartialEq, Clone)]
 pub enum NullsOrdering {
@@ -430,7 +417,7 @@ pub enum InExpression {
     Empty,
 
     /// Select
-    Select(SelectStatement),
+    Select(SelectStatementType),
 
     /// Expressions
     Expression(Vec<Expression>),
@@ -446,10 +433,10 @@ pub enum InExpression {
 #[derive(Debug, PartialEq, Clone)]
 pub enum ExistsStatement {
     /// Exists
-    Exists(SelectStatement),
+    Exists(SelectStatementType),
 
     /// Not Exists
-    NotExists(SelectStatement),
+    NotExists(SelectStatementType),
 }
 
 /// A case expression

src/ast/mod.rs

@@ -1,5 +1,6 @@
 mod alter;
 mod create;
+mod cte;
 mod delete;
 mod drop;
 mod explain;
@@ -39,7 +40,7 @@ pub use update::UpdateStatement;
 #[derive(Debug, PartialEq)]
 pub enum Statement {
     /// Data Query Language (DQL), see [SelectStatement]
-    Select(SelectStatement),
+    Select(SelectStatementType),
 
     /// Data Manipulation Language (DML), see [InsertStatement]
     Insert(InsertStatement),
@@ -97,6 +98,17 @@ pub enum Statement {
     Explain(ExplainStatement),
 }
 
+/// An ordering term, used in the ORDER BY clause
+#[derive(Debug, PartialEq, Clone)]
+pub struct OrderingTerm {
+    /// The expression to order by
+    pub expression: Box<Expression>,
+    /// The ordering
+    pub ordering: Option<Ordering>,
+    /// The nulls ordering
+    pub nulls_ordering: Option<NullsOrdering>,
+}
+
 /// An ordering
 #[derive(Debug, PartialEq, Clone)]
 pub enum Ordering {

src/ast/select.rs

@@ -1,8 +1,20 @@
-use super::Expression;
+use super::{Expression, Identifier, OrderingTerm, WindowDefinition};
+
+/// An enum representing the possible types of SELECT statements
+#[derive(Debug, PartialEq, Clone)]
+pub enum SelectStatementType {
+    /// A normal SELECT statement
+    Select(SelectStatement),
+    /// A VALUES statement
+    Values(ValuesStatement),
+}
 
 /// An AST for [SELECT](https://www.sqlite.org/lang_select.html) SQL statement.
 #[derive(Debug, PartialEq, Default, Clone)]
 pub struct SelectStatement {
+    /// Whether the SELECT statement is a VALUES statement
+    pub values: bool,
+
     /// Whether the SELECT statement is distinct
     pub distinct: bool,
 
@@ -14,10 +26,24 @@ pub struct SelectStatement {
 
     /// The FROM clause
     pub from: Option<SelectFrom>,
-    // pub where_clause: Option<Expression>,
-    // pub order_by: Option<OrderBy>,
-    // pub limit: Option<Expression>,
-    // pub offset: Option<Expression>,
+
+    /// The WHERE clause
+    pub where_clause: Option<Box<Expression>>,
+
+    /// The GROUP BY clause
+    pub group_by: Option<Vec<Box<Expression>>>,
+
+    /// The HAVING clause
+    pub having: Option<Box<Expression>>,
+
+    /// The WINDOW clause
+    pub window: Option<Vec<WindowDefinition>>,
+
+    /// The ORDER BY clause
+    pub order_by: Option<OrderingTerm>,
+
+    /// The LIMIT clause
+    pub limit: Option<LimitClause>,
 }
 
 /// An enum representing the possible items in a SELECT statement
@@ -53,19 +79,26 @@ pub enum SelectFrom {
 /// A table in a FROM clause
 #[derive(Debug, PartialEq, Clone)]
 pub struct SelectFromTable {
-    pub schema: Option<String>,
-    pub table_name: String,
+    pub table_id: Identifier,
+
     pub alias: Option<String>,
 
-    pub indexed_by: Option<String>,
-    pub not_indexed: Option<bool>,
+    pub indexed_type: Option<IndexedType>,
+}
+
+/// An enum representing the possible indexed types
+#[derive(Debug, PartialEq, Clone)]
+pub enum IndexedType {
+    /// Indexed by a specific index
+    Indexed(String),
+    /// Not indexed
+    NotIndexed,
 }
 
 /// A function in a FROM clause
 #[derive(Debug, PartialEq, Clone)]
 pub struct SelectFromFunction {
-    pub schema: Option<String>,
-    pub function_name: String,
+    pub function_name: Identifier,
     pub arguments: Vec<Expression>,
     pub alias: Option<String>,
 }
@@ -81,24 +114,32 @@ pub struct SelectFromSubquery {
 #[derive(Debug, PartialEq, Clone)]
 pub struct JoinClause {
     pub lhs_table: Box<SelectFrom>,
+
+    pub join_tables: Vec<JoinTable>,
+}
+
+/// A table in a JOIN clause
+#[derive(Debug, PartialEq, Clone)]
+pub struct JoinTable {
     pub join_type: JoinType,
-    pub rhs_table: Box<SelectFrom>,
-    pub join_constraints: Vec<JoinConstraint>,
+    pub table: Box<SelectFrom>,
+    pub constraints: JoinConstraint,
 }
 
+/// A type alias for the `NATURAL` keyword in a JOIN clause
+pub type IsNaturalJoin = bool;
+
 /// A type of JOIN clause
 #[derive(Debug, PartialEq, Clone)]
 pub enum JoinType {
-    /// INNER JOIN
-    Inner,
     /// LEFT JOIN
-    Left,
+    Left(IsNaturalJoin),
     /// RIGHT JOIN
-    Right,
-    /// NATURAL JOIN
-    Natural(Box<JoinType>),
-    /// OUTER JOIN (LEFT OUTER JOIN, RIGHT OUTER JOIN, FULL OUTER JOIN)
-    Outer(Box<JoinType>),
+    Right(IsNaturalJoin),
+    /// FULL JOIN
+    Full(IsNaturalJoin),
+    /// INNER JOIN
+    Inner(IsNaturalJoin),
     /// CROSS JOIN
     Cross,
 }
@@ -111,3 +152,18 @@ pub enum JoinConstraint {
     /// USING clause
     Using(Vec<String>),
 }
+
+/// A clause for a LIMIT statement
+#[derive(Debug, PartialEq, Clone)]
+pub struct LimitClause {
+    pub limit: Box<Expression>,
+    pub offset: Option<Box<Expression>>,
+    pub additional_limit: Option<Box<Expression>>,
+}
+
+/// A VALUES statement
+#[derive(Debug, PartialEq, Clone)]
+pub struct ValuesStatement {
+    /// The list of values in a VALUES statement grouped by parenthesis
+    pub values: Vec<Vec<Expression>>,
+}

src/parser/expression/exists_expr.rs

@@ -33,22 +33,28 @@ impl<'a> ExistsExpressionParser for Parser<'a> {
 
 #[cfg(test)]
 mod exists_expression_tests {
-    use crate::{SelectItem, SelectStatement};
+    use crate::{SelectItem, SelectStatement, SelectStatementType};
 
     use crate::parser::expression::test_utils::*;
 
+    fn select_statement(columns: Vec<SelectItem>) -> SelectStatementType {
+        SelectStatementType::Select(SelectStatement {
+            distinct: false,
+            all: false,
+            columns,
+            ..Default::default()
+        })
+    }
+
     #[test]
     fn test_expression_exists() {
         run_sunny_day_test(
             "SELECT EXISTS (SELECT 1);",
             &exist_expression(
                 false,
-                SelectStatement {
-                    distinct: false,
-                    all: false,
-                    columns: vec![SelectItem::Expression(numeric_literal_expression("1"))],
-                    from: None,
-                },
+                select_statement(vec![SelectItem::Expression(numeric_literal_expression(
+                    "1",
+                ))]),
             ),
         );
     }
@@ -59,12 +65,9 @@ mod exists_expression_tests {
             "SELECT NOT EXISTS (SELECT 1);",
             &exist_expression(
                 true,
-                SelectStatement {
-                    distinct: false,
-                    all: false,
-                    columns: vec![SelectItem::Expression(numeric_literal_expression("1"))],
-                    from: None,
-                },
+                select_statement(vec![SelectItem::Expression(numeric_literal_expression(
+                    "1",
+                ))]),
             ),
         );
     }
@@ -75,12 +78,9 @@ mod exists_expression_tests {
             "SELECT NOT (SELECT 21);",
             &exist_expression(
                 true,
-                SelectStatement {
-                    distinct: false,
-                    all: false,
-                    columns: vec![SelectItem::Expression(numeric_literal_expression("21"))],
-                    from: None,
-                },
+                select_statement(vec![SelectItem::Expression(numeric_literal_expression(
+                    "21",
+                ))]),
             ),
         );
     }