Vue d’ensemble

L'instruction RETURN vous permet de spécifier les colonnes à inclure dans la table finale. Chaque colonne est définie par une expression pouvant inclure des variables, des propriétés, des fonctions, des constantes, etc.

<return statement> ::= 
  "RETURN" [ <set quantifier> ] { <"*"> | <return item list> }
  [ <group by clause> ]
                          
<return item list> ::= <return item> [ { "," <return item> }... ]

<return item> ::= <value expression> [ <return item alias> ]
  
<return item alias> ::= "AS" <identifier>

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

Détails

• Lorsque le quantificateur d'ensemble DISTINCT est spécifié, chaque élément de retour est un opérande d'une opération de regroupement, les enregistrements en double sont supprimés et seuls les distincts sont retournés.
• * retourne toutes les colonnes de la table de travail actuelle.
• Le mot-clé AS est utilisé pour renommer les colonnes.
• L'instruction RETURN prend en charge l'utilisation de la clause GROUP BY pour regrouper la table finale en spécifiant des clés de regroupement.

Exemple de Graphe

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

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

INSERT (alex:Student {_id: 's1', name: 'Alex', gender: 'male'}),
       (susan:Student {_id: 's2', name: 'Susan', gender: 'female'}),
       (art:Course {_id: 'c1', name: 'Art', credit: 13}),
       (literature:Course {_id: 'c2', name: 'Literature', credit: 15}),
       (alex)-[:Take {year: 2024, term: 'Spring'}]->(art),
       (susan)-[:Take {year: 2023, term: 'Fall'}]->(art),
       (susan)-[:Take {year: 2023, term: 'Spring'}]->(literature)

Retourner les nœuds

Une variable liée aux nœuds retourne le label et les propriétés de chaque nœud.

MATCH (n:Course)
RETURN n

Résultat: n

Retourner les arêtes

Une variable liée aux arêtes retourne le label et les propriétés de chaque arête.

MATCH ()-[e]->()
RETURN e

Résultat: e

Retourner les chemins

Une variable liée aux chemins retourne les nœuds et arêtes inclus dans chaque chemin. Chaque élément inclut son label et ses propriétés.

MATCH p = ()-[:Take {term: "Spring"}]->()
RETURN p

Résultat:

Retourner les labels

La fonction labels() peut être utilisée pour retourner les labels des nœuds et arêtes.

MATCH ({_id: "s2"})-[e]->(n)
RETURN labels(e), labels(n)

Résultat:

Retourner les propriétés

L'opérateur point . peut être utilisé pour extraire la valeur d'une propriété spécifiée à partir d'une variable liée aux nœuds ou arêtes. La valeur null sera retournée si la propriété spécifiée n'est pas trouvée sur les nœuds ou arêtes.

MATCH (:Student {name:"Susan"})-[]->(c:Course)
RETURN c.name, c.credit, c.type

Résultat:

Retourner tout

* est utilisé pour retourner toutes les colonnes dans la table de travail actuelle.

MATCH (s:Student {name:"Susan"})-[]->(c:Course)
RETURN *

Résultat:

s

c

Alias de colonne

Le mot-clé AS est utilisé pour renommer les colonnes retournées.

MATCH (s:Student)-[t:Take]->(c:Course)
RETURN s.name AS Student, c.name AS Course, t.year AS TakenIn

Résultat:

Retourner des enregistrements distincts

Le quantificateur d'ensemble DISTINCT peut être utilisé pour retourner des enregistrements dédupliqués.

MATCH ()-[e]->()
RETURN DISTINCT e.year

Résultat:

Retourner avec agrégation

Les fonctions d'agrégation, comme sum() et max(), peuvent être directement appliquées dans l'instruction RETURN.

MATCH (:Student {name:"Susan"})-[]->(c:Course)
RETURN sum(c.credit)

Résultat:

Retourner par CAS

Les fonctions CASE peuvent être directement appliquées dans l'instruction RETURN.

MATCH (n:Course)
RETURN n.name AS Course, CASE WHEN n.credit > 14 THEN "Y" ELSE "N" END AS Recommended

Résultat:

Retourner des enregistrements limités

L'instruction LIMIT peut être utilisée pour restreindre le nombre de lignes retournées.

MATCH (n:Course)
RETURN n.name LIMIT 1

Résultat:

Retourner des enregistrements ordonnés

L'instruction ORDER BY peut être utilisée pour trier les lignes selon les valeurs spécifiées.

MATCH (n:Course)
RETURN n ORDER BY n.credit DESC

Résultat: n

Retourner avec regroupement

La clause GROUP BY peut être utilisée optionnellement pour regrouper la table finale.

MATCH ()-[e:Take]->()
RETURN e.term AS Term, count(e) GROUP BY Term

Résultat: