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
Ab Engine-Version 1.0.5.1 unterstützt Amazon Neptune 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 niedriger Latenz und ohne E/A-Kosten abgerufen, solange sie sich im Cache befinden. Dies funktioniert für Abfragen, die sowohl an einem HTTP Endpunkt als auch mithilfe von Websockets gesendet werden, entweder als Bytecode oder in Zeichenkettenform.
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. Beispielsweise:
Sie können zwischengespeicherte Ergebnisse in Blöcken paginiert abrufen.
Sie können das 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
Zur Aktivierung des Abfrageergebnis-Cache in Neptune legen Sie in der Konsole den DB-Instance-Parameter neptune_result_cache auf 1 (aktiviert) fest.
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 ist, 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 ü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 time-to-live Ergebnisse vorhanden sind.
Sie können auf die zwischengespeicherten Ergebnisse auch über dieselbe Abfrage mit dem Abfragehinweis enableResultCacheWithTTL zugreifen. Beispielsweise:
g.with('Neptune#enableResultCacheWithTTL', 140) .V().has('genre','drama').in('likes')
Bis 120 Sekunden vergangen sind (d. h. die TTL aktuell gültige), gibt diese neue Abfrage, die den enableResultCacheWithTTL Abfragehinweis verwendet, die zwischengespeicherten Ergebnisse zurück. Nach 120 Sekunden würde sie neue Ergebnisse zurückgeben und sie mit einem Wert time-to-live von 140 Sekunden zwischenspeichern.
Anmerkung
Wenn die Ergebnisse für einen Abfrageschlüssel bereits zwischengespeichert sind, generiert derselbe enableResultCacheWithTTL Abfrageschlüssel keine neuen Ergebnisse und hat auch keine Auswirkungen auf die time-to-live aktuell zwischengespeicherten Ergebnisse.
Wenn Ergebnisse zuvor mit zwischengespeichert wurden
enableResultCache, muss der Cache zuerst geleert werden, bevor neue ErgebnisseenableResultCacheWithTTLgeneriert und diese für die TTL angegebenen Werte zwischengespeichert werden.Wurden Ergebnisse zuvor unter Verwendung von zwischengespeichert
enableResultCachewithTTL, TTL muss der vorherige Wert zuerst ablaufen, bevor neue ErgebnisseenableResultCacheWithTTLgeneriert und diese für den TTL angegebenen Wert zwischengespeichert werden.
Verwenden von invalidateResultCacheKey
Sie können mittels des Abfragehinweises invalidateResultCacheKey zwischengespeicherte Ergebnisse für eine bestimmte Abfrage löschen. Beispielsweise:
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. Beispielsweise:
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! 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
numResultsCachedangeben, 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
numResultsCachedangeben, 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:
Alle Cache-bezogenen Abfragehinweise außer
numResultsCachedwerden ignoriert.Ein letzter
iterate()-Schritt wird ignoriert.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')
