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 instead parses these literals into a big decimal type that
is capable of representing every decimal fraction exactly. Downstream
consumers can lower this representation into something more efficient
but less precise (like the old f64) if desired.

Author: benesch

Cargo.toml

@@ -19,8 +19,8 @@ name = "sqlparser"
 path = "src/lib.rs"
 
 [dependencies]
+bigdecimal = "0.1.0"
 log = "0.4.5"
-ordered-float = "1.0.2"
 
 [dev-dependencies]
 simple_logger = "1.0.1"

src/ast/value.rs

@@ -10,16 +10,16 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use ordered_float::OrderedFloat;
+use bigdecimal::BigDecimal;
 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>),
+    /// Unsigned decimal fraction
+    Decimal(BigDecimal),
     /// 'string value'
     SingleQuotedString(String),
     /// N'string value'
@@ -61,7 +61,7 @@ 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::Decimal(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,6 +12,7 @@
 
 //! SQL Parser
 
+use bigdecimal::BigDecimal;
 use log::debug;
 
 use super::ast::*;
@@ -1236,9 +1237,9 @@ 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) 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)),

tests/sqlparser_common.rs

@@ -1178,6 +1178,23 @@ fn parse_aggregate_with_group_by() {
     //TODO: assertions
 }
 
+#[test]
+fn parse_literal_decimal() {
+    // These numbers were explicitly chosen to not roundtrip if represented as
+    // f64s (i.e., as 64-bit binary floating point numbers).
+    let sql = "SELECT 0.300000000000000004, 9007199254740993.0";
+    let select = verified_only_select(sql);
+    assert_eq!(2, select.projection.len());
+    assert_eq!(
+        &Expr::Value(Value::Decimal("0.300000000000000004".parse().unwrap())),
+        expr_from_projection(&select.projection[0]),
+    );
+    assert_eq!(
+        &Expr::Value(Value::Decimal("9007199254740993.0".parse().unwrap())),
+        expr_from_projection(&select.projection[1]),
+    )
+}
+
 #[test]
 fn parse_literal_string() {
     let sql = "SELECT 'one', N'national string', X'deadBEEF'";