

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.

# Verwenden von Gremlin für den Zugriff auf Grafikdaten in Amazon Neptune
<a name="get-started-graph-gremlin"></a>

Du kannst die Gremlin Console verwenden, um mit Graphen und Abfragen in einer REPL-Umgebung (Loop) zu experimentieren TinkerPop . read-eval-print 

Das folgende Tutorial führt Sie durch die Verwendung der Gremlin-Konsole und zeigt, wie Sie Eckpunkte, Kanten, Eigenschaften und mehr zu Graph-Diagrammen hinzufügen. Außerdem wird auch auf einige Besonderheiten bei der Neptune-spezifischen Gremlin-Implementierung hingewiesen.

**Anmerkung**  
In diesem Beispiel wird davon ausgegangen, dass Sie Folgendes durchgeführt haben:  
Sie haben über SSH eine Verbindung mit einer Amazon–EC2-Instance hergestellt.
Sie haben einen Neptune-Cluster wie in [Neptun-Cluster erstellen](get-started-create-cluster.md) beschrieben erstellt.
Sie haben die Gremlin-Konsole wie in [Installieren der Gremlin-Konsole](access-graph-gremlin-console.md) beschrieben installiert.

**Verwenden der Gremlin-Konsole**

1. Wechseln Sie in den Ordner, in dem die Dateien der Gremlin-Konsole extrahiert werden.

   ```
   cd apache-tinkerpop-gremlin-console-3.7.2
   ```

1. Geben Sie den folgenden Befehl ein, um die Gremlin-Konsole auszuführen.

   ```
   bin/gremlin.sh
   ```

   Die Ausgabe sollte folgendermaßen aussehen:

   ```
            \,,,/
            (o o)
   -----oOOo-(3)-oOOo-----
   plugin activated: tinkerpop.server
   plugin activated: tinkerpop.utilities
   plugin activated: tinkerpop.tinkergraph
   gremlin>
   ```

   Sie sehen nun die `gremlin>`-Eingabeaufforderung. Die nächsten Schritte geben Sie über diese Eingabeaufforderung ein.

1. Geben Sie an der `gremlin>`-Eingabeaufforderung Folgendes ein, um eine Verbindung zur Neptune-DB-Instance herzustellen.

   ```
   :remote connect tinkerpop.server conf/neptune-remote.yaml
   ```

1. Geben Sie an der `gremlin>`-Eingabeaufforderung Folgendes ein, um in den Remote-Modus zu wechseln. Dadurch werden alle Gremlin-Abfragen an die Remote-Verbindung gesendet.

   ```
   :remote console
   ```

1. **Fügen Sie einen Eckpunkt mit Bezeichnung und Eigenschaft hinzu.**

   ```
   g.addV('person').property('name', 'justin')
   ```

   Dem Vertex wird eine `string`-ID mit einer GUID zugewiesen. Alle Scheitelpunkte IDs sind Zeichenketten in Neptune.

1. **Fügen Sie einen Eckpunkt mit einer benutzerdefinierter ID hinzu.**

   ```
   g.addV('person').property(id, '1').property('name', 'martin')
   ```

   Die `id`-Eigenschaft wird nicht in Anführungszeichen gesetzt. Es handelt sich um ein Schlüsselwort für die ID des Vertex. Die Vertex-ID ist eine Zeichenfolge mit der Zahl `1`.

   Normale Eigenschaftsnamen müssen in Anführungszeichen eingeschlossen werden.

1. **Ändern Sie die Eigenschaft oder fügen Sie eine Eigenschaft hinzu, wenn keine vorhanden ist.**

   ```
   g.V('1').property(single, 'name', 'marko')
   ```

   Hier ändern Sie die `name`-Eigenschaft für den Vertex aus dem vorherigen Schritt. Dadurch werden alle vorhandenen Werte aus der `name`-Eigenschaft entfernt.

   Wenn Sie `single` nicht angegeben haben, wird stattdessen der Wert der `name`-Eigenschaft angehängt, sofern dieser Vorgang noch nicht ausgeführt wurde. 

1. **Hinzufügen einer Eigenschaft bzw. Anfügen der Eigenschaft, wenn die Eigenschaft bereits über einen Wert verfügt **

   ```
   g.V('1').property('age', 29)
   ```

   Neptune verwendet Set-Kardinalität als Standardaktion.

   Dieser Befehl fügt die Eigenschaft `age` mit dem Wert `29` hinzu, ersetzt jedoch keine vorhandenen Werte. 

   Wenn die `age`-Eigenschaft bereits einen Wert enthält, fügt dieser Befehl der Eigenschaft `29` an. Beispiel: Wenn die `age`-Eigenschaft `27` lautet, ist der neue Wert `[ 27, 29 ]`.

1. **Fügen Sie mehrere Eckpunkte hinzu.**

   ```
   g.addV('person').property(id, '2').property('name', 'vadas').property('age', 27).iterate()
   g.addV('software').property(id, '3').property('name', 'lop').property('lang', 'java').iterate()
   g.addV('person').property(id, '4').property('name', 'josh').property('age', 32).iterate()
   g.addV('software').property(id, '5').property('name', 'ripple').property('lang', 'java').iterate()
   g.addV('person').property(id, '6').property('name', 'peter').property('age', 35)
   ```

   Sie können mehrere Anweisungen gleichzeitig an Neptune senden.

   Anweisungen können durch Zeilenumbrüche (`'\n'`), Leerzeichen (`' '`), Semikolon (`'; '`) oder nichts (`g.addV(‘person’).iterate()g.V()` ist z. B. gültig) getrennt werden. 
