Merge branch 'join-support' of https://github.com/fredrikroos/sqlparser-rs into fredrikroos-join-support

src/dialect/generic_sql.rs

@@ -11,6 +11,8 @@ impl Dialect for GenericSqlDialect {
             STORED, CSV, PARQUET, LOCATION, WITH, WITHOUT, HEADER, ROW, // SQL types
             CHAR, CHARACTER, VARYING, LARGE, OBJECT, VARCHAR, CLOB, BINARY, VARBINARY, BLOB, FLOAT,
             REAL, DOUBLE, PRECISION, INT, INTEGER, SMALLINT, BIGINT, NUMERIC, DECIMAL, DEC,
+            BOOLEAN, DATE, TIME, TIMESTAMP, CASE, WHEN, THEN, ELSE, END, JOIN, LEFT, RIGHT, FULL,
+            CROSS, OUTER, INNER, NATURAL, ON, USING,
             BOOLEAN, DATE, TIME, TIMESTAMP, CASE, WHEN, THEN, ELSE, END, LIKE,
         ];
     }

src/dialect/postgresql.rs

@@ -14,7 +14,7 @@ impl Dialect for PostgreSqlDialect {
             DOUBLE, PRECISION, INT, INTEGER, SMALLINT, BIGINT, NUMERIC, DECIMAL, DEC, BOOLEAN,
             DATE, TIME, TIMESTAMP, VALUES, DEFAULT, ZONE, REGCLASS, TEXT, BYTEA, TRUE, FALSE, COPY,
             STDIN, PRIMARY, KEY, UNIQUE, UUID, ADD, CONSTRAINT, FOREIGN, REFERENCES, CASE, WHEN,
-            THEN, ELSE, END, LIKE,
+            THEN, ELSE, END, JOIN, LEFT, RIGHT, FULL, CROSS, OUTER, INNER, NATURAL, ON, USING,
         ];
     }
 

src/sqlast/mod.rs

