Armazenar em cache os resultados da consulta no Gremlin do Amazon Neptune - Amazon Neptune
Habilitar o cacheUsar o cachePaginar resultados em cacheConsultar chaves de cacheExceções

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Armazenar em cache os resultados da consulta no Gremlin do Amazon Neptune

A partir da versão 1.0.5.1 do mecanismo, o Amazon Neptune é compatível com um cache de resultados para consultas do Gremlin.

É possível habilitar o cache de resultados da consulta e, depois, usar uma dica de consulta para armazenar em cache os resultados de uma consulta somente leitura do Gremlin.

Depois, qualquer nova execução da consulta recupera os resultados em cache com baixa latência e sem custos de E/S, desde que eles ainda estejam no cache. Isso funciona para consultas enviadas em um HTTP endpoint e usando Websockets, como código de bytes ou em formato de string.

nota

As consultas enviadas ao endpoint do perfil não são armazenadas em cache, mesmo quando o cache de consultas está habilitado.

É possível controlar como o cache de resultados da consulta do Neptune se comporta de várias maneiras. Por exemplo:

  • Você pode obter resultados em cache paginados, em blocos.

  • Você pode especificar o time-to-live (TTL) para consultas especificadas.

  • Você pode limpar o cache para consultas específicas.

  • É possível limpar todo o cache.

  • Você pode configurar para ser notificado se os resultados excederem o tamanho do cache.

O cache é mantido usando uma política least-recently-used (LRU), o que significa que, quando o espaço alocado para o cache estiver cheio, os least-recently-used resultados serão removidos para liberar espaço quando novos resultados forem armazenados em cache.

Importante

O cache de resultados da consulta não está disponível em nossos tipos de instância t3.medium ou t4.medium.

Habilitar o cache de resultados da consulta no Neptune

Para habilitar o cache de resultados de consultas no Neptune, use o console para definir o parâmetro de instância de banco de dados neptune_result_cache como 1 (habilitado).

Depois que o cache de resultados é habilitado, o Neptune reserva uma parte da memória atual para armazenar em cache os resultados das consultas. Quanto maior o tipo de instância que você estiver usando e quanto mais memória estiver disponível, mais memória o Neptune reservará para o cache.

Se a memória cache dos resultados ficar cheia, o Neptune automaticamente least-recently-used descarta LRU () os resultados em cache para dar lugar a novos.

Você pode conferir o status atual do cache de resultados usando o comando Status de instância.

Usar dicas para armazenar em cache os resultados da consulta

Depois que o cache de resultados da consulta estiver habilitado, você usará dicas de consulta para controlar o armazenamento de consultas em cache. Todos os exemplos abaixo se aplicam ao mesmo percurso de consulta, a saber:

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

Utilizar o enableResultCache

Com o cache de resultados de consultas habilitado, é possível armazenar em cache os resultados de uma consulta do Gremlin usando a dica de consulta enableResultCache, da seguinte forma:

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

Depois, o Neptune exibe os resultados da consulta e também os armazena em cache. Posteriormente, é possível acessar os resultados em cache emitindo exatamente a mesma consulta novamente.

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

A chave de cache que identifica os resultados em cache é a própria string da consulta, a saber:

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

Utilizar o enableResultCacheWithTTL

É possível especificar por quanto tempo os resultados da consulta devem ser armazenados em cache usando a dica de consulta enableResultCacheWithTTL. Por exemplo, a seguinte consulta especifica que os resultados da consulta devem expirar após 120 segundos:

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

Novamente, a chave de cache que identifica os resultados em cache é a própria string da consulta:

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

E, novamente, é possível acessar os resultados em cache usando essa string de consulta com a dica de consulta enableResultCache:

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

Se tiverem passado 120 segundos ou mais desde que os resultados foram armazenados em cache, essa consulta retornará novos resultados e os armazenará em cache, sem nenhum time-to-live.

Você também pode acessar os resultados em cache emitindo a mesma consulta novamente com a dica de consulta enableResultCacheWithTTL. Por exemplo:

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

Até que tenham passado 120 segundos (ou seja, os TTL atualmente em vigor), essa nova consulta usando a dica de enableResultCacheWithTTL consulta retorna os resultados em cache. Após 120 segundos, ele retornaria novos resultados e os armazenaria em time-to-live cache com 140 segundos.

nota

Se os resultados de uma chave de consulta já estiverem armazenados em cache, a mesma chave de consulta enableResultCacheWithTTL não gerará novos resultados e não terá efeito sobre os time-to-live resultados atualmente armazenados em cache.

  • Se os resultados foram previamente armazenados em cache usandoenableResultCache, o cache deve primeiro ser limpo antes de enableResultCacheWithTTL gerar novos resultados e armazená-los em cache para o TTL que ele especifica.

  • Se os resultados foram armazenados em cache anteriormente usandoenableResultCachewithTTL, esse anterior TTL deve primeiro expirar antes de enableResultCacheWithTTL gerar novos resultados e armazená-los em cache para o TTL que ele especifica.

