Merge branch 'sqlparser-rs:main' into main

Author: BohuTANG

CHANGELOG.md

@@ -8,6 +8,15 @@ Given that the parser produces a typed AST, any changes to the AST will technica
 ## [Unreleased]
 Check https://github.com/sqlparser-rs/sqlparser-rs/commits/main for undocumented changes.
 
+## [0.12.0] 2020-10-14
+
+### Added
+* Add support for [NOT] IS DISTINCT FROM (#306) - @Dandandan
+
+### Changed
+* Move the keywords module - Thanks @koushiro!
+
+
 ## [0.11.0] 2020-09-24
 
 ### Added

docs/releasing.md

@@ -31,8 +31,8 @@ $ cargo install cargo-release
     $ cargo release minor --push-remote upstream
     ```
 
-    You can add `--dry-run` to see what the command is going to do,
-    or `--skip-push` to stop before actually publishing the release.
+    After verifying, you can rerun with `--execute` if all looks good. 
+    You can add `--no-push` to stop before actually publishing the release.
 
     `cargo release` will then:
 

src/ast/mod.rs

@@ -169,10 +169,14 @@ pub enum Expr {
     QualifiedWildcard(Vec<Ident>),
     /// Multi-part identifier, e.g. `table_alias.column` or `schema.table.col`
     CompoundIdentifier(Vec<Ident>),
-    /// `IS NULL` expression
+    /// `IS NULL` operator
     IsNull(Box<Expr>),
-    /// `IS NOT NULL` expression
+    /// `IS NOT NULL` operator
     IsNotNull(Box<Expr>),
+    /// `IS DISTINCT FROM` operator
+    IsDistinctFrom(Box<Expr>, Box<Expr>),
+    /// `IS NOT DISTINCT FROM` operator
+    IsNotDistinctFrom(Box<Expr>, Box<Expr>),
     /// `[ NOT ] IN (val1, val2, ...)`
     InList {
         expr: Box<Expr>,
@@ -387,6 +391,8 @@ impl fmt::Display for Expr {
 
                 write!(f, ")")
             }
+            Expr::IsDistinctFrom(a, b) => write!(f, "{} IS DISTINCT FROM {}", a, b),
+            Expr::IsNotDistinctFrom(a, b) => write!(f, "{} IS NOT DISTINCT FROM {}", a, b),
             Expr::Trim { expr, trim_where } => {
                 write!(f, "TRIM(")?;
                 if let Some((ident, trim_char)) = trim_where {

src/dialect/mod.rs

@@ -87,9 +87,8 @@ mod tests {
 
         assert!(dialect_of!(generic_holder is GenericDialect |  AnsiDialect),);
         assert!(!dialect_of!(generic_holder is  AnsiDialect));
-
-        assert!(dialect_of!(ansi_holder is  AnsiDialect));
-        assert!(dialect_of!(ansi_holder is  GenericDialect | AnsiDialect),);
-        assert!(!dialect_of!(ansi_holder is  GenericDialect | MsSqlDialect),);
+        assert!(dialect_of!(ansi_holder is AnsiDialect));
+        assert!(dialect_of!(ansi_holder is GenericDialect | AnsiDialect));
+        assert!(!dialect_of!(ansi_holder is GenericDialect | MsSqlDialect));
     }
 }

src/parser.rs

@@ -935,8 +935,18 @@ impl<'a> Parser<'a> {
                         Ok(Expr::IsNull(Box::new(expr)))
                     } else if self.parse_keywords(&[Keyword::NOT, Keyword::NULL]) {
                         Ok(Expr::IsNotNull(Box::new(expr)))
+                    } else if self.parse_keywords(&[Keyword::DISTINCT, Keyword::FROM]) {
+                        let expr2 = self.parse_expr()?;
+                        Ok(Expr::IsDistinctFrom(Box::new(expr), Box::new(expr2)))
+                    } else if self.parse_keywords(&[Keyword::NOT, Keyword::DISTINCT, Keyword::FROM])
+                    {
+                        let expr2 = self.parse_expr()?;
+                        Ok(Expr::IsNotDistinctFrom(Box::new(expr), Box::new(expr2)))
                     } else {
-                        self.expected("NULL or NOT NULL after IS", self.peek_token())
+                        self.expected(
+                            "[NOT] NULL or [NOT] DISTINCT FROM after IS",
+                            self.peek_token(),
+                        )
                     }
                 }
                 Keyword::NOT | Keyword::IN | Keyword::BETWEEN => {

tests/sqlparser_common.rs

@@ -642,6 +642,31 @@ fn parse_is_not_null() {
     );
 }
 
+#[test]
+fn parse_is_distinct_from() {
+    use self::Expr::*;
+    let sql = "a IS DISTINCT FROM b";
+    assert_eq!(
+        IsDistinctFrom(
+            Box::new(Identifier(Ident::new("a"))),
+            Box::new(Identifier(Ident::new("b")))
+        ),
+        verified_expr(sql)
+    );
+}
+#[test]
+fn parse_is_not_distinct_from() {
+    use self::Expr::*;
+    let sql = "a IS NOT DISTINCT FROM b";
+    assert_eq!(
+        IsNotDistinctFrom(
+            Box::new(Identifier(Ident::new("a"))),
+            Box::new(Identifier(Ident::new("b")))
+        ),
+        verified_expr(sql)
+    );
+}
+
 #[test]
 fn parse_not_precedence() {
     // NOT has higher precedence than OR/AND, so the following must parse as (NOT true) OR true