Mise en cache des résultats des requêtes dans Amazon Neptune Gremlin - Amazon Neptune

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Mise en cache des résultats des requêtes dans Amazon Neptune Gremlin

À partir deversion du moteur 1.0.5.1, Amazon Neptune prend en charge un cache de résultats pour les requêtes Gremlin.

Vous pouvez activer le cache des résultats de requête, puis utiliser un indice de requête pour mettre en cache les résultats d'une requête Gremlin en lecture seule.

Toute nouvelle exécution de la requête permet de récupérer les résultats mis en cache avec une faible latence et sans coûts d'E/S, tant qu'ils sont toujours dans le cache. Cela fonctionne pour les requêtes soumises à la fois sur un point de terminaison HTTP et à l'aide de Websockets, soit sous forme de code octet, soit sous forme de chaîne.

Vous pouvez contrôler le comportement du cache des résultats des requêtes Neptune de différentes manières. Par exemple :

  • Vous pouvez obtenir les résultats mis en cache paginés, par blocs.

  • Vous pouvez spécifier le time-to-live (TTL) pour les requêtes spécifiées.

  • Vous pouvez vider le cache pour les requêtes spécifiées.

  • Vous pouvez vider la totalité du cache.

  • Vous pouvez configurer pour être averti si les résultats dépassent la taille du cache.

Le cache est maintenu à l'aide d'un least-recently-used (LRU), ce qui signifie qu'une fois que l'espace alloué au cache est plein, least-recently-used les résultats sont supprimés pour faire de la place lorsque de nouveaux résultats sont mis en cache.

Important

Le cache des résultats des requêtes n'est pas disponible surt2.mediumout3.mediumTypes d'instance.

Activation du cache des résultats de requêtes dans Neptune

Pour activer le cache des résultats des requêtes dans Neptune, utilisez la console pour définirneptune_result_cacheParamètre d'instance DB pour1(activé).

Une fois que le cache des résultats est activé, Neptune réserve une partie de la mémoire actuelle pour la mise en cache des résultats des requêtes. Plus le type d'instance que vous utilisez est grand et plus la mémoire disponible est importante, plus Neptune réserve de mémoire au cache.

Si la mémoire cache des résultats est pleine, Neptune disparaît automatiquement least-recently-used (LRU) a mis en cache les résultats pour faire place à de nouveaux.

Vous pouvez vérifier l'état actuel du cache des résultats à l'aide duStatut d’une instancecommande.

Utilisation d'astuces pour mettre en cache les résultats des

Une fois que le cache des résultats des requêtes est activé, vous pouvez utiliser des indicateurs de requête pour contrôler la mise en cache des requêtes. Tous les exemples ci-dessous s'appliquent à la même traversée de requêtes, à savoir :

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

Utiliser enableResultCache

Lorsque le cache des résultats de requête est activé, vous pouvez mettre en cache les résultats d'une requête Gremlin à l'aide duenableResultCacheindice de requête, comme suit :

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

Neptune vous renvoie ensuite les résultats de la requête et les met également en cache. Plus tard, vous pouvez accéder aux résultats mis en cache en exécutant à nouveau exactement la même requête :

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

La clé de cache qui identifie les résultats mis en cache est la chaîne de requête elle-même, à savoir :

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

Utiliser enableResultCacheWithTTL

Vous pouvez spécifier la durée pendant laquelle les résultats de la requête doivent être mis en cache à l'aide duenableResultCacheWithTTLIndicateurs de requête. Par exemple, la requête suivante indique que les résultats de la requête doivent expirer au bout de 120 secondes :

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

Encore une fois, la clé de cache qui identifie les résultats mis en cache est la chaîne de requête de base :

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

Et encore une fois, vous pouvez accéder aux résultats mis en cache à l'aide de cette chaîne de requête avecenableResultCacheastuce de requête :

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

Si 120 secondes ou plus se sont écoulées depuis la mise en cache des résultats, cette requête renverra de nouveaux résultats et les mettra en cache, sans aucun time-to-live.

Vous pouvez également accéder aux résultats mis en cache en exécutant à nouveau la même requête à l'aide duenableResultCacheWithTTLIndicateurs de requête. Par exemple :

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

Jusqu'à ce que 120 secondes se soient écoulées (c'est-à-dire le TTL actuellement en vigueur), cette nouvelle requête utilise leenableResultCacheWithTTLquery hint renvoie les résultats mis en cache. Après 120 secondes, il renverrait de nouveaux résultats et les mettrait en cache avec un time-to-live de 140 secondes.

Note

Si les résultats d'une clé de requête sont déjà mis en cache, alors la même clé de requête avecenableResultCacheWithTTLne génère pas de nouveaux résultats et n'a aucun effet sur time-to-live des résultats actuellement mis en cache.

  • Si les résultats ont déjà été mis en cache en utilisantenableResultCache, le cache doit d'abord être vidé avantenableResultCacheWithTTLgénère de nouveaux résultats et les met en cache pour le TTL qu'il spécifie.

  • Si les résultats ont déjà été mis en cache en utilisantenableResultCachewithTTL, cette TTL précédente doit d'abord expirer avantenableResultCacheWithTTLgénère de nouveaux résultats et les met en cache pour le TTL qu'il spécifie.

Utiliser invalidateResultCacheKey

Vous pouvez utiliser le plugininvalidateResultCacheKeyindice de requête pour effacer les résultats mis en cache pour une requête particulière. Par exemple :

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

Cette requête efface le cache pour la clé de requête,g.V().has('genre','drama').in('likes'), et renvoie de nouveaux résultats pour cette requête.

Vous pouvez également combinerinvalidateResultCacheKeyavecenableResultCacheouenableResultCacheWithTTL. Par exemple, la requête suivante efface les résultats actuellement mis en cache, met en cache les nouveaux résultats et les renvoie :

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

Utiliser invalidateResultCache

Vous pouvez utiliser le plugininvalidateResultCacheindice de requête pour effacer tous les résultats mis en cache dans le cache des résultats de requête. Par exemple :

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

Cette requête efface l'intégralité du cache de résultats et renvoie de nouveaux résultats pour la requête.

Vous pouvez également combinerinvalidateResultCacheavecenableResultCacheouenableResultCacheWithTTL. Par exemple, la requête suivante efface l'intégralité du cache des résultats, met en cache les nouveaux résultats pour cette requête et les renvoie :

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

Pagination des résultats de requête en cache

Supposons que vous ayez déjà mis en cache un grand nombre de résultats comme celui-ci :

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

Supposons maintenant que vous émettiez la requête de plage suivante :

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

Neptune cherche d'abord la clé de cache complète, à savoirg.V().has('genre','drama').in('likes').range(0,10). Si cette clé n'existe pas, Neptune cherche ensuite à voir s'il existe une clé pour cette chaîne de requête sans la plage (à savoirg.V().has('genre','drama').in('likes')). Lorsqu'il trouve cette clé, Neptune récupère les dix premiers résultats de son cache, selon la plage spécifiée.

Note

Si vous utilisez le plugininvalidateResultCacheKeyindice de requête avec une requête qui a une plage à la fin, Neptune vide le cache pour une requête sans plage s'il ne trouve pas de correspondance exacte pour la requête avec la plage.

Utilisation de numResultsCached avec .iterate()

Utilisation denumResultsCachedconseil de requête, vous pouvez remplir le cache des résultats sans renvoyer tous les résultats mis en cache, ce qui peut être utile lorsque vous préférez paginer un grand nombre de résultats.

Dans lanumResultsCachedL'astuce de requête ne fonctionne qu'avec les requêtes se terminant pariterate().

Par exemple, si vous souhaitez mettre en cache les 50 premiers résultats de l'exemple de requête :

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

Dans ce cas, la clé de requête dans le cache est : g.with("Neptune#numResultsCached", 50).V().has('genre','drama').in('likes'). Vous pouvez maintenant récupérer les dix premiers résultats mis en cache avec cette requête :

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

De plus, vous pouvez récupérer les dix résultats suivants à partir de la requête comme suit :

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

N'oubliez pas d'inclure lenumResultsCachedIndicateurs ! Il s'agit d'un élément essentiel de la clé de requête et doit donc être présent pour accéder aux résultats mis en cache.

Quelques points à garder à l'esprit lors de l'utilisationnumResultsCached

  • Le numéro que vous fournisseznumResultsCachedest appliqué à la fin de la requête.   Cela signifie, par exemple, que la requête suivante met réellement en cache les résultats de la plage(1000, 1500) :

    g.with("Neptune#enableResultCache", true) .with("Neptune#numResultsCached", 500) .V().range(1000, 2000).iterate()
  • Le numéro que vous fournisseznumResultsCachedspécifie le nombre maximal de résultats à mettre en cache.   Cela signifie, par exemple, que la requête suivante met réellement en cache les résultats de la plage(1000, 2000) :

    g.with("Neptune#enableResultCache", true) .with("Neptune#numResultsCached", 100000) .V().range(1000, 2000).iterate()
  • Résultats mis en cache par des requêtes qui se terminent par.range().iterate()ont leur propre gamme.   Par exemple, supposons que vous mettiez en cache les résultats en utilisant une requête comme celle-ci :

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

    Pour récupérer les 100 premiers résultats du cache, vous devez écrire une requête comme celle-ci :

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

    Ces cent résultats seraient équivalents aux résultats de la requête de base dans la plage(1000, 1100).

Les clés de cache de requêtes utilisées pour localiser les résultats mis en cache

Une fois que les résultats d'une requête ont été mis en cache, les requêtes suivantes contenant les mêmesClé de cache derécupérer les résultats du cache plutôt que d'en générer de nouveaux. La clé de cache de requête d'une requête est évaluée comme suit :

  1. Les conseils de requête sont ignorés, sauf pournumResultsCached.

  2. Une finaleiterate()l'étape est ignorée.

  3. Le reste de la requête est ordonné en fonction de sa représentation par code octet.

La chaîne résultante est comparée à un index des résultats de la requête déjà présents dans le cache afin de déterminer s'il existe un accès au cache pour la requête.

Exceptions liées au cache des résultats

Si les résultats d'une requête que vous essayez de mettre en cache sont trop volumineux pour tenir dans la mémoire cache, même après avoir supprimé tout ce qui était précédemment mis en cache, Neptune déclenche uneQueryLimitExceededExceptionErreur. Aucun résultat n'est renvoyé et l'exception génère le message d'erreur suivant :

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

Vous pouvez supprimer ce message à l'aide denoCacheExceptionsindice de requête, comme suit :

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