Merge branch 'master' into not

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "sqlparser"
 description = "Extensible SQL Lexer and Parser with support for ANSI SQL:2011"
-version = "0.1.10-alpha.0"
+version = "0.1.11-alpha.0"
 authors = ["Andy Grove <andygrove73@gmail.com>"]
 homepage = "https://github.com/andygrove/sqlparser-rs"
 documentation = "https://docs.rs/sqlparser/"

README.md

@@ -8,7 +8,7 @@
 
 The goal of this project is to build a SQL lexer and parser capable of parsing SQL that conforms with the [ANSI SQL:2011](https://jakewheat.github.io/sql-overview/sql-2011-foundation-grammar.html#_5_1_sql_terminal_character) standard but also making it easy to support custom dialects so that this crate can be used as a foundation for vendor-specific parsers.
 
-This parser is currently being used by the [DataFusion](https://github.com/datafusion-rs/datafusion) query engine.
+This parser is currently being used by the [DataFusion](https://github.com/andygrove/datafusion) query engine and [LocustDB](https://github.com/cswinter/LocustDB).
 
 ## Example
 

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, LIKE
         ];
     }
 

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

@@ -95,15 +95,7 @@ impl Parser {
                     "INSERT" => Ok(self.parse_insert()?),
                     "ALTER" => Ok(self.parse_alter()?),
                     "COPY" => Ok(self.parse_copy()?),
-                    "TRUE" => {
+                    "TRUE" | "FALSE" | "NULL" => {
-                        self.prev_token();
-                        self.parse_sql_value()
-                    }
-                    "FALSE" => {
-                        self.prev_token();
-                        self.parse_sql_value()
-                    }
-                    "NULL" => {
                         self.prev_token();
                         self.parse_sql_value()
                     }
@@ -120,7 +112,7 @@ impl Parser {
                         self.parse_cast_expression()
                     } else {
                         match self.peek_token() {
-                            Some(Token::LParen) => self.parse_function_or_pg_cast(&id),
+                            Some(Token::LParen) => self.parse_function(&id),
                             Some(Token::Period) => {
                                 let mut id_parts: Vec<String> = vec![id];
                                 while self.peek_token() == Some(Token::Period) {
@@ -140,19 +132,10 @@ impl Parser {
                         }
                     }
                 }
-                Token::Number(_) => {
+                Token::Number(_)
-                    self.prev_token();
+                | Token::String(_)
-                    self.parse_sql_value()
+                | Token::SingleQuotedString(_)
-                }
+                | Token::DoubleQuotedString(_) => {
-                Token::String(_) => {
-                    self.prev_token();
-                    self.parse_sql_value()
-                }
-                Token::SingleQuotedString(_) => {
-                    self.prev_token();
-                    self.parse_sql_value()
-                }
-                Token::DoubleQuotedString(_) => {
                     self.prev_token();
                     self.parse_sql_value()
                 }
@@ -172,15 +155,6 @@ impl Parser {
         }
     }
 
-    pub fn parse_function_or_pg_cast(&mut self, id: &str) -> Result<ASTNode, ParserError> {
-        let func = self.parse_function(&id)?;
-        if let Some(Token::DoubleColon) = self.peek_token() {
-            self.parse_pg_cast(func)
-        } else {
-            Ok(func)
-        }
-    }
-
     pub fn parse_function(&mut self, id: &str) -> Result<ASTNode, ParserError> {
         self.consume_token(&Token::LParen)?;
         if let Ok(true) = self.consume_token(&Token::RParen) {
@@ -245,25 +219,13 @@ impl Parser {
         })
     }
 
-    /// Parse a postgresql casting style which is in the form or expr::datatype
+    /// Parse a postgresql casting style which is in the form of `expr::datatype`
     pub fn parse_pg_cast(&mut self, expr: ASTNode) -> Result<ASTNode, ParserError> {
         let _ = self.consume_token(&Token::DoubleColon)?;
-        let datatype = if let Ok(data_type) = self.parse_data_type() {
+        Ok(ASTNode::SQLCast {
-            Ok(data_type)
-        } else if let Ok(table_name) = self.parse_tablename() {
-            Ok(SQLType::Custom(table_name))
-        } else {
-            parser_err!("Expecting datatype or identifier")
-        };
-        let pg_cast = ASTNode::SQLCast {
             expr: Box::new(expr),
-            data_type: datatype?,
+            data_type: self.parse_data_type()?,
-        };
+        })
-        if let Some(Token::DoubleColon) = self.peek_token() {
-            self.parse_pg_cast(pg_cast)
-        } else {
-            Ok(pg_cast)
-        }
     }
 
     /// Parse an expression infix (typically an operator)
@@ -376,11 +338,17 @@ impl Parser {
         }
     }
 
+    /// Return first non-whitespace token that has not yet been processed
     pub fn peek_token(&self) -> Option<Token> {
-        self.peek_token_skip_whitespace()
+        if let Some(n) = self.til_non_whitespace() {
+            self.token_at(n)
+        } else {
+            None
+        }
     }
 
-    pub fn skip_whitespace(&mut self) -> Option<Token> {
+    /// Get the next token skipping whitespace and increment the token index
+    pub fn next_token(&mut self) -> Option<Token> {
         loop {
             match self.next_token_no_skip() {
                 Some(Token::Whitespace(_)) => {
@@ -420,19 +388,6 @@ impl Parser {
         }
     }
 
-    pub fn peek_token_skip_whitespace(&self) -> Option<Token> {
-        if let Some(n) = self.til_non_whitespace() {
-            self.token_at(n)
-        } else {
-            None
-        }
-    }
-
-    /// Get the next token skipping whitespace and increment the token index
-    pub fn next_token(&mut self) -> Option<Token> {
-        self.skip_whitespace()
-    }
-
     pub fn next_token_no_skip(&mut self) -> Option<Token> {
         if self.index < self.tokens.len() {
             self.index = self.index + 1;
@@ -442,9 +397,9 @@ impl Parser {
         }
     }
 
-    /// if prev token is whitespace skip it
+    /// Push back the last one non-whitespace token
-    /// if prev token is not whitespace skipt it as well
+    pub fn prev_token(&mut self) -> Option<Token> {
-    pub fn prev_token_skip_whitespace(&mut self) -> Option<Token> {
+        // TODO: returned value is unused (available via peek_token)
         loop {
             match self.prev_token_no_skip() {
                 Some(Token::Whitespace(_)) => {
@@ -457,12 +412,8 @@ impl Parser {
         }
     }
 
-    pub fn prev_token(&mut self) -> Option<Token> {
-        self.prev_token_skip_whitespace()
-    }
-
     /// Get the previous token and decrement the token index
-    pub fn prev_token_no_skip(&mut self) -> Option<Token> {
+    fn prev_token_no_skip(&mut self) -> Option<Token> {
         if self.index > 0 {
             self.index = self.index - 1;
             Some(self.tokens[self.index].clone())
@@ -500,6 +451,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
@@ -745,30 +708,13 @@ impl Parser {
                         "NULL" => Ok(Value::Null),
                         _ => return parser_err!(format!("No value parser for keyword {}", k)),
                     },
-                    //TODO: parse the timestamp here
+                    //TODO: parse the timestamp here (see parse_timestamp_value())
                     Token::Number(ref n) if n.contains(".") => match n.parse::<f64>() {
                         Ok(n) => Ok(Value::Double(n)),
-                        Err(e) => {
+                        Err(e) => parser_err!(format!("Could not parse '{}' as i64: {}", n, e)),
-                            let index = self.index;
-                            self.prev_token();
-                            if let Ok(timestamp) = self.parse_timestamp_value() {
-                                println!("timstamp: {:?}", timestamp);
-                                Ok(timestamp)
-                            } else {
-                                self.index = index;
-                                parser_err!(format!("Could not parse '{}' as i64: {}", n, e))
-                            }
-                        }
                     },
                     Token::Number(ref n) => match n.parse::<i64>() {
-                        Ok(n) => {
+                        Ok(n) => Ok(Value::Long(n)),
-                            //                            if let Some(Token::Minus) = self.peek_token() {
-                            //                                self.prev_token();
-                            //                                self.parse_timestamp_value()
-                            //                            } else {
-                            Ok(Value::Long(n))
-                            //                            }
-                        }
                         Err(e) => parser_err!(format!("Could not parse '{}' as i64: {}", n, e)),
                     },
                     Token::Identifier(id) => Ok(Value::String(id.to_string())),
@@ -796,13 +742,13 @@ impl Parser {
         }
     }
 
-    /// Parse a literal integer/long
+    /// Parse a literal double
     pub fn parse_literal_double(&mut self) -> Result<f64, ParserError> {
         match self.next_token() {
             Some(Token::Number(s)) => s.parse::<f64>().map_err(|e| {
-                ParserError::ParserError(format!("Could not parse '{}' as i64: {}", s, e))
+                ParserError::ParserError(format!("Could not parse '{}' as f64: {}", s, e))
             }),
-            other => parser_err!(format!("Expected literal int, found {:?}", other)),
+            other => parser_err!(format!("Expected literal number, found {:?}", other)),
         }
     }
 
@@ -883,19 +829,17 @@ impl Parser {
         self.consume_token(&Token::Colon)?;
         let min = self.parse_literal_int()?;
         self.consume_token(&Token::Colon)?;
+        // On one hand, the SQL specs defines <seconds fraction> ::= <unsigned integer>,
+        // so it would be more correct to parse it as such
         let sec = self.parse_literal_double()?;
-        let _ = (sec.fract() * 1000.0).round();
+        // On the other, chrono only supports nanoseconds, which should(?) fit in seconds-as-f64...
-        if let Ok(true) = self.consume_token(&Token::Period) {
+        let nanos = (sec.fract() * 1_000_000_000.0).round();
-            let ms = self.parse_literal_int()?;
+        Ok(NaiveTime::from_hms_nano(
-            Ok(NaiveTime::from_hms_milli(
             hour as u32,
             min as u32,
             sec as u32,
-                ms as u32,
+            nanos as u32,
         ))
-        } else {
-            Ok(NaiveTime::from_hms(hour as u32, min as u32, sec as u32))
-        }
     }
 
     /// Parse a SQL datatype (in the context of a CREATE TABLE statement for example)
@@ -987,13 +931,10 @@ impl Parser {
                 }
                 _ => parser_err!(format!("Invalid data type '{:?}'", k)),
             },
-            Some(Token::Identifier(id)) => {
+            Some(Token::Identifier(_)) => {
-                if let Ok(true) = self.consume_token(&Token::Period) {
+                self.prev_token();
-                    let ids = self.parse_tablename()?;
+                let type_name = self.parse_tablename()?; // TODO: this actually reads a possibly schema-qualified name of a (custom) type
-                    Ok(SQLType::Custom(format!("{}.{}", id, ids)))
+                Ok(SQLType::Custom(type_name))
-                } else {
-                    Ok(SQLType::Custom(id))
-                }
             }
             other => parser_err!(format!("Invalid data type: '{:?}'", other)),
         }
@@ -1119,11 +1060,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") {
+        let (relation, joins): (Option<Box<ASTNode>>, Vec<Join>) = if self.parse_keyword("FROM") {
-            //TODO: add support for JOIN
+            let relation = Some(Box::new(self.parse_expr(0)?));
-            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") {
@@ -1169,6 +1111,7 @@ impl Parser {
                 projection,
                 selection,
                 relation,
+                joins,
                 limit,
                 order_by,
                 group_by,
@@ -1177,6 +1120,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");

tests/sqlparser_generic.rs

@@ -486,6 +486,150 @@ fn parse_delete_with_semi_colon() {
     }
 }
 
+#[test]
+fn parse_implicit_join() {
+    let sql = "SELECT * FROM t1,t2";
+
+    match parse_sql(sql) {
+        ASTNode::SQLSelect { joins, .. } => {
+            assert_eq!(joins.len(), 1);
+            assert_eq!(
+                joins[0],
+                Join {
+                    relation: ASTNode::SQLIdentifier("t2".to_string()),
+                    join_operator: JoinOperator::Implicit
+                }
+            )
+        }
+        _ => assert!(false),
+    }
+}
+
+#[test]
+fn parse_cross_join() {
+    let sql = "SELECT * FROM t1 CROSS JOIN t2";
+
+    match parse_sql(sql) {
+        ASTNode::SQLSelect { joins, .. } => {
+            assert_eq!(joins.len(), 1);
+            assert_eq!(
+                joins[0],
+                Join {
+                    relation: ASTNode::SQLIdentifier("t2".to_string()),
+                    join_operator: JoinOperator::Cross
+                }
+            )
+        }
+        _ => assert!(false),
+    }
+}
+
+#[test]
+fn parse_joins_on() {
+    fn join_with_constraint(
+        relation: impl Into<String>,
+        f: impl Fn(JoinConstraint) -> JoinOperator,
+    ) -> Join {
+        Join {
+            relation: ASTNode::SQLIdentifier(relation.into()),
+            join_operator: f(JoinConstraint::On(ASTNode::SQLBinaryExpr {
+                left: Box::new(ASTNode::SQLIdentifier("c1".into())),
+                op: SQLOperator::Eq,
+                right: Box::new(ASTNode::SQLIdentifier("c2".into())),
+            })),
+        }
+    }
+    assert_eq!(
+        joins_from(verified("SELECT * FROM t1 JOIN t2 ON c1 = c2")),
+        vec![join_with_constraint("t2", JoinOperator::Inner)]
+    );
+    assert_eq!(
+        joins_from(verified("SELECT * FROM t1 LEFT JOIN t2 ON c1 = c2")),
+        vec![join_with_constraint("t2", JoinOperator::LeftOuter)]
+    );
+    assert_eq!(
+        joins_from(verified("SELECT * FROM t1 RIGHT JOIN t2 ON c1 = c2")),
+        vec![join_with_constraint("t2", JoinOperator::RightOuter)]
+    );
+    assert_eq!(
+        joins_from(verified("SELECT * FROM t1 FULL JOIN t2 ON c1 = c2")),
+        vec![join_with_constraint("t2", JoinOperator::FullOuter)]
+    );
+}
+
+#[test]
+fn parse_joins_using() {
+    fn join_with_constraint(
+        relation: impl Into<String>,
+        f: impl Fn(JoinConstraint) -> JoinOperator,
+    ) -> Join {
+        Join {
+            relation: ASTNode::SQLIdentifier(relation.into()),
+            join_operator: f(JoinConstraint::Using(vec!["c1".into()])),
+        }
+    }
+
+    assert_eq!(
+        joins_from(verified("SELECT * FROM t1 JOIN t2 USING(c1)")),
+        vec![join_with_constraint("t2", JoinOperator::Inner)]
+    );
+    assert_eq!(
+        joins_from(verified("SELECT * FROM t1 LEFT JOIN t2 USING(c1)")),
+        vec![join_with_constraint("t2", JoinOperator::LeftOuter)]
+    );
+    assert_eq!(
+        joins_from(verified("SELECT * FROM t1 RIGHT JOIN t2 USING(c1)")),
+        vec![join_with_constraint("t2", JoinOperator::RightOuter)]
+    );
+    assert_eq!(
+        joins_from(verified("SELECT * FROM t1 FULL JOIN t2 USING(c1)")),
+        vec![join_with_constraint("t2", JoinOperator::FullOuter)]
+    );
+}
+
+#[test]
+fn parse_complex_join() {
+    let sql = "SELECT c1, c2 FROM t1, t4 JOIN t2 ON t2.c = t1.c LEFT JOIN t3 USING(q, c) WHERE t4.c = t1.c";
+    assert_eq!(sql, parse_sql(sql).to_string());
+}
+
+#[test]
+fn parse_join_syntax_variants() {
+    fn parses_to(from: &str, to: &str) {
+        assert_eq!(to, &parse_sql(from).to_string())
+    }
+
+    parses_to(
+        "SELECT c1 FROM t1 INNER JOIN t2 USING(c1)",
+        "SELECT c1 FROM t1 JOIN t2 USING(c1)",
+    );
+    parses_to(
+        "SELECT c1 FROM t1 LEFT OUTER JOIN t2 USING(c1)",
+        "SELECT c1 FROM t1 LEFT JOIN t2 USING(c1)",
+    );
+    parses_to(
+        "SELECT c1 FROM t1 RIGHT OUTER JOIN t2 USING(c1)",
+        "SELECT c1 FROM t1 RIGHT JOIN t2 USING(c1)",
+    );
+    parses_to(
+        "SELECT c1 FROM t1 FULL OUTER JOIN t2 USING(c1)",
+        "SELECT c1 FROM t1 FULL JOIN t2 USING(c1)",
+    );
+}
+
+fn verified(query: &str) -> ASTNode {
+    let ast = parse_sql(query);
+    assert_eq!(query, &ast.to_string());
+    ast
+}
+
+fn joins_from(ast: ASTNode) -> Vec<Join> {
+    match ast {
+        ASTNode::SQLSelect { joins, .. } => joins,
+        _ => panic!("Expected SELECT"),
+    }
+}
+
 fn parse_sql(sql: &str) -> ASTNode {
     let dialect = GenericSqlDialect {};
     let mut tokenizer = Tokenizer::new(&dialect, &sql);

tests/sqlparser_postgres.rs

@@ -517,20 +517,40 @@ fn parse_create_table_from_pg_dump() {
         ASTNode::SQLCreateTable { name, columns } => {
             assert_eq!("public.customer", name);
 
-            let c_name = &columns[0];
+            let c_customer_id = &columns[0];
-            assert_eq!("customer_id", c_name.name);
+            assert_eq!("customer_id", c_customer_id.name);
-            assert_eq!(SQLType::Int, c_name.data_type);
+            assert_eq!(SQLType::Int, c_customer_id.data_type);
-            assert_eq!(false, c_name.allow_null);
+            assert_eq!(false, c_customer_id.allow_null);
 
-            let c_lat = &columns[1];
+            let c_store_id = &columns[1];
-            assert_eq!("store_id", c_lat.name);
+            assert_eq!("store_id", c_store_id.name);
-            assert_eq!(SQLType::SmallInt, c_lat.data_type);
+            assert_eq!(SQLType::SmallInt, c_store_id.data_type);
-            assert_eq!(false, c_lat.allow_null);
+            assert_eq!(false, c_store_id.allow_null);
 
-            let c_lng = &columns[2];
+            let c_first_name = &columns[2];
-            assert_eq!("first_name", c_lng.name);
+            assert_eq!("first_name", c_first_name.name);
-            assert_eq!(SQLType::Varchar(Some(45)), c_lng.data_type);
+            assert_eq!(SQLType::Varchar(Some(45)), c_first_name.data_type);
-            assert_eq!(false, c_lng.allow_null);
+            assert_eq!(false, c_first_name.allow_null);
+
+            let c_create_date1 = &columns[8];
+            assert_eq!(
+                Some(Box::new(ASTNode::SQLCast {
+                    expr: Box::new(ASTNode::SQLCast {
+                        expr: Box::new(ASTNode::SQLValue(Value::SingleQuotedString(
+                            "now".to_string()
+                        ))),
+                        data_type: SQLType::Text
+                    }),
+                    data_type: SQLType::Date
+                })),
+                c_create_date1.default
+            );
+
+            let c_release_year = &columns[10];
+            assert_eq!(
+                SQLType::Custom("public.year".to_string()),
+                c_release_year.data_type
+            );
         }
         _ => assert!(false),
     }
@@ -637,6 +657,7 @@ fn parse_timestamps_example() {
     let sql = "2016-02-15 09:43:33";
     let _ = parse_sql(sql);
     //TODO add assertion
+    //assert_eq!(sql, ast.to_string());
 }
 
 #[test]
@@ -644,6 +665,7 @@ fn parse_timestamps_with_millis_example() {
     let sql = "2017-11-02 19:15:42.308637";
     let _ = parse_sql(sql);
     //TODO add assertion
+    //assert_eq!(sql, ast.to_string());
 }
 
 #[test]
@@ -717,6 +739,150 @@ fn parse_function_now() {
     assert_eq!(sql, ast.to_string());
 }
 
+#[test]
+fn parse_implicit_join() {
+    let sql = "SELECT * FROM t1, t2";
+
+    match verified(sql) {
+        ASTNode::SQLSelect { joins, .. } => {
+            assert_eq!(joins.len(), 1);
+            assert_eq!(
+                joins[0],
+                Join {
+                    relation: ASTNode::SQLIdentifier("t2".to_string()),
+                    join_operator: JoinOperator::Implicit
+                }
+            )
+        }
+        _ => assert!(false),
+    }
+}
+
+#[test]
+fn parse_cross_join() {
+    let sql = "SELECT * FROM t1 CROSS JOIN t2";
+
+    match verified(sql) {
+        ASTNode::SQLSelect { joins, .. } => {
+            assert_eq!(joins.len(), 1);
+            assert_eq!(
+                joins[0],
+                Join {
+                    relation: ASTNode::SQLIdentifier("t2".to_string()),
+                    join_operator: JoinOperator::Cross
+                }
+            )
+        }
+        _ => assert!(false),
+    }
+}
+
+#[test]
+fn parse_joins_on() {
+    fn join_with_constraint(
+        relation: impl Into<String>,
+        f: impl Fn(JoinConstraint) -> JoinOperator,
+    ) -> Join {
+        Join {
+            relation: ASTNode::SQLIdentifier(relation.into()),
+            join_operator: f(JoinConstraint::On(ASTNode::SQLBinaryExpr {
+                left: Box::new(ASTNode::SQLIdentifier("c1".into())),
+                op: SQLOperator::Eq,
+                right: Box::new(ASTNode::SQLIdentifier("c2".into())),
+            })),
+        }
+    }
+    assert_eq!(
+        joins_from(verified("SELECT * FROM t1 JOIN t2 ON c1 = c2")),
+        vec![join_with_constraint("t2", JoinOperator::Inner)]
+    );
+    assert_eq!(
+        joins_from(verified("SELECT * FROM t1 LEFT JOIN t2 ON c1 = c2")),
+        vec![join_with_constraint("t2", JoinOperator::LeftOuter)]
+    );
+    assert_eq!(
+        joins_from(verified("SELECT * FROM t1 RIGHT JOIN t2 ON c1 = c2")),
+        vec![join_with_constraint("t2", JoinOperator::RightOuter)]
+    );
+    assert_eq!(
+        joins_from(verified("SELECT * FROM t1 FULL JOIN t2 ON c1 = c2")),
+        vec![join_with_constraint("t2", JoinOperator::FullOuter)]
+    );
+}
+
+#[test]
+fn parse_joins_using() {
+    fn join_with_constraint(
+        relation: impl Into<String>,
+        f: impl Fn(JoinConstraint) -> JoinOperator,
+    ) -> Join {
+        Join {
+            relation: ASTNode::SQLIdentifier(relation.into()),
+            join_operator: f(JoinConstraint::Using(vec!["c1".into()])),
+        }
+    }
+
+    assert_eq!(
+        joins_from(verified("SELECT * FROM t1 JOIN t2 USING(c1)")),
+        vec![join_with_constraint("t2", JoinOperator::Inner)]
+    );
+    assert_eq!(
+        joins_from(verified("SELECT * FROM t1 LEFT JOIN t2 USING(c1)")),
+        vec![join_with_constraint("t2", JoinOperator::LeftOuter)]
+    );
+    assert_eq!(
+        joins_from(verified("SELECT * FROM t1 RIGHT JOIN t2 USING(c1)")),
+        vec![join_with_constraint("t2", JoinOperator::RightOuter)]
+    );
+    assert_eq!(
+        joins_from(verified("SELECT * FROM t1 FULL JOIN t2 USING(c1)")),
+        vec![join_with_constraint("t2", JoinOperator::FullOuter)]
+    );
+}
+
+#[test]
+fn parse_join_syntax_variants() {
+    fn parses_to(from: &str, to: &str) {
+        assert_eq!(to, &parse_sql(from).to_string())
+    }
+
+    parses_to(
+        "SELECT c1 FROM t1 INNER JOIN t2 USING(c1)",
+        "SELECT c1 FROM t1 JOIN t2 USING(c1)",
+    );
+    parses_to(
+        "SELECT c1 FROM t1 LEFT OUTER JOIN t2 USING(c1)",
+        "SELECT c1 FROM t1 LEFT JOIN t2 USING(c1)",
+    );
+    parses_to(
+        "SELECT c1 FROM t1 RIGHT OUTER JOIN t2 USING(c1)",
+        "SELECT c1 FROM t1 RIGHT JOIN t2 USING(c1)",
+    );
+    parses_to(
+        "SELECT c1 FROM t1 FULL OUTER JOIN t2 USING(c1)",
+        "SELECT c1 FROM t1 FULL JOIN t2 USING(c1)",
+    );
+}
+
+#[test]
+fn parse_complex_join() {
+    let sql = "SELECT c1, c2 FROM t1, t4 JOIN t2 ON t2.c = t1.c LEFT JOIN t3 USING(q, c) WHERE t4.c = t1.c";
+    assert_eq!(sql, parse_sql(sql).to_string());
+}
+
+fn verified(query: &str) -> ASTNode {
+    let ast = parse_sql(query);
+    assert_eq!(query, &ast.to_string());
+    ast
+}
+
+fn joins_from(ast: ASTNode) -> Vec<Join> {
+    match ast {
+        ASTNode::SQLSelect { joins, .. } => joins,
+        _ => panic!("Expected SELECT"),
+    }
+}
+
 fn parse_sql(sql: &str) -> ASTNode {
     debug!("sql: {}", sql);
     let mut parser = parser(sql);