Added fast paths for scanning from the beginning or end of an index

Author: dimitribouniol

Sources/CodableDatastore/Persistence/Disk Persistence/Datastore/DatastoreIndex.swift

@@ -491,6 +491,52 @@ extension DiskPersistence.Datastore.Index {
         throw DatastoreInterfaceError.instanceNotFound
     }
 
+    var firstInsertionCursor: DiskPersistence.InsertionCursor {
+        get {
+            DiskPersistence.InsertionCursor(
+                persistence: datastore.snapshot.persistence,
+                datastore: datastore,
+                index: self,
+                insertAfter: nil
+            )
+        }
+    }
+    
+    var lastInsertionCursor: DiskPersistence.InsertionCursor {
+        get async throws {
+            let pages = try await manifest.orderedPages
+            var pageIndex = pages.count - 1
+            
+            for pageInfo in pages.reversed() {
+                defer { pageIndex -= 1 }
+                
+                let page: DiskPersistence.Datastore.Page
+                switch pageInfo {
+                case .removed: continue
+                case .existing(let pageID), .added(let pageID):
+                    page = await datastore.page(for: .init(index: self.id, page: pageID))
+                }
+                
+                let blocks = try await page.blocks.reduce(into: []) { $0.append($1) }
+                guard !blocks.isEmpty else { throw DiskPersistenceError.invalidPageFormat }
+                
+                return DiskPersistence.InsertionCursor(
+                    persistence: datastore.snapshot.persistence,
+                    datastore: datastore,
+                    index: self,
+                    insertAfter: DiskPersistence.CursorBlock(
+                        pageIndex: pageIndex,
+                        page: page,
+                        blockIndex: blocks.count - 1
+                    )
+                )
+            }
+            
+            /// Couldn't find a last page, so the cursor is the same as the first insertion cursor.
+            return firstInsertionCursor
+        }
+    }
+    
     func insertionCursor<T>(
         for proposedEntry: T,
         comparator: (_ lhs: T, _ rhs: DatastorePageEntry) throws -> SortOrder

Sources/CodableDatastore/Persistence/Disk Persistence/Transaction/Transaction.swift

@@ -658,10 +658,15 @@ extension DiskPersistence.Transaction {
 
         switch range.order {
         case .ascending:
-            let startCursor = try await index.insertionCursor(
-                for: (range.lowerBoundExpression, range.order),
-                comparator: primaryIndexBoundComparator
-            )
+            let startCursor: DiskPersistence.InsertionCursor
+            if range.lowerBoundExpression == .extent {
+                startCursor = await index.firstInsertionCursor
+            } else {
+                startCursor = try await index.insertionCursor(
+                    for: (range.lowerBoundExpression, range.order),
+                    comparator: primaryIndexBoundComparator
+                )
+            }
 
             try await index.forwardScanEntries(after: startCursor) { entry in
                 guard case .descending = try primaryIndexBoundComparator(
@@ -677,10 +682,15 @@ extension DiskPersistence.Transaction {
                 return true
             }
         case .descending:
-            let startCursor = try await index.insertionCursor(
-                for: (range.upperBoundExpression, range.order),
-                comparator: primaryIndexBoundComparator
-            )
+            let startCursor: DiskPersistence.InsertionCursor
+            if range.upperBoundExpression == .extent {
+                startCursor = try await index.lastInsertionCursor
+            } else {
+                startCursor = try await index.insertionCursor(
+                    for: (range.upperBoundExpression, range.order),
+                    comparator: primaryIndexBoundComparator
+                )
+            }
 
             try await index.backwardScanEntries(before: startCursor) { entry in
                 guard case .ascending = try primaryIndexBoundComparator(