Tous les Opérateurs

Opérateurs de Propriété

Référence de Propriété

Le . (point) vous permet de référencer une propriété d'un élément de graph.

MATCH (n)
RETURN n._id LIMIT 10

Prédicat d'Existence de Propriété

Le prédicat PROPERTY_EXISTS(<elemVar>, <propertyName>) détermine si un élément de graph référencé a une propriété.

Détails

• Chaque <elemVar> doit avoir un degré de référence singleton.

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

Opérateurs Logiques

AND

Combine deux ou plusieurs conditions de sorte que toutes doivent être vraies pour que l'expression entière soit évaluée comme vraie.

Table de vérité pour l'opérateur AND:

Cette requête renvoie les utilisateurs dont age dépasse 30 et incomeGroup est égal à 4:

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

OR

Combine deux ou plusieurs conditions dont l'une d'elles doit être vraie pour que l'expression entière soit évaluée comme vraie.

Table de vérité pour l'opérateur OR:

Cette requête renvoie les utilisateurs dont age dépasse 30, ou incomeGroup est égal à 4:

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

XOR

Combine deux ou plusieurs conditions. L'expression entière est évaluée comme vraie uniquement lorsque exactement une des conditions est vraie. Si les deux conditions sont vraies ou les deux sont fausses, elle retourne faux.

Table de vérité pour l'opérateur XOR:

Cette requête renvoie les utilisateurs dont age dépasse 30 ou incomeGroup est égal à 4, mais exclut les utilisateurs qui répondent aux deux critères:

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

NOT

Négocie une condition, renvoyant vrai si la condition spécifiée est fausse et inversement.

Table de vérité pour l'opérateur NOT:

Cette requête renvoie les utilisateurs dont age n'est pas 30:

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

Opérateurs Arithmétiques

Effectue des opérations mathématiques sur des valeurs numériques. GQL supporte les opérateurs arithmétiques suivants:

• Addition: +
• Soustraction: -
• Multiplication: *
• Division: /
• Modulus: %
• Exponentiation: ^

RETURN (2+8)%3

Résultat:

Opérateurs de Comparaison

Compare deux valeurs ou expressions et retourne vrai ou faux. GQL supporte les opérateurs de comparaison suivants:

• Égal à: =
• Différent de: <>
• Supérieur à: >
• Inférieur à: <
• Supérieur ou égal à: >=
• Inférieur ou égal à: <=

Cette requête renvoie les utilisateurs dont age n'est pas 30:

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

Opérateurs de Chaîne

Concaténation de Chaîne

L'opérateur de concaténation || combine plusieurs chaînes en une seule chaîne en fusionnant les caractères de chaque chaîne dans l'ordre.

RETURN "data" || "base"

Résultat:

Prédicats Normalisés

Détermine si une valeur de chaîne de caractères est normalisée. GQL supporte les prédicats normalisés suivants:

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

Détails

• La <normal form> par défaut est NFC. D'autres formes de normalisation disponibles sont NFD, NFKC et NFKD.

RETURN "Å" IS NORMALIZED AS normRes

Résultat:

RETURN "Å" IS NFD NORMALIZED AS normRes

Résultat:

Opérateurs de Liste

Construction de Liste

Les [] peuvent créer une liste en plaçant des éléments séparés par des virgules à l'intérieur.

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

Résultat:

Les [] peuvent également construire une liste imbriquée:

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

Résultat:

Accès aux Éléments

Les [] peuvent accéder aux éléments au sein d'une liste par leurs index. Les listes utilisent des index basés sur zéro, ce qui signifie que le premier élément est à l'index 0.

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

Résultat:

Vérification de l'Appartenance

L'opérateur d'appartenance IN vérifie si un élément spécifié existe au sein d'une liste. Il s'évalue à 1 pour vrai et 0 pour faux.

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

Résultat:

L'opérateur IN peut filtrer efficacement les éléments de graph en fonction de l'appartenance à une liste spécifiée. Par exemple, cette requête récupère les nœuds dont _id est "U01" ou "U02":

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

Concaténation de Liste

L'opérateur de concaténation || combine plusieurs listes en une seule liste en fusionnant les éléments de chaque liste dans l'ordre.

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

Résultat:

Opérateurs de Chemin

Construction de Chemin

Le PATH[] crée un chemin en énumérant les références de node et d'edge dans l'ordre.

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

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

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

Détails

• Si <path element list> contient la valeur null ou n'identifie pas un chemin, une exception est levée: Malformed path.

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

Concaténation de Chemin

L'opérateur de concaténation || joint plusieurs chemins en un chemin unique continu, fusionnant le dernier node du premier chemin avec le premier node du second chemin lorsqu'ils sont identiques. Si cette condition n'est pas remplie, une exception est levée: Malformed path.

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

Opérateurs de Record

Construction de Record

Le RECORD{} crée un record en spécifiant des champs.

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

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

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

Résultat:

Référence de Champ

Le . (point) vous permet de référencer un champ d'un record.

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

Résultat:

Prédicats de Null

Spécifie un test pour une valeur null. GQL supporte les prédicats de null suivants:

• IS NULL
• IS NOT NULL

Cette requête récupère le title de chaque node :Paper si la valeur n'est pas null; sinon, elle renvoie le message TITLE NOT FOUND.

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

Prédicats de Type de Valeur

Détermine si une valeur est conforme à un type spécifique. GQL supporte les prédicats de type de valeur suivants:

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

Détails

• Actuellement, la <value type> supporte les mots-clés de type de données suivants: STRING, BOOL.

RETURN "a" IS TYPED BOOL AS typeCheck

Résultat:

Prédicats Étiquetés

Détermine si un élément de graph satisfait une instruction d'étiquette. GQL supporte les prédicats étiquetés suivants:

• IS LABELED
• IS NOT LABELED
• :

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

MATCH (n:Paper)
RETURN n

Prédicats Source/Destination

Détermine si un node est la source ou la destination d'un edge. GQL supporte les prédicats source/destination suivants:

• <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

Prédicats Dirigés

Les prédicats dirigés déterminent si une variable d'edge est liée à un edge dirigé. GQL supporte les prédicats dirigés suivants:

• IS DIRECTED
• IS NOT DIRECTED

Détails

• Tous les edges créés dans Ultipa Graph Database sont dirigés.

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

Résultat:

Prédicat Tout Différent

Détermine si tous les éléments de graph liés à une liste de variables d'éléments sont doublement différents les uns des autres. GQL supporte le prédicat tout différent suivant:

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

Détails

• Chaque <elemVar> doit avoir un degré de référence singleton.
• Aucun des <elemVar>s ne doit être lié à une valeur null.
• Toutes les valeurs liées aux <elemVar>s doivent être comparables.

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

Résultat:

Prédicat Même

Détermine si toutes les variables d'éléments lient au même élément de graph. GQL supporte le prédicat même suivant:

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

Détails

• Chaque <elemVar> doit avoir un degré de référence singleton.
• Aucun des <elemVar>s ne doit être lié à une valeur null.
• Toutes les valeurs liées aux <elemVar>s doivent être comparables.

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

Résultat:

Prédicats de Valeur Booléenne

Évalue la véracité d'une expression booléenne ou d'une variable, déterminant si elle est vraie ou fausse. GQL supporte les prédicats de valeur booléenne suivants:

• IS TRUE
• IS FALSE

RETURN 1 > 2 IS TRUE

Résultat: