Operators

Operators are symbols or keywords used to perform operations on data.

All Operators

Property Accessor

The . (dot) operator allows you to access a property of a graph element.

GQL
MATCH (n)
RETURN n._id LIMIT 10

Logical Operators

AND

Combines two or more conditions in a way that all of them must be true for the entire expression to evaluate to true.

Truth table for the AND operator:

This query returns users whose age exceeds 30 and incomeGroup equals to 4:

GQL
MATCH (n:User)
WHERE n.age > 30 AND n.incomeGroup = 4
RETURN n

OR

Combines two or more conditions where only one of them needs to be true for the entire expression to evaluate to true.

Truth table for the OR operator:

This query returns users whose age exceeds 30, or incomeGroup equals to 4:

GQL
MATCH (n:User)
WHERE n.age > 30 OR n.incomeGroup = 4
RETURN n

XOR

Combines two or more conditions by evaluating two conditions at a time. For two conditions, the result is true only if exactly one of the conditions is true. If both are true or both are false, the result is false. When applied to multiple conditions, XOR first evaluates the result of the first two conditions, then compares that result with the next condition, continuing this process until all conditions are checked.

Truth table for the XOR operator:

This query returns users whose age exceeds 30, or incomeGroup equals to 4, but excludes users who meet both criteria:

GQL
MATCH (n:Person)
WHERE n.age > 30 XOR n.incomeGroup = 4
RETURN n

NOT

Negates a condition, returning true if the specified condition is false and vice versa.

Truth table for the NOT operator:

This query returns users whose age is not 30:

GQL
MATCH (n:Person)
WHERE NOT n.age = 30
RETURN n

Arithmetic Operators

Performs mathematical operations on numerical values. GQL supports the following arithmetic operators:

• Addition: +
• Subtraction: -
• Multiplication: *
• Division: /
• Modulus: %
• Power: ^

GQL
RETURN 2 + 8

Assignment Operators

The = operator is used to assign values in statements like LET and SET, and to declare path variables within MATCH statements.

GQL
LET a = 1 RETURN a

GQL
MATCH (n:Person WHERE n.name = "John Doe")
SET n.gender = "male"

GQL
MATCH p = ()->() RETURN p

String Operators

String Concatenation

The || or + operators combines multiple strings into a single string by merging the characters of each string in order.

GQL
RETURN "data" || "base",   // "database"
       "data" + "base"     // "database"

String Matching

The CONTAINS operator checks if one string contains another (case-sensitive).

This query returns user nodes whose aboutMe contains "graph database":

GQL
MATCH (n:user WHERE n.aboutMe CONTAINS "graph database")
RETURN n

You can transform all letters to upper or lower cases for case-insensitive matching:

GQL
MATCH (n:user WHERE lower(n.aboutMe) CONTAINS "graph database")
RETURN n

The CONTAINS operator is also used to match the specified keywords with tokens of a full-text index (precise or fuzzy match). See Full-text Index.

This query finds nodes using the full-text index prodDesc where their tokens include "graph" and "database":

GQL
MATCH (n WHERE ~prodDesc CONTAINS "graph database")
RETURN n

The STARTS WITH operator checks if a string starts with a given prefix (case-sensitive):

GQL
MATCH (n:Paper WHERE n.title STARTS WITH "Efficient")
RETURN n

The ENDS WITH operator checks if a string ends with a given suffix (case-sensitive):

GQL
MATCH (n:Paper WHERE n.title ENDS WITH "Search")
RETURN n

List Operators

List Construction

The [] or LIST[] or ARRAY[] can create a list by placing comma-separated elements inside.

GQL
LET items = [1,2,3]
RETURN items          // [1, 2, 3]

The [] can also construct a nested list:

GQL
LET items = [[1,2],[2,3]]
RETURN items          // [[1,2],[2,3]]

Elements Accessing

The [] can access elements within a list by their indexes. Lists use 0-based indexing, meaning the first element is at index 0.

Note: m and n are both positive integers and n > m.

GQL
LET items = ["a", 1, "b", 34]
RETURN items[0], items[1], items[-1], items[-2], items[1:], items[:2], items[1:3]

Result:

Membership Checking

The IN checks whether a specified element exists within a list. NOT IN checks that it does not. Both evaluate to 1 for true and 0 for false.

GQL
MATCH (n) WHERE n._id IN ["U01", "U02"]
RETURN n

GQL
MATCH (n) WHERE n._id NOT IN ["U01", "U02"]
RETURN n

List Concatenation

The concatenation operator || combines multiple lists into a single list by merging the elements of each list in order.

GQL
RETURN [1,2,3] || [3,4,5]     // [1, 2, 3, 3, 4, 5]

Path Operators

Path Construction

The PATH[] creates a path by enumerating node and edge references in order.

GQL
MATCH (a {_id: "P1"})-[e]->(b)
RETURN PATH[a, e, b]

Path Concatenation

The concatenation operator || joins multiple paths into a continuous single path, merging the last node of the first path with the first node of the second path when they are identical.

GQL
MATCH p1 = ({_id: "P1"})->(n), p2 = (n)->()
RETURN p1 || p2

Record Operators

Record Construction

The {} or RECORD{} creates a record. You can define its fields and corresponding values.

GQL
LET rec = {length: 20, width: 59, height: 10}
RETURN rec.length    // 20

Field Reference

The . (period) operator allows you to reference a field of a record.

GQL
LET rec = RECORD{length: 20, width: 59, height: 10}
RETURN rec.length * rec.width * rec.height     // 11800

Deduplication

The DISTINCT ensures that only unique values are included.

This query returns distinct age values of users:

GQL
MATCH (n:User)
RETURN DISTINCT n.age