Fix Numeric String Serialization (#78)

* fix numeric serialization where many zeroes come after integer or before fraction

* remove debug print

* cleanup code comments

* test 1_000_000 numerics on linux

* comment out slow test

Author: tanner0101

Sources/PostgresNIO/Data/PostgresData+Numeric.swift

@@ -18,12 +18,17 @@ public struct PostgresNumeric: CustomStringConvertible, CustomDebugStringConvert
     }
 
     public var debugDescription: String {
+        var copy = self.value
+        var values: [Int16] = []
+        while let value = copy.readInteger(endianness: .big, as: Int16.self) {
+            values.append(value)
+        }
         return """
         ndigits: \(self.ndigits)
         weight: \(self.weight)
         sign: \(self.sign)
         dscale: \(self.dscale)
-        value: \(self.value.debugDescription)
+        value: \(values)
         """
     }
 
@@ -122,56 +127,73 @@ public struct PostgresNumeric: CustomStringConvertible, CustomDebugStringConvert
         guard self.ndigits > 0 else {
             return "0"
         }
+        // print(self.debugDescription)
 
+        // Digits before the decimal point.
         var integer = ""
+
+        // Digits after the decimal point.
         var fractional = ""
 
+        // Consume digits from the value buffer.
         var value = self.value
         for offset in 0..<self.ndigits {
-            /// extract current char and advance memory
             let char = value.readInteger(endianness: .big, as: Int16.self) ?? 0
 
-            /// convert the current char to its string form
-            let string: String
-            if char == 0 {
-                /// 0 means 4 zeros
-                string = "0000"
+            // Depending on offset, append value before or after the decimal point.
+            if self.weight - offset >= 0 {
+                if offset == 0 {
+                    // First integer offset doesn't have trailing zeroes.
+                    integer += char.description
+                } else {
+                    integer += String(repeating: "0", count: 4 - char.description.count) + char.description
+                }
             } else {
-                string = char.description
+                fractional += String(repeating: "0", count: 4 - char.description.count)
+                    + char.description
             }
+        }
 
-            /// depending on our offset, append the string to before or after the decimal point
-            if offset < self.weight + 1 {
-                // insert zeros (skip leading)
-                if offset > 0 {
-                    integer += String(repeating: "0", count: 4 - string.count)
+        // Check for any remaining zeroes required before or after decimal point.
+        let offset: Int16
+        if self.weight > 0 {
+            offset = (self.weight + 1) - self.ndigits
+        } else {
+            offset = abs(self.weight) - self.ndigits
+        }
+        if offset > 0 {
+            for _ in 0..<offset {
+                if self.weight > 0 {
+                    integer = integer + "0000"
+                } else {
+                    fractional = "0000" + fractional
                 }
-                integer += string
-            } else {
-                // leading zeros matter with fractional
-                fractional += String(repeating: "0", count: 4 - string.count) + string
             }
         }
 
+        // Prevent fraction without leading "0"
         if integer.count == 0 {
             integer = "0"
         }
 
+        // Remove extraneous zeroes at the end of the fraction.
         if fractional.count > self.dscale {
-            /// use the dscale to remove extraneous zeroes at the end of the fractional part
-            let lastSignificantIndex = fractional.index(fractional.startIndex, offsetBy: Int(self.dscale))
-            fractional = String(fractional[..<lastSignificantIndex])
+            let lastSignificant = fractional.index(
+                fractional.startIndex,
+                offsetBy: Int(self.dscale)
+            )
+            fractional = String(fractional[..<lastSignificant])
         }
 
-        /// determine whether fraction is empty and dynamically add `.`
+        // Determine whether fraction is empty to add decimal point.
         let numeric: String
         if fractional != "" {
             numeric = integer + "." + fractional
         } else {
             numeric = integer
         }
 
-        /// use sign to determine adding a leading `-`
+        // Indicate whether or not the value is negative.
         if (self.sign & 0x4000) != 0 {
             return "-" + numeric
         } else {

Tests/PostgresNIOTests/PostgresNIOTests.swift

@@ -378,12 +378,60 @@ final class PostgresNIOTests: XCTestCase {
             '1234.5678'::numeric as a,
             '-123.456'::numeric as b,
             '123456.789123'::numeric as c,
-            '3.14159265358979'::numeric as d
+            '3.14159265358979'::numeric as d,
+            '10000'::numeric as e,
+            '0.00001'::numeric as f,
+            '100000000'::numeric as g,
+            '0.000000001'::numeric as h,
+            '100000000000'::numeric as i,
+            '0.000000000001'::numeric as j,
+            '123000000000'::numeric as k,
+            '0.000000000123'::numeric as l,
+            '0.5'::numeric as m
         """).wait()
         XCTAssertEqual(rows[0].column("a")?.string, "1234.5678")
         XCTAssertEqual(rows[0].column("b")?.string, "-123.456")
         XCTAssertEqual(rows[0].column("c")?.string, "123456.789123")
         XCTAssertEqual(rows[0].column("d")?.string, "3.14159265358979")
+        XCTAssertEqual(rows[0].column("e")?.string, "10000")
+        XCTAssertEqual(rows[0].column("f")?.string, "0.00001")
+        XCTAssertEqual(rows[0].column("g")?.string, "100000000")
+        XCTAssertEqual(rows[0].column("h")?.string, "0.000000001")
+        XCTAssertEqual(rows[0].column("k")?.string, "123000000000")
+        XCTAssertEqual(rows[0].column("l")?.string, "0.000000000123")
+        XCTAssertEqual(rows[0].column("m")?.string, "0.5")
+    }
+
+    func testSingleNumericParsing() throws {
+        // this seemingly duped test is useful for debugging numeric parsing
+        let conn = try PostgresConnection.test(on: eventLoop).wait()
+        defer { try! conn.close().wait() }
+        let numeric = "790226039477542363.6032384900176272473"
+        let rows = try conn.query("""
+        select
+            '\(numeric)'::numeric as n
+        """).wait()
+        XCTAssertEqual(rows[0].column("n")?.string, numeric)
+    }
+
+    func testRandomlyGeneratedNumericParsing() throws {
+        // this test takes a long time to run
+        return
+
+        let conn = try PostgresConnection.test(on: eventLoop).wait()
+        defer { try! conn.close().wait() }
+
+        for _ in 0..<1_000_000 {
+            let integer = UInt.random(in: UInt.min..<UInt.max)
+            let fraction = UInt.random(in: UInt.min..<UInt.max)
+            let number = "\(integer).\(fraction)"
+                .trimmingCharacters(in: CharacterSet(["0"]))
+            let rows = try conn.query("""
+            select
+                '\(number)'::numeric as n
+            """).wait()
+            XCTAssertEqual(rows[0].column("n")?.string, number)
+        }
     }
 
     func testNumericSerialization() throws {