Vue d’ensemble

Instruction de Requête Linéaire

En GQL, une instruction de requête linéaire fait référence à une requête exécutée séquentiellement, où chaque instruction est traitée successivement sans aucune ramification ni logique conditionnelle. Le résultat est renvoyé dans une progression directe et linéaire.

Par exemple, c'est une requête linéaire où les instructions MATCH, FILTER et RETURN sont traitées dans un ordre linéaire :

MATCH (:User {_id: "U01"})-[:Follows]->(u:User)
FILTER u.city = "New York"
RETURN u

<linear query statement> ::=  
  [ <simple linear query statement> ] <result statement>

<simple linear query statement> ::= <simple query statement>...

<simple query statement> ::=  
    <match statement>
  | <filter statement>
  | <let statement>
  | <for statement>
  | <order by statement>
  | <limit statement>
  | <skip statement>
  | <call statement>

<result statement> ::=  
  <return statement> [ <order by statement> ] [ <skip statement> ] [ <limit statement> ]

Détails

• Une instruction de requête linéaire se termine par une instruction de résultat et peut inclure une composition linéaire d'instructions de requête simples avant cela.

Instruction de Requête Composite

Une instruction de requête composite combine une liste d'instructions de requête linéaires avec des conjonctions de requêtes.

<composite query statement> ::=  
  <linear query statement> <query conjunction> <linear query statement>
  [ { <query conjunction> <linear query statement> }... ]

<query conjunction> ::= <set operator> | "OTHERWISE"

<set operator> ::= "UNION" [ <set quantifier> ]
                 | "EXCEPT" [ <set quantifier> ]
                 | "INTERSECT" [ <set quantifier> ]

<set quantifier> ::= "DISTINCT" | "ALL"

Détails

• Le nombre, l'ordre et les noms des colonnes doivent être identiques dans les instructions RETURN de toutes les requêtes linéaires.
• Les tables de liaison produites par les instructions de requête linéaires sont composées ensemble.
• Si l'opérateur d'ensemble est spécifié tandis que le quantificateur d'ensemble ne l'est pas, alors DISTINCT est implicite. La déduplication est effectuée sur les enregistrements de la table de liaison.
• Vous pouvez utiliser différentes conjonctions de requête dans une instruction de requête composite.

Exemple de Graph

Les exemples suivants s'exécutent sur ce graph :

Pour créer ce graph, exécutez la requête suivante sur un graph vide :

INSERT (rowlock:User {_id:'U01', name:'rowlock'}),
       (brainy:User {_id:'U02', name:'Brainy'}),
       (purplechalk:User {_id:'U03', name:'purplechalk'}),
       (mochaeach:User {_id:'U04', name:'mochaeach'}),
       (lionbower:User {_id:'U05', name:'lionbower'}),
       (c01:Club {_id:'C01'}),
       (c02:Club {_id:'C02'}),
       (rowlock)-[:Follows]->(brainy),
       (brainy)-[:Follows]->(rowlock),
       (mochaeach)-[:Follows]->(brainy),
       (brainy)-[:Follows]->(purplechalk),
       (purplechalk)-[:Follows]->(brainy),
       (brainy)-[:Joins]->(c01),
       (lionbower)-[:Joins]->(c01),
       (mochaeach)-[:Joins]->(c02)

UNION

UNION combine les résultats de deux ou plusieurs requêtes linéaires en un ensemble de résultats unique incluant les lignes distinctes présentes dans l'une des requêtes.

MATCH (n:Club) RETURN n
UNION
MATCH (n) RETURN n

Résultat : n

UNION ALL

UNION ALL combine les résultats de deux ou plusieurs requêtes linéaires en un ensemble de résultats unique incluant toutes les lignes de chaque requête sans supprimer les doublons.

MATCH (n:Club) RETURN n
UNION ALL
MATCH (n) RETURN n

Résultat : n

EXCEPT

EXCEPT renvoie un ensemble de résultats incluant les lignes distinctes de la première requête qui ne sont pas présentes dans les requêtes suivantes.

MATCH ({_id: "U02"})-(n) RETURN n
EXCEPT
MATCH ({_id: "U05"})-(n) RETURN n

Résultat : n

EXCEPT ALL

EXCEPT ALL renvoie un ensemble de résultats incluant les lignes de la première requête qui ne sont pas présentes dans les requêtes suivantes sans supprimer les doublons.

MATCH ({_id: "U02"})-(n) RETURN n
EXCEPT ALL
MATCH ({_id: "U05"})-(n) RETURN n

Résultat : n

INTERSECT

INTERSECT renvoie un ensemble de résultats incluant uniquement les lignes distinctes communes à toutes les requêtes linéaires, en filtrant les lignes qui n'apparaissent pas dans chaque requête.

MATCH ({_id: "U01"})-(u:User) RETURN u
INTERSECT
MATCH ({_id: "U03"})-(u:User) RETURN u

Résultat : u

INTERSECT ALL

INTERSECT ALL renvoie un ensemble de résultats incluant uniquement les lignes communes à toutes les requêtes linéaires sans supprimer les doublons, en filtrant les lignes qui n'apparaissent pas dans chaque requête.

MATCH ({_id: "U01"})-(u:User) RETURN u
INTERSECT ALL
MATCH ({_id: "U03"})-(u:User) RETURN u

Résultat : u

OTHERWISE

OTHERWISE renvoie l'ensemble de résultats de la première requête si elle produit des résultats. Si la première requête ne donne aucun résultat, elle retourne l'ensemble de résultats de la deuxième requête, et ainsi de suite, jusqu'à ce qu'une requête avec un ensemble de résultats non vide soit trouvée.

MATCH ({_id: "U04"})<-[]-(u:User) RETURN u
OTHERWISE
MATCH ({_id: "U02"})<-[]-(u:User) RETURN u

Résultat : u

Cet ensemble de résultats de la première requête linéaire contient une valeur null, ce n'est pas vide en raison de l'utilisation de OPTIONAL :

OTHERWISE renvoie l'ensemble de résultats de la première requête linéaire si elle contient des lignes, y compris une ligne avec la valeur null :

OPTIONAL MATCH ({_id: "U04"})<-[]-(u:User) RETURN u
OTHERWISE
MATCH ({_id: "U02"})<-[]-(u:User) RETURN u

Résultat :

Renommage des Colonnes

Vous pouvez utiliser le mot-clé AS pour renommer les colonnes pour garantir que les tables de liaison des requêtes linéaires peuvent être composées.

MATCH ({_id: "C01"})<-(u) RETURN u.name, 1 AS Club
UNION
MATCH ({_id: "C02"})<-(u) RETURN u.name, 2 AS Club

Résultat :

Utilisation de Différentes Conjonctions de Requête

MATCH (n:Club) RETURN n._id
OTHERWISE
MATCH (n) RETURN n._id
UNION ALL
MATCH (n)-[]->(:Club) RETURN n._id

Résultat :