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.

# Diffuser les résultats des requêtes avec Gremlin
<a name="access-graph-gremlin-streaming"></a>

Lorsque vous exécutez une traversée Gremlin qui renvoie un grand nombre de résultats, Neptune les renvoie au client par lots via la connexion. WebSocket Neptune envoie les lots de résultats au fur et à mesure de leur production, sans attendre que le client en demande davantage. Cela peut être avantageux si vous souhaitez traiter les résultats tels qu'ils sont renvoyés par le serveur, mais cela nécessite d'utiliser des modèles d'itération paresseux pour éviter de collecter l'ensemble de résultats complet en mémoire.

Neptune envoie les résultats par lots de 64 par WebSocket image par défaut. Vous ne pouvez pas modifier cette valeur par défaut côté serveur, mais la taille du lot peut être modifiée par demande par le client à l'aide de l'option de [`batchSize`](https://tinkerpop.apache.org/docs/current/reference/#gremlin-java-configuration) demande (appelée `Tokens.ARGS_BATCH_SIZE` dans le pilote Java ou `connectionPool.resultIterationBatchSize` par défaut au niveau du pilote).

Pour plus de détails sur la configuration `batchSize` dans d'autres pilotes de langue, consultez la section Configuration de chaque pilote dans la [ documentation des pilotes et variantes d'](https://tinkerpop.apache.org/docs/current/reference/#gremlin-drivers-variants)Apache TinkerPop Gremlin.

Comme le serveur transmet automatiquement les résultats, la contre-pression côté client est gérée implicitement via le protocole TCP et le contrôle de flux. WebSocket Si le client met du temps à lire depuis le socket, les écritures du serveur finiront par être bloquées jusqu'à ce que le client rattrape son retard.

**Important**  
Le streaming est plus efficace avec les traversées qui peuvent produire des résultats de manière incrémentielle. Les traversées qui incluent`order()`,, `groupCount()` `group()``dedup()`, ou d'autres étapes nécessitant la fin de la traversée complète avant d'émettre des résultats obligeront Neptune à matérialiser l'ensemble de résultats complet en mémoire avant le début de la diffusion. Dans ces cas, le traitement par lots réduit tout de même la charge de sérialisation par image, mais ne réduit pas l'utilisation de la mémoire côté serveur.

## Consommer les résultats de manière incrémentielle
<a name="access-graph-gremlin-streaming-usage"></a>

Pour traiter les résultats au fur et à mesure qu'ils arrivent, itérez paresseusement en utilisant`hasNext()`/`next()`ou des API équivalentes plutôt que de rassembler tous les résultats dans une liste. Vous pouvez l'utiliser `next(batchSize)` pour extraire les résultats par lots au niveau de l'application, ce qui vous permet d'effectuer un travail intermédiaire entre les lots pendant que le serveur continue à produire des résultats.

**Example Java (bytecode GLV)**  

```
GraphTraversalSource g = traversal().withRemote(connection);

int batchSize = 10;
int batchNum = 0;
var traversal = g.V().hasLabel("movie").values("title").limit(1000);
while (traversal.hasNext()) {
    var batch = traversal.next(batchSize);
    batchNum++;
    for (var title : batch) {
        System.out.println("  " + title);
    }

    // Do other intermediary work here between batch calls
    System.out.println("Batch " + batchNum + " processing complete\n");
}
```

**Example Python**  

```
g = traversal().with_remote(connection)

BATCH_SIZE = 10
batch_num = 0
t = g.V().has_label('movie').values('title').limit(1000)
while t.has_next():
    batch = t.next(BATCH_SIZE)
    batch_num += 1
    for title in batch:
        print(f"  {title}")

    # Do other intermediary work here between batch calls
    print(f"Batch {batch_num} processing complete\n")
```

**Example Go**  

```
// The Go driver does not support next(n), so batches are accumulated manually.
g := gremlingo.Traversal_().WithRemote(connection)

resultSet, err := g.V().HasLabel("movie").Values("title").Limit(1000).GetResultSet()
if err != nil {
    log.Fatal(err)
}

batchSize := 10
batchNum := 0
for {
    var batch []interface{}
    for i := 0; i < batchSize; i++ {
        result, ok, err := resultSet.One() // returns (value, ok, error); ok is false when results are exhausted
        if err != nil {
            log.Fatal(err)
        }
        if !ok {
            break
        }
        batch = append(batch, result)
    }
    if len(batch) == 0 {
        break
    }
    batchNum++
    for _, v := range batch {
        fmt.Printf("  %v\n", v)
    }

    // Do other intermediary work here between batch calls
    fmt.Printf("Batch %d processing complete\n\n", batchNum)
}
```

**Example .NET**  

```
var g = Traversal().WithRemote(connection);

var batchSize = 10;
var batchNum = 0;
var traversal = g.V().HasLabel("movie").Values<string>("title").Limit<string>(1000);
while (traversal.HasNext())
{
    var batch = traversal.Next(batchSize);
    batchNum++;
    foreach (var title in batch)
    {
        Console.WriteLine($"  {title}");
    }

    // Do other intermediary work here between batch calls
    Console.WriteLine($"Batch {batchNum} processing complete\n");
}
```

**Example Node.js**  

```
// The Node.js driver does not support next(n), so batches are accumulated manually.
const g = traversal().withRemote(connection);

const batchSize = 10;
let batchNum = 0;
const t = g.V().hasLabel('movie').values('title').limit(1000);
while (true) {
    const batch = [];
    for (let i = 0; i < batchSize; i++) {
        const result = await t.next();
        if (result.done) break;
        batch.push(result.value);
    }
    if (batch.length === 0) break;
    batchNum++;
    for (const title of batch) {
        console.log(`  ${title}`);
    }

    // Do other intermediary work here between batch calls
    console.log(`Batch ${batchNum} processing complete\n`);
}
```

## Consommation anticipée ou consommation incrémentielle
<a name="access-graph-gremlin-streaming-avoid"></a>

Le streaming vous permet de traiter les résultats de manière incrémentielle au fur et à mesure que des données supplémentaires sont récupérées et renvoyées. Les méthodes suivantes se bloquent jusqu'à ce que l'ensemble des résultats soit collecté en mémoire, empêchant ainsi votre application d'agir sur les résultats au fur et à mesure qu'ils arrivent :
+ **Java : ** `toList()` ou `toSet()`
+ **Python : ** `toList()` ou `toSet()`
+ **Allez : **`ToList()`,`ToSet()`, ou `GetResultSet().GetAll()`
+ **.NET : ** `ToList()` ou `Promise()`
+ **Node.js:** `toList()`

**Note**  
Les données continuent de circuler de manière incrémentielle sur la WebSocket connexion, même en utilisant ces méthodes. La différence est que votre application ne peut pas traiter les résultats individuels tant que la collection n'est pas complète. Pour traiter les résultats au fur et à mesure qu'ils arrivent, utilisez l'itération différée ou les modèles de lots présentés dans les exemples ci-dessus.