Query filter using two fields in a `LinkingObjects`

luc · 2024-08-12T15:24:01.484Z

Based on the example below, Is it possible to query Profile based on two fields within a ``LinkingObjects, such as friendSent`? I have a profile type and a friend request type:

class Profile: Object {
    // ...

    @Persisted(originProperty: "sender")    var friendSent: LinkingObjects<FriendRequest>
    @Persisted(originProperty: "recipient") var friendRcvd: LinkingObjects<FriendRequest>
}

class FriendRequest: Object {
    @Persisted var sender:    Profile!
    @Persisted var recipient: Profile!
    @Persisted var status: RequestStatusEnum = .active
}
`

I'd then like to make a query for a `@ObservedResults(Profile.self) var users`

profile = Profile(…) // some profile
let friends_of_profile = users.where({
($0.friendRcvd.sender == profile && $0.friendRcvd.status == .active)
&& ($0.friendSent.recipient == profile && $0.friendSent.status == .active)
});


This nearly works, however, the individual clauses for `friendSent` and `friendRcvd` don't seem to be applied to only the same document. So I'm seeing the clauses for  `$0.friendRcvd` evaluate to `true` if there exists a document where  `.sender == profile` and one where `.status == .active`, but they aren't necessarily the same one.

Is it possible to write a query that requires those two filters to be applied to the same document?

Thanks!

Jay · 2024-08-12T19:13:30.158Z

I think the answer is ‘Yes’ but the formatting in the question make is challenging to read. Only the code should be code formatted - the rest of the text should not be.