@@ -75,6 +75,8 @@ pub enum ASTNode {
         projection: Vec<ASTNode>,
         /// FROM
         relation: Option<Box<ASTNode>>,
+        // JOIN
+        joins: Vec<Join>,
         /// WHERE
         selection: Option<Box<ASTNode>>,
         /// ORDER BY
@@ -189,6 +191,7 @@ impl ToString for ASTNode {
             ASTNode::SQLSelect {
                 projection,
                 relation,
+                joins,
                 selection,
                 order_by,
                 group_by,
@@ -206,6 +209,9 @@ impl ToString for ASTNode {
                 if let Some(relation) = relation {
                     s += &format!(" FROM {}", relation.as_ref().to_string());
                 }
+                for join in joins {
+                    s += &join.to_string();
+                }
                 if let Some(selection) = selection {
                     s += &format!(" WHERE {}", selection.as_ref().to_string());
                 }
@@ -408,3 +414,72 @@ impl ToString for SQLColumnDef {
         s
     }
 }
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Join {
+    pub relation: ASTNode,
+    pub join_operator: JoinOperator,
+}
+
+impl ToString for Join {
+    fn to_string(&self) -> String {
+        fn prefix(constraint: &JoinConstraint) -> String {
+            match constraint {
+                JoinConstraint::Natural => "NATURAL ".to_string(),
+                _ => "".to_string(),
+            }
+        }
+        fn suffix(constraint: &JoinConstraint) -> String {
+            match constraint {
+                JoinConstraint::On(expr) => format!("ON {}", expr.to_string()),
+                JoinConstraint::Using(attrs) => format!("USING({})", attrs.join(", ")),
+                _ => "".to_string(),
+            }
+        }
+        match &self.join_operator {
+            JoinOperator::Inner(constraint) => format!(
+                " {}JOIN {} {}",
+                prefix(constraint),
+                self.relation.to_string(),
+                suffix(constraint)
+            ),
+            JoinOperator::Cross => format!(" CROSS JOIN {}", self.relation.to_string()),
+            JoinOperator::Implicit => format!(", {}", self.relation.to_string()),
+            JoinOperator::LeftOuter(constraint) => format!(
+                " {}LEFT JOIN {} {}",
+                prefix(constraint),
+                self.relation.to_string(),
+                suffix(constraint)
+            ),
+            JoinOperator::RightOuter(constraint) => format!(
+                " {}RIGHT JOIN {} {}",
+                prefix(constraint),
+                self.relation.to_string(),
+                suffix(constraint)
+            ),
+            JoinOperator::FullOuter(constraint) => format!(
+                " {}FULL JOIN {} {}",
+                prefix(constraint),
+                self.relation.to_string(),
+                suffix(constraint)
+            ),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum JoinOperator {
+    Inner(JoinConstraint),
+    LeftOuter(JoinConstraint),
+    RightOuter(JoinConstraint),
+    FullOuter(JoinConstraint),
+    Implicit,
+    Cross,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum JoinConstraint {
+    On(ASTNode),
+    Using(Vec<String>),
+    Natural,
+}

src/sqlparser.rs

@@ -437,6 +437,18 @@ impl Parser {
         true
     }
 
+    pub fn expect_keyword(&mut self, expected: &'static str) -> Result<(), ParserError> {
+        if self.parse_keyword(expected) {
+            Ok(())
+        } else {
+            parser_err!(format!(
+                "Expected keyword {}, found {:?}",
+                expected,
+                self.peek_token()
+            ))
+        }
+    }
+
     //TODO: this function is inconsistent and sometimes returns bool and sometimes fails
 
     /// Consume the next token if it matches the expected token, otherwise return an error
@@ -1034,11 +1046,12 @@ impl Parser {
     pub fn parse_select(&mut self) -> Result<ASTNode, ParserError> {
         let projection = self.parse_expr_list()?;
 
-        let relation: Option<Box<ASTNode>> = if self.parse_keyword("FROM") {
-            //TODO: add support for JOIN
-            Some(Box::new(self.parse_expr(0)?))
+        let (relation, joins): (Option<Box<ASTNode>>, Vec<Join>) = if self.parse_keyword("FROM") {
+            let relation = Some(Box::new(self.parse_expr(0)?));
+            let joins = self.parse_joins()?;
+            (relation, joins)
         } else {
-            None
+            (None, vec![])
         };
 
         let selection = if self.parse_keyword("WHERE") {
@@ -1084,6 +1097,7 @@ impl Parser {
                 projection,
                 selection,
                 relation,
+                joins,
                 limit,
                 order_by,
                 group_by,
@@ -1092,6 +1106,131 @@ impl Parser {
         }
     }
 
+    fn parse_join_constraint(&mut self, natural: bool) -> Result<JoinConstraint, ParserError> {
+        if natural {
+            Ok(JoinConstraint::Natural)
+        } else if self.parse_keyword("ON") {
+            let constraint = self.parse_expr(0)?;
+            Ok(JoinConstraint::On(constraint))
+        } else if self.parse_keyword("USING") {
+            if self.consume_token(&Token::LParen)? {
+                let attributes = self
+                    .parse_expr_list()?
+                    .into_iter()
+                    .map(|ast_node| match ast_node {
+                        ASTNode::SQLIdentifier(ident) => Ok(ident),
+                        unexpected => {
+                            parser_err!(format!("Expected identifier, found {:?}", unexpected))
+                        }
+                    })
+                    .collect::<Result<Vec<String>, ParserError>>()?;
+
+                if self.consume_token(&Token::RParen)? {
+                    Ok(JoinConstraint::Using(attributes))
+                } else {
+                    parser_err!(format!("Expected token ')', found {:?}", self.peek_token()))
+                }
+            } else {
+                parser_err!(format!("Expected token '(', found {:?}", self.peek_token()))
+            }
+        } else {
+            parser_err!(format!(
+                "Unexpected token after JOIN: {:?}",
+                self.peek_token()
+            ))
+        }
+    }
+
+    fn parse_joins(&mut self) -> Result<Vec<Join>, ParserError> {
+        let mut joins = vec![];
+        loop {
+            let natural = match &self.peek_token() {
+                Some(Token::Comma) => {
+                    self.next_token();
+                    let relation = self.parse_expr(0)?;
+                    let join = Join {
+                        relation,
+                        join_operator: JoinOperator::Implicit,
+                    };
+                    joins.push(join);
+                    continue;
+                }
+                Some(Token::Keyword(kw)) if kw == "CROSS" => {
+                    self.next_token();
+                    self.expect_keyword("JOIN")?;
+                    let relation = self.parse_expr(0)?;
+                    let join = Join {
+                        relation,
+                        join_operator: JoinOperator::Cross,
+                    };
+                    joins.push(join);
+                    continue;
+                }
+                Some(Token::Keyword(kw)) if kw == "NATURAL" => {
+                    self.next_token();
+                    true
+                }
+                Some(_) => false,
+                None => return Ok(joins),
+            };
+
+            let join = match &self.peek_token() {
+                Some(Token::Keyword(kw)) if kw == "INNER" => {
+                    self.next_token();
+                    self.expect_keyword("JOIN")?;
+                    Join {
+                        relation: self.parse_expr(0)?,
+                        join_operator: JoinOperator::Inner(self.parse_join_constraint(natural)?),
+                    }
+                }
+                Some(Token::Keyword(kw)) if kw == "JOIN" => {
+                    self.next_token();
+                    Join {
+                        relation: self.parse_expr(0)?,
+                        join_operator: JoinOperator::Inner(self.parse_join_constraint(natural)?),
+                    }
+                }
+                Some(Token::Keyword(kw)) if kw == "LEFT" => {
+                    self.next_token();
+                    self.parse_keyword("OUTER");
+                    self.expect_keyword("JOIN")?;
+                    Join {
+                        relation: self.parse_expr(0)?,
+                        join_operator: JoinOperator::LeftOuter(
+                            self.parse_join_constraint(natural)?,
+                        ),
+                    }
+                }
+                Some(Token::Keyword(kw)) if kw == "RIGHT" => {
+                    self.next_token();
+                    self.parse_keyword("OUTER");
+                    self.expect_keyword("JOIN")?;
+                    Join {
+                        relation: self.parse_expr(0)?,
+                        join_operator: JoinOperator::RightOuter(
+                            self.parse_join_constraint(natural)?,
+                        ),
+                    }
+                }
+                Some(Token::Keyword(kw)) if kw == "FULL" => {
+                    self.next_token();
+                    self.parse_keyword("OUTER");
+                    self.expect_keyword("JOIN")?;
+                    Join {
+                        relation: self.parse_expr(0)?,
+                        join_operator: JoinOperator::FullOuter(
+                            self.parse_join_constraint(natural)?,
+                        ),
+                    }
+                }
+                _ => break,
+            };
+            joins.push(join);
+        }
+
+        Ok(joins)
+    }
+
     /// Parse an INSERT statement
     pub fn parse_insert(&mut self) -> Result<ASTNode, ParserError> {
         self.parse_keyword("INTO");