The operators are grouped by category. Most of them return a null value if any operand has a null value. Anyway, there are some exceptions. So, for each operator, the behavior in case of a null value operand is specified.
Comparison operators are binary operators that return a Boolean or a null value as results. They are mostly used in the WHERE clause (see Chapter 2, Filter, Aggregate, and Combine Results, for details) to filter data according to a condition, although they can be used in the RETURN clause as well.
In Cypher, comparison operators can be grouped in two classes: ordering operators and equality operators.
Ordering operators are used to compare values (usually property values or literals). They are as follows:
|
Operator |
Description |
|---|---|
|
|
Less than |
|
|
Less than or equal to |
|
|
Greater than |
|
|
Greater than or equal to |
Let's see an example using one of these operators. This query looks for all books published in 2012 or later. If a PublishedBy relationship doesn't have the year property set, it will be discarded. The query is as follows:
MATCH (a:Book)-[r:PublishedBy]-(b:Publisher) WHERE r.year >= 2012 RETURN a,r,b
Note the following outcomes:
Only numbers and string values are supported.
Comparing any value to a
nullvalue will result in anullvalue. For example, all of the following expressions will give anullvalue:1 < NULLNULL < "String"NULL < NULL
Comparing nodes or relationships is an illegal operation. It will result in a syntax error.
Comparing numbers of different types (a double value with an integer value or a long value with an integer value) is supported; however, numbers will be converted before being compared.
Comparing arrays is not supported.
Comparing numbers to string values will generate a runtime error. If you don't know whether a property is a number in the dataset and if a string comparison is enough, you can resort to the
STRfunction (this is covered later in this appendix).
Equality operators are used to test the equality of two values. They return a Boolean value or a null value. They are as follows:
=returnstrueif the two values are equal<>returnstrueif the two values are not equal
The following query returns the books that have the specified title:
MATCH (a:Book) WHERE a.title = "Learning Cypher" RETURN a
Note the following:
Comparing any value to a
nullvalue will result in anullvalue. To testnullvalues, use the NULL equality operators mentioned in the next section. For example, all of the following expressions will give anullvalue as the result:230.0 = NULLNULL = "String"NULL = NULL
Comparing values of properties of different types is supported and will always return
false, except for the numbers that will be converted before the comparison.String comparison is case sensitive.
Nodes, relationships, and paths can be compared for equality as well, as explained in the following list:
Two nodes are equal only if they are the same node
Two relationships are equal only if they are the same relationship
Two paths are equal only if they contain both the same nodes and the same relationships
Comparing either a node, a relationship, or a path to a property value (number or string) will generate a syntax error.
The operators IS NULL and IS NOT NULL are used to check whether a value is a null value. These operators always return a Boolean value. They are mostly used to check whether or not a property is set in a node or in a relationship. The following query returns all books that have a title property:
MATCH (b:Book) WHERE b.title IS NOT NULL RETURN b
All values can be tested; not only node properties and relationship properties but also nodes, relationships, and paths.
Mathematical operators work with number values. They are binary operators except the unary minus (-). The binary operators are +, -, *, /, %, and ^. Consider the following query:
MATCH (a)-[r:PublishedBy]-(b) WHERE r.year % 2 = 1 RETURN -2^ 1.0 * COUNT(DISTINCT a) / COUNT(DISTINCT b)
This query performs an example mathematical operation on the number of distinct books per publisher.
Note the following:
Every operator will return a
nullvalue if any operand is aNULLvalue. Refer to theCOALESCEfunction, described in a later section, to deal with the default values in case of anullvalue.Every operator will throw an exception if any operand is not a number, except for the
+operator. This also holds true for strings and collections, but with a different meaning (see the next section).
Both strings and collections have the + operator. It is used to concatenate items to strings and collections. Consider the following query:
RETURN "Hello" + " Cypher " + 2
This simple query just concatenates some strings. The number 2 is converted to string just before being concatenated. Now consider the following query:
MATCH (aa:Book) RETURN aa.tags + ["book","found"]
This query, for each book in the database, returns a collection computed by concatenating the book's tags with a fixed collection of tags.
Note the following:
This operator returns a
nullvalue if any operand is anullvalue.When concatenating strings, the
+operator will try to convert the operand to string, except when an operand is a collection. In this case, the result will be in a new collection with the string concatenated.
The IN predicate is used to check whether a given value is in a collection of items. It returns either a Boolean value or a null value if any operand has a null value. Consider the following query:
MATCH (aa:Book) WHERE 'drama' IN (aa.tags) RETURN aa.title
This query returns all books that have the word drama in their tags.
To check whether a string value matches a regular expression, use the =~ operator. This operator is explained in detail in Chapter 2, Filter, Aggregate, and Combine Results. As a reminder, following is an example query that looks for books that contain the word tale:
MATCH (aa:Book) WHERE aa.title =~ "(?i).*tale.*" RETURN aa