Efficient way to query the root verticies (nodes) of a graph?

[ActuallyHappening]

The data I want to map: I have a table of things, that is the primary data of my project. I want these things to have some way of expressing they have parents (plural), which are other things. Initially I added a field to the thing table like this: parents: set<record<thing>>, which works fine.

But then for some reason I tried using graph relations, my requirements haven't changed. I created a relations table parents which had both its in and out parameters with a type of thing. Now I'm writing this, I realise maybe continuing without a graph table would potentially be better, because I need to define a few functions:

Efficient access of root nodes

So far, using the graph implementation, I've come up with this working function:

DEFINE FUNCTION OVERWRITE fn::root_things() {
    let $mentioned_as_children = <set>(SELECT in FROM parent).map(|$val| $val.in);
    RETURN (SELECT id FROM thing WHERE !($mentioned_as_children.matches(id).any())).map(|$id| $id.id);
};

Usage:

fn::root_things()

Example output:

[
	"thing:4rmjxi39gbewv98kx6qd",
	"thing:6g1gkrhe5xgqhkmrsouz",
	"thing:6uwvf0js9234j0tnvp92",
	"thing:745695y6czooa4pwgxvk",
	"thing:83y89uy452e4r9axrm8a",
	"thing:8dyx2qbiceneh3p6x3f7",
	"thing:9ex01w9121bksggss2ew",
	"thing:a5driynt0d52box43u2d",
]

The problem with this query is that, to my knowledge, it has to linearly scan + collect all of the parents relational table then perform another superlinear array/set comparison compared to the sizes of the thing and parent tables.

Efficient access of child and parent nodes

Also, I want given a specific ID of a thing record e.g. thing:4rmjxi39gbewv98kx6qd to be able to list its children's IDs and parent IDs, ideally that scales well with lots of thing and parent records

The question

Is such a solution possible with the graph feature of surrealdb? SurrealDB is the first databasing solution I've used to construct my own schemas, so I don't even have a reference frame compared to other database implementations.
I'm assuming this sort of problem is solvable with some clever DEFINE INDEX, but before I prematurely optimize (which is the root of all evil ofc) I wanted to ask the community before commiting to the graph/relational path

[dbaudisch]

Could a query such as

SELECT *, ->parent->thing AS parents, <-parent<-thing AS children FROM thing:4rmjxi39gbewv98kx6qd;

be a possible solution for your requirements?

[ActuallyHappening]

Root nodes meaning nodes that don’t have parents

[dbaudisch]

Does SELECT VALUE id FROM thing WHERE !<-parent; work for you then?

[ActuallyHappening]

What? Maybe, never seen that syntax before