Utilizar o invalidateResultCacheKey

É possível usar a dica de consulta invalidateResultCacheKey para limpar os resultados em cache de uma consulta específica. Por exemplo:

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

Essa consulta limpa o cache da chave de consulta, g.V().has('genre','drama').in('likes'), e gera novos resultados para essa consulta.

Você também pode combinar invalidateResultCacheKey com enableResultCache ou enableResultCacheWithTTL. Por exemplo, a seguinte consulta limpa os resultados atuais em cache, armazena novos resultados em cache e os exibe:

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

Utilizar o invalidateResultCache

Você pode usar a dica de consulta invalidateResultCache para limpar todos os resultados em cache no cache de resultados da consulta. Por exemplo:

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

Essa consulta limpa todo o cache de resultados e gera novos resultados para essa consulta.

Você também pode combinar invalidateResultCache com enableResultCache ou enableResultCacheWithTTL. Por exemplo, a seguinte consulta limpa todo o cache de resultados, armazena novos resultados em cache para essa consulta e os exibe:

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

Paginar resultados de consulta em cache

Suponha que você já tenha armazenado em cache um grande número de resultados como este:

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

Agora, suponha que você emita a seguinte consulta de intervalo:

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

O Neptune primeiro procura a chave de cache completa, ou seja, g.V().has('genre','drama').in('likes').range(0,10). Se essa chave não existir, o Neptune, depois, vai conferir se há uma chave para essa string de consulta sem o intervalo (ou seja, g.V().has('genre','drama').in('likes')). Quando encontra essa chave, o Neptune busca os dez primeiros resultados do cache, conforme especifica o intervalo.

nota

Se você usar a dica de consulta invalidateResultCacheKey com uma consulta que tenha um intervalo no final, o Neptune limpará o cache de uma consulta sem o intervalo se não encontrar uma correspondência exata para a consulta com o intervalo.

Usar o numResultsCached com o .iterate()

Usando a dica de consulta numResultsCached, você pode preencher o cache de resultados sem exibir todos os resultados que estão sendo armazenados em cache, o que pode ser útil quando você prefere paginar um grande número de resultados.

A dica de consulta numResultsCached só funciona com consultas que terminam com iterate().

Por exemplo, se você quiser armazenar em cache os primeiros 50 resultados da consulta de amostra:

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

Nesse caso, a chave de consulta no cache é: g.with("Neptune#numResultsCached", 50).V().has('genre','drama').in('likes'). Agora você pode recuperar os dez primeiros resultados em cache com esta consulta:

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

Além disso, é possível recuperar os próximos dez resultados da consulta da seguinte forma:

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

Não se esqueça de incluir a dica numResultsCached! É uma parte essencial da chave de consulta e, portanto, deve estar presente para acessar os resultados em cache.

Ao usar numResultsCached, tenha em mente que:

  • O número fornecido com numResultsCached é aplicado ao final da consulta.   Isso significa, por exemplo, que a seguinte consulta realmente armazena em cache os resultados no intervalo (1000, 1500):

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

  • O número fornecido com numResultsCached especifica o número máximo de resultados a serem armazenados em cache.   Isso significa, por exemplo, que a seguinte consulta realmente armazena em cache os resultados no intervalo (1000, 2000):

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

  • Os resultados armazenados em cache por consultas que terminam com .range().iterate() têm o próprio intervalo.   Por exemplo, suponhamos que você armazene os resultados em cache usando uma consulta como esta:

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

    Para recuperar os primeiros cem resultados do cache, você escreveria uma consulta como esta:

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

    Esses cem resultados seriam equivalentes aos resultados da consulta básica no intervalo (1000, 1100).

As chaves de cache de consulta usadas para localizar resultados em cache

Depois que os resultados de uma consulta são armazenados em cache, as consultas subsequentes com a mesma chave de cache de consulta recuperam os resultados do cache em vez de gerar novos. A chave de cache de uma consulta é avaliada da seguinte forma:

  1. Todas as dicas de consulta relacionadas ao cache são ignoradas, exceto numResultsCached.

  2. Uma etapa final iterate() é ignorada.

  3. O restante da consulta é ordenado de acordo com a representação em código de bytes.

A string resultante é comparada com um índice dos resultados da consulta que já estão no cache para determinar se há uma ocorrência de cache para a consulta.

Por exemplo, tome esta consulta como exemplo:

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

Ela será armazenada como a versão em código de bytes desta:

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

Exceções relacionadas ao cache de resultados

Se os resultados de uma consulta que você está tentando armazenar em cache forem muito grandes para caber na memória de cache, mesmo depois de remover tudo o que estava anteriormente armazenado, o Neptune gerará uma falha QueryLimitExceededException. Nenhum resultado é gerado, e a exceção gera a seguinte mensagem de erro:

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

É possível suprimir essa mensagem usando a dica de consulta noCacheExceptions, da seguinte forma:

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