Return a subgraph touched by a query

[mikebellerU]

Hi -- I just discovered CozoDB and I think it's really an excellent piece of technology! I am working on a problem in AI for financial services. I've previously been using neo4j/memgraphdb and cypher. I feel like datalog/cozo potentially can be a better fit, but I am having problems when it comes to visualizing the subgraphs that were 'touched' by a query. Cypher makes this very easy -- and I am not sure how might be a good way to do the same with Cozo.

Here is an example in cozo. There are clients. They have accounts. Accounts have types. Certain clients are eligible for certain account types.

client[name] <- [['Alex'],['Blake']]
account[aid] <- [['A1'],['A2'],['B1']]
has_account[name,aid] <- [['Alex','A1'],['Alex','A2'], ['Blake','B1']]
account_type[atype] <- [['Taxable'], ['IRA'], ['401k']]
has_account_type[aid,atype] <- [['A1', 'Taxable'], ['A2', 'IRA'], ['B1', 'IRA']]
eligible[name,atype] <- [
    ['Alex', 'Taxable'], ['Alex', 'IRA'], ['Alex', '401k'],
    ['Blake', 'Taxable'], ['Blake', 'IRA']]

I want to ask "which accounts is Alex eligible for, that they do not already have?"

In Cozo it's easily doable as follows:

?[atype] := name = 'Alex', eligible[name,atype],
    not (has_account[name, aid], has_account_type[aid, atype])

In cypher, here is the equivalent:

MATCH (c:Client {name: 'Alex'})-[:ELIGIBLE_FOR]->(at:AccountType)
WHERE NOT EXISTS (
    (c)-[:HAS_ACCOUNT]->(:Account)-[:HAS_TYPE]->(at)
)
RETURN at.name as account_type;

But with a tiny tweak to the cypher query, I can return the entire subgraph (nodes and links) touched by the query:

MATCH (c:Client {name: 'Alex'})-[e:ELIGIBLE_FOR]->(at:AccountType)
WHERE NOT EXISTS (
    (c)-[:HAS_ACCOUNT]->(:Account)-[:HAS_TYPE]->(at)
)
RETURN c, e, at;

This ability to easily return nodes and links from a query makes it very easy to visualize (using graph visualization tools) what is going on in the system. Is there a straightforward way to get this same type of information in Cozo? (All links/nodes 'included' in a query result)

Thanks

Mike

[ryanjshaw]

Have you found a solution? It's my understanding that Datalog-style languages answer queries by repeatedly applying rules to facts until they reach a fixpoint (i.e. the rules don't produce new information), and then the query itself is evaluated. While theoretically it seems possible to keep a record of what rule produced which new fact, it doesn't seem like CozoDB implements this. Instead, as far as I can tell, you need to track this information explicitly yourself, e.g.:

edge[f, t] <- [['A', 'B'], ['B', 'C'], ['C', 'D']]
path[x,y,via] := edge[x,y], via=[[x,y]]
path[x,z,via] := path[x,y,_via], edge[y,z], via=concat(_via,[[y,z]])

?[from,to,via] := path[from,to,via], from = 'A', to ='D'

produces:

from	to	via
A	D	[['A', 'B'], ['B', 'C'], ['C', 'D']]

[MikeBeller]

Thanks Ryan! I didn’t find any other solution.

[aramallo]

You could extend @ryanjshaw 's idea and use those node IDs to join another rule that based on The ID constructs and returns a JSON object containing all the node properties.