Native Unterstützung für Gremlin-Schritte in Amazon Neptune - Amazon Neptune
Jederzeit konvertierbarIn einigen Fällen konvertierbarNiemals konvertierbarÜberhaupt nicht unterstützt

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.

Native Unterstützung für Gremlin-Schritte in Amazon Neptune

Die Amazon-Neptune-Engine bietet zurzeit keine vollständige native Unterstützung für alle Gremlin-Schritte, wie in Optimieren von Gremline-Abfragen beschrieben. Die aktuelle Unterstützung lässt sich in vier Kategorien einteilen:

Gremlin-Schritte, die jederzeit in native Neptune-Engine-Operationen konvertiert werden können

Viele Gremlin-Schritte können in native Neptune-Engine-Operationen konvertiert werden, solange sie die folgenden Bedingungen erfüllen:

  • Ihnen geht in der Abfrage kein Schritt voraus, der nicht konvertiert werden kann.

  • Der übergeordnete Schritt, wenn vorhanden, kann konvertiert werden.

  • Alle untergeordneten Schritte, wenn vorhanden, können konvertiert werden.

Die folgenden Gremlin-Schritte können stets in native Neptune-Engine-Operationen konvertiert werden, solange sie die folgenden Bedingungen erfüllen:

Gremlin-Schritte, die in einigen Fällen in native Neptune-Engine-Operationen konvertiert werden können

Einige Gremlin-Schritte können in einigen Situationen in native Neptune-Engine-Operationen konvertiert werden, in anderen nicht:

  • addE( )   –   Der Schritt addE() kann grundsätzlich in eine native Neptune-Engine-Operation konvertiert werden, es sei denn, der unmittelbar folgende Schritt ist ein property()-Schritt mit einer Traversierung als Schlüssel.

  • addV( )   –   Der Schritt addV() kann grundsätzlich in eine native Neptune-Engine-Operation konvertiert werden, es sei denn, ihm folgt unmittelbar ein property()-Schritt, der eine Traversierung als Schlüssel enthält oder es sind mehrere Bezeichnungen zugewiesen.

  • aggregate( )   –   Der Schritt aggregate() kann grundsätzlich in eine native Neptune-Engine-Operation konvertiert werden, es sei denn, der Schritt wird in einer untergeordneten Traversierung oder Subtraversierung verwendet oder es handelt sich beim gespeicherten Wert nicht um einen Eckpunkt-, Kanten-, ID-, Bezeichnungs- oder Eigenschaftswert.

    Im folgenden Beispiel wird aggregate() nicht konvertiert, da er in einer untergeordneten Traversierung verwendet wird:

    g.V().has('code','ANC').as('a')
     .project('flights').by(select('a')
     .outE().aggregate('x'))

    In diesem Beispiel wird aggregate( ) nicht konvertiert, da min() gespeichert wird:

    g.V().has('code','ANC').outE().aggregate('x').by(values('dist').min())

  • barrier( )   –   Der Schritt barrier() kann grundsätzlich in eine native Neptun-Engine-Operation konvertiert werden, es sei denn, der folgende Schritt wird nicht konvertiert.

  • cap( )   –   Der einzige Fall, in dem der Schritt cap() konvertiert wird, ist in Kombination mit dem Schritt unfold(), um die nicht entfaltete Version eines Aggregats von Eckpunkt-, Kanten-, ID- oder Eigenschaftswerten zurückzugeben. In diesem Beispiel wird cap() konvertiert, weil .unfold() folgt:

    g.V().has('airport','country','IE').aggregate('airport').limit(2)
     .cap('airport').unfold()

    Wenn Sie .unfold() entfernen, wird cap() jedoch nicht konvertiert:

    g.V().has('airport','country','IE').aggregate('airport').limit(2)
     .cap('airport')

  • coalesce () — Der coalesce() Schritt wird nur konvertiert, wenn er dem auf der Rezeptseite empfohlenen Upsert-Muster folgt. TinkerPop Andere coalesce( )-Muster sind nicht erlaubt. Die Konvertierung erfolgt nur, wenn alle untergeordneten Traversierungen konvertiert werden können, alle denselben Typ als Ausgabe erzeugen (Eckpunkt, Kante, ID, Wert, Schlüssel oder Bezeichnung), alle zu einem neuen Element traversieren und sie nicht den Schritt repeat() enthalten.

  • constant( )   –   Der Schritt constant() wird zurzeit nur konvertiert, wenn er innerhalb des sack().by()-Teils einer Traversierung verwendet wird, um einen konstanten Wert zuzuweisen, z. B.:

    g.V().has('code','ANC').sack(assign).by(constant(10)).out().limit(2)

  • cyclicPath() — Der cyclicPath() Schritt kann im Allgemeinen in eine native Neptune-Engine-Operation umgewandelt werden, es sei denn, der Schritt wird mit by()from(), oder to() Modulatoren verwendet. In den folgenden Abfragen wird cyclicPath() beispielsweise nicht konvertiert:

    g.V().has('code','ANC').as('a').out().out().cyclicPath().by('code')
