Performant conversion to Swift Object from MongoDB GraphQL result

Question

In our Realm Swift SDK we are using GraphQL. The query is an aggregate with two lookups, it takes quite long (3s+) until 10 results (of a collection with only 200 entries) are displayed.

Query code:

let aggregatePipeline: [Document] = [
                "$match": [
                    "$and": [
                        [ "example": AnyBSON(stringLiteral: "test")           ],
                        [ "_id": ["$ne": AnyBSON("123") ] ]
                    ]
                ]
            ]
// realm database object loaded elsewhere
let collection = database.collection(withName: "Example")
do {
            let resultObjectsRaw = try await collection.aggregate(pipeline: aggregatePipeline)
} catch {
            print("error")
        }

The query only took around 0.5s or less. The rest of the time is converting the result to our swift objects (Subclassed from RealmSwift's Object, see implementation below) (sometimes up to 1s per object). Is there a better way to convert the result of the query to swift objects?

This is what the result resultObjectsRaw looks like:

array(
  [
      Optional(RealmSwift.AnyBSON.document([
           "_id": Optional(RealmSwift.AnyBSON.string("xyz")), 
           "example": Optional(RealmSwift.AnyBSON.string("yzx"))
       ])),
      Optional(RealmSwift.AnyBSON.document([
           "_id": Optional(RealmSwift.AnyBSON.string("142")), 
           "example": Optional(RealmSwift.AnyBSON.string("647"))
       ]))
])

and we need it as an array of Swift objects. i.e:

class ExampleObject: Identifiable {
    var id = UUID().uuidString
    var example: String?
    
    init(id: String? = nil, example: String? = nil) {
        self.init()
        if let id = id {
            self.id = id
        }
        self.example = example
    }
}

This is what we currently use to convert:

guard let documentId = document["_id"]??.stringValue else { return nil }
let property = document["example"]??.stringValue
// more properties ...
let object = ExampleObject(id: documentId, example: example) // creating the swift object

It should be noted that our actual objects have around 10 properties, where one property is a linked document (thus the lookup number 1) and this linked document once again has a linked document (thus lookup number 2). But all properties are either strings, Date objects or similarly "small" data.

P.S: There is this similar question on the MongoDB Community Forum, however it has no solution and is around a year old..

Answer 1

I believe the objective here is to retrieve documents from an Atlas collection, those are then used to populate Swift objects (non-Realm) and stored in an array.

For clarity, this question/answer does not use the Realm database - it uses the Swift SDK to communicate directly with MongoDB to retrieve the collections. There are no realm objects involved - but the UnmanagedTaskClass (see below) could easily be converted to a Realm object if local/synced persistence is needed.

In this example, we are loading all of the Tasks from a given _partitionKey into an array. The code was tested with 10,000 objects - ignoring the retrieval time from MongoDB, the 'conversion' took about a second to complete.

Starting with an array to hold the Swift objects

var myTasks = [UnmanagedTaskClass]()

and then the code to retrieve the documents from a MongoDB collection

collection.find(filter: ["_partitionKey": AnyBSON(whichPartition)], { (result) in
    // Note: this completion handler may be called on a background thread.
    //       If you intend to operate on the UI, dispatch back to the main
    //       thread with `DispatchQueue.main.async {}`.
    switch result {
    case .failure(let error):
        print("Call to MongoDB failed: \(error.localizedDescription)")
        return
    case .success(let documents):
        documents.forEach({(document) in
            let task = UnmanagedTaskClass(withDoc: document)
            //print(task._id, task.partitionkey, task.name, task.status)
            self.myTasks.append(task)
        })
    }
})

then the document is used to instantiate an UnmanagedTaskClass via the convenience init

class UnmanagedTaskClass {
    var partitionkey = ""
    var status = ""
    var name = ""
    var _id: ObjectId!
    
    convenience init(withDoc: [String: AnyBSON?] ) {
        self.init()
        
        withDoc.forEach { dict in
            switch dict.key {
            case "_partitionKey":
                self.partitionkey = dict.value?.stringValue ?? "No partition"
                
            case "status":
                self.status = dict.value?.stringValue ?? "No status"
                
            case "name":
                self.name = dict.value?.stringValue ?? "No name"
                
            case "_id":
                self._id = dict.value?.objectIdValue ?? ObjectId()
                
            default:
                break
            }
        }
    }
}

The above could be improved and shortened using Codable protocols but that also comes with its own set of issues. I prefer the above for this use case.

If you're uploading data to MongoDB, there's some options using codable in this answer.