RETURN effectue des opérations fonctionnelles sur l'alias et assemble plusieurs valeurs de retour à renvoyer au client. Les valeurs de retour qui sont hétérologues ne seront PAS tronquées.

Syntaxe : RETURN <expression> as <alias>, <expression> as <alias>, ...
Entrées :

• <expression> : Valeur de retour
• <alias> : Alias de la valeur de retour, optionnel

La clause RETURN est généralement la dernière instruction d'un UQL, mais peut également être suivie de ORDER BY, LIMIT ou SKIP. La dé-duplication d'un alias dans la clause RETURN n'affectera pas ses alias homologues.

Par exemple, assembler 3 valeurs de retour, dont n1 est hétérologue avec les deux autres ; la dé-duplication sur n2.color n'affecte PAS pnodes(path), qui est homologue avec n2.color :

find().nodes() as n1 limit 5
n(3).e()[2].n(as n2) as path
return n1, pnodes(path), dedup(n2.color)

Pour savoir comment désigner les propriétés à être portées par NODE, EDGE, ou PATH dans la clause RETURN, veuillez vous référer au Chapitre Query - Alias System.

Exemple de graph : (à utiliser pour les exemples suivants)

create().node_schema("account").node_schema("movie").edge_schema("rate").edge_schema("wishlist")
create().node_property(@*, "name").node_property(@account, "age", int32).node_property(@movie, "year", int32).edge_property(@rate, "score", int32)
insert().into(@account).nodes([{_id:"S001", _uuid:1, name:"Pepe", age:24}, {_id:"S002", _uuid:2, name:"Lina", age:23}, {_id:"S003", _uuid:3, name:"Emma", age:26}])
insert().into(@movie).nodes([{_id:"M001", _uuid:4, name:"Léon", year:1994}, {_id:"M002", _uuid:5, name:"Avatar", year:2009}])
insert().into(@rate).edges([{_uuid:1, _from_uuid:1, _to_uuid:4, score:9}, {_uuid:2, _from_uuid:3, _to_uuid:5, score:8}])
insert().into(@wishlist).edges([{_uuid:3, _from_uuid:2, _to_uuid:4}, {_uuid:4, _from_uuid:3, _to_uuid:4}])

Return NODE

Exemple : Transporter toutes les propriétés

find().nodes({@account}) as n
return n{*} 

|-------- @account ---------|
| _id  | _uuid | name | age |
|------|-------|------|-----|
| S001 | 1     | Pepe | 24  |
| S002 | 2     | Lina | 23  |
| S003 | 3     | Emma | 26  |

Exemple : Transporter certaines propriétés personnalisées

find().nodes() as n
return n{name, year} 

|------ @account -----|
| _id  | _uuid | name |
|------|-------|------|
| S001 | 1     | Pepe |
| S002 | 2     | Lina |
| S003 | 3     | Emma |

|----------- @movie -----------|
| _id  | _uuid |  name  | year |
|------|-------|--------|------|
| M001 | 4     | Léon   | 1994 |
| M002 | 5     | Avatar | 2009 |

Analyse : NODE transporte uniquement les propriétés qu'il possède.

Exemple : Transporter uniquement les propriétés système

find().nodes({@movie}) as n
return n 

|--- @movie ---|
| _id  | _uuid |
|------|-------|
| M001 | 4     |
| M002 | 5     |

Return EDGE

Exemple : Transporter toutes les propriétés

find().edges({@rate}) as e
return e{*} 

|------------------------ @rate -----------------------|
| _uuid | _from | _to  | _from_uuid | _to_uuid | score |
|-------|-------|------|------------|----------|-------|
|   1   | S001  | M001 | 1          | 4        | 9     |
|   2   | S003  | M002 | 3          | 5        | 8     |

Exemple : Transporter uniquement les propriétés système

find().edges() as e
return e 

|-------------------- @rate -------------------|
| _uuid | _from | _to  | _from_uuid | _to_uuid |
|-------|-------|------|------------|----------|
|   1   | S001  | M001 | 1          | 4        |
|   2   | S003  | M002 | 3          | 5        |

|------------------ @wishlist -----------------|
| _uuid | _from | _to  | _from_uuid | _to_uuid |
|-------|-------|------|------------|----------|
|   3   | S002  | M001 | 2          | 4        |
|   4   | S003  | M001 | 3          | 4        |

Return PATH

Exemple : Transporter certaines propriétés personnalisées

n({@account}).e({@rate}).n({@movie}) as p
return p{name}{*}

[
  {
    "nodes":[
      {"id":"S001","uuid":"1","schema":"account","values":{"name":"Pepe"}},
      {"id":"M001","uuid":"4","schema":"movie","values":{"name":"Léon"}}
    ],
    "edges":[
      {"uuid":"1","from":"S001","to":"M001","from_uuid":"1","to_uuid":"4","schema":"rate","values":{"score":"9"}}
    ],
    "length":1
  },
  {
    "nodes":[
      {"id":"S003","uuid":"3","schema":"account","values":{"name":"Emma"}},
      {"id":"M002","uuid":"5","schema":"movie","values":{"name":"Avatar"}}
    ],
    "edges":[
      {"uuid":"2","from":"S003","to":"M002","from_uuid":"3","to_uuid":"5","schema":"rate","values":{"score":"8"}}
    ],
    "length":1
  }
]

Exemple : Transporter uniquement les propriétés système

n({@movie}).e({@rate}).n({@account}).e({@wishlist}).n({@movie}) as p
return p

[
  {
    "nodes":[
      {"id":"M002","uuid":"5","schema":"movie","values":{}},
      {"id":"S003","uuid":"3","schema":"account","values":{}},
      {"id":"M001","uuid":"4","schema":"movie","values":{}}
    ],
    "edges":[
      {"uuid":"2","from":"S003","to":"M002","from_uuid":"3","to_uuid":"5","schema":"rate","values":{}},
      {"uuid":"4","from":"S003","to":"M001","from_uuid":"3","to_uuid":"4","schema":"wishlist","values":{}}
    ],
    "length":2
  }
]

Return TABLE

Exemple : Trouver le chemin à une étape @account-@movie, assembler le name des comptes et des films dans un tableau

n({@account} as a).e({@wishlist}).n({@movie} as b)
return table(a.name, b.name)

| a.name | b.name |
|--------|--------|
| Lina   | Léon   | 
| Emma   | Léon   | 

Return ATTR - Atomique

Exemple : Retourner les propriétés personnalisées des "nodes" de manière indépendante

find().nodes() as n
return n.name, n.age, n.year 

Pepe
Lina
Emma
Léon
Avatar

24
23
26
null
null

null
null
null
1994
2009

Analyse : Un null sera retourné lors de l'appel d'une propriété qui n'existe pas.

Return ATTR - Liste

Exemple : Assembler le name des voisins à 1 bond de chaque film dans une liste

khop().n({@movie} as a).e().n() as b
group by a
return a.name, collect(b.name)

Léon
Avatar

["Pepe","Lina","Emma"]
["Emma"]

Format de Retour Valide

Supposons que nodes, edges, paths, mytable, mylist, mypoint et myitem soient des alias de type NODE, EDGE, PATH, TABLE, list, point et autres, les formats de retour ci-dessous sont supportés :