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
<a name="gremlin-step-support"></a>

Die Amazon-Neptune-Engine bietet zurzeit keine vollständige native Unterstützung für alle Gremlin-Schritte, wie in [Optimieren von Gremline-Abfragen](gremlin-traversal-tuning.md) 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](#gremlin-steps-always)
+ [Gremlin-Schritte, die in einigen Fällen in native Neptune-Engine-Operationen konvertiert werden können](#gremlin-steps-sometimes) 
+ [Gremlin-Schritte, die niemals in native Neptune-Engine-Operationen konvertiert werden können](#gremlin-steps-never) 
+ [Gremlin-Schritte, die in Neptune überhaupt nicht unterstützt werden](#neptune-gremlin-steps-unsupported) 

## Gremlin-Schritte, die jederzeit in native Neptune-Engine-Operationen konvertiert werden können
<a name="gremlin-steps-always"></a>

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:
+ [and( )](http://tinkerpop.apache.org/docs/current/reference/#and-step)
+ [as( )](http://tinkerpop.apache.org/docs/current/reference/#as-step)
+ [count( )](http://tinkerpop.apache.org/docs/current/reference/#count-step)
+ [E( )](http://tinkerpop.apache.org/docs/current/reference/#graph-step)
+ [emit( )](http://tinkerpop.apache.org/docs/current/reference/#emit-step)
+ [explain( )](http://tinkerpop.apache.org/docs/current/reference/#explain-step)
+ [group( )](http://tinkerpop.apache.org/docs/current/reference/#group-step)
+ [groupCount( )](http://tinkerpop.apache.org/docs/current/reference/#groupcount-step)
+ [identity( )](http://tinkerpop.apache.org/docs/current/reference/#identity-step)
+ [is( )](http://tinkerpop.apache.org/docs/current/reference/#is-step)
+ [key( )](http://tinkerpop.apache.org/docs/current/reference/#key-step)
+ [label( )](http://tinkerpop.apache.org/docs/current/reference/#label-step)
+ [limit( )](http://tinkerpop.apache.org/docs/current/reference/#limit-step)
+ [local( )](http://tinkerpop.apache.org/docs/current/reference/#local-step)
+ [loops( )](http://tinkerpop.apache.org/docs/current/reference/#loops-step)
+ [not( )](http://tinkerpop.apache.org/docs/current/reference/#not-step)
+ [or( )](http://tinkerpop.apache.org/docs/current/reference/#or-step)
+ [profile( )](http://tinkerpop.apache.org/docs/current/reference/#profile-step)
+ [properties( )](http://tinkerpop.apache.org/docs/current/reference/#properties-step)
+ [subgraph( )](http://tinkerpop.apache.org/docs/current/reference/#subgraph-step)
+ [until( )](http://tinkerpop.apache.org/docs/current/reference/#until-step)
+ [V( )](http://tinkerpop.apache.org/docs/current/reference/#graph-step)
+ [value( )](http://tinkerpop.apache.org/docs/current/reference/#value-step)
+ [valueMap( )](http://tinkerpop.apache.org/docs/current/reference/#valuemap-step)
+ [values( )](http://tinkerpop.apache.org/docs/current/reference/#values-step)

## Gremlin-Schritte, die in einigen Fällen in native Neptune-Engine-Operationen konvertiert werden können
<a name="gremlin-steps-sometimes"></a>

Einige Gremlin-Schritte können in einigen Situationen in native Neptune-Engine-Operationen konvertiert werden, in anderen nicht:
+ [addE( )](http://tinkerpop.apache.org/docs/current/reference/#addedge-step)   –   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( )](http://tinkerpop.apache.org/docs/current/reference/#addvertex-step)   –   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( )](http://tinkerpop.apache.org/docs/current/reference/#store-step)   –   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( )](http://tinkerpop.apache.org/docs/current/reference/#barrier-step)   –   Der Schritt `barrier()` kann grundsätzlich in eine native Neptun-Engine-Operation konvertiert werden, es sei denn, der folgende Schritt wird nicht konvertiert.
+ [cap( )](http://tinkerpop.apache.org/docs/current/reference/#cap-step)   –   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 ()](http://tinkerpop.apache.org/docs/current/reference/#coalesce-step) [— Der `coalesce()` Schritt wird nur konvertiert, wenn er dem auf der Rezeptseite empfohlenen [Upsert-Muster](http://tinkerpop.apache.org/docs/current/recipes/#element-existence) folgt. TinkerPop ](http://tinkerpop.apache.org/docs/current/recipes/) 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( )](http://tinkerpop.apache.org/docs/current/reference/#constant-step)   –   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( )](http://tinkerpop.apache.org/docs/current/reference/#cyclicpath-step)   –   Der Schritt `cyclicPath()` kann grundsätzlich in eine native Neptune-Engine-Operation konvertiert werden, es sei denn, der Schritt wird mit den Modulatoren `by()`, `from()` oder `to()` 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( )](http://tinkerpop.apache.org/docs/current/reference/#drop-step)   –   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 ()](http://tinkerpop.apache.org/docs/current/reference/#fold-step) — Es gibt nur zwei Situationen, in denen der Schritt fold () konvertiert werden kann, nämlich wenn er in dem [Upsert-Muster](http://tinkerpop.apache.org/docs/current/recipes/#element-existence) verwendet wird, das auf der [TinkerPop Rezeptseite](http://tinkerpop.apache.org/docs/current/recipes/) 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())
  ```
+  [has ()](http://tinkerpop.apache.org/docs/current/reference/#has-step) — Der Schritt `has () `kann im Allgemeinen in eine native Neptune-Engine-Operation umgewandelt werden, vorausgesetzt, Abfragen mit `T` verwenden das Prädikat `P.eq`, `P.neq` oder `p.Contains`. Erwarte Variationen von `has () `, die implizieren, dass diese Instanzen von `P` ebenfalls in native Versionen konvertiert werden, wie zum Beispiel `hasID ('id1234')`, was `has (eq, t.ID, 'id1234') `entspricht. 
+ [id( )](http://tinkerpop.apache.org/docs/current/reference/#id-step)   –   Der Schritt `id()` wird konvertiert, wenn er nicht in einer Eigenschaft verwendet wird, z. B.:

  ```
  g.V().has('code','ANC').properties('code').id()
  ```
+  [mergeE ()](https://tinkerpop.apache.org/docs/current/reference/#mergeedge-step) — Der `mergeE()` Schritt kann in eine native Neptune-Engine-Operation umgewandelt werden, wenn die Parameter (die Zusammenführungsbedingung, `onCreate` und`onMatch`) konstant sind (entweder `null` eine Konstante `Map` oder `select()` von a). `Map` Alle Beispiele in [Upserting](https://docs.aws.amazon.com//neptune/latest/userguide/gremlin-efficient-upserts.html#gremlin-upserts-edges) Edges können konvertiert werden. 
+  [mergeV ()](https://tinkerpop.apache.org/docs/current/reference/#mergevertex-step) — Der Schritt mergeV () kann in eine native Neptune-Engine-Operation umgewandelt werden, wenn die Parameter (die Zusammenführungsbedingung, `onCreate` und`onMatch`) 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.](https://docs.aws.amazon.com//neptune/latest/userguide/gremlin-efficient-upserts.html#gremlin-upserts-vertices) 
+ [order( )](http://tinkerpop.apache.org/docs/current/reference/#order-step)   –   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( )](http://tinkerpop.apache.org/docs/current/reference/#project-step)   –   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( )](http://tinkerpop.apache.org/docs/current/reference/#range-step)   –   Der Schritt `range()` wird nur konvertiert, wenn das untere Ende des jeweiligen Bereichs null ist (z. B. `range(0,3)`).
+ [repeat( )](http://tinkerpop.apache.org/docs/current/reference/#repeat-step)   –   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( )](http://tinkerpop.apache.org/docs/current/reference/#sack-step)   –   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( )](http://tinkerpop.apache.org/docs/current/reference/#sum-step)   –   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( )](http://tinkerpop.apache.org/docs/current/reference/#union-step)   –   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 ()](http://tinkerpop.apache.org/docs/current/reference/#unfold-step) — Der `unfold()` Schritt kann nur dann in eine native Neptune-Engine-Operation umgewandelt werden, wenn er in dem auf der [TinkerPopRezeptseite](http://tinkerpop.apache.org/docs/current/recipes/) [empfohlenen Upsert-Muster](http://tinkerpop.apache.org/docs/current/recipes/#element-existence) 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( )](http://tinkerpop.apache.org/docs/current/reference/#where-step)   –   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
<a name="gremlin-steps-never"></a>

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.
+ [choose( )](http://tinkerpop.apache.org/docs/current/reference/#choose-step)
+ [coin( )](http://tinkerpop.apache.org/docs/current/reference/#coin-step)
+ [inject( )](http://tinkerpop.apache.org/docs/current/reference/#inject-step)
+ [match( )](http://tinkerpop.apache.org/docs/current/reference/#match-step)
+ [math( )](http://tinkerpop.apache.org/docs/current/reference/#math-step)
+ [max( )](http://tinkerpop.apache.org/docs/current/reference/#max-step)
+ [mean( )](http://tinkerpop.apache.org/docs/current/reference/#mean-step)
+ [min( )](http://tinkerpop.apache.org/docs/current/reference/#min-step)
+ [option( )](http://tinkerpop.apache.org/docs/current/reference/#option-step)
+ [optional( )](http://tinkerpop.apache.org/docs/current/reference/#optional-step)
+ [path( )](http://tinkerpop.apache.org/docs/current/reference/#path-step)
+ [propertyMap( )](http://tinkerpop.apache.org/docs/current/reference/#propertymap-step)
+ [sample( )](http://tinkerpop.apache.org/docs/current/reference/#sample-step)
+ [skip( )](http://tinkerpop.apache.org/docs/current/reference/#skip-step)
+ [tail( )](http://tinkerpop.apache.org/docs/current/reference/#tail-step)
+ [timeLimit( )](http://tinkerpop.apache.org/docs/current/reference/#timelimit-step)
+ [tree( )](http://tinkerpop.apache.org/docs/current/reference/#tree-step)

## Gremlin-Schritte, die in Neptune überhaupt nicht unterstützt werden
<a name="neptune-gremlin-steps-unsupported"></a>

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.
+ [connectedComponent( )](http://tinkerpop.apache.org/docs/current/reference/#connectedcomponent-step)
+ [io( )](http://tinkerpop.apache.org/docs/current/reference/#io-step)
+ [shortestPath( )](http://tinkerpop.apache.org/docs/current/reference/#shortestpath-step)
+ [withComputer( )](http://tinkerpop.apache.org/docs/current/reference/#with-step)
+ [pageRank( )](http://tinkerpop.apache.org/docs/current/reference/#pagerank-step)
+ [peerPressure( )](http://tinkerpop.apache.org/docs/current/reference/#peerpressure-step)
+ [program( )](http://tinkerpop.apache.org/docs/current/reference/#program-step)

Der Schritt `io()` wird tatsächlich teilweise unterstützt, da er für `read()` über eine URL verwendet werden kann, nicht jedoch für `write()`.