Getting incorrect values with COUNT() in OPTIONAL MATCH query - neo4j

Question

Ok so here is my data model:
(User)-[:ASSIGNED_TO]-(Account)
(Location)-[:BELONGS_TO]->(Account)
(User)-[:ASSIGNED_TO]-(Location)
In my database there is 1 account, 1 location and 16 users. Each user is :ASSIGNED_TO the account and also :ASSIGNED_TO the location. The location :BELONGS_TO the account.
I'm trying to select a specific account by id and also return the number of users and locations for that account. Here is my query:
MATCH (account:Account)
WHERE account.id = '123456'
WITH account
OPTIONAL MATCH (location:Location)-[:BELONGS_TO]->(account)
OPTIONAL MATCH (user:User)-[:ASSIGNED_TO]->(account)
RETURN account, count(location) as locationCount, count(user) as userCount
The result is the account, a userCount = 16 (correct) and a locationCount = 16 (incorrect; should be 1). If I add distinct to the location count, count(distinct location), I get the correct result (1) and if I remove the OPTIONAL MATCH for the users, I also get a location count of 1. I know it has something to do with the users having a relationship to the account and the location but I'm just trying to understand why the query without distinct doesn't work. Also, is there a better way to write this?

Answer 1

It is indeed a bit tricky. This is the query rewritten to show the pattern you are looking for :
MATCH (account:Account)
WHERE account.id = '123456'
MATCH (location:Location)-[:BELONGS_TO]->(account)<-[:ASSIGNED_TO]-(user:User)
RETURN account, count (location), count (user)
There's one account in the middle, but you don't know what the numbers are on each side. The resultset will contain all matches for the pattern (happens to be 16, but there could have been more locations and users assigned to multiple locations). So actually neither count is correct (you just get lucky for the users).
MATCH (account:Account)
WHERE account.id = '123456'
MATCH (location:Location)-[:BELONGS_TO]->(account)<-[:ASSIGNED_TO]-(user:User)
RETURN account, count (DISTINCT location), count (DISTINCT user)
DISTINCT solves the problem. Aggregated by account (there is only one so no real aggregation happens) there are 16 locations in the resultset. DISTINCT makes sure you only count the unique ones. And the same DOES apply for the users too !
Take a look at this query to see the difference :
MATCH (account:Account)
WHERE account.id = '123456'
MATCH (location:Location)-[:BELONGS_TO]->(account)
RETURN account.id as id, "location count" as type, count(location) as ct
UNION
MATCH (account:Account)
WHERE account.id = '123456'
MATCH (account)<-[:ASSIGNED_TO]-(user:User)
RETURN account.id as id, "user count" as type, count(user) as ct
Hope this helps.
Regards,
Tom

Answer 2

If you view your result in row instead of graph, you can see that there are actually 16 rows of data. Each row will contain location, count(location) is actually returning the number of lines that has location.
I prefer using distinct for removing duplicates. We have service in production and we are using distinct in a similar scenario.

Answer 3

I was facing a similar problem and it helped to think of it from an RDBMS perspective.
Consider a table of Users like so (I'll use 4 for my example):
Users
-----
u1
u2
u3
u4
And consider 2 tables of Locations and Accounts each (with one record each, as in your case):
Locations
---------
loc1
Accounts
--------
acc1
Now, when Neo4j evaluates a query like MATCH (location:Location)-[:BELONGS_TO]->(account)<-[:ASSIGNED_TO]-(user:User), it starts looking for User nodes, and Location nodes, and follows relationships inwards to Account nodes, where it then performs a join. So, to break that query into intermediate queries, it would look like: MATCH (location:Location)-[:BELONGS_TO]->(account) and MATCH (account)<-[:ASSIGNED_TO]-(user:User). Evaluating those 2 queries would give us something like the following tables:
Location-Account
----------------
loc1 | acc1
Account-User
------------
u1 | acc1
u2 | acc1
u3 | acc1
u4 | acc1
Finally, Neo4j performs a join on the intermediate results, to return something like the following combined table:
User-Account-Location
---------------------
u1 | acc1 | loc1
u2 | acc1 | loc1
u3 | acc1 | loc1
u4 | acc1 | loc1
count(location) as per this table would be 4, while count(DISTINCT(location)) would be 1 :)