Memorizzazione nella cache dei risultati delle query con Gremlin in Amazon Neptune - Amazon Neptune
Abilitazione della cacheUtilizzo della cachePaginazione dei risultati memorizzati nella cacheChiavi della cache delle queryEccezioni

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Memorizzazione nella cache dei risultati delle query con Gremlin in Amazon Neptune

A partire dal rilascio 1.0.5.1 del motore, Amazon Neptune supporta una cache dei risultati per le query Gremlin.

È possibile abilitare la cache dei risultati delle query e quindi utilizzare un hint di query per memorizzare nella cache i risultati di una query di sola lettura Gremlin.

Qualsiasi riesecuzione della query recupera quindi i risultati memorizzati nella cache con bassa latenza e senza costi di I/O, purché siano ancora nella cache. Funziona per le query inviate sia su un HTTP endpoint che utilizzando Websockets, sia come byte-code che sotto forma di stringa.

Nota

Le query inviate all'endpoint del profilo non vengono memorizzate nella cache anche quando la cache delle query è abilitata.

È possibile controllare il comportamento della cache dei risultati delle query di Neptune in diversi modi. Per esempio:

  • È possibile ottenere risultati memorizzati nella cache paginati, in blocchi.

  • È possibile specificare il () per le query specificate. time-to-live TTL

  • È possibile cancellare la cache per query specifiche.

  • È possibile cancellare l'intera cache.

  • È possibile impostare la possibilità di ricevere una notifica se i risultati superano la dimensione della cache.

La cache viene gestita utilizzando una politica least-recently-used (LRU), il che significa che una volta che lo spazio assegnato alla cache è pieno, i least-recently-used risultati vengono rimossi per fare spazio quando i nuovi risultati vengono memorizzati nella cache.

Importante

La cache dei risultati delle query non è disponibile per i tipi di istanza t3.medium o t4.medium.

Abilitazione della cache dei risultati delle query in Neptune

Per abilitare la cache dei risultati delle query in Neptune, usare la console per impostare il parametro dell'istanza database neptune_result_cache su 1 (abilitato).

Una volta abilitata la cache dei risultati, Neptune riserva una parte della memoria corrente per memorizzare nella cache i risultati delle query. Più grande è il tipo di istanza utilizzato e maggiore è la memoria disponibile, maggiore sarà la quantità di memoria che Neptune riserverà per la cache.

Se la memoria cache dei risultati si riempie, Neptune least-recently-used elimina automaticamente LRU () i risultati memorizzati nella cache per far posto a quelli nuovi.

È possibile verificare lo stato corrente della cache dei risultati utilizzando il comando Stato dell'istanza.

Utilizzo degli hint per memorizzare nella cache i risultati delle query

Una volta abilitata la cache dei risultati delle query, è possibile utilizzare gli hint di query per controllare la memorizzazione nella cache delle query. Tutti gli esempi seguenti si applicano allo stesso attraversamento della query, vale a dire:

g.V().has('genre','drama').in('likes')

Uso di enableResultCache

Con la cache dei risultati delle query abilitata, è possibile memorizzare nella cache i risultati di una query Gremlin utilizzando l'hint di query enableResultCache, come segue:

g.with('Neptune#enableResultCache', true)
 .V().has('genre','drama').in('likes')

Neptune restituisce quindi i risultati della query e li memorizza nella cache. Successivamente, è possibile accedere ai risultati memorizzati nella cache eseguendo di nuovo esattamente la stessa query:

g.with('Neptune#enableResultCache', true)
 .V().has('genre','drama').in('likes')

La chiave della cache che identifica i risultati memorizzati nella cache è la stringa di query stessa, vale a dire:

g.V().has('genre','drama').in('likes')

Uso di enableResultCacheWithTTL

È possibile specificare per quanto tempo i risultati delle query devono essere memorizzati nella cache utilizzando l'hint di query enableResultCacheWithTTL. Ad esempio, la seguente query specifica che i risultati della query devono scadere dopo 120 secondi:

g.with('Neptune#enableResultCacheWithTTL', 120)
 .V().has('genre','drama').in('likes')

Anche in questo caso, la chiave della cache che identifica i risultati memorizzati nella cache è la stringa di query di base:

g.V().has('genre','drama').in('likes')

E anche in questo caso, è possibile accedere ai risultati memorizzati nella cache usando tale stringa di query con l'hint di query enableResultCache:

g.with('Neptune#enableResultCache', true)
 .V().has('genre','drama').in('likes')

