Aggregating two queries into one on local RealmDB using swiftSDK

Welcome to the forums!

Yes, there is a way (and maybe lots of ways) to do that but some clarity is needed in the question.

Is the goal to retrieve all of the pills that contain a specific drug? Also, drug names change so using that as a key to look things up may not be the best idea - I can suggest some better options on that once we have clarity on the goal in the question.

In the future, it’s a good idea to include your actual Realm objects in the question along with sample data to clarify what’s being asked. (and format your code!)

It appears that Pills can contain several drugs and a Drug can appear in a variety of pills. In that case we have a two-way relationship between Pills and Drugs.

One possible setup would have two classes

class PillClass: Object {
   @Persisted var drug_list = List<DrugClass>()
}

class DrugClass: Object {
   @Persisted var drug _id = ""
   @Persisted(originProperty: "drug_list") var linkedPills: LinkingObjects<PillClass>
}

The PillClass has list of Drugs that are in that pill and the DrugClass appears in different Pills

To then get the pills that contain a specific drugID the query would be

let results = realm.objects(PillClass.self ).where { $0.drug_list.drug_id == "some drug id" }

You could also then traverse the graph from Drugs back to pills to for example, detect drug interactions with certain pills.

It Pill to Drug is always 1-1 then you should consider should use embedded objects as that simplifies the structures and queries.

However that would mean that 1 pill only ever has one drug and 1 drug is only ever contained in one pill. Is that correct?

Sure. Assuming there’s a Drug object with a List if EmbeddedObjects of Pills, you can filter for drug.pill == ‘some pill’ to return Drugs that contain that pill.

Ok, first thing is that MongoDB Is a NoSQL Database - so there are not really any ‘join’ queries like what you would find in SQL. Realm puts a nice ‘face’ on that NoSQL data so we can run more human-readable queries and joins are done through relationships (forward through the object graph with Lists, and backward with LinkingObjects).

Second thing is (when) you’re using embedded objects, only one object will be managed; the parent object that contains the embedded object. Embedded objects never stand alone.

The last thing is that it’s not really clear what you’re trying to query for and why don’t want to use the solution presented above.

It seems like you want to retrieve pills that contain a specific drug and that’s exact what my example above does, all in one query.

let results = realm.objects(PillClass.self ).where { $0.drug_list.drug_id == "some drug id" }

Is there a reason you don’t want to use that?

My pleasure.

To answer your question, yes! and the above solution does that - it’s a single query with two independent collections.

Joining is (can be) done through a common column in SQL and joining is done through references in Realm.

Keep in mind that in your original question, there’s really only one query - the first statement retrieves the objectId your after and the second line is the actual query.

That would be akin to not knowing the column name you want to join by in SQL; If you know the column name though - you can SQL query join in one line.

Likewise, if you know the ObjectID in Realm, you can get the results with a single query.