Almacenamiento en caché de los resultados de las consultas en Gremlin de Amazon Neptune - Amazon Neptune
Habilitación de la cachéUso de la cachéPaginación de los resultados en cachéClaves de caché de consultasExcepciones

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Almacenamiento en caché de los resultados de las consultas en Gremlin de Amazon Neptune

A partir de la versión 1.0.5.1 del motor, Amazon Neptune admite una caché de resultados para las consultas de Gremlin.

Puede habilitar la caché de resultados de las consultas y, a continuación, utilizar una sugerencia de consulta para almacenar en caché los resultados de una consulta de solo lectura de Gremlin.

Al volver a ejecutar la consulta, se recuperan los resultados en caché con una latencia baja y sin costos de E/S, siempre y cuando sigan en la memoria caché. Esto funciona para las consultas enviadas tanto en un HTTP punto final como mediante Websockets, ya sea como código de bytes o en forma de cadena.

nota

Las consultas que se envían al punto de conexión del perfil no se almacenan en caché ni siquiera cuando la caché de consultas está habilitada.

Hay varias maneras de controlar el comportamiento de la caché de resultados de consultas de Neptune. Por ejemplo:

  • Puede paginar los resultados almacenados en caché en bloques.

  • Puede especificar el time-to-live (TTL) para consultas específicas.

  • Puede borrar la caché para consultas específicas.

  • Puede borrar toda la caché.

  • Puede configurarlo para que se le notifique si los resultados superan el tamaño de la caché.

La memoria caché se mantiene mediante una política least-recently-used (LRU), lo que significa que, una vez que el espacio asignado a la memoria caché esté lleno, los least-recently-used resultados se eliminarán para dejar espacio cuando se almacenen nuevos resultados en la memoria caché.

importante

La caché de resultados de consultas no está disponible en los tipos de instancias t3.medium y t4.medium.

Habilitación de la caché de resultados de consultas en Neptune

Para habilitar la caché de resultados de consultas en Neptune, utilice la consola para configurar el parámetro de instancia de base de datos neptune_result_cache en 1 (habilitado).

Una vez que se habilita la caché de resultados, Neptune reserva una parte de la memoria actual para almacenar en caché los resultados de las consultas. Cuanto más grande sea el tipo de instancia que utilice y más memoria haya disponible, más memoria reservará Neptune para la caché.

Si la memoria caché de resultados se llena, Neptune descarta automáticamente least-recently-used (LRU) los resultados en caché para dar paso a otros nuevos.

Puede comprobar el estado actual de la caché de resultados mediante el comando Estado de la instancia.

Uso de sugerencias para almacenar en caché los resultados de las consultas

Una vez que se habilita la caché de resultados de consultas, las sugerencias de consulta se utilizan para controlar el almacenamiento en caché de las consultas. Todos los ejemplos siguientes se aplican al mismo recorrido de consultas:

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

Uso de enableResultCache

Con la caché de resultados de consultas habilitada, puede almacenar en caché los resultados de una consulta de Gremlin utilizando la sugerencia de consulta enableResultCache, de la siguiente manera:

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

A continuación, Neptune le devuelve los resultados de la consulta y también los almacena en caché. Luego, puede acceder a los resultados en caché emitiendo exactamente la misma consulta de nuevo:

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

La clave de caché que identifica los resultados en caché es la propia cadena de consulta:

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

Uso de enableResultCacheWithTTL

Puede especificar durante cuánto tiempo se deben almacenar en caché los resultados de la consulta mediante la sugerencia de consulta enableResultCacheWithTTL. Por ejemplo, la siguiente consulta especifica que los resultados de la consulta deben caducar después de 120 segundos:

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

De nuevo, la clave de caché que identifica los resultados almacenados en caché es la cadena de consulta base:

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

Y, de nuevo, puede acceder a los resultados en caché utilizando esa cadena de consulta con la sugerencia de consulta enableResultCache:

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

Si han pasado 120 segundos o más desde que los resultados se almacenaron en caché, la consulta devolverá nuevos resultados y los guardará en la memoria caché, sin ninguno time-to-live.

También puede acceder a los resultados almacenados en caché si vuelve a ejecutar la misma consulta con la sugerencia de consulta enableResultCacheWithTTL. Por ejemplo:

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

Hasta que hayan transcurrido 120 segundos (es decir, los que TTL están en vigor actualmente), esta nueva consulta que utilice la sugerencia de enableResultCacheWithTTL consulta devolverá los resultados almacenados en caché. Transcurridos 120 segundos, devolvería nuevos resultados y los almacenaría en la memoria caché durante 140 segundos. time-to-live

nota

Si los resultados de una clave de consulta ya están en caché, la misma clave de consulta enableResultCacheWithTTL no genera nuevos resultados y no tiene ningún efecto en time-to-live los resultados actualmente almacenados en caché.

  • Si los resultados se almacenaron previamente en caché utilizandoenableResultCache, primero se debe borrar la caché antes de enableResultCacheWithTTL generar nuevos resultados y almacenarlos en caché para el TTL tiempo que especifique.

  • Si los resultados se almacenaron previamente en caché utilizandoenableResultCachewithTTL, la versión anterior TTL debe caducar antes de enableResultCacheWithTTL generar nuevos resultados y almacenarlos en la TTL memoria caché según lo especificado.