Also, there’s a ``users` object in the question but we don’t know what that is.

The query in the question has a bunch of &&, meaning all of those statement must be true for the object to be returned, and, they all most be true on a single object. So the parens () are extraneous.

This code is puzzling

let friends_of_profile = users.where({ ($0.friendRcvd.sender

as $0 would be a user object, not a profile object. So the user object would have to have a Profile property to then reach the .sender property - like this

class User: Object {
   @Persisted var friendRcvd: Profile

so is friendRcvd a property of User, Profile or something else?

Also LinkingObjects can contain one or more objects so naming the property as plural may help clarify the code. So instead of

friendSent: LinkingObjects<FriendRequest>

it would be better

friendsSent: LinkingObjects<FriendRequest>

I think the question needs editing and updating for clarity.

luc · 2024-08-15T12:32:34.330Z

Sorry for the formatting problems- I didn’t get a chance to preview it during the posting process. It also looks like I can’t edit my post, so here’s it again:

Based on the example below, Is it possible to query Profile based on two fields within a LinkingObjects , such as friendSent? I have a profile type and a friend request type:

class Profile: Object {
    // ...

    @Persisted(originProperty: "sender")    var friendSent: LinkingObjects<FriendRequest>
    @Persisted(originProperty: "recipient") var friendRcvd: LinkingObjects<FriendRequest>
}

class FriendRequest: Object {
    @Persisted var sender:    Profile!
    @Persisted var recipient: Profile!
    @Persisted var status: RequestStatusEnum = .active
}

I’d then like to make a query for a @ObservedResults(Profile.self) var users

profile = Profile(…) // some profile
let friends_of_profile = users.where({
    ($0.friendRcvd.sender == profile && $0.friendRcvd.status == .active)
    && ($0.friendSent.recipient == profile && $0.friendSent.status == .active)
});

This nearly works, however, the individual clauses for friendSent and friendRcvd don’t seem to be applied to only the same document. So I’m seeing the clauses for $0.friendRcvd evaluate to true if there exists a document where .sender == profile and one where .status == .active, but they aren’t necessarily the same one.

Is it possible to write a query that requires those two filters to be applied to the same document?

Thank you!

Jay · 2024-08-15T21:58:25.881Z

Again, the query does not match the objects presented in the question

let friends_of_profile = users.where

Is querying the users collection - and each User class object would need to have a .friendRcvd and a .friendSent property. But there is no User object in the question.

More importantly the Profile Object LinkingObjects property are not ONE object - they are one or more objects.

Lastly, do you have a use case where the friendRcvd.sender and friendSent.recipient would be the same profile? That seems odd.

luc · 2024-08-18T22:20:51.374Z

Hi Jay,

Jay:

let friends_of_profile = users.where

Is querying the users collection

I specified the definition of users in my question - there is no users collection:

luc:

@ObservedResults(Profile.self) var users

Apologies for the confusing naming. I also understand regarding the singular/plural naming of .friendRcvd as well.

Jay:

Lastly, do you have a use case where the friendRcvd.sender and friendSent.recipient would be the same profile? That seems odd.

So the query is looking for friends: profile A is a friend of profile B if A and B have both sent active FriendRequests to each other. Therefore, my query:

luc:

profile = Profile(…) // some profile
let friends_of_profile = users.where({
    ($0.friendRcvd.sender == profile && $0.friendRcvd.status == .active)
    && ($0.friendSent.recipient == profile && $0.friendSent.status == .active)
});

queries for profiles (within the full users set) where they have received active friend requests from profile and have sent active friend requests to profile.

However, my question proposed in my post still stands:

luc:

This nearly works, however, the individual clauses for friendSent and friendRcvd don’t seem to be applied to only the same document. So I’m seeing the clauses for $0.friendRcvd evaluate to true if there exists a document where .sender == profile and one where .status == .active, but they aren’t necessarily the same one.

Thanks,
Luc

Jay · 2024-08-19T22:06:55.736Z

luc:

($0.friendRcvd.sender == profile && $0.friendRcvd.status == .active)
    && ($0.friendSent.recipient == profile && $0.friendSent.status == .active)

One issue may be an assumption of what this resolves to. Let me present an example

let a, b, c, d = 0

if ( a == 0 && b == 0) && ( c == 0 && d == 0) {
    //do something if above is true
}

is equivalent to

if  a == 0 && b == 0 && c == 0 && d == 0 {
    //do something if above is true - note no () as it all must be true or if fails in either case.
}

The other thing when you’re doing a query like that, the query is an ANY query. In other words, return profiles that have ANY linked profile containing profile and ANY linked profile where status is active. I have still not fully wrapped my brain around the query though but I think you might run into circular references. Going to give this more thought and see if I can provide a better solution/answer.

luc · 2024-08-20T03:41:12.358Z

Jay:

The other thing when you’re doing a query like that, the query is an ANY query. In other words, return profiles that have ANY linked profile containing profile and ANY linked profile where status is active.

This sort of query behavior matches my testing. Is there a way to evaluate the two parts of a clause like

luc:

$0.friendRcvd.sender == profile && $0.friendRcvd.status == .active

on strictly the same FriendRequest document? That way this clause could successfully query for specifically active friend requests from profile .

Thanks,
Luc

Jay · 2024-08-20T18:13:45.969Z

luc:

Is there a way

I don’t believe there’s a way with the current schema. The issue is there’s too many back and forward references within the database to return more singular data. So the big picture is that it’s returning results where the collection has ANY profiles that match and ANY status == .active.

One approach is to break out the invites into their own collection instead of trying to do it all in one. It’s somewhat denormalizing the data but will provide more granular access to specific data. Something like

InviteClass: Object {
   @Persisted var whoWasInvited: User!
   @Persisted var invitedByWho: User!
   @Persisted var inviteCompletedDate: Date? // nil would mean the invite was not completed
}

luc · 2024-08-26T04:35:10.064Z

I see- In this case, you could check just inviteCompletedDate != nil, which doesn’t suffer from the same ANY problem with a query.

Is there a way to write my original intended query using a standard MongoDB query, instead of the Realm interface? I’m wondering if this is a limitation of the interface or MongoDB itself.

Jay · 2024-08-26T13:28:31.664Z

luc:

Is there a way

Maybe? But the issue is how the schema is constructed.

When doing a query on a top level object about something in a LinkingObjects List, it’s asking Realm/Mongo to return top level objects that have ANY x matching y in their List property.

If you want to query for more granular data, then you need to query on that data - like in my above example to then get which objects match exactly.

luc · 2024-08-27T23:20:46.688Z

Jay:

If you want to query for more granular data, then you need to query on that data

Is it possible to do two subqueries on FriendRequest and then a union between them?

Jay · 2024-08-28T13:49:47.674Z

luc:

Is it possible

Possible? Yes. The correct solution? Maybe.

One issue is the size of the dataset. Realm objects are lazily loaded - meaning working with thousands (tens-of) requires very little memory as objects are only loaded when they are being worked with.

Creating a Union would require the objects to be loaded - possibly into an array - and that defeats the lazy-loadingness aspect. If the dataset is small, then yes, it’s possible.

If the data set is large or will scale, then no, not a good idea as all of those objects could overwhelm the devices memory.

Also, subqueries are somewhat difficult to manage. I often find that during development it sounds like a great idea but more often than not, I end up ditching the subquery to implement something more straightforward- denormalizing the data per above pretty much gets around all of those issues.

That being said, I am not totally clear on what the results of the query should be. For example, I don’t understand in what use case the Recipient and Sender would be the same profile. If you look at the InviteClass above, it solves those issues. Here’s a sample query

let results = realm.objects(InviteClass.self).where { 
   ($0.whoWasInvited == profileA && $0.invitedByWho == profileB)
   ||
   ($0.whoWasInvited == profileB && $0.invitedByWho == profileA)
}

That query should return exactly two matches of the Invite Class. For example suppose profileA is “Jay” and profileB is “Cindy”

If 
  Jay was invited by Cindy
  OR 
  Cindy was invited by Jay

would be two matches. If there were no invites or if it was one or the other the results.count would be 0 or 1.

luc · 2024-09-04T22:51:20.832Z

Would it be possible to run two queries, one for finding “active” friend requests to Person A and then “active” friend requests from Person A. If these could be combined as one query, by union-ing two subqueries, then I could use .count ontop of that. That way this action could be performed directly on the FriendRequest data, instead of on the linking objects of Profile.

Jay · 2024-09-05T13:02:14.099Z

luc:

Would it be possible

Again, “possible” leaves a lot of possibilities so yes, it’s possible.

luc:

one for finding “active” friend requests to Person A and then “active” friend requests from Person A

The issue is the schema setup - if you want to run a query for specific data in the FriendsRequest collection, run it against that collection, not a LinkingObjects property of another collection. If it’s run against linking objects, it returns the top level model in the other collection where ANY in the linking objects is a match.

Here is your current model (from the initial question)

luc:

class FriendRequest: Object {
    @Persisted var sender:    Profile!
    @Persisted var recipient: Profile!
    @Persisted var status: RequestStatusEnum = .active
}

So something like

let results = realm.objects(FriendRequest.self).where { ($0.sender == personA || $0.recipient == personA) && $0.status == .active)

would return all active friend requests that were either initiated or received by personA.

Topic	Replies	Views	Activity
Error while updating object property in flutter. Error code: 2005 Realm transactions flutter	8	893	Jun 2024
[Realm.Sync.Client.Network - error] Realm	2	445	Jun 2024
Realm actors blocking each other Realm swift	1	294	Jul 2024
Saving Lists does not automatically happen during a write Realm swift	4	307	Aug 2024
I need help for resolving CrossTableLinkTarget exception Realm swift	2	211	Aug 2024

Query filter using two fields in a `LinkingObjects`

Query filter using two fields in a `LinkingObjects`

New & Unread Topics

Want to read more? Browse other topics in Realm or view latest topics.