Swift Firebase get batches of documents in order

Question

For context, I have a bunch of documents that hold fields similar to a social media post. (photo url link, like count, date uploaded, person who uploaded it, etc.) And I am showing this data in a gallery (lazyvgrid). I do not want to get all of the documents at once so when the user scrolls down the gallery I am getting 20 documents at a time based on how far the user scrolls down the gallery view. I am sorting my get request with:

self.eventsDataCollection.document(currentEventID).collection("eventMedias").order(by: "savesCount", descending: true).limit(to: 20).getDocuments

I have no problem getting the first 20 using this code. How can I get the next 20 and the 20 after that, and so on?

Have you checked [Pagination with Firebase firestore - swift 4](https://stackoverflow.com/q/52192062/13130697) and the examples in [documentation](https://firebase.google.com/docs/firestore/query-data/query-cursors#use_a_document_snapshot_to_define_the_query_cursor)? — Dharmaraj, Mar 19 '22 at 05:41

score 0 · Answer 1 · answered Mar 19 '22 at 08:54

With query cursors in Cloud Firestore, you can split data returned by a query into batches according to the parameters you define in your query. Query cursors define the start and end points for a query, allowing you to:

Return a subset of the data.
Paginate query results.

Use the startAt() or startAfter() methods to define the start point for a query. Use the endAt() or endBefore() methods to define an endpoint for your query results.

As Dharmaraj mentioned for your case, it will be best if we use Pagination with Firestore.

Paginate queries by combining query cursors with the limit() method to limit the number of documents you would want to show in the gallery. And as you want no definite numbers, but the user should be able to scroll through as long as he wants, and as long as there are documents, I would suggest to put a cursor until the last document, like in the below code sample.

 To get the last document, 
    
let first = db.collection("collectionname")
    .order(by: "fieldname")
    

first.addSnapshotListener { (snapshot, error) in
    guard let snapshot = snapshot else {
        print("Error retrieving cities: \(error.debugDescription)")
        return
    }

guard let lastSnapshot = snapshot.documents.last else {
 // The collection is empty.
  return
    }

This is a good answer but it does not have the code to support it. I referenced Dharmaraj's link and the accepted answer there was more what I was looking for. — Trevor, Mar 20 '22 at 00:39
No problem. Its great you found the solution. You can either upvote/accept answers. If you found my answer good/helpful for the community, you may upvote it. But again that is completely your choice. — Priyashree Bhadra, Mar 20 '22 at 14:07

score 0 · Accepted Answer · answered Mar 20 '22 at 00:45

I ended up referencing Dharmaraj's link in his comment.

@Published var isFetchingMoreDocs: Bool = false
private var lastDocQuery: DocumentSnapshot!

    public func getUpdatedEventMedias(currentEventID: String, eventMedias: [EventMedia], completion: @escaping (_ eventMedias: [EventMedia]) -> Void) {
        self.isFetchingMoreDocs = true
        var docQuery: Query!
        if eventMedias.isEmpty {
            docQuery = self.eventsDataCollection.document(currentEventID).collection("eventMedias").order(by: "savesCount", descending: true).limit(to: 20)
        } else if let lastDocQuery = self.lastDocQuery {
            docQuery = self.eventsDataCollection.document(currentEventID).collection("eventMedias").order(by: "savesCount", descending: true).limit(to: 20).start(afterDocument: lastDocQuery)
        }
        
        if let docQuery = docQuery {
            print("GET DOCS")
            docQuery.getDocuments { (document, error) in
                if let documents = document?.documents {
                    var newEventMedias: [EventMedia] = []
                    for doc in documents {
                        if let media = try? doc.data(as: EventMedia.self) {
                            newEventMedias.append(media)
                        }
                    }
                    self.lastDocQuery = document?.documents.last
                    self.isFetchingMoreDocs = false
                    completion(newEventMedias)
                } else if let error = error {
                    print("Error getting updated event media: \(error)")
                    self.isFetchingMoreDocs = false
                    completion([])
                }
            }
        } else {
            self.isFetchingMoreDocs = false
            completion([])
        }
    }

As seen in my code, by utilizing:

.order(by: "savesCount", descending: true).limit(to: 20).start(afterDocument: lastDocQuery)

I am able to start exactly where I left off. I should also note that I am only calling this function if !isFetchingMoreDocs - otherwise the func will be called dozens of times in a matter of seconds while scrolling. The most important thing about this code is that I am checking lastDocQuery if it is nil. After the user scrolls all the way to the bottom, the lastDocQuery will no longer be valid and cause a fatal error. Also I am using a custom scroll view that tracks the scroll offset in order to fetch more media and make more calls to firebase.

Swift Firebase get batches of documents in order

2 Answers2