Uso de invalidateResultCacheKey

Puede utilizar la sugerencia de consulta invalidateResultCacheKey para borrar los resultados en caché de una consulta concreta. Por ejemplo:

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

Esa consulta borra la caché de la clave de consulta, g.V().has('genre','drama').in('likes'), y devuelve nuevos resultados para esa consulta.

También se puede combinar invalidateResultCacheKey con enableResultCache o enableResultCacheWithTTL. Por ejemplo, la siguiente consulta borra los resultados actuales almacenados en caché, almacena en caché los nuevos resultados y los devuelve:

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

Uso de invalidateResultCache

Puede usar la sugerencia de consulta invalidateResultCache para borrar todos los resultados en caché de la caché de resultados de consultas. Por ejemplo:

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

Esa consulta borra la caché de resultados completa y devuelve nuevos resultados para la consulta.

También se puede combinar invalidateResultCache con enableResultCache o enableResultCacheWithTTL. Por ejemplo, la siguiente consulta borra toda la caché de resultados, almacena en caché los nuevos resultados de esta consulta y los devuelve:

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

Paginación de los resultados de consultas en caché

Supongamos que ya ha almacenado en caché un gran número de resultados como este:

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

Ahora supongamos que ejecuta la siguiente consulta de rango:

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

Neptune busca primero la clave de caché completa, es decir, g.V().has('genre','drama').in('likes').range(0,10). Si esa clave no existe, Neptune busca si hay una clave para esa cadena de consulta sin el rango (es decir, g.V().has('genre','drama').in('likes')). Cuando encuentra esa clave, Neptune obtiene los diez primeros resultados de su caché, según lo que especifique el rango.

nota

Si usa la sugerencia de consulta invalidateResultCacheKey con una consulta que tiene un rango al final, Neptune borra la caché de una consulta sin el rango si no encuentra una coincidencia exacta para la consulta con el rango.

Uso de numResultsCached con .iterate()

Con la sugerencia de consulta numResultsCached, puede rellenar la caché de resultados sin devolver todos los resultados almacenados en la caché, lo que puede resultar útil cuando prefiere paginar un gran número de resultados.

La sugerencia de consulta numResultsCached solo funciona con las consultas que terminan en iterate().

Por ejemplo, si quiere almacenar en caché los primeros 50 resultados de la consulta de ejemplo:

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

En este caso, la clave de consulta de la caché es g.with("Neptune#numResultsCached", 50).V().has('genre','drama').in('likes'). Ahora puede recuperar los diez primeros resultados en caché con esta consulta:

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

Además, puede recuperar los diez resultados siguientes de la consulta de la siguiente manera:

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

¡No se olvide incluir la sugerencia numResultsCached! Es una parte esencial de la clave de consulta y, por lo tanto, debe estar presente para poder acceder a los resultados almacenados en caché.

Algunas cosas a tener en cuenta al usar numResultsCached

  • El número que proporcione con numResultsCached se aplica al final de la consulta.   Esto significa, por ejemplo, que la siguiente consulta almacena en caché los resultados del rango(1000, 1500):

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

  • El número que proporcione con numResultsCached especifica el número máximo de resultados que se van a almacenar en caché.   Esto significa, por ejemplo, que la siguiente consulta almacena en caché los resultados del rango(1000, 2000):

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

  • Los resultados que almacenan en caché las consultas que terminan con .range().iterate() tienen su propio rango.   Por ejemplo, supongamos que se almacenan en caché los resultados mediante una consulta como esta:

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

    Para recuperar los primeros 100 resultados de la caché, escribiría una consulta como esta:

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

    Esos cien resultados equivaldrían a los resultados de la consulta base del rango (1000, 1100).

Las claves de caché de consultas que se utilizan para localizar los resultados en caché

Una vez guardados en caché los resultados de una consulta, las consultas posteriores con la misma clave de caché de consultas recuperan los resultados de la caché en lugar de generar otros nuevos. La clave de caché de consultas de una consulta se evalúa de la siguiente manera:

  1. Se omiten todas las sugerencias de consulta relacionadas con la caché, excepto numResultsCached.

  2. Se omite un último paso iterate().

  3. El resto de la consulta se ordena según su representación en código de bytes.

La cadena resultante se compara con un índice de los resultados de la consulta que ya están en la caché para determinar si hay un acierto de caché para la consulta.

Por ejemplo, vamos a tomar como ejemplo esta consulta:

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

Se almacenará como la versión de código de bytes de esto:

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

Excepciones relacionadas con la caché de resultados

Si los resultados de una consulta que está intentando almacenar en caché son demasiado grandes para caber en la memoria caché incluso después de eliminar todo lo que estaba almacenado en caché anteriormente, Neptune genera un error QueryLimitExceededException. No se devuelve ningún resultado y la excepción genera el siguiente mensaje de error:

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

Puede suprimir este mensaje mediante la sugerencia de consulta noCacheExceptions, de la siguiente manera:

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