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.

OpenCypher-Erweiterungen in Amazon Neptune

Amazon Neptune unterstützt die Referenzversion 9 der OpenCypher-Spezifikation. Einzelheiten finden Sie Einhaltung der OpenCypher-Spezifikationen in Amazon Neptune in Amazon Neptune. Darüber hinaus unterstützt Amazon Neptune die hier aufgeführten Funktionen. Sofern keine spezifischen Versionen erwähnt werden, sind die Funktionen in Neptune Database und Neptune Analytics verfügbar.

Die Neptune-spezifische Funktion join()

Verfügbar in Neptune Database und Neptune Analytics.

Neptune implementiert die Funktion join(), die in der openCypher-Spezifikation nicht enthalten ist. Sie erstellt aus einer Liste von Zeichenfolgen-Literalen und einem Zeichenfolgen-Trennzeichen ein Zeichenfolgen-Literal. Sie verwendet zwei Argumente:

Beispiel:

join(["abc", "def", "ghi"], ", ")    // Returns "abc, def, ghi"

Die Neptune-spezifische Funktion removeKeyFromMap()

Verfügbar in Neptune Database und Neptune Analytics.

Neptune implementiert die Funktion removeKeyFromMap(), die in der openCypher-Spezifikation nicht enthalten ist. Sie entfernt einen angegebenen Schlüssel aus einer Map und gibt die resultierende neue Map zurück.

Die Funktion verwendet zwei Argumente:

Die Funktion removeKeyFromMap() ist besonders nützlich in Situationen, in denen Sie Werte für einen Knoten oder eine Beziehung festlegen möchten, indem Sie eine Liste von Maps entladen. Zum Beispiel:

UNWIND [{`~id`: 'id1', name: 'john'}, {`~id`: 'id2', name: 'jim'}] as val
CREATE (n {`~id`: val.`~id`})
SET n = removeKeyFromMap(val, '~id')

Benutzerdefinierte ID-Werte für Knoten- und Beziehungseigenschaften

Verfügbar in Neptune Database 1.2.0.2 und höher und Neptune Analytics.

Ab Engine-Version 1.2.0.2 hat Neptune die openCypher-Spezifikation erweitert, sodass Sie jetzt die id-Werte für Knoten und Beziehungen in den Klauseln CREATE, MERGE und MATCH angeben können. Auf diese Weise können Sie benutzerfreundliche Zeichenketten anstelle von UUIDs systemgenerierten Zeichenketten zuweisen, um Knoten und Beziehungen zu identifizieren.

In Neptune Analytics sind benutzerdefinierte ID-Werte für Kanten nicht verfügbar.

Dies ist ein Beispiel für die Erstellung von Knoten und Beziehungen mit benutzerdefinierten IDS:

CREATE (n {`~id`: 'fromNode', name: 'john'})
  -[:knows {`~id`: 'john-knows->jim', since: 2020}]
  ->(m {`~id`: 'toNode', name: 'jim'})

Wenn Sie versuchen, eine benutzerdefinierte ID zu erstellen, die bereits verwendet wird, gibt Neptune den Fehler DuplicateDataException aus.

Dies ist ein Beispiel für die Verwendung einer benutzerdefinierten ID in einer MATCH-Klausel:

MATCH (n {`~id`: 'id1'})
RETURN n

Hier ist ein Beispiel für die Verwendung von Benutzerdefiniert IDs in einer MERGE Klausel:

MATCH (n {name: 'john'}), (m {name: 'jim'})
MERGE (n)-[r {`~id`: 'john->jim'}]->(m)
RETURN r

Was Sie tun sollten, wenn Sie ~id zurzeit als Eigenschaft verwenden

An Engine-Version 1.2.0.2 wird der ~id-Schlüssel in openCypher-Klauseln nicht mehr als Eigenschaft, sondern als id behandelt. Das bedeutet, dass der Zugriff auf eine Eigenschaft nicht mehr möglich ist, wenn Sie diese mit ~id benannt haben.

Wenn Sie die Eigenschaft ~id verwenden, müssen Sie vor dem Upgrade auf Engine-Version 1.2.0.2 oder höher zunächst die vorhandene Eigenschaft ~id zu einem neuen Eigenschaftsschlüssel migrieren und dann die Eigenschaft ~id entfernen. Betrachten Sie die folgende Abfrage:

MATCH (n)
WHERE exists(n.`~id`)
SET n.newId = n.`~id`
REMOVE n.`~id`

Dies muss für alle Beziehungen in den Daten ausgeführt werden, die die Eigenschaft ~id besitzen.

Sie müssen auch alle Abfragen ändern, die auf die Eigenschaft ~id verweisen. Beispielsweise würde diese Abfrage:

MATCH (n)
WHERE n.`~id` = 'some-value'
RETURN n

... wie folgt geändert werden:

MATCH (n)
WHERE n.newId = 'some-value'
RETURN n

