View a markdown version of this page

Streaming hasil kueri dengan Gremlin - Amazon Neptune
Mengkonsumsi hasil secara bertahapKonsumsi yang bersemangat vs. konsumsi tambahan

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

Streaming hasil kueri dengan Gremlin

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 ditetapkan ke dalam memori.

Neptunus mengirimkan hasil dalam batch 64 per WebSocket frame secara default. Anda tidak dapat mengubah default sisi server ini, tetapi ukuran batch dapat diganti berdasarkan per-permintaan dari klien menggunakan opsi batchSize permintaan (dipanggil Tokens.ARGS_BATCH_SIZE dalam driver Java, atau connectionPool.resultIterationBatchSize sebagai default tingkat driver).

Untuk detail tentang mengkonfigurasi driver batchSize bahasa lain, lihat bagian Konfigurasi untuk setiap driver dalam dokumentasi Driver dan Var TinkerPop ian Apache Gremlin.

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 mengejar ketinggalan.

penting

Streaming paling efektif dengan lintasan yang dapat menghasilkan hasil secara bertahap. Traversal yang mencakuporder(),,groupCount(), group()dedup(), atau langkah-langkah lain yang memerlukan lintasan 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

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

contoh Java (kode byte 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");
}
contoh 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")
contoh 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)
}
contoh.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");
}
contoh 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 yang bersemangat vs. konsumsi tambahan

Streaming memungkinkan Anda memproses hasil secara bertahap saat data tambahan diambil dan dikembalikan. Metode berikut memblokir hingga seluruh rangkaian hasil dikumpulkan ke dalam memori, mencegah aplikasi Anda bertindak berdasarkan hasil saat mereka tiba:

  • Java: toList() atau toSet()

  • Python: toList() atau 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 individual sampai seluruh koleksi selesai. Untuk memproses hasil saat tiba, gunakan iterasi lambat atau pola batch yang ditunjukkan pada contoh di atas.