g.V().has('code','ANC').as('a').out().out().cyclicPath().from('a')
g.V().has('code','ANC').as('a').out().out().cyclicPath().to('a')

  • drop( )   –   Der Schritt drop() kann grundsätzlich in eine native Neptune-Engine-Operation konvertiert werden, es sei denn, der Schritt wird innerhalb des Schritts sideEffect( oder optional() verwendet.

  • fold () — Es gibt nur zwei Situationen, in denen der Schritt fold () konvertiert werden kann, nämlich wenn er in dem Upsert-Muster verwendet wird, das auf der TinkerPop Rezeptseite empfohlen wird, und wenn er in einem group().by() Kontext wie diesem verwendet wird:

    g.V().has('code','ANC').out().group().by().by(values('code', 'city').fold())

  • id( )   –   Der Schritt id() wird konvertiert, wenn er nicht in einer Eigenschaft verwendet wird, z. B.:

    g.V().has('code','ANC').properties('code').id()

  • mergeE () — Der mergeE() Schritt kann in eine native Neptune-Engine-Operation umgewandelt werden, wenn die Parameter (die Zusammenführungsbedingung, onCreate undonMatch) konstant sind (entweder null eine Konstante Map oder select() von a). Map Alle Beispiele in Upserting Edges können konvertiert werden.

  • mergeV () — Der Schritt mergeV () kann in eine native Neptune-Engine-Operation umgewandelt werden, wenn die Parameter (die Zusammenführungsbedingung, onCreate undonMatch) konstant sind (entweder null eine Konstante oder von a). Map select() Map Alle Beispiele, bei denen Scheitelpunkte nach oben verschoben werden, können konvertiert werden.

  • order( )   –   Der Schritt order() kann grundsätzlich in eine native Neptun-Engine-Operation konvertiert werden, es sei denn, eine der folgenden Bedingungen wird erfüllt:

    • Der Schritt order() ist Teil einer verschachtelten untergeordneten Traversierung wie folgt:

      g.V().has('code','ANC').where(V().out().order().by(id))

    • Es wird eine lokale Anordnung verwendet, zum Beispiel mit order(local).

    • In der Modulation by(), nach der sortiert werden werden soll, wird ein benutzerdefinierter Komparator verwendet. Ein Beispiel ist diese Verwendung von sack():

      g.withSack(0).
  V().has('code','ANC').
      repeat(outE().sack(sum).by('dist').inV()).times(2).limit(10).
      order().by(sack())

    • Es gibt mehrere Anordnungen für dasselbe Element.

  • project( )   –   Der Schritt project() kann grundsätzlich in eine native Neptune-Engine-Operation konvertiert werden, es sei denn, die Anzahl der by()-Anweisungen, die auf project() folgen, stimmt nicht mit der Anzahl der angegebenen Bezeichnungen überein, z. B.:

    g.V().has('code','ANC').project('x', 'y').by(id)

  • range( )   –   Der Schritt range() wird nur konvertiert, wenn das untere Ende des jeweiligen Bereichs null ist (z. B. range(0,3)).

  • repeat( )   –   Der Schritt repeat() kann grundsätzlich in eine native Neptune-Engine-Operation konvertiert werden, es sei denn, er ist in einem anderen repeat()-Schritt verschachtelt, z. B.:

    g.V().has('code','ANC').repeat(out().repeat(out()).times(2)).times(2)

  • sack( )   –   Der Schritt sack() kann grundsätzlich in eine native Neptune-Engine-Operation konvertiert werden, außer in den folgenden Fällen:

    • Wenn ein nicht-numerischer sack-Operator verwendet wird.

    • Wenn ein anderer numerischer sack-Operator als +, -, mult, div, min und max verwendet wird.

    • Wenn sack() innerhalb eines where()-Schritts verwendet wird, um nach einem sack-Wert zu filtern, z. B.:

      g.V().has('code','ANC').sack(assign).by(values('code')).where(sack().is('ANC'))

  • sum( )   –   Der Schritt sum() kann grundsätzlich in eine native Neptune-Engine-Operation konvertiert werden, jedoch nicht, wenn er zur Berechnung einer globalen Summierung verwendet wird, z. B.:

    g.V().has('code','ANC').outE('routes').values('dist').sum()

  • union( )   –   Der Schritt union() kann in eine native Neptune-Engine-Operation konvertiert werden, solange er abgesehen vom letzten Schritt der letzte Schritt in der Abfrage ist.

  • unfold () — Der unfold() Schritt kann nur dann in eine native Neptune-Engine-Operation umgewandelt werden, wenn er in dem auf der TinkerPopRezeptseite empfohlenen Upsert-Muster verwendet wird und wenn er zusammen mit dem folgenden verwendet wird: cap()

    g.V().has('airport','country','IE').aggregate('airport').limit(2)
     .cap('airport').unfold()

  • where( )   –   Der Schritt where() kann grundsätzlich in eine native Neptune-Engine-Operation konvertiert werden, außer in den folgenden Fällen:

    • Wenn by()-Modulationen verwendet werden, z. B.:

      g.V().hasLabel('airport').as('a')
     .where(gt('a')).by('runways')

    • Wenn andere Vergleichsoperatoren als eq, neq, within und without verwendet werden.

    • Wenn vom Benutzer bereitgestellte Aggregationen verwendet werden.

Gremlin-Schritte, die niemals in native Neptune-Engine-Operationen konvertiert werden können

Die folgenden Gremlin-Schritte werden in Neptune unterstützt, können jedoch nie in native Neptune-Engine-Operationen konvertiert werden. Sie werden stattdessen vom Gremlin-Server ausgeführt.

Gremlin-Schritte, die in Neptune überhaupt nicht unterstützt werden

Die folgenden Gremlin-Schritte werden in Neptune überhaupt nicht unterstützt. In den meisten Fällen liegt dies daran, dass sie GraphComputer erfordern, was Neptune derzeit nicht unterstützt.

Der io() Schritt wird sogar teilweise unterstützt, da er für „read()von aURL“ verwendet werden kann, aber nicht für „bis“. write()