Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Hasil kueri streaming dengan Gremlin
<a name="access-graph-gremlin-streaming"></a>

Saat Anda menjalankan traversal Gremlin yang mengembalikan sejumlah besar hasil, Neptunus mengalirkannya kembali ke klien dalam batch melalui koneksi. WebSocket Neptunus mengirimkan batch hasil saat diproduksi, tanpa menunggu klien meminta lebih banyak. Ini bisa menguntungkan jika Anda ingin memproses hasil saat dikembalikan dari server, tetapi memerlukan penggunaan pola iterasi malas untuk menghindari pengumpulan hasil lengkap yang disetel ke dalam memori.

Neptunus mengirimkan hasil dalam batch 64 WebSocket per frame secara default. Anda tidak dapat mengubah default sisi server ini, tetapi ukuran batch dapat diganti berdasarkan per-permintaan dari klien menggunakan opsi [https://tinkerpop.apache.org/docs/current/reference/#gremlin-java-configuration](https://tinkerpop.apache.org/docs/current/reference/#gremlin-java-configuration)permintaan (dipanggil `Tokens.ARGS_BATCH_SIZE` di driver Java, atau sebagai default tingkat driver). `connectionPool.resultIterationBatchSize`

Untuk detail tentang mengonfigurasi driver `batchSize` bahasa lain, lihat bagian Konfigurasi untuk setiap driver di dokumentasi [Apache TinkerPop Gremlin Drivers](https://tinkerpop.apache.org/docs/current/reference/#gremlin-drivers-variants) and Variants.

Karena server mendorong hasil secara otomatis, tekanan balik sisi klien ditangani secara implisit melalui TCP dan kontrol aliran. WebSocket Jika klien lambat membaca dari soket, penulisan server pada akhirnya akan diblokir sampai klien menyusul.

**penting**  
Streaming paling efektif dengan traversal yang dapat menghasilkan hasil secara bertahap. Traversal yang mencakup`order()`,,`groupCount()`, `group()``dedup()`, atau langkah-langkah lain yang memerlukan traversal penuh untuk diselesaikan sebelum memancarkan hasil akan menyebabkan Neptunus mewujudkan seluruh hasil yang ditetapkan dalam memori sebelum streaming dimulai. Dalam kasus ini, batching masih mengurangi overhead serialisasi per frame, tetapi tidak mengurangi penggunaan memori sisi server.

## Mengkonsumsi hasil secara bertahap
<a name="access-graph-gremlin-streaming-usage"></a>

Untuk memproses hasil saat mereka tiba, ulangi dengan malas menggunakan`hasNext()`/`next()`atau setara APIs daripada mengumpulkan semua hasil ke dalam daftar. Anda dapat menggunakan `next(batchSize)` untuk menarik hasil dalam batch tingkat aplikasi, memungkinkan Anda untuk melakukan pekerjaan menengah antar batch sementara server terus menghasilkan hasil.

**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`);
}
```

## Konsumsi bersemangat vs. tambahan
<a name="access-graph-gremlin-streaming-avoid"></a>

Streaming memungkinkan Anda memproses hasil secara bertahap karena data tambahan diambil dan dikembalikan. Metode berikut memblokir hingga seluruh kumpulan hasil dikumpulkan ke dalam memori, mencegah aplikasi Anda bertindak berdasarkan hasil saat tiba:
+ **Java:** `toList()` atau `toSet()`
+ **Python**: atau `toList()` `toSet()`
+ **Pergi:**`ToList()`,`ToSet()`, atau `GetResultSet().GetAll()`
+ **.NET:** `ToList()` atau `Promise()`
+ **Node.js:** `toList()`

**catatan**  
Data masih mengalir secara bertahap melalui WebSocket koneksi bahkan saat menggunakan metode ini. Perbedaannya adalah bahwa aplikasi Anda tidak dapat memproses hasil individu sampai seluruh koleksi selesai. Untuk memproses hasil saat mereka tiba, gunakan iterasi malas atau pola batch yang ditunjukkan pada contoh di atas.