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.

# Indicateur de requête Gremlin repeatMode
<a name="gremlin-query-hints-repeatMode"></a>

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
<a name="gremlin-query-hints-repeatMode-syntax"></a>

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
<a name="gremlin-query-hints-repeatMode-example"></a>

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.