CODEWITHSUNDEEP
neo4jcypher
ulkas
ulkas

Reputation: 5918

neo4j - how to match only first n relations

is there a default way how to match only first n relationships except that filtering on LIMIT n later?

i have this query:

START n=node({id})
MATCH n--u--n2
RETURN u, count(*) as cnt order by cnt desc limit 10;

but assuming the number of n--u relationships is very high, i want to relax this query and took for example first 100 random relationships and than continue with u--n2...

this is for a collaborative filtering task, and assuming the users are more-less similar i dont want to match all users u but a random subset. this approach should be faster in performance - now i got ~500ms query time but would like to drop it under 50ms.

i know i could break the above query into 2 separate ones, but still in the first query it goes through all users and than later it limits the output. i want to limit the max rels during match phase.

Upvotes: 6

Views: 7392

Answers (2)

Bouncner
Bouncner

Reputation: 2369

This is not a direct solution to your question, but since I was running into a similar problem, my work-around might be interesting for you.

What I need to do is: get relationships by index (might yield many thousands) and get the start node of these. Since the start node is always the same with that index-query, I only need the very first relationship's startnode.

Since I wasn't able to achieve that with cypher (the proposed query by ean5533 does not perform any better), I am using a simple unmanaged extension (nice template).

@GET
@Path("/address/{address}")
public Response getUniqueIDofSenderAddress(@PathParam("address") String addr, @Context GraphDatabaseService graphDB) throws IOException
{
    try {
        RelationshipIndex index = graphDB.index().forRelationships("transactions");
        IndexHits<Relationship> rels = index.get("sender_address", addr);

        int unique_id = -1;
        for (Relationship rel : rels) {
            Node sender = rel.getStartNode();
            unique_id = (Integer) sender.getProperty("unique_id");
            rels.close();
            break;
        }

        return Response.ok().entity("Unique ID: " + unique_id).build();
    } catch (Exception e) {
        return Response.serverError().entity("Could not get unique ID.").build();
    }
}

For this case here, the speed up is quite nice.

I don't know your exact use case, but since Neo4j even supports HTTP streaming afaik, you should be able to create to convert your query to an unmanaged extension and still get the full performance. E.g., "java-querying" all your qualifying nodes and emit the partial result to the HTTP stream.

Upvotes: 1

ean5533
ean5533

Reputation: 8994

You can pipe the current results of your query using WITH, then LIMIT those initial results, and then continue on in the same query:

START n=node({id})
MATCH n--u
WITH u
LIMIT 10
MATCH u--n2
RETURN u, count(*) as cnt 
ORDER BY cnt desc 
LIMIT 10;

The query above will give you the first 10 us found, and then continue to find the first ten matching n2s.

Optionally, you can leave off the second LIMIT and you will get all matching n2s for the first ten us (meaning you could have more than ten rows returned if they matched the first 10 us).

Upvotes: 4

Related Questions