Merge pull request apache#9 from mshauneu/main

add DIV operator

Author: sundy-li

src/ast/operator.rs

@@ -60,6 +60,7 @@ pub enum BinaryOperator {
     Minus,
     Multiply,
     Divide,
+    Div,
     Modulo,
     StringConcat,
     Gt,
@@ -95,6 +96,7 @@ impl fmt::Display for BinaryOperator {
             BinaryOperator::Minus => "-",
             BinaryOperator::Multiply => "*",
             BinaryOperator::Divide => "/",
+            BinaryOperator::Div => "DIV",
             BinaryOperator::Modulo => "%",
             BinaryOperator::StringConcat => "||",
             BinaryOperator::Gt => ">",

src/keywords.rs

@@ -179,6 +179,7 @@ define_keywords!(
     DISCONNECT,
     DISTINCT,
     DISTRIBUTE,
+    DIV,
     DOUBLE,
     DROP,
     DYNAMIC,

src/parser.rs

@@ -893,7 +893,7 @@ impl<'a> Parser<'a> {
             Token::Pipe => Some(BinaryOperator::BitwiseOr),
             Token::Caret => Some(BinaryOperator::BitwiseXor),
             Token::Ampersand => Some(BinaryOperator::BitwiseAnd),
-            Token::Div => Some(BinaryOperator::Divide),
+            Token::Divide => Some(BinaryOperator::Divide),
             Token::ShiftLeft if dialect_of!(self is PostgreSqlDialect) => {
                 Some(BinaryOperator::PGBitwiseShiftLeft)
             }
@@ -908,6 +908,7 @@ impl<'a> Parser<'a> {
             Token::ExclamationMarkTilde => Some(BinaryOperator::PGRegexNotMatch),
             Token::ExclamationMarkTildeAsterisk => Some(BinaryOperator::PGRegexNotIMatch),
             Token::Word(w) => match w.keyword {
+                Keyword::DIV => Some(BinaryOperator::Div),
                 Keyword::AND => Some(BinaryOperator::And),
                 Keyword::OR => Some(BinaryOperator::Or),
                 Keyword::LIKE => Some(BinaryOperator::Like),
@@ -1077,6 +1078,7 @@ impl<'a> Parser<'a> {
             Token::Word(w) if w.keyword == Keyword::BETWEEN => Ok(Self::BETWEEN_PREC),
             Token::Word(w) if w.keyword == Keyword::LIKE => Ok(Self::BETWEEN_PREC),
             Token::Word(w) if w.keyword == Keyword::ILIKE => Ok(Self::BETWEEN_PREC),
+            Token::Word(w) if w.keyword == Keyword::DIV => Ok(40),
             Token::Eq
             | Token::Lt
             | Token::LtEq
@@ -1093,7 +1095,7 @@ impl<'a> Parser<'a> {
             Token::Caret | Token::Sharp | Token::ShiftRight | Token::ShiftLeft => Ok(22),
             Token::Ampersand => Ok(23),
             Token::Plus | Token::Minus => Ok(Self::PLUS_MINUS_PREC),
-            Token::Mul | Token::Div | Token::Mod | Token::StringConcat => Ok(40),
+            Token::Mul | Token::Divide | Token::Mod | Token::StringConcat => Ok(40),
             Token::DoubleColon => Ok(50),
             Token::ExclamationMark => Ok(50),
             Token::LBracket | Token::RBracket => Ok(10),

src/tokenizer.rs

@@ -81,7 +81,7 @@ pub enum Token {
     /// Multiplication operator `*`
     Mul,
     /// Division operator `/`
-    Div,
+    Divide,
     /// Modulo Operator `%`
     Mod,
     /// String concatenation `||`
@@ -166,7 +166,7 @@ impl fmt::Display for Token {
             Token::Plus => f.write_str("+"),
             Token::Minus => f.write_str("-"),
             Token::Mul => f.write_str("*"),
-            Token::Div => f.write_str("/"),
+            Token::Divide => f.write_str("/"),
             Token::StringConcat => f.write_str("||"),
             Token::Mod => f.write_str("%"),
             Token::LParen => f.write_str("("),
@@ -504,7 +504,7 @@ impl<'a> Tokenizer<'a> {
                             })))
                         }
                         // a regular '/' operator
-                        _ => Ok(Some(Token::Div)),
+                        _ => Ok(Some(Token::Divide)),
                     }
                 }
                 '+' => self.consume_and_return(chars, Token::Plus),

tests/sqlparser_common.rs

@@ -602,6 +602,25 @@ fn parse_compound_expr_2() {
     );
 }
 
+#[test]
+fn parse_compound_expr_3() {
+    use self::BinaryOperator::*;
+    use self::Expr::*;
+    let sql = "a + b DIV c";
+    assert_eq!(
+        BinaryOp {
+            left: Box::new(Identifier(Ident::new("a"))),
+            op: Plus,
+            right: Box::new(BinaryOp {
+                left: Box::new(Identifier(Ident::new("b"))),
+                op: Div,
+                right: Box::new(Identifier(Ident::new("c")))
+            })
+        },
+        verified_expr(sql)
+    );
+}
+
 #[test]
 fn parse_unary_math() {
     use self::Expr::*;