Fix parsing of negative values

Author: Agaev Huseyn

src/parser/mod.rs

@@ -7274,22 +7274,6 @@ impl<'a> Parser<'a> {
                 let placeholder = tok.to_string() + &ident.value;
                 Ok(Value::Placeholder(placeholder))
             }
-            tok @ Token::Minus | tok @ Token::Plus => {
-                let next_token = self.next_token();
-                match next_token.token {
-                    Token::Number(n, l) => {
-                        if tok == Token::Minus {
-                            Ok(Value::Number(
-                                Self::parse(tok.to_string() + &n, location)?,
-                                l,
-                            ))
-                        } else {
-                            Ok(Value::Number(Self::parse(n, location)?, l))
-                        }
-                    }
-                    _ => self.expected("number", next_token),
-                }
-            }
             unexpected => self.expected(
                 "a value",
                 TokenWithLocation {
@@ -7300,6 +7284,7 @@ impl<'a> Parser<'a> {
         }
     }
 
+    /// Parse an unsigned numeric literal
     pub fn parse_number_value(&mut self) -> Result<Value, ParserError> {
         match self.parse_value()? {
             v @ Value::Number(_, _) => Ok(v),
@@ -7311,6 +7296,26 @@ impl<'a> Parser<'a> {
         }
     }
 
+    /// Parse a numeric literal and return Expr::UnaryOp if the number is signed,
+    /// otherwise return Expr::Value
+    pub fn parse_number_value_with_sign(&mut self) -> Result<Expr, ParserError> {
+        let next_token = self.next_token();
+        match next_token.token {
+            Token::Plus => Ok(Expr::UnaryOp {
+                op: UnaryOperator::Plus,
+                expr: Box::new(Expr::Value(self.parse_number_value()?)),
+            }),
+            Token::Minus => Ok(Expr::UnaryOp {
+                op: UnaryOperator::Minus,
+                expr: Box::new(Expr::Value(self.parse_number_value()?)),
+            }),
+            _ => {
+                self.prev_token();
+                Ok(Expr::Value(self.parse_number_value()?))
+            }
+        }
+    }
+
     fn parse_introduced_string_value(&mut self) -> Result<Value, ParserError> {
         let next_token = self.next_token();
         let location = next_token.location;
@@ -11625,29 +11630,29 @@ impl<'a> Parser<'a> {
         if self.parse_keywords(&[Keyword::INCREMENT]) {
             if self.parse_keywords(&[Keyword::BY]) {
                 sequence_options.push(SequenceOptions::IncrementBy(
-                    Expr::Value(self.parse_number_value()?),
+                    self.parse_number_value_with_sign()?,
                     true,
                 ));
             } else {
                 sequence_options.push(SequenceOptions::IncrementBy(
-                    Expr::Value(self.parse_number_value()?),
+                    self.parse_number_value_with_sign()?,
                     false,
                 ));
             }
         }
         //[ MINVALUE minvalue | NO MINVALUE ]
         if self.parse_keyword(Keyword::MINVALUE) {
-            sequence_options.push(SequenceOptions::MinValue(Some(Expr::Value(
-                self.parse_number_value()?,
-            ))));
+            sequence_options.push(SequenceOptions::MinValue(Some(
+                self.parse_number_value_with_sign()?,
+            )));
         } else if self.parse_keywords(&[Keyword::NO, Keyword::MINVALUE]) {
             sequence_options.push(SequenceOptions::MinValue(None));
         }
         //[ MAXVALUE maxvalue | NO MAXVALUE ]
         if self.parse_keywords(&[Keyword::MAXVALUE]) {
-            sequence_options.push(SequenceOptions::MaxValue(Some(Expr::Value(
-                self.parse_number_value()?,
-            ))));
+            sequence_options.push(SequenceOptions::MaxValue(Some(
+                self.parse_number_value_with_sign()?,
+            )));
         } else if self.parse_keywords(&[Keyword::NO, Keyword::MAXVALUE]) {
             sequence_options.push(SequenceOptions::MaxValue(None));
         }
@@ -11656,21 +11661,19 @@ impl<'a> Parser<'a> {
         if self.parse_keywords(&[Keyword::START]) {
             if self.parse_keywords(&[Keyword::WITH]) {
                 sequence_options.push(SequenceOptions::StartWith(
-                    Expr::Value(self.parse_number_value()?),
+                    self.parse_number_value_with_sign()?,
                     true,
                 ));
             } else {
                 sequence_options.push(SequenceOptions::StartWith(
-                    Expr::Value(self.parse_number_value()?),
+                    self.parse_number_value_with_sign()?,
                     false,
                 ));
             }
         }
         //[ CACHE cache ]
         if self.parse_keywords(&[Keyword::CACHE]) {
-            sequence_options.push(SequenceOptions::Cache(Expr::Value(
-                self.parse_number_value()?,
-            )));
+            sequence_options.push(SequenceOptions::Cache(self.parse_number_value_with_sign()?));
         }
         // [ [ NO ] CYCLE ]
         if self.parse_keywords(&[Keyword::NO, Keyword::CYCLE]) {

tests/sqlparser_common.rs

@@ -2820,35 +2820,15 @@ fn parse_window_function_null_treatment_arg() {
 }
 
 #[test]
-fn parse_signed_value() {
-    let sql1 = "CREATE SEQUENCE name1
-    AS BIGINT
-    INCREMENT   -15
-    MINVALUE - 2000  MAXVALUE -50
-    START WITH -   60";
-    one_statement_parses_to(
-        sql1,
-        "CREATE SEQUENCE name1 AS BIGINT INCREMENT -15 MINVALUE -2000 MAXVALUE -50 START WITH -60",
-    );
+fn parse_negative_value() {
+    let sql1 = "SELECT -1";
+    one_statement_parses_to(sql1, "SELECT -1");
 
-    let sql2 = "CREATE SEQUENCE name2
-    AS BIGINT
-    INCREMENT   +10
-    MINVALUE + 30  MAXVALUE +5000
-    START WITH +   45";
+    let sql2 = "CREATE SEQUENCE name INCREMENT -10 MINVALUE -1000 MAXVALUE 15 START -100;";
     one_statement_parses_to(
         sql2,
-        "CREATE SEQUENCE name2 AS BIGINT INCREMENT 10 MINVALUE 30 MAXVALUE 5000 START WITH 45",
-    );
-
-    let sql3 = "CREATE SEQUENCE name3 INCREMENT -10 MINVALUE -1000 MAXVALUE 1 START -100;";
-    one_statement_parses_to(
-        sql3,
-        "CREATE SEQUENCE name3 INCREMENT -10 MINVALUE -1000 MAXVALUE 1 START -100",
+        "CREATE SEQUENCE name INCREMENT -10 MINVALUE -1000 MAXVALUE 15 START -100",
     );
-
-    let sql4 = "SELECT -1";
-    one_statement_parses_to(sql4, "SELECT -1");
 }
 
 #[test]

tests/sqlparser_postgres.rs

@@ -277,6 +277,26 @@ fn parse_create_sequence() {
         "CREATE TEMPORARY SEQUENCE IF NOT EXISTS name3 INCREMENT 1 NO MINVALUE MAXVALUE 20 OWNED BY NONE",
     );
 
+    let sql7 = "CREATE SEQUENCE name4
+    AS BIGINT
+    INCREMENT   -15
+    MINVALUE - 2000  MAXVALUE -50
+    START WITH -   60";
+    pg().one_statement_parses_to(
+        sql7,
+        "CREATE SEQUENCE name4 AS BIGINT INCREMENT -15 MINVALUE -2000 MAXVALUE -50 START WITH -60",
+    );
+
+    let sql8 = "CREATE SEQUENCE name5
+    AS BIGINT
+    INCREMENT   +10
+    MINVALUE + 30  MAXVALUE +5000
+    START WITH +   45";
+    pg().one_statement_parses_to(
+        sql8,
+        "CREATE SEQUENCE name5 AS BIGINT INCREMENT +10 MINVALUE +30 MAXVALUE +5000 START WITH +45",
+    );
+
     assert!(matches!(
         pg().parse_sql_statements("CREATE SEQUENCE foo INCREMENT 1 NO MINVALUE NO"),
         Err(ParserError::ParserError(_))