From eaea3f7aae3d72570acb1b8c0258aa562b7499d7 Mon Sep 17 00:00:00 2001
From: kenta okamura <okamura@qoncept.co.jp>
Date: Mon, 11 Oct 2021 18:08:54 +0900
Subject: [PATCH 1/2] fix reverseChunked does not work correctly.

---
 .../PostgresNIO/Data/PostgresData+Numeric.swift   | 15 ++++++---------
 Tests/IntegrationTests/PostgresNIOTests.swift     |  8 ++++++--
 2 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/Sources/PostgresNIO/Data/PostgresData+Numeric.swift b/Sources/PostgresNIO/Data/PostgresData+Numeric.swift
index 5e564d6d..a3a9e65e 100644
--- a/Sources/PostgresNIO/Data/PostgresData+Numeric.swift
+++ b/Sources/PostgresNIO/Data/PostgresData+Numeric.swift
@@ -268,16 +268,13 @@ private extension Collection {
     // splits the collection into chunks of the supplied size
     // if the collection is not evenly divisible, the first chunk will be smaller
     func reverseChunked(by maxSize: Int) -> [SubSequence] {
-        var lastDistance = 0
+        let firstChunkSize = self.count % maxSize
+        if firstChunkSize == 0 {
+            return self.chunked(by: maxSize)
+        }
         var chunkStartIndex = self.startIndex
-        return stride(from: 0, to: self.count, by: maxSize).reversed().map { current in
-            let distance = (self.count - current) - lastDistance
-            lastDistance = distance
-            let chunkEndOffset = Swift.min(
-                self.distance(from: chunkStartIndex, to: self.endIndex),
-                distance
-            )
-            let chunkEndIndex = self.index(chunkStartIndex, offsetBy: chunkEndOffset)
+        return stride(from: firstChunkSize, through: self.count, by: maxSize).map { current in
+            let chunkEndIndex = self.index(self.startIndex, offsetBy: current)
             defer { chunkStartIndex = chunkEndIndex }
             return self[chunkStartIndex..<chunkEndIndex]
         }
diff --git a/Tests/IntegrationTests/PostgresNIOTests.swift b/Tests/IntegrationTests/PostgresNIOTests.swift
index 308ecfee..15e46629 100644
--- a/Tests/IntegrationTests/PostgresNIOTests.swift
+++ b/Tests/IntegrationTests/PostgresNIOTests.swift
@@ -463,20 +463,24 @@ final class PostgresNIOTests: XCTestCase {
         let a = PostgresNumeric(string: "123456.789123")!
         let b = PostgresNumeric(string: "-123456.789123")!
         let c = PostgresNumeric(string: "3.14159265358979")!
+        let d = PostgresNumeric(string: "1234567890123")!
         var rows: PostgresQueryResult?
         XCTAssertNoThrow(rows = try conn?.query("""
         select
             $1::numeric::text as a,
             $2::numeric::text as b,
-            $3::numeric::text as c
+            $3::numeric::text as c,
+            $4::numeric::text as d
         """, [
             .init(numeric: a),
             .init(numeric: b),
-            .init(numeric: c)
+            .init(numeric: c),
+            .init(numeric: d)
         ]).wait())
         XCTAssertEqual(rows?.first?.column("a")?.string, "123456.789123")
         XCTAssertEqual(rows?.first?.column("b")?.string, "-123456.789123")
         XCTAssertEqual(rows?.first?.column("c")?.string, "3.14159265358979")
+        XCTAssertEqual(rows?.first?.column("d")?.string, "1234567890123")
     }
 
     func testMoney() {

From 2b7cb97c72ca35f46db6f777af62819f2060348d Mon Sep 17 00:00:00 2001
From: kenta okamura <okamura@qoncept.co.jp>
Date: Thu, 14 Oct 2021 21:30:26 +0900
Subject: [PATCH 2/2] simpler with sequence and zip

---
 .../Data/PostgresData+Numeric.swift           | 39 ++++++++-----------
 1 file changed, 16 insertions(+), 23 deletions(-)

diff --git a/Sources/PostgresNIO/Data/PostgresData+Numeric.swift b/Sources/PostgresNIO/Data/PostgresData+Numeric.swift
index a3a9e65e..ded3135c 100644
--- a/Sources/PostgresNIO/Data/PostgresData+Numeric.swift
+++ b/Sources/PostgresNIO/Data/PostgresData+Numeric.swift
@@ -251,33 +251,26 @@ extension PostgresData {
 }
 
 private extension Collection {
-    // splits the collection into chunks of the supplied size
-    // if the collection is not evenly divisible, the last chunk will be smaller
+    /// Split the collection into chunks of `maxSize` length each. The last chunk may contain anywhere between 1 and maxSize elements. `maxSize` must be greater than zero.
     func chunked(by maxSize: Int) -> [SubSequence] {
-        return stride(from: 0, to: self.count, by: maxSize).map { current in
-            let chunkStartIndex = self.index(self.startIndex, offsetBy: current)
-            let chunkEndOffset = Swift.min(
-                self.distance(from: chunkStartIndex, to: self.endIndex),
-                maxSize
-            )
-            let chunkEndIndex = self.index(chunkStartIndex, offsetBy: chunkEndOffset)
-            return self[chunkStartIndex..<chunkEndIndex]
+        let terminatorIndex = self.index(self.endIndex, offsetBy: -1, limitedBy: self.startIndex) ?? self.endIndex
+        let strided = Array(sequence(first: self.startIndex) {
+            self.index($0, offsetBy: maxSize, limitedBy: terminatorIndex)
+        })
+        return zip(strided, strided.dropFirst() + CollectionOfOne(self.endIndex)).map {
+            self[$0..<$1]
         }
     }
-    
-    // splits the collection into chunks of the supplied size
-    // if the collection is not evenly divisible, the first chunk will be smaller
+
+    /// Split the collection into chunks of `maxSize` length each. The **first** chunk may contain anywhere between 1 and maxSize elements. `maxSize` must be greater than zero.
     func reverseChunked(by maxSize: Int) -> [SubSequence] {
-        let firstChunkSize = self.count % maxSize
-        if firstChunkSize == 0 {
-            return self.chunked(by: maxSize)
-        }
-        var chunkStartIndex = self.startIndex
-        return stride(from: firstChunkSize, through: self.count, by: maxSize).map { current in
-            let chunkEndIndex = self.index(self.startIndex, offsetBy: current)
-            defer { chunkStartIndex = chunkEndIndex }
-            return self[chunkStartIndex..<chunkEndIndex]
+        let terminatorIndex = self.index(self.startIndex, offsetBy: 1, limitedBy: self.endIndex) ?? self.startIndex
+        let strided = Array(sequence(first: self.endIndex) {
+            self.index($0, offsetBy: -maxSize, limitedBy: terminatorIndex)
+        })
+        return zip(strided, strided.dropFirst() + CollectionOfOne(self.startIndex)).map {
+            self[$1..<$0]
         }
+        .reversed()
     }
 }
-