Se sono trascorsi 120 o più secondi da quando i risultati sono stati memorizzati nella cache, quella query restituirà nuovi risultati e li memorizzerà nella cache, senza alcun time-to-live risultato.

È inoltre possibile accedere ai risultati memorizzati nella cache inviando nuovamente la stessa query con l'hint di query enableResultCacheWithTTL. Per esempio:

g.with('Neptune#enableResultCacheWithTTL', 140)
 .V().has('genre','drama').in('likes')

Fino a quando non sono trascorsi 120 secondi (ovvero quelli TTL attualmente in vigore), questa nuova query che utilizza il suggerimento di enableResultCacheWithTTL interrogazione restituisce i risultati memorizzati nella cache. Dopo 120 secondi, restituirà nuovi risultati e li memorizzerà nella cache per 140 secondi. time-to-live

Nota

Se i risultati di una chiave di query sono già memorizzati nella cache, la stessa chiave di query con enableResultCacheWithTTL non genera nuovi risultati e non ha alcun effetto sui time-to-live risultati attualmente memorizzati nella cache.

  • Se i risultati sono stati precedentemente memorizzati nella cache utilizzandoenableResultCache, è necessario prima cancellare la cache prima di enableResultCacheWithTTL generare nuovi risultati e memorizzarli nella cache per quanto specificato. TTL

  • Se i risultati venivano precedentemente memorizzati nella cache utilizzandoenableResultCachewithTTL, quel precedente TTL deve prima scadere prima di enableResultCacheWithTTL generare nuovi risultati e li memorizza nella cache per quanto specificato. TTL

Uso di invalidateResultCacheKey

È possibile utilizzare l'hint di query invalidateResultCacheKey per cancellare i risultati memorizzati nella cache per una determinata query. Per esempio:

g.with('Neptune#invalidateResultCacheKey', true)
 .V().has('genre','drama').in('likes')

Questa query cancella la cache per la chiave di query, g.V().has('genre','drama').in('likes'), e restituisce nuovi risultati per la query.

È inoltre possibile combinare invalidateResultCacheKey con enableResultCache o enableResultCacheWithTTL. Ad esempio, la seguente query cancella i risultati correnti memorizzati nella cache, memorizza nella cache i nuovi risultati e li restituisce:

g.with('Neptune#enableResultCache', true)
 .with('Neptune#invalidateResultCacheKey', true)
 .V().has('genre','drama').in('likes')

Uso di invalidateResultCache

È possibile utilizzare l'hint di query invalidateResultCache per cancellare tutti i risultati memorizzati nella cache dei risultati della query. Per esempio:

g.with('Neptune#invalidateResultCache', true)
 .V().has('genre','drama').in('likes')

Questa query cancella l'intera cache dei risultati e restituisce nuovi risultati per la query.

È inoltre possibile combinare invalidateResultCache con enableResultCache o enableResultCacheWithTTL. Ad esempio, la seguente query cancella l'intera cache dei risultati, memorizza nella cache i nuovi risultati per questa query e li restituisce:

g.with('Neptune#enableResultCache', true)
 .with('Neptune#invalidateResultCache', true)
 .V().has('genre','drama').in('likes')

Paginazione dei risultati delle query memorizzati nella cache

Supponiamo di aver già memorizzato nella cache un gran numero di risultati come questo:

g.with('Neptune#enableResultCache', true)
 .V().has('genre','drama').in('likes')

Supponiamo ora di inviare la seguente query di intervallo:

g.with('Neptune#enableResultCache', true)
 .V().has('genre','drama').in('likes').range(0,10)

Neptune cerca innanzitutto la chiave completa della cache, vale a dire g.V().has('genre','drama').in('likes').range(0,10). Se tale chiave non esiste, Neptune cerca se esiste una chiave per la stringa di query senza l'intervallo (vale a dire g.V().has('genre','drama').in('likes')). Quando trova la chiave, Neptune recupera i primi dieci risultati dalla relativa cache, come specificato dall'intervallo.

Nota

Se si usa l'hint di query invalidateResultCacheKey con una query che ha un intervallo alla fine, Neptune cancella la cache per una query senza l'intervallo se non trova una corrispondenza esatta per la query con l'intervallo.

Uso di numResultsCached con .iterate()

Utilizzando l'hint di query numResultsCached, è possibile popolare la cache dei risultati senza restituire tutti i risultati memorizzati nella cache, il che può essere utile quando si preferisce paginare un numero elevato di risultati.

