All Operators

Property Operators

Property Reference

The . (period) allows you to reference a property of a graph element.

MATCH (n)
RETURN n._id LIMIT 10

Property Exists Predicate

The PROPERTY_EXISTS(<elemVar>, <propertyName>) predicate determines if a referenced graph element has a property.

Details

• Each <elemVar> must have a singleton degree of reference.

MATCH (n:User) LIMIT 1
RETURN PROPERTY_EXISTS(n, "uuid")

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:

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:

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

XOR

Combines two or more conditions. The entire expression evaluates to true only when exactly one of the conditions is true. If both conditions are true or both are false, it returns false.

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:

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:

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: %
• Exponentiation: ^

RETURN (2+8)%3

Result:

Comparison Operators

Compares two values or expressions and returns true or false. GQL supports the following comparison operators:

• Equal to: =
• Not equal to: <>
• Greater than: >
• Less than: <
• Greater than or equal to: >=
• Less than or equal to: <=

This query returns users whose age is not 30:

MATCH (n:Person)
WHERE n.age <> 30
RETURN n

String Operators

String Concatenation

The concatenation operator || combines multiple strings into a single string by merging the characters of each string in order.

RETURN "data" || "base"

Result:

Normalized Predicates

Determines whether a character string value is normalized. GQL supports the following normalized predicates:

• IS [ <normal form> ] NORMALIZED
• IS NOT [ <normal form> ] NORMALIZED

Details

• The <normal form> defaults to NFC. Other available normalization forms are NFD, NFKC and NFKD.

RETURN "Å" IS NORMALIZED AS normRes

Result:

RETURN "Å" IS NFD NORMALIZED AS normRes

Result:

List Operators

List Construction

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

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

Result:

The [] can also construct a nested list:

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

Result:

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.

LET items = ["a", 1, "b"]
RETURN items[0]

Result:

Membership Checking

The membership operator IN checks whether a specified element exists within a list. It evaluates to 1 for true and 0 for flase.

RETURN 2 IN [1,2,3] AS inList

Result:

The IN operator can effectively filters graph elements based on membership within a specified list. For example, this query retrieves nodes whose _id is "U01" or "U02":

MATCH (n) WHERE n._id 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.

RETURN [1,2,3] || [3,4,5] AS newList

Result:

Path Operators

Path Construction

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

<path value constructor> ::= "PATH[" <path element list> "]"

<path element list> ::= <node reference> [ <path element list step>... ]

<path element list step> ::= "," <edge reference> "," <node reference>

Details

• If <path element list> contains the null value or does not identify a path, then an exception condition is raised: Malformed path.

MATCH (n1 {_id: "U01"}), (n2 {_id: "U02"}), -[e {_uuid:39}]->
RETURN PATH[n2, e, n1]

Path Concatenation

The concatenation operator || joins multiple paths into a continuous single path, merging the last node of the first path merges with the first node of the second path when they are identical. If this condition is not met, then an exception condition is raised: Malformed path.

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

Record Operators

Record Construction

The RECORD{} creates a record by specifying fields.

<record constructor> ::=
  [ "RECORD" ] "{" [ <field> [ { "," <field> }... ] ] "}"

<field> ::= <field name> ":" <value expression>

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

Result:

Field Reference

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

LET rec = RECORD{length: 20, width: 59, height: 10}
RETURN rec.length * rec.width * rec.height AS capacity

Result:

Null Predicates

Specifies a test for a null value. GQL supports the following null predicates:

• IS NULL
• IS NOT NULL

This query retrieves the title of each :Paper node if the value is not null; otherwise, it returns the message TITLE NOT FOUND.

MATCH (n:Paper)
RETURN CASE 
  WHEN n.title IS NOT NULL THEN n.title
  ELSE "TITLE NOT FOUND"
END

Value Type Predicates

Determines whether a value conforms to a specific type. GQL supports the following value type predicates:

• IS TYPED <value type>
• IS NOT TYPED <value type>

Details

• Currently, the <value type> supports the following data type keywords: STRING, BOOL.

RETURN "a" IS TYPED BOOL AS typeCheck

Result:

Labeled Predicates

Determines whether a graph element satisfies a label expression. GQL supports the following value type predicates:

• IS LABELED
• IS NOT LABELED
• :

MATCH (n) WHERE n IS NOT LABELED Paper
RETURN n

MATCH (n:Paper)
RETURN n

Source/Destination Predicates

Determines whether a node is the source or destination of an edge. GQL supports the following source/destination predicates:

• <node reference> IS SOURCE OF <edge reference>
• <node reference> IS NOT SOURCE OF <edge reference>
• <node reference> IS DESTINATION OF <edge reference>
• <node reference> IS NOT DESTINATION OF <edge reference>

MATCH (n {_id: "P1"}), ()-[e:Cites]->() WHERE n IS SOURCE OF e
RETURN e

Directed Predicates

Directed predicates determine whether an edge variable is bound to a directed edge. GQL supports the following directed predicates:

• IS DIRECTED
• IS NOT DIRECTED

Details

• All edges created in Ultipa Graph Database are directed.

MATCH ()-[e]-()
RETURN e IS DIRECTED

Result:

All Different Predicate

Determines whether all graph elements bound to a list of element variables are pairwise different from one another. GQL supports the following all different predicate:

• ALL_DIFFERENT(<elemVar>, <elemVar>[{，<elemVar>}...])

Details

• Each <elemVar> must have a singleton degree of reference.
• None of the <elemVar>s are allowed to be bound to a null value.
• All values bound to the <elemVar>s must be comparable.

MATCH (n1:User {_id: "U05"}), (n2)-[:Joins]->(n3)
RETURN n1._id, n2._id, n3._id, ALL_DIFFERENT(n1, n2, n3)

Result:

Same Predicate

Determines whether all element variables bind to the same graph element. GQL supports the following same predicate:

• SAME(<elemVar>, <elemVar>[{，<elemVar>}...])

Details

• Each <elemVar> must have a singleton degree of reference.
• None of the <elemVar>s are allowed to be bound to a null value.
• All values bound to the <elemVar>s must be comparable.

MATCH (n1:User {_id: "U05"}), ()-[:Follows]->(n2), (n3)-[:Joins]->()
RETURN n1._id, n2._id, n3._id, SAME(n1, n2, n3)

Result:

Boolean Value Predicates

Evaluates the truthiness of a boolean expression or variable, determining whether it is true or false. GQL supports the following boolean value predicates:

• IS TRUE
• IS FALSE

RETURN 1 > 2 IS TRUE

Result: