CODEWITHSUNDEEP
neo4jcypher
Abdullah Al Noman
Abdullah Al Noman

Reputation: 2878

Cypher query condition is always returning true

MATCH (c:OBJ {dummy:false})
where [{param} is null or [(c)-[]->(p:PRO {dummy:false}) WHERE p.val ={param} | true ] ]
return c

I have a big query from which there is this simple part. But

[{param} is null or [(c)-[]->(p:PRO {dummy:false}) WHERE  p.val = {param} | true] ]

part is always returning true even if p.val ={param} is false. What did I do wrong here? The syntax looks fine for me.

Upvotes: 0

Views: 391

Answers (2)

cybersam
cybersam

Reputation: 67044

A pattern comprehension will always return a list, even if it is empty.

So, the following will never equate to false or NULL:

[(c)-[]->(p:PRO {dummy:false}) WHERE  p.val = {param} | true]

This query (which tests the size of the inner comprehension result) will probably work for you:

MATCH (c:OBJ {dummy:false})
WHERE [$param IS NULL or SIZE([(c)-->(p:PRO {dummy:false}) WHERE p.val = $param | true]) > 0 ]
RETURN c

Upvotes: 2

InverseFalcon
InverseFalcon

Reputation: 30417

There's a couple things going on here. Note cybersam's answer, as it relates to the pattern comprehension within.

However, the bigger problem is that the WHERE clause will ultimately be evaluating a list, NOT a boolean!

By using square brackets for the entirety of your WHERE clause, that means you're creating a list, and its contents will be whatever is inside. The stuff inside will evaluate to a boolean, so this means that there are two possibilities for how this will turn out:

WHERE [true]

or

WHERE [false]

and in either of these cases, these are NOT booleans, but single-element lists, where the only element in the list is a boolean!

Using WHERE on a list like this will ALWAYS evaluate to true. No matter what is in the list. No matter how many elements are in the list. No matter if the list is empty. If the list itself exists, it's going to be evaluated as true, and the WHERE clause succeeds.

So to fix all this, do NOT use square brackets as some means to compartmentalize boolean logic. Use parenthesis instead, and only if you really need them:

MATCH (c:OBJ {dummy:false})
WHERE ( {param} is null or (c)-->(:PRO {dummy:false, val:{param}}) )
RETURN c

In the above, the parenthesis in use when using the WHERE clause aren't really needed, but you can use them if you like.

This should also be a better way of expressing the predicate you want. In this case we don't need the pattern comprehension at all. It's enough to say that we either need the {param} parameter to be null, or this pattern (where one of the properties is the {param} parameter) must exist.

If you really do end up needing a pattern comprehension, follow cybersam's advice and make sure you're testing whether the the list resulting from the comprehension is empty or non-empty.

Upvotes: 1

Related Questions