Unterstützung für CALL-Unterabfragen in Neptune

Verfügbar in Neptune Database 1.4.1.0 und höher und Neptune Analytics.

Amazon Neptune unterstützt CALL Unterabfragen. Eine CALL Unterabfrage ist ein Teil der Hauptabfrage, der in einem isolierten Bereich für jede Eingabe der Unterabfrage ausgeführt wird. CALL

Nehmen wir beispielsweise an, ein Diagramm enthält Daten über Personen, ihre Freunde und Städte, in denen sie gelebt haben. Mithilfe einer CALL Unterabfrage können wir die beiden größten Städte abrufen, in denen jeder Freund von jemandem gelebt hat:

MATCH (person:Person)-[:knows]->(friend) 
CALL { 
  WITH friend 
  MATCH (friend)-[:lived_in]->(city) 
  RETURN city 
  ORDER BY city.population DESC
  LIMIT 2 
} 
RETURN person, friend, city

In diesem Beispiel wird der CALL { ... } darin enthaltene Abfrageteil für jede Abfrage ausgeführt, auf friend die die vorherige MATCH-Klausel zutrifft. Wenn die innere Abfrage ausgeführt wird, beziehen sich die ORDER LIMIT UND-Klauseln auf die Städte, in denen ein bestimmter Freund gelebt hat. Wir erhalten also (höchstens) zwei Städte pro Freund.

Alle Abfrageklauseln sind in Unterabfragen verfügbar. CALL Dies schließt auch verschachtelte CALL Unterabfragen ein. Es gibt einige Einschränkungen für die erste WITH Klausel und die ausgegebenen Variablen, die im Folgenden erklärt werden.

Gültigkeitsbereich der Variablen innerhalb der CALL-Unterabfrage

Die Variablen aus den Klauseln vor der Unterabfrage, die in der CALL Unterabfrage verwendet werden, müssen von der ersten Klausel importiert werden. WITH Im Gegensatz zu regulären WITH Klauseln kann sie nur eine Liste von Variablen enthalten, erlaubt aber kein Aliasing und kann nicht zusammen mitDISTINCT,,ORDER BY, WHERE oder verwendet werden. SKIP LIMIT

Von der CALL-Unterabfrage zurückgegebene Variablen

Die Variablen, die von der CALL Unterabfrage ausgegeben werden, werden mit der letzten RETURN Klausel angegeben. Beachten Sie, dass sich die ausgegebenen Variablen nicht mit Variablen vor der CALL Unterabfrage überschneiden dürfen.

Einschränkungen

Derzeit werden Aktualisierungen innerhalb einer CALL Unterabfrage nicht unterstützt.

Neptune OpenCypher-Funktionen

Verfügbar in Neptune Database 1.4.1.0 und höher und Neptune Analytics.

textIndexOf

textIndexOf(text :: STRING, lookup :: STRING, from = 0 :: INTEGER?, to = -1 :: INTEGER?) :: (INTEGER?)

Gibt den Index des ersten Vorkommens von lookup im Bereich von text Offset from (einschließlich) bis Offset (ausschließlich) zurück. to Wenn -1 to ist, wird der Bereich bis zum Ende von fortgesetzttext. Die Indizierung basiert auf Null und wird in Unicode-Skalarwerten (keine Surrogatcodepunkte) ausgedrückt.

RETURN textIndexOf('Amazon Neptune', 'e')
{
  "results": [{
      "textIndexOf('Amazon Neptune', 'e')": 8
    }]
}

collToSet

collToSet(values :: LIST OF ANY?) :: (LIST? OF ANY?)

Gibt eine neue Liste zurück, die nur die eindeutigen Elemente aus der ursprünglichen Liste enthält. Die Reihenfolge der ursprünglichen Liste wird beibehalten (z. B. [1, 6, 5, 1, 5] Rückgabe[1, 6, 5]).

RETURN collToSet([1, 6, 5, 1, 1, 5])
{
  "results": [{
      "collToSet([1, 6, 5, 1, 1, 5])": [1, 6, 5]
    }]
}

collSubtract

collSubtract(first :: LIST OF ANY?, second :: LIST OF ANY?) :: (LIST? OF ANY?)

Gibt eine neue Liste zurück, die alle eindeutigen Elemente für das first Ausschließen von Elementen enthält. second

RETURN collSubtract([2, 5, 1, 0], [1, 5])
{
  "results": [{
      "collSubtract([2, 5, 1, 0], [1, 5])": [0, 2]
    }]
}

collIntersection

collIntersection(first :: LIST? OF ANY?, second :: LIST? OF ANY?) :: (LIST? OF ANY?)

Gibt eine neue Liste zurück, die alle eindeutigen Elemente des Schnittpunkts von first und second enthält.

RETURN collIntersection([2, 5, 1, 0], [1, 5])
{
  "results": [{
      "collIntersection([2, 5, 1, 0], [1, 5])": [1, 5]
    }]
}