**Anmerkung**  
Die Gremlin-Konsole sendet bei jedem Zeilenumbruch (`'\n'`) einen separaten Befehl, sodass in diesem Fall jeweils eine separate Transaktion stattfindet. Dieses Beispiel enthält alle Befehle in getrennten Zeilen, um die Lesbarkeit zu verbessern. Entfernen Sie die Zeilenumbruch-Zeichen (`'\n'`), um sie als einen einzelnen Befehl über die Gremlin-Konsole zu senden.

   Alle Anweisungen mit Ausnahme der letzten müssen mit einem Beendigungsschritt wie `.next()` oder `.iterate()` enden. Andernfalls werden sie nicht ausgeführt. Die Gremlin-Konsole erfordert keinen Beendigungsschritt. Verwenden Sie `.iterate` immer dann, wenn die Ergebnisse nicht serialisiert werden müssen.

   Alle Anweisungen, die zusammen gesendet werden, sind in einer einzigen Transaktion enthalten und sind entweder alle erfolgreich oder schlagen alle fehl.

1. **Fügen Sie Eckpunkte hinzu.**

   ```
   g.V('1').addE('knows').to(__.V('2')).property('weight', 0.5).iterate()
   g.addE('knows').from(__.V('1')).to(__.V('4')).property('weight', 1.0)
   ```

   Nachfolgend sind zwei verschiedene Möglichkeiten zum Hinzufügen einer Edge aufgeführt.

1. **Fügen Sie den Rest des Graphs „Modern“ hinzu.**

   ```
   g.V('1').addE('created').to(__.V('3')).property('weight', 0.4).iterate()
   g.V('4').addE('created').to(__.V('5')).property('weight', 1.0).iterate()
   g.V('4').addE('knows').to(__.V('3')).property('weight', 0.4).iterate()
   g.V('6').addE('created').to(__.V('3')).property('weight', 0.2)
   ```

1. **Löschen Sie einen Eckpunkt.**

   ```
   g.V().has('name', 'justin').drop()
   ```

   Entfernt den Vertex mit der `name`-Eigenschaft gleich `justin`.
**Wichtig**  
*Wenn Sie hier aufhören, haben Sie das vollständige Apache TinkerPop Modern-Diagramm. Die Beispiele im [Abschnitt Traversal](https://tinkerpop.apache.org/docs/current/reference/#graph-traversal-steps) der TinkerPop Dokumentation verwenden den Modern-Graphen.*

1. **Führen Sie einen Durchlauf aus.**

   ```
   g.V().hasLabel('person')
   ```

   Gibt alle `person`-Eckpunkte zurück.

1. **Führen Sie einen Durchlauf mit den Werten (valueMap()) aus.**

   ```
   g.V().has('name', 'marko').out('knows').valueMap()
   ```

   Gibt Schlüssel-Wert-Paare für alle Vertices zurück, die `marko` "kennt".

1. **Geben Sie mehrere Bezeichnungen an.**

   ```
   g.addV("Label1::Label2::Label3") 
   ```

   Neptune unterstützt mehrere Bezeichnungen für einen Eckpunkt. Sie können mehrere Bezeichnungen angeben, indem Sie diese durch `::` trennen.

   In diesem Beispiel wird ein Vertex mit drei verschiedenen Bezeichnungen hinzugefügt. 

   Der `hasLabel`-Schritt entspricht dem Knoten mit allen drei Bezeichnungen: `hasLabel("Label1")`, `hasLabel("Label2")` und `hasLabel("Label3")`. 

   Das `::`-Trennzeichen ist dieser Verwendung vorbehalten. 

   Sie können im `hasLabel`-Schritt nicht mehrere Bezeichnungen angeben. Beispiel: Für `hasLabel("Label1::Label2")` gibt es keine Übereinstimmung. 

1. **Geben Sie Uhrzeit/Datum an**.

   ```
   g.V().property(single, 'lastUpdate', datetime('2018-01-01T00:00:00'))
   ```

   Neptune unterstützt kein Java-Datum. Verwenden Sie stattdessen die `datetime()` Funktion. `datetime()`akzeptiert eine ISO8061 -konforme `datetime` Zeichenfolge.

   Unterstützt werden die folgenden Formate: `YYYY-MM-DD, YYYY-MM-DDTHH:mm`, `YYYY-MM-DDTHH:mm:SS` und `YYYY-MM-DDTHH:mm:SSZ`.

1. **Löschen Sie Eckpunkte, Eigenschaften oder Edges.**

   ```
   g.V().hasLabel('person').properties('age').drop().iterate()
   g.V('1').drop().iterate()
   g.V().outE().hasLabel('created').drop()
   ```

   Im Folgenden finden Sie einige "drop"-Beispiele.
**Anmerkung**  
 Der `.next()`-Schritt funktioniert nicht mit `.drop()`. Verwenden Sie stattdessen `.iterate()`.

1. Wenn Sie fertig sind, geben Sie den folgenden Befehl ein, um die Gremlin-Konsole zu beenden.

   ```
   :exit
   ```

**Anmerkung**  
Verwenden Sie ein Semikolon (`;`) oder ein Zeilenumbruchzeichen (`\n`), um die Anweisungen voneinander abzutrennen.   
Jede Traversierung, die der letzten Traversierung vorausgeht, muss zum Ausführen mit `iterate()` enden. Es werden nur die Daten der letzten Traversierung zurückgegeben.