     }
 }
 
+public final class DropFirstCursor<Base: Cursor> : Cursor {
+    private var base: Base
+    private let limit: Int
+    private var dropped: Int = 0
+
+    init(_ base: Base, limit: Int) {
+        GRDBPrecondition(limit >= 0, "Can't drop a negative number of elements from a cursor")
+        self.base = base
+        self.limit = limit
+    }
+    
+    public func next() throws -> Base.Element? {
+        while dropped < limit {
+            if try base.next() == nil {
+                dropped = limit
+                return nil
+            }
+            dropped += 1
+        }
+        return try base.next()
+    }
+}
+
 /// A cursor whose elements consist of the elements that follow the initial
 /// consecutive elements of some base cursor that satisfy a given predicate.
 public final class DropWhileCursor<Base: Cursor> : Cursor {

        return DropWhileCursor(self, predicate: predicate)
    }
    
    /// Returns a cursor over the concatenated results of mapping transform
    /// over self.
    public func flatMap<SegmentOfResult: Sequence>(_ transform: @escaping (Element) throws -> SegmentOfResult) -> FlattenCursor<MapCursor<Self, IteratorCursor<SegmentOfResult.Iterator>>> {

    /// cursor.
    ///
    ///     let numbers = IteratorCursor([1, 2, 3, 4, 5])
    ///     try print(numbers.suffix(2))
    ///     // Prints "[4, 5]"
    ///     try print(numbers.suffix(10))
    ///     // Prints "[1, 2, 3, 4, 5]"
    ///
    /// - Parameter maxLength: The maximum number of elements to return. The
    ///   value of `maxLength` must be greater than or equal to zero.
    public func suffix(_ maxLength: Int) throws -> [Element] {
        GRDBPrecondition(maxLength >= 0, "Can't take a suffix of negative length from a cursor")
        if maxLength == 0 {