Funktionen zum Sortieren

In den folgenden Abschnitten werden Funktionen zum Sortieren von Sammlungen definiert. Diese Funktionen verwenden (in einigen Fällen optionale) config Zuordnungsargumente oder eine Liste mehrerer solcher Zuordnungen, die den Sortierschlüssel und/oder die Sortierrichtung definieren:

{ key: STRING, order: STRING }

Hier key ist entweder eine Map- oder eine Node-Eigenschaft, deren Wert für die Sortierung verwendet werden soll. orderist entweder "" oder asc "desc" (Groß- und Kleinschreibung wird nicht beachtet), um eine aufsteigende bzw. absteigende Sortierung anzugeben. Standardmäßig erfolgt die Sortierung in aufsteigender Reihenfolge.

collSort

collSort(coll :: LIST OF ANY, config :: MAP?) :: (LIST? OF ANY?)

Gibt eine neue sortierte Liste zurück, die die Elemente aus der coll Eingabeliste enthält.

RETURN collSort([5, 3, 1], {order: 'asc'})
{
  "results": [{
      "collSort([5, 3, 1])": [1, 3, 5]
    }]
}

collSortMaps

collSortMaps(coll :: LIST OF MAP, config :: MAP) :: (LIST? OF ANY?)

Gibt eine Liste von Maps zurück, sortiert nach dem Wert der angegebenen key Eigenschaft.

RETURN collSortMaps([{name: 'Alice', age: 25}, {name: 'Bob', age: 35}, {name: 'Charlie', age: 18}], {key: 'age', order: 'desc'})
{
  "results": [{
      "x": [{
          "age": 35,
          "name": "Bob"
        }, {
          "age": 25,
          "name": "Alice"
        }, {
          "age": 18,
          "name": "Charlie"
        }]
    }]
}

collSortMulti

collSortMulti(coll :: LIST OF MAP?, 
configs = [] :: LIST OF MAP, 
limit = -1 :: INTEGER?, 
skip = 0 :: INTEGER?) :: (LIST? OF ANY?)

Gibt eine Liste von Maps zurück, sortiert nach dem Wert der angegebenen key Eigenschaften, wobei optional Limit und Skip angewendet wird.

RETURN collSortMulti([{name: 'Alice', age: 25}, {name: 'Bob', age: 35}, {name: 'Charlie', age: 18}], [{key: 'age', order: 'desc'}, {key:'name'}]) as x
{
  "results": [{
      "x": [{
          "age": 35,
          "name": "Bob"
        }, {
          "age": 25,
          "name": "Alice"
        }, {
          "age": 18,
          "name": "Charlie"
        }]
    }]
}

collSortNodes

collSortNodes(coll :: LIST OF NODE, config :: MAP) :: (LIST? OF NODE?)

Gibt eine sortierte Version der coll Eingabeliste zurück, wobei die Knotenelemente nach den Werten ihrer jeweiligen key Eigenschaften sortiert werden.

create (n:person {name: 'Alice', age: 23}), (m:person {name: 'Eve', age: 21}), (o:person {name:'Bob', age:25})
{"results":[]}

match (n:person) with collect(n) as people return collSortNodes(people, {key: 'name', order: 'desc'})
{
  "results": [{
      "collSortNodes(people, 'name')": [{
          "~id": "e599240a-8c23-4337-8aa8-f603c8fb5488",
          "~entityType": "node",
          "~labels": ["person"],
          "~properties": {
            "age": 21,
            "name": "Eve"
          }
        }, {
          "~id": "8a6ef785-59e3-4a0b-a0ff-389655a9c4e6",
          "~entityType": "node",
          "~labels": ["person"],
          "~properties": {
            "age": 25,
            "name": "Bob"
          }
        }, {
          "~id": "466bc826-f47f-452c-8a27-6b7bdf7ae9b4",
          "~entityType": "node",
          "~labels": ["person"],
          "~properties": {
            "age": 23,
            "name": "Alice"
          }
        }]
    }]
}

match (n:person) with collect(n) as people return collSortNodes(people, {key: 'age'})
{
  "results": [{
      "collSortNodes(people, '^age')": [{
          "~id": "e599240a-8c23-4337-8aa8-f603c8fb5488",
          "~entityType": "node",
          "~labels": ["person"],
          "~properties": {
            "age": 21,
            "name": "Eve"
          }
        }, {
          "~id": "466bc826-f47f-452c-8a27-6b7bdf7ae9b4",
          "~entityType": "node",
          "~labels": ["person"],
          "~properties": {
            "age": 23,
            "name": "Alice"
          }
        }, {
          "~id": "8a6ef785-59e3-4a0b-a0ff-389655a9c4e6",
          "~entityType": "node",
          "~labels": ["person"],
          "~properties": {
            "age": 25,
            "name": "Bob"
          }
        }]
    }]
}