L'hint di query numResultsCached funziona solo con le query che terminano con iterate().

Ad esempio, se si desidera memorizzare nella cache i primi 50 risultati della query di esempio:

g.with("Neptune#enableResultCache", true)
 .with("Neptune#numResultsCached", 50)
 .V().has('genre','drama').in('likes').iterate()

In questo caso la chiave di query nella cache è: g.with("Neptune#numResultsCached", 50).V().has('genre','drama').in('likes'). Ora è possibile recuperare i primi dieci risultati memorizzati nella cache con questa query:

g.with("Neptune#enableResultCache", true)
 .with("Neptune#numResultsCached", 50)
 .V().has('genre','drama').in('likes').range(0, 10)

Inoltre, è possibile recuperare i dieci risultati successivi dalla query nel modo seguente:

g.with("Neptune#enableResultCache", true)
 .with("Neptune#numResultsCached", 50)
 .V().has('genre','drama').in('likes').range(10, 20)

Non dimenticare di includere l'hint numResultsCached. È una parte essenziale della chiave di query e deve quindi essere presente per poter accedere ai risultati memorizzati nella cache.

Alcune cose da tenere a mente quando si utilizza numResultsCached:

  • Il numero fornito con numResultsCached viene applicato alla fine della query.   Ciò significa, ad esempio, che la seguente query memorizza effettivamente nella cache i risultati nell'intervallo (1000, 1500):

    g.with("Neptune#enableResultCache", true)
 .with("Neptune#numResultsCached", 500)
 .V().range(1000, 2000).iterate()

  • Il numero fornito con numResultsCached specifica il numero massimo di risultati da memorizzare nella cache.   Ciò significa, ad esempio, che la seguente query memorizza effettivamente nella cache i risultati nell'intervallo (1000, 2000):

    g.with("Neptune#enableResultCache", true)
 .with("Neptune#numResultsCached", 100000)
 .V().range(1000, 2000).iterate()

  • I risultati memorizzati nella cache delle query che terminano con .range().iterate() hanno un proprio intervallo.   Ad esempio, supponiamo di memorizzare nella cache i risultati utilizzando una query come questa:

    g.with("Neptune#enableResultCache", true)
 .with("Neptune#numResultsCached", 500)
 .V().range(1000, 2000).iterate()

    Per recuperare i primi 100 risultati dalla cache, scrivere una query come questa:

    g.with("Neptune#enableResultCache", true)
 .with("Neptune#numResultsCached", 500)
 .V().range(1000, 2000).range(0, 100)

    Questi cento risultati saranno equivalenti ai risultati della query di base nell'intervallo (1000, 1100).

Chiavi della cache delle query utilizzate per individuare i risultati memorizzati nella cache

Dopo che i risultati di una query sono stati memorizzati nella cache, le query successive con la stessa chiave di cache delle query recuperano i risultati dalla cache anziché generarne di nuovi. La chiave di cache di una query viene valutata come segue:

  1. Tutti gli hint di query relativi alla cache vengono ignorati, ad eccezione di numResultsCached.

  2. Il passaggio finale iterate() viene ignorato.

  3. Il resto della query viene ordinato in base alla rappresentazione del codice byte.

La stringa risultante viene confrontata con un indice dei risultati della query già presenti nella cache per determinare se esiste un riscontro nella cache per la query.

Ad esempio, prendiamo questa query:

g.withSideEffect('Neptune#typePromotion', false).with("Neptune#enableResultCache", true)
 .with("Neptune#numResultsCached", 50)
 .V().has('genre','drama').in('likes').iterate()

Verrà memorizzata come versione in codice byte di questa:

g.withSideEffect('Neptune#typePromotion', false)
 .with("Neptune#numResultsCached", 50)
 .V().has('genre','drama').in('likes')

Eccezioni relative alla cache dei risultati

Se i risultati di una query che si sta cercando di memorizzare nella cache sono troppo grandi per essere contenuti nella memoria cache anche dopo aver rimosso tutto ciò che era precedentemente memorizzato nella cache, Neptune genera un errore QueryLimitExceededException. Non viene restituito alcun risultato e l'eccezione genera il seguente messaggio di errore:

The result size is larger than the allocated cache,
      please refer to results cache best practices for options to rerun the query.

È possibile eliminare questo messaggio utilizzando l'hint di query noCacheExceptions, come segue:

g.with('Neptune#enableResultCache', true)
 .with('Neptune#noCacheExceptions', true)
 .V().has('genre','drama').in('likes')