Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Zwischenspeichern von Abfrageergebnissen in Amazon Neptune Gremlin
Amazon Neptune unterstützt einen Ergebnis-Cache für Gremlin-Abfragen.
Sie können den Abfrageergebnis-Cache aktivieren und dann einen Abfragehinweis verwenden, um die Ergebnisse einer schreibgeschützten Gremlin-Abfrage zwischenzuspeichern.
Bei jeder erneuten Ausführung der Abfrage werden die zwischengespeicherten Ergebnisse mit geringer Latenz und ohne I/O Kosten abgerufen, sofern sie sich noch im Cache befinden. Dies funktioniert für Abfragen, die über HTTP-Endpunkte oder Websockets als Bytecode oder Zeichenfolgen gesendet werden.
**Anmerkung**
An den Profilendpunkt gesendete Abfragen werden nicht zwischengespeichert, auch wenn der Abfrage-Cache aktiviert ist.
Sie können das Verhalten des Neptune-Abfrageergebnis-Cache auf verschiedene Arten steuern. Beispiel:
+ Sie können zwischengespeicherte Ergebnisse in Blöcken paginiert abrufen.
+ Sie können die time-to-live (TTL) für bestimmte Abfragen angeben.
+ Sie können den Cache für bestimmte Abfragen leeren.
+ Sie können den gesamten Cache löschen.
+ Sie können Benachrichtigungen für den Fall einrichten, dass die Ergebnisse die Cachegröße überschreiten.
Der Cache wird mithilfe einer least-recently-used (LRU-) Richtlinie verwaltet. Das bedeutet, dass, sobald der dem Cache zugewiesene Speicherplatz voll ist, die least-recently-used Ergebnisse entfernt werden, um Platz für das Zwischenspeichern neuer Ergebnisse zu schaffen.
**Wichtig**
Der Abfrageergebnis-Cache ist für die Instance-Typen `t3.medium` oder `t4.medium` nicht verfügbar.
## Aktivieren des Abfrageergebnis-Cache in Neptune
Der Cache für Abfrageergebnisse kann für alle Instanzen in einem Cluster oder pro Instanz aktiviert werden. Um den Ergebnis-Cache auf allen Instances in einem Cluster zu aktivieren, setzen Sie den `neptune_result_cache` Parameter im Cluster `cluster-parameter-group` auf`1`. Um dies für eine bestimmte Instance zu aktivieren, setzen Sie den `neptune_result_cache` Parameter in der Instanz `instance-parameter-group` auf`1`. Die Einstellung für die Cluster-Parametergruppe überschreibt den Wert der Instanzparametergruppe.
Auf allen betroffenen Instances ist ein Neustart erforderlich, damit die Parametereinstellungen für den Ergebnis-Cache angewendet werden. Sie können den Ergebnis-Cache zwar über für alle Instances in einem Cluster aktivieren`cluster-parameter-group`, aber jede Instanz verwaltet ihren eigenen Cache. Bei der Cache-Funktion für Abfrageergebnisse handelt es sich nicht um einen clusterweiten Cache.
Nach Aktivierung des Ergebnis-Caches reserviert Neptune einen Teil des aktuellen Arbeitsspeichers für das Zwischenspeichern von Abfrageergebnissen. Je größer der verwendete Instance-Typ und je größer der verfügbare Speicher, desto mehr Speicher reserviert Neptune für den Cache.
Wenn der Speicher des Ergebniscaches voll wird, löscht Neptune automatisch least-recently-used (LRU) zwischengespeicherte Ergebnisse, um Platz für neue zu machen.
Sie können den aktuellen Status des Ergebniscaches mithilfe des Befehls [Instance-Status](access-graph-status.md) überprüfen.
## Verwenden von Hinweisen zum Zwischenspeichern von Abfrageergebnissen
Nach der Aktivierung des Abfrageergebnis-Caches können Sie das Zwischenspeichern von Abfragen mittels Abfragehinweisen steuern. Alle folgenden Beispiele beziehen sich auf diese Abfragetraversierung:
```
g.V().has('genre','drama').in('likes')
```
### Verwenden von `enableResultCache`
Nach der Aktivierung des Abfrageergebnis-Caches können Sie die Ergebnisse einer Gremlin-Abfrage über den Abfragehinweis `enableResultCache` wie folgt zwischenspeichern:
```
g.with('Neptune#enableResultCache', true)
.V().has('genre','drama').in('likes')
```
Neptune gibt anschließend die Abfrageergebnisse zurück und speichert diese auch im Cache. Später können Sie auf die zwischengespeicherten Ergebnisse zugreifen, indem Sie genau dieselbe Abfrage erneut ausführen.
```
g.with('Neptune#enableResultCache', true)
.V().has('genre','drama').in('likes')
```
Der Cache-Schlüssel, der die zwischengespeicherten Ergebnisse identifiziert, ist die Abfragezeichenfolge selbst:
```
g.V().has('genre','drama').in('likes')
```
### Verwenden von `enableResultCacheWithTTL`
Über den Abfragehinweis `enableResultCacheWithTTL` können Sie angeben, wie lange die Abfrageergebnisse zwischengespeichert werden sollen. Die folgende Abfrage gibt beispielsweise an, dass die Abfrageergebnisse nach 120 Sekunden ablaufen sollen:
```
g.with('Neptune#enableResultCacheWithTTL', 120)
.V().has('genre','drama').in('likes')
```
Der Cache-Schlüssel, der die zwischengespeicherten Ergebnisse identifiziert, ist auch hier die Abfragezeichenfolge selbst:
```
g.V().has('genre','drama').in('likes')
```
Und auch hier können Sie auf die zwischengespeicherten Ergebnisse über diese Abfragezeichenfolge und den Abfragehinweis `enableResultCache` zugreifen:
```
g.with('Neptune#enableResultCache', true)
.V().has('genre','drama').in('likes')
```
Wenn seit dem Zwischenspeichern der Ergebnisse 120 oder mehr Sekunden vergangen sind, gibt diese Abfrage neue Ergebnisse zurück und speichert sie im Cache, ohne dass irgendwelche Ergebnisse vorhanden sind. time-to-live
Sie können auf die zwischengespeicherten Ergebnisse auch über dieselbe Abfrage mit dem Abfragehinweis `enableResultCacheWithTTL` zugreifen. Beispiel:
```
g.with('Neptune#enableResultCacheWithTTL', 140)
.V().has('genre','drama').in('likes')
```
Bis zum Ablauf von 120 Sekunden (d. h. der aktuell gültigen TTL) gibt diese neue Abfrage unter Verwendung des Abfragehinweises `enableResultCacheWithTTL` die zwischengespeicherten Ergebnisse zurück. Nach 120 Sekunden würde sie neue Ergebnisse zurückgeben und sie mit einer Dauer time-to-live von 140 Sekunden zwischenspeichern.
**Anmerkung**
Wenn die Ergebnisse für einen Abfrageschlüssel bereits zwischengespeichert sind, generiert derselbe Abfrageschlüssel `enableResultCacheWithTTL` keine neuen Ergebnisse und hat keine Auswirkungen auf die time-to-live aktuell zwischengespeicherten Ergebnisse.
Wenn bereits Ergebnisse mit `enableResultCache` zwischengespeichert wurden, muss der Cache zunächst geleert werden, bevor `enableResultCacheWithTTL` neue Ergebnisse generiert und für die angegebene TTL zwischenspeichert.
Wenn Ergebnisse zuvor mit `enableResultCachewithTTL` zwischengespeichert wurden, muss die vorherige TTL zunächst ablaufen, bevor `enableResultCacheWithTTL` neue Ergebnisse generiert und für die angegebene TTL zwischenspeichert.
### Verwenden von `invalidateResultCacheKey`
Sie können mittels des Abfragehinweises `invalidateResultCacheKey` zwischengespeicherte Ergebnisse für eine bestimmte Abfrage löschen. Beispiel:
```
g.with('Neptune#invalidateResultCacheKey', true)
.V().has('genre','drama').in('likes')
```
Diese Abfrage löscht den Cache für den Abfrageschlüssel `g.V().has('genre','drama').in('likes')` und gibt neue Ergebnisse für diese Abfrage zurück.
Sie können `invalidateResultCacheKey` auch mit `enableResultCache` oder `enableResultCacheWithTTL` kombinieren. Die folgende Abfrage löscht beispielsweise die aktuellen zwischengespeicherten Ergebnisse, speichert neue Ergebnisse im Cache und gibt diese zurück:
```
g.with('Neptune#enableResultCache', true)
.with('Neptune#invalidateResultCacheKey', true)
.V().has('genre','drama').in('likes')
```
### Verwenden von `invalidateResultCache`
Sie können mittels des Abfragehinweises `invalidateResultCache` alle zwischengespeicherten Ergebnisse im Abfrageergebnis-Cache löschen. Beispiel:
```
g.with('Neptune#invalidateResultCache', true)
.V().has('genre','drama').in('likes')
```
Diese Abfrage löscht den gesamten Ergebnis-Cache und gibt neue Ergebnisse für die Abfrage zurück.
Sie können `invalidateResultCache` auch mit `enableResultCache` oder `enableResultCacheWithTTL` kombinieren. Die folgende Abfrage löscht beispielsweise den gesamten aktuellen Ergebnis-Cache, speichert neue Ergebnisse für diese Abfrage im Cache und gibt diese zurück:
```
g.with('Neptune#enableResultCache', true)
.with('Neptune#invalidateResultCache', true)
.V().has('genre','drama').in('likes')
```
## Paginieren zwischengespeicherter Abfrageergebnisse
Angenommen, Sie haben bereits eine große Anzahl von Ergebnissen wie folgt zwischengespeichert:
```
g.with('Neptune#enableResultCache', true)
.V().has('genre','drama').in('likes')
```
Nehmen Sie nun an, Sie geben die folgende Bereichsabfrage aus:
```
g.with('Neptune#enableResultCache', true)
.V().has('genre','drama').in('likes').range(0,10)
```
Neptune sucht zunächst nach dem vollständigen Cache-Schlüssel, `g.V().has('genre','drama').in('likes').range(0,10)`. Wenn dieser Schlüssel nicht vorhanden ist, sucht Neptune als Nächstes nach einem Schlüssel für diese Abfragezeichenfolge ohne Bereich (`g.V().has('genre','drama').in('likes')`). Wenn dieser Schlüssel vorhanden ist, ruft Neptune die ersten zehn Ergebnisse aus dem Cache ab wie vom Bereich angegeben.
**Anmerkung**
Wenn Sie den Abfragehinweis `invalidateResultCacheKey` mit einer Abfrage mit Bereich am Ende verwenden, löscht Neptune den Cache für eine Abfrage ohne diesen Bereich, wenn es keine exakte Übereinstimmung für die Abfrage mit Bereich gibt.
### Verwenden von `numResultsCached` mit `.iterate()`
Mittels des Abfragehinweises `numResultsCached` können Sie den Ergebniscache auffüllen, ohne alle zwischengespeicherten Ergebnisse zurückzugeben. Dies kann nützlich sein, wenn Sie eine große Anzahl von Ergebnissen paginieren möchten.
Der Abfragehinweis `numResultsCached` funktioniert nur bei Abfragen, die mit `iterate()` enden.
Wenn Sie beispielsweise die ersten 50 Ergebnisse der Beispielabfrage zwischenspeichern möchten:
```
g.with("Neptune#enableResultCache", true)
.with("Neptune#numResultsCached", 50)
.V().has('genre','drama').in('likes').iterate()
```
In diesem Fall ist der Abfrageschlüssel im Cache: `g.with("Neptune#numResultsCached", 50).V().has('genre','drama').in('likes')`. Sie können jetzt die ersten zehn der zwischengespeicherten Ergebnisse mit dieser Abfrage abrufen:
```
g.with("Neptune#enableResultCache", true)
.with("Neptune#numResultsCached", 50)
.V().has('genre','drama').in('likes').range(0, 10)
```
Sie können die nächsten zehn Ergebnisse aus der Abfrage wie folgt abrufen:
```
g.with("Neptune#enableResultCache", true)
.with("Neptune#numResultsCached", 50)
.V().has('genre','drama').in('likes').range(10, 20)
```
Vergessen Sie nicht, den Abfragehinweis `numResultsCached` einzufügen\$1 Dieser ist ein wesentlicher Bestandteil des Abfrageschlüssels und muss daher vorhanden sein, um auf die zwischengespeicherten Ergebnisse zugreifen zu können.
**Dinge, die Sie bei der Verwendung von `numResultsCached` berücksichtigen sollten:**
+ **Die Zahl, die Sie mit `numResultsCached` angeben, wird am Ende der Abfrage angewendet.** Das bedeutet zum Beispiel, dass die folgende Abfrage tatsächlich Ergebnisse im Bereich `(1000, 1500)` zwischenspeichert:
```
g.with("Neptune#enableResultCache", true)
.with("Neptune#numResultsCached", 500)
.V().range(1000, 2000).iterate()
```
+ **Die Zahl, die Sie mit `numResultsCached` angeben, gibt die maximale Anzahl von Ergebnissen an, die zwischengespeichert werden sollen.** Das bedeutet zum Beispiel, dass die folgende Abfrage tatsächlich Ergebnisse im Bereich `(1000, 2000)` zwischenspeichert:
```
g.with("Neptune#enableResultCache", true)
.with("Neptune#numResultsCached", 100000)
.V().range(1000, 2000).iterate()
```
+ **Ergebnisse, die von Abfragen zwischengespeichert werden, die mit `.range().iterate()` enden, haben einen eigenen Bereich.** Angenommen, Sie speichern Ergebnisse mithilfe einer Abfrage wie der folgenden im Cache:
```
g.with("Neptune#enableResultCache", true)
.with("Neptune#numResultsCached", 500)
.V().range(1000, 2000).iterate()
```
Um die ersten 100 Ergebnisse aus dem Cache abzurufen, würden Sie eine Abfrage wie diese schreiben:
```
g.with("Neptune#enableResultCache", true)
.with("Neptune#numResultsCached", 500)
.V().range(1000, 2000).range(0, 100)
```
Diese hundert Ergebnisse würden den Ergebnissen der Basisabfrage im Bereich `(1000, 1100)` entsprechen.
## Abfrage-Cache-Schlüssel für die Suche nach zwischengespeicherten Ergebnissen
Nach dem Zwischenspeichern der Ergebnisse einer Abfrage rufen nachfolgende Abfragen mit demselben *Abfrage-Cache-Schlüssel* Ergebnisse aus dem Cache ab, anstatt neue zu generieren. Der Abfrage-Cache-Schlüssel einer Abfrage wird wie folgt ausgewertet:
1. Alle Cache-bezogenen Abfragehinweise außer `numResultsCached` werden ignoriert.
1. Ein letzter `iterate()`-Schritt wird ignoriert.
1. Der Rest der Abfrage wird entsprechend ihrer Bytecode-Darstellung angeordnet.
Die resultierende Zeichenfolge wird mit dem Index der Abfrageergebnisse abgeglichen, die sich bereits im Cache befinden, um festzustellen, ob es für die Abfrage einen Cache-Treffer gibt.
Betrachten Sie beispielsweise diese Abfrage:
```
g.withSideEffect('Neptune#typePromotion', false).with("Neptune#enableResultCache", true)
.with("Neptune#numResultsCached", 50)
.V().has('genre','drama').in('likes').iterate()
```
Sie wird als Bytecode-Version hiervon gespeichert:
```
g.withSideEffect('Neptune#typePromotion', false)
.with("Neptune#numResultsCached", 50)
.V().has('genre','drama').in('likes')
```
## Ausnahmen für den Ergebnis-Cache
Wenn die Ergebnisse einer Abfrage, die Sie zwischenspeichern möchten, zu groß für den Cache sind, auch wenn alle zuvor zwischengespeicherten Daten entfernt wurden, gibt Neptune den Fehler `QueryLimitExceededException` aus. Es werden keine Ergebnisse zurückgegeben und die Ausnahme generiert die folgende Fehlermeldung:
```
The result size is larger than the allocated cache,
please refer to results cache best practices for options to rerun the query.
```
Sie können diese Meldung mittels des Abfragehinweises `noCacheExceptions` wie folgt unterdrücken:
```
g.with('Neptune#enableResultCache', true)
.with('Neptune#noCacheExceptions', true)
.V().has('genre','drama').in('likes')
```