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:
AND |
True | False |
---|---|---|
True | True | False |
False | False | False |
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:
OR |
True | False |
---|---|---|
True | True | True |
False | True | False |
This query returns users whose age
exceeds 30, or incomeGroup
equals to 4:
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:
XOR |
True | False |
---|---|---|
True | False | True |
False | True | False |
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:
NOT |
True | False |
---|---|---|
False | True |
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:
(2+8)%3 |
---|
1 |
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:
<=
- Belong to:
in
(See Membership Checking)
This query returns users whose age
is not 30:
MATCH (n:User)
WHERE n.age <> 30
RETURN n
String Operators
String Concatenation
The ||
combines multiple strings into a single string by merging the characters of each string in order.
RETURN "data" || "base"
Result:
"data" || "base" |
---|
database |
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 toNFC
. Other available normalization forms areNFD
,NFKC
andNFKD
.
RETURN "Å" IS NORMALIZED AS normRes
Result:
normRes |
---|
1 |
RETURN "Å" IS NFD NORMALIZED AS normRes
Result:
normRes |
---|
0 |
List Operators
List Construction
The []
can create a list by placing comma-separated elements inside.
LET items = [1,2,3]
RETURN items
Result:
items |
---|
[1,2,3] |
The []
can also construct a nested list:
LET items = [[1,2],[2,3]]
RETURN items
Result:
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
.
LET items = ["a", 1, "b"]
RETURN items[0]
Result:
items[0] |
---|
a |
Membership Checking
The IN
checks whether a specified element exists within a list. It evaluates to 1
for true and 0
for false.
This query returns nodes whose _id
can be found in the list of ["U01", "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:
newList |
---|
[1,2,3,3,4,5] |
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:
rec.length |
---|
20 |
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:
capacity |
---|
11800 |
Deduplication
The DISTINCT
ensures that only unique values are included.
This query returns distinct age
values of users:
MATCH (n:User)
RETURN DISTINCT n.age
Exists Predicate
The EXISTS
predicate evaluates whether a specified graph pattern or query returns any results. If it finds matching data, the predicate evaluates to true; otherwise, it evaluates to false. Note that the EXISTS
predicate is not supported in the MATCH
statement.
<exists predicate> ::=
"EXISTS" {
"{" <graph pattern> "}"
| "(" <graph pattern> ")"
| "{" { <match statement>... } "}"
| "(" { <match statement>... } ")"
| <nested query specification>
}
<nested query specification> ::= "{" <query specification> "}"
This query checks whether any path with node A
as source node exists in the graph and returns the result as a boolean:
RETURN EXISTS {({_id:"A"})->()}
This query checks whether there is an edge with score
exceeds 2 exist between nodes A
and B
in the graph and returns the result as a boolean:
RETURN EXISTS {
MATCH ({_id: "A"})-[e]->({_id: "B"})
WHERE e.score > 2
}
This query checks whether any element in a list is greater than 3 and returns the result as a boolean:
RETURN EXISTS {
FOR item in [1,2,3]
FILTER item > 3
RETURN item
}
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:
typeCheck |
---|
0 |
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:
e IS DIRECTED |
---|
1 |
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:
n1._id | n2._id | n3._id | ALL_DIFFERENT(n1, n2, n3) |
---|---|---|---|
U05 | U05 | C01 | 0 |
U05 | U04 | C02 | 1 |
U05 | U02 | C01 | 1 |
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:
n1._id | n2._id | n3._id | SAME(n1, n2, n3) |
---|---|---|---|
U05 | U03 | U04 | 0 |
U05 | U03 | U05 | 0 |
U05 | U05 | U04 | 0 |
U05 | U05 | U05 | 1 |
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:
1 > 2 IS TRUE |
---|
0 |