Merge branch 'master' into materialize-master

Author: benesch

.travis.yml

@@ -49,7 +49,8 @@ script:
   - travis-cargo clippy -- --all-targets --all-features -- -D warnings
   - travis-cargo build
   - travis-cargo test
-  - travis-cargo --only nightly fmt -- -- --check --config-path <(echo 'license_template_path = "HEADER"')
+  - travis-cargo test -- all-features
+  - cargo +nightly fmt -- --check --config-path <(echo 'license_template_path = "HEADER"')
 
 after_success:
   - cargo coveralls --verbose

Cargo.toml

@@ -19,7 +19,7 @@ name = "sqlparser"
 path = "src/lib.rs"
 
 [dependencies]
-bigdecimal = "0.1.0"
+bigdecimal = { version = "0.1.0", optional = true }
 log = "0.4.5"
 
 [dev-dependencies]

src/ast/ddl.rs

@@ -1,3 +1,15 @@
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
 //! AST types specific to CREATE/ALTER variants of [Statement]
 //! (commonly referred to as Data Definition Language, or DDL)
 use super::{display_comma_separated, DataType, Expr, Ident, ObjectName};

src/ast/value.rs

@@ -10,6 +10,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#[cfg(feature = "bigdecimal")]
 use bigdecimal::BigDecimal;
 use std::fmt;
 
@@ -32,10 +33,11 @@ impl fmt::Display for ValueError {
 /// Primitive SQL values such as number and string
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum Value {
-    /// Unsigned integer value
-    Long(u64),
-    /// Unsigned decimal fraction
-    Decimal(BigDecimal),
+    /// Numeric literal
+    #[cfg(not(feature = "bigdecimal"))]
+    Number(String),
+    #[cfg(feature = "bigdecimal")]
+    Number(BigDecimal),
     /// 'string value'
     SingleQuotedString(String),
     /// N'string value'
@@ -70,8 +72,7 @@ impl fmt::Display for Value {
     #[allow(clippy::unneeded_field_pattern)] // want to be warned if we add another field
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Value::Long(v) => write!(f, "{}", v),
-            Value::Decimal(v) => write!(f, "{}", v),
+            Value::Number(v) => write!(f, "{}", v),
             Value::SingleQuotedString(v) => write!(f, "'{}'", escape_single_quote_string(v)),
             Value::NationalStringLiteral(v) => write!(f, "N'{}'", v),
             Value::HexStringLiteral(v) => write!(f, "X'{}'", v),

src/parser.rs

@@ -12,7 +12,6 @@
 
 //! SQL Parser
 
-use bigdecimal::BigDecimal;
 use log::debug;
 
 use super::ast::*;
@@ -1422,13 +1421,12 @@ impl Parser {
                         return parser_err!(format!("No value parser for keyword {}", k.keyword));
                     }
                 },
-                Token::Number(ref n) if n.contains('.') => match n.parse::<BigDecimal>() {
-                    Ok(n) => Ok(Value::Decimal(n)),
-                    Err(e) => parser_err!(format!("Could not parse '{}' as decimal: {}", n, e)),
-                },
-                Token::Number(ref n) => match n.parse::<u64>() {
-                    Ok(n) => Ok(Value::Long(n)),
-                    Err(e) => parser_err!(format!("Could not parse '{}' as u64: {}", n, e)),
+                // The call to n.parse() returns a bigdecimal when the
+                // bigdecimal feature is enabled, and is otherwise a no-op
+                // (i.e., it returns the input string).
+                Token::Number(ref n) => match n.parse() {
+                    Ok(n) => Ok(Value::Number(n)),
+                    Err(e) => parser_err!(format!("Could not parse '{}' as number: {}", n, e)),
                 },
                 Token::SingleQuotedString(ref s) => Ok(Value::SingleQuotedString(s.to_string())),
                 Token::NationalStringLiteral(ref s) => {
@@ -1441,6 +1439,16 @@ impl Parser {
         }
     }
 
+    pub fn parse_number_value(&mut self) -> Result<Value, ParserError> {
+        match self.parse_value()? {
+            v @ Value::Number(_) => Ok(v),
+            _ => {
+                self.prev_token();
+                self.expected("literal number", self.peek_token())
+            }
+        }
+    }
+
     /// Parse an unsigned literal integer/long
     pub fn parse_literal_uint(&mut self) -> Result<u64, ParserError> {
         match self.next_token() {
@@ -1847,7 +1855,7 @@ impl Parser {
                 modes: self.parse_transaction_modes()?,
             })
         } else {
-            self.expected("variable name", self.peek_token())
+            self.expected("equals sign or TO", self.peek_token())
         }
     }
 
@@ -2187,16 +2195,13 @@ impl Parser {
         if self.parse_keyword("ALL") {
             Ok(None)
         } else {
-            self.parse_literal_uint()
-                .map(|n| Some(Expr::Value(Value::Long(n))))
+            Ok(Some(Expr::Value(self.parse_number_value()?)))
         }
     }
 
     /// Parse an OFFSET clause
     pub fn parse_offset(&mut self) -> Result<Expr, ParserError> {
-        let value = self
-            .parse_literal_uint()
-            .map(|n| Expr::Value(Value::Long(n)))?;
+        let value = Expr::Value(self.parse_number_value()?);
         self.expect_one_of_keywords(&["ROW", "ROWS"])?;
         Ok(value)
     }

src/test_utils.rs

@@ -136,3 +136,7 @@ pub fn expr_from_projection(item: &SelectItem) -> &Expr {
         _ => panic!("Expected UnnamedExpr"),
     }
 }
+
+pub fn number(n: &'static str) -> Value {
+    Value::Number(n.parse().unwrap())
+}

src/tokenizer.rs

@@ -789,5 +789,4 @@ mod tests {
         //println!("------------------------------");
         assert_eq!(expected, actual);
     }
-
 }