Indicateur de requête Gremlin repeatMode

L’indicateur de requête Neptune repeatMode indique la façon dont le moteur Neptune évalue l’étape repeat() dans une traversée Gremlin : largeur en premier, profondeur en premier ou profondeur en premier par blocs.

Le mode d'évaluation de l'étape repeat() est important lorsqu'il est utilisé pour rechercher ou suivre un chemin, au lieu de simplement répéter une étape un nombre limité de fois.

Syntaxe

L'indicateur de requête repeatMode est spécifié en ajoutant une étape withSideEffect à la requête.

g.withSideEffect('Neptune#repeatMode', 'mode').gremlin-traversal

Note

Tous les effets secondaires d'indicateurs de requête Gremlin sont préfixés avec Neptune#.

Modes disponibles

• BFS

  (Breadth-First Search) Recherche dans la largeur en premier

  Mode d'exécution par défaut pour l'étape repeat(). Ce mode permet d'obtenir tous les nœuds de même niveau avant d'aller plus en profondeur dans le chemin.

  Cette version est gourmande en mémoire et les frontières peuvent être très étendues. Le risque que la requête manque de mémoire et soit annulée par le moteur Neptune est plus élevé. Ce mode correspond au plus près aux autres implémentations Gremlin.

• DFS

  (Depth-First Search) Recherche en profondeur en premier

  Suit chaque chemin jusqu'à la profondeur maximale avant de passer à la solution suivante.

  Ce mode utilise moins de mémoire. Il peut offrir de meilleures performances dans des situations comme la recherche d'un chemin unique à partir d'un point de départ vers plusieurs tronçons.

• CHUNKED_DFS

  (Chunked Depth-First Search) Recherche en profondeur en premier par blocs

  Approche hybride qui explore le graphe en profondeur en premier par blocs de 1 000 nœuds, plutôt que 1 nœud (DFS) ou tous les nœuds (BFS).

  Le moteur Neptune extrait jusqu'à 1 000 nœuds à chaque niveau avant de suivre le chemin plus en profondeur.

  Cela constitue un bon compromis entre la vitesse et l'utilisation de la mémoire.

  Cette approche s'avère également utile si vous souhaitez utiliser la mode BFS, mais la que requête utilise trop de mémoire.

Exemple

La section suivante décrit l'effet du mode de répétition sur un parcours Gremlin.

Dans Neptune, le mode par défaut pour l'étape repeat() consiste à effectuer une stratégie d'exécution dans la largeur en premier (BFS) pour toutes les traversées.

Dans la plupart des cas, l' TinkerGraph implémentation utilise la même stratégie d'exécution, mais dans certains cas, elle modifie l'exécution d'une traversée.

Par exemple, l' TinkerGraph implémentation modifie la requête suivante.

g.V("3").repeat(out()).times(10).limit(1).path()

L'étape repeat() de ce parcours est « déroulée » dans le parcours suivant, ce qui se traduit par une stratégie en profondeur en premier (DFS).

g.V(<id>).out().out().out().out().out().out().out().out().out().out().limit(1).path()

Important

Le moteur de requête Neptune ne procède pas ainsi automatiquement.

Breadth-first (BFS) est la stratégie d'exécution par défaut et est similaire TinkerGraph dans la plupart des cas. Cependant, il y a certains cas où les stratégies en profondeur en premier (DFS) sont préférables.

BFS (valeur par défaut)

BFS (dans la largeur en premier) est la stratégie d'exécution par défaut pour l'opérateur repeat().

g.V("3").repeat(out()).times(10).limit(1).path()

Le moteur Neptune explore entièrement les premières frontières à neuf tronçons avant de rechercher une solution à partir du dixième tronçon. Cette approche est efficace dans de nombreux cas, notamment dans celui d'une requête au chemin le plus court.

Cependant, dans l'exemple précédent, le parcours serait beaucoup plus rapide à l'aide du mode profondeur en premier (DFS) pour l'opérateur repeat().

DFS

La requête suivante utilise le mode DFS (profondeur en premier) pour l'opérateur repeat().

g.withSideEffect("Neptune#repeatMode", "DFS").V("3").repeat(out()).times(10).limit(1)

Ce mode suit chaque solution jusqu'à la profondeur maximale avant d'explorer la solution suivante.