Don't lose precision when parsing decimal fractions

The SQL standard requires that numeric literals with a decimal point,
like 1.23, are represented exactly, up to some precision. That means
that parsing these literals into f64s is invalid, as it is impossible
to represent many decimal numbers exactly in binary floating point (for
example, 0.3).

This commit parses all numeric literals into a new `Value` variant
`Number(String)`, removing the old `Long(u64)` and `Double(f64)`
variants. This is slightly less convenient for downstream consumers, but
far more flexible, as numbers that do not fit into a u64 and f64 are now
representable.

Author: benesch

Cargo.toml

@@ -20,7 +20,6 @@ path = "src/lib.rs"
 
 [dependencies]
 log = "0.4.5"
-ordered-float = "1.0.2"
 
 [dev-dependencies]
 simple_logger = "1.0.1"

src/ast/value.rs

@@ -10,16 +10,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use ordered_float::OrderedFloat;
 use std::fmt;
 
 /// Primitive SQL values such as number and string
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum Value {
-    /// Unsigned integer value
-    Long(u64),
-    /// Unsigned floating point value
-    Double(OrderedFloat<f64>),
+    /// Numeric literal
+    Number(String),
     /// 'string value'
     SingleQuotedString(String),
     /// N'string value'
@@ -60,8 +57,7 @@ pub enum Value {
 impl fmt::Display for Value {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Value::Long(v) => write!(f, "{}", v),
-            Value::Double(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

@@ -1183,14 +1183,7 @@ impl Parser {
                         return parser_err!(format!("No value parser for keyword {}", k.keyword));
                     }
                 },
-                Token::Number(ref n) if n.contains('.') => match n.parse::<f64>() {
-                    Ok(n) => Ok(Value::Double(n.into())),
-                    Err(e) => parser_err!(format!("Could not parse '{}' as f64: {}", 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)),
-                },
+                Token::Number(ref n) => Ok(Value::Number(n.to_string())),
                 Token::SingleQuotedString(ref s) => Ok(Value::SingleQuotedString(s.to_string())),
                 Token::NationalStringLiteral(ref s) => {
                     Ok(Value::NationalStringLiteral(s.to_string()))
@@ -1864,15 +1857,15 @@ impl Parser {
             Ok(None)
         } else {
             self.parse_literal_uint()
-                .map(|n| Some(Expr::Value(Value::Long(n))))
+                .map(|n| Some(Expr::Value(Value::Number(n.to_string()))))
         }
     }
 
     /// 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)))?;
+            .map(|n| Expr::Value(Value::Number(n.to_string())))?;
         self.expect_one_of_keywords(&["ROW", "ROWS"])?;
         Ok(value)
     }