La requête spread().src().depth() peut trouver et retourner des edges à partir d'un node de départ dans un rayon de K sauts, en spécifiant l'indice k, en appliquant des filtres sur le node initial, tous les edges et tous les nodes voisins. Les edges trouvés sont retournés des moins profonds aux plus profonds, sous forme de chemins à 1 étape (node de départ, edge, node de fin).

Spread est une méthode de requête BFS (Breadth First Search) couramment utilisée dans l'industrie de l'analyse graphique pour observer les couches de relations autour d'une entité, et pour récupérer et acquérir des données rapidement.

Syntaxe :

• Alias de déclaration : supporté (PATH)
• Tous les paramètres :

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

create().edge_property(@default, "weight", int32)
insert().into(@default).nodes([{_id:"A", _uuid:1}, {_id:"B", _uuid:2}, {_id:"C", _uuid:3}, {_id:"D", _uuid:4}, {_id:"E", _uuid:5}, {_id:"F", _uuid:6}])
insert().into(@default).edges([{_uuid:1, _from_uuid:1, _to_uuid:3, weight:1}, {_uuid:2, _from_uuid:5, _to_uuid:2 , weight:1}, {_uuid:3, _from_uuid:1, _to_uuid:5 , weight:4}, {_uuid:4, _from_uuid:4, _to_uuid:3 , weight:2}, {_uuid:5, _from_uuid:5, _to_uuid:4 , weight:3}, {_uuid:6, _from_uuid:2, _to_uuid:1 , weight:2}, {_uuid:7, _from_uuid:6, _to_uuid:1 , weight:4}])

Filtrer la Profondeur

Trouver les edges à 1~2 sauts du node D, les retourner sous forme de chemins et transporter toutes les propriétés

spread().src({_id == "D"}).depth(2) as e
return e{*}

A --1--> C
E --5--> D
A --3--> E
D --4--> C
E --2--> B
B --6--> A

Analyse : Les nodes de départ et d'arrivée de l'edge 6 sont à 2 sauts du node D, l'edge 6 est également considéré comme à 2 sauts du node D.

Filtrer les Nodes Voisins

Exemple : Trouver les edges à 1~2 sauts du node D, dont le chemin le plus court ne passe pas par le node E, les retourner sous forme de chemins et transporter toutes les propriétés

spread().src({_id == "D"}).depth(2)
  .node_filter({_id != "E"}) as e
return e{*}

A --1--> C
D --4--> C

Analyse : Lorsque les chemins les plus courts ne doivent pas passer par le node E, cela équivaut à retirer le node E et ses edges adjacents 2, 3 et 5 du graph, auquel cas l'edge 6 est à 3 sauts du node D et n'est pas présent dans le résultat.

Filtrer les Edges

Exemple : Trouver les edges à 1~2 sauts du node D, dont le chemin le plus court ne passe pas par l'edge 5, les retourner sous forme de chemins et transporter toutes les propriétés

spread().src({_id == "D"}).depth(2)
  .edge_filter({_uuid != 5}) as e
return e{*}

A --1--> C
D --4--> C

Analyse : Lorsque les chemins les plus courts ne doivent pas passer par l'edge 5, cela équivaut à retirer l'edge 5 du graph, auquel cas les edges 3 et 6 sont à 3 sauts du node D, l'edge 2 est à 4 sauts du node D.

Filtrer la Direction des Edges

Exemple : Trouver les edges à 1~2 sauts du node D, avec tous les edges pointant vers la droite, les retourner sous forme de chemins et transporter toutes les propriétés

spread().src({_id == "D"}).depth(2)
  .direction(right) as e
return e{*}

D --4--> C

Lorsque tous les edges dans le chemin le plus court pointent vers la droite (sortant), le node D n'a qu'un seul edge à 1 saut 4, et n'a pas d'edge à 2 sauts ou plus car le node de fin de l'edge 4 n'a pas d'edge sortant.

Exemple : Trouver les edges à 1~2 sauts du node D, avec tous les edges pointant vers la gauche, les retourner sous forme de chemins et transporter toutes les propriétés

spread().src({_id == "D"}).depth(2)
  .direction(left) as e
return e{*}

E --5--> D
A --3--> E

Analyse : Lorsque tous les edges dans le chemin le plus court pointent vers la gauche (entrant), le node D a un edge à 1 saut 5 et un edge à 2 sauts 3.

Limiter le Résultat de la Sous-Requête

Exemple : Trouver trois edges à 1~3 sauts du node D, les retourner sous forme de chemins et transporter toutes les propriétés

spread().src({_id == "D"}).depth(3).limit(3) as e
return e{*}

E --5--> D
A --3--> E
D --4--> C