Indication de requête Gremlin RepeatMode - Amazon Neptune

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Indication de requête Gremlin RepeatMode

Le NeptunerepeatModeUne astuce de requête indique comment le moteur Neptune évalue lerepeat()étape d'une traversée de Gremlin : largeur d'abord, profondeur en premier ou profondeur en morceaux d'abord.

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 soit à court 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 obtiendra jusqu'à 1 000 nœuds à chaque niveau avant de suivre le chemin plus profondément.

    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 pourrepeat()l'étape consiste à effectuer d'abord une opération en largeur (BFS) stratégie d'exécution pour toutes les traversées.

Dans la plupart des cas, TinkerGraph L'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, TinkerGraph l'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êtes Neptune ne le fait pas automatiquement.

La largeur d'abord (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 pleinement les frontières des neuf premiers sauts avant de trouver une solution à dix sauts. 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.