Query-time S3-Datenzugriff Die Funktion join()Die Funktion removeKeyFromMap()Benutzerdefinierte ID-Werte CALL-Unterstützung für Unterabfragen in Neptune Neptune OpenCypher funktioniert Funktionen zum Sortieren Zeitliche Funktionen

OpenCypher-Erweiterungen in Amazon Neptune

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

Query-time S3-Datenzugriff

Verfügbar in Neptune Database 1.4.7.0 und höher.

Neptune unterstützt die neptune.read() Funktion zum Lesen von CSV- oder Parquet-Daten aus Amazon S3 direkt in OpenCypher-Abfragen. Im Gegensatz zum Bulk-Loader, der Daten vor der Abfrage importiert, neptune.read() greift er bei der Ausführung der Abfrage auf Amazon S3-Daten zu.

Eine vollständige Dokumentation finden Sie unter. neptune.read ()

Die `Funktion Neptune-specific` 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:

Das erste Argument ist eine Liste von Zeichenfolgenliteralen.
Das zweite Argument ist die Trennzeichenfolge, die aus null, einem oder mehreren Zeichen bestehen kann.

Beispiel:


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

Die Neptune-specific `Funktion remove () KeyFromMap`

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:

Das erste Argument ist die Map, aus der der Schlüssel entfernt werden soll.
Das zweite Argument ist der Schlüssel, der aus der Map entfernt werden soll.

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. 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 sowie in 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. So können Sie benutzerfreundliche Zeichenfolgen anstelle systemgenerierter UUIDs zuweisen, um Knoten und Beziehungen zu identifizieren.

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

Warnung

Diese Erweiterung der openCypher-Spezifikation ist abwärtsinkompatibel, da ~id jetzt als reservierter Eigenschaftsname gilt. Wenn Sie in Ihren Daten und Abfragen ~id bereits als Eigenschaft verwenden, müssen Sie die vorhandene Eigenschaft zu einem neuen Eigenschaftsschlüssel migrieren und den alten entfernen. Siehe Was ist zu tun, wenn Sie derzeit ~id als Eigenschaft verwenden.

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

Dies ist ein Beispiel für die Verwendung benutzerdefinierter IDs in einer MERGE-Klausel:


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

Was ist zu tun, wenn Sie derzeit `~id 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:

Sie erstellt eine neue Eigenschaft mit dem Namen 'newId' für alle Knoten.
Sie kopiert den Wert der Eigenschaft '~id' in die Eigenschaft 'newID'.
Sie entfernt die Eigenschaft '~id' aus den Daten.


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

CALL-Unterstützung für Unterabfragen in Neptune

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

Amazon CALL Neptune unterstützt Unterabfragen. Eine CALL Unterabfrage ist ein Teil der Hauptabfrage, der für jede Eingabe der Unterabfrage in einem isolierten Bereich 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. Wir können die beiden größten Städte abrufen, in denen jeder Freund von jemandem gelebt hat, indem wir eine CALL Unterabfrage verwenden:


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 jeden ausgeführt, auf den friend die vorhergehende 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, sodass wir (maximal) zwei Städte pro Freund erhalten.

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.

Umfang der Variablen in der CALL-Unterabfrage

Die Variablen aus den Klauseln vor der CALL Unterabfrage, die in der Unterabfrage verwendet werden, müssen von der ursprünglichen Klausel importiert werden. WITH Im Gegensatz zu regulären WITH Klauseln kann es 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 können.

Einschränkungen

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

Neptune OpenCypher funktioniert

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

Text IndexOf

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

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


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

coll ToSet

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ücksendungen[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 enthält, aus denen Elemente first ausgeschlossen werden. 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 and/or die Sortierrichtung definieren:


{ key: STRING, order: STRING }

Hier key ist entweder eine Karten- oder eine Knoteneigenschaft, 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 wird die Sortierung in aufsteigender Reihenfolge durchgeführt.

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]
    }]
}

coll SortMaps

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"
        }]
    }]
}

coll SortMulti


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 werden.


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"
        }]
    }]
}

coll SortNodes

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

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


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"
          }
        }]
    }]
}

Zeitliche Funktionen

Temporale Funktionen sind ab Neptune-Version https://docs.aws.amazon.com/releases/release-1.4.5.0.xml 1.4.5.0 und höher verfügbar.

Tag

day(temporal :: (datetime | date)) :: (LONG)

Gibt den Wert day des Monats aus einem Oder-Wert zurück. datetime date Fürdatetime: Die Werte werden auf der Grundlage der Eingabe auf UTC normalisiert, bevor der Tag extrahiert wird. Fürdate: Der Tag wird auf der Grundlage der Zeitzone extrahiert.

Die datetime Eingabe ist sowohl in Neptune Database als auch in Neptune Analytics verfügbar:


RETURN day(datetime('2021-06-03T01:48:14Z'))
{
  "results": [{
      "day(datetime('2021-06-03T01:48:14Z'))": 3
    }]
}

Hier datetime ist das auf UTC normalisiert, sodass + 08:00 auf den 2. Juni zurückgeht.


RETURN day(datetime('2021-06-03T00:00:00+08:00'))
{
  "results": [{
      "day(datetime('2021-06-03T00:00:00+08:00'))": 2
    }]
}

Die date Eingabe ist nur in Neptune Analytics verfügbar:


RETURN day(date('2021-06-03Z'))
{
  "results": [{
      "day(date('2021-06-03Z'))": 3
    }]
}

Das date behält die Zeitzone bei, wobei der 3. Juni beibehalten wird.


RETURN day(date('2021-06-03+08:00'))
{
  "results": [{
      "day(date('2021-06-03+08:00'))": 3
    }]
}

Monat

month(temporal :: (datetime | date)) :: (LONG)

Gibt den Monat anhand eines datetime date ODER-Werts (1—12) zurück. Fürdatetime: Die Werte werden auf der Grundlage der Eingabe auf UTC normalisiert, bevor der Monat extrahiert wird. Fürdate: Der Monat wird auf der Grundlage der Zeitzone extrahiert.

Die datetime Eingabe ist sowohl in Neptune Database als auch in Neptune Analytics verfügbar:


RETURN month(datetime('2021-06-03T01:48:14Z'))
{
  "results": [{
      "month(datetime('2021-06-03T01:48:14Z'))": 6
    }]
}

Hier datetime ist das auf UTC normalisiert, sodass + 08:00 auf den 31. Mai zurückgeht.



RETURN month(datetime('2021-06-01T00:00:00+08:00'))
{
  "results": [{
      "month(datetime('2021-06-01T00:00:00+08:00'))": 5
    }]
}

Die date Eingabe ist nur in Neptune Analytics verfügbar:


RETURN month(date('2021-06-03Z'))
{
  "results": [{
      "month(date('2021-06-03Z'))": 6
    }]
}

Das date behält die Zeitzone bei, wobei der 1. Juni beibehalten wird.


RETURN month(date('2021-06-01+08:00'))
{
  "results": [{
      "month(date('2021-06-01+08:00'))": 6
    }]
}

Jahr

year(temporal :: (datetime | date)) :: (LONG)

Gibt das Jahr aus einem datetime date OR-Wert zurück. Fürdatetime: Die Werte werden auf der Grundlage der Eingabe auf UTC normalisiert, bevor das Jahr extrahiert wird. Fürdate: Das Jahr wird auf der Grundlage der Zeitzone extrahiert.

Die datetime Eingabe ist sowohl in Neptune Database als auch in Neptune Analytics verfügbar:



RETURN year(datetime('2021-06-03T01:48:14Z'))
{
  "results": [{
      "year(datetime('2021-06-03T01:48:14Z'))": 2021
    }]
}

Hier datetime ist das auf UTC normalisiert, sodass + 08:00 auf den 31. Dezember 2020 zurückgeht.


RETURN year(datetime('2021-01-01T00:00:00+08:00'))
{
  "results": [{
      "year(datetime('2021-01-01T00:00:00+08:00'))": 2020
    }]
}

Die date Eingabe ist nur in Neptune Analytics verfügbar:


RETURN year(date('2021-06-03Z'))
{
  "results": [{
      "year(date('2021-06-03Z'))": 2021
    }]
}

Das date behält die Zeitzone bei, wobei Juni 2021 beibehalten wird.


RETURN year(date('2021-01-01+08:00'))
{
  "results": [{
      "year(date('2021-01-01+08:00'))": 2021
    }]
}

Neptune OpenCypher funktioniert

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

reduzieren ()

Reduce verarbeitet jedes Listenelement sequentiell, indem es mit einer laufenden Summe oder einem 'Akkumulator' kombiniert wird. Ausgehend von einem Anfangswert aktualisiert es den Akkumulator nach jeder Operation und verwendet diesen aktualisierten Wert in der nächsten Iteration.

for i in (0, ..., n) acc = acc X list[I], where X denotes any binary operator

Sobald alle Elemente verarbeitet wurden, wird das endgültige akkumulierte Ergebnis zurückgegeben.

Eine typische reduce () -Struktur wäre - reduce(accumulator = initial , variable IN list | expression)

Technische Daten des Typs:

- initial: starting value for the accumulator :: (Long | FLOAT | STRING | LIST? OF (STRING, LONG, FLOAT)) - list: the input list :: LIST OF T where T matches initial type - variable :: represents each element in the input list - expression :: Only supports '+' and '*' operator - return :: Same type as initial

Einschränkungen:

Derzeit unterstützt der reduce() Ausdruck nur:

Numerische Multiplikation
Numerische Addition
Zeichenfolgenverkettung
Verkettung der Liste

Sie werden durch den Operator oder dargestellt. + * Der Ausdruck sollte ein binärer Ausdruck sein, wie unten angegeben - expression pattern: accumulator + any variable or accumulator * any variable

Behandlung von Überläufen:

Neptune erkennt während der reduce() Auswertung einen numerischen Überlauf und reagiert je nach Datentyp unterschiedlich:


LONG (signed 64‑bit)
--------------------
• Valid range: –9 223 372 036 854 775 808 … 9 223 372 036 854 775 807  
• If any intermediate or final value falls outside this range,
  Neptune aborts the query with long overflow error message.
  
FLOAT (IEEE‑754 double)
-----------------------
• Largest finite value ≈ 1.79 × 10^308  
• Larger results overflow to INF
  Once `INF` is produced, it propagates through the remainder
  of the reduction.

Beispiele:

Sehen Sie sich die folgenden Beispiele für die Funktion reduce () an.



1. Long Addition:
RETURN reduce(sum = 0, n IN [1, 2, 3] | sum + n)
{
  "results": [{
      "reduce(sum = 0, n IN [1, 2, 3] | sum + n)": 6
    }]
}

2. String Concatenation:
RETURN reduce(str = "", x IN ["A", "B", "C"] | str + x) 
{
  "results": [{
      "reduce(str = "", x IN ["A", "B", "C"] | str + x)": "ABC"
    }]
}

3. List Combination:
RETURN reduce(lst = [], x IN [1, 2, 3] | lst + x)
{
  "results": [{
      "reduce(lst = [], x IN [1, 2, 3] | lst + x)": [1, 2, 3]
    }]
}

4. Float Addition:
RETURN reduce(total = 0.0, x IN [1.5, 2.5, 3.5] | total + x) 
{
  "results": [{
      "reduce(total = 0.0, x IN [1.5, 2.5, 3.5] | total + x)": 7.5
    }]
}

5. Long Multiplication:
RETURN reduce(product = 1, n IN [1, 2, 3] | product * n)
{
  "results": [{
      "reduce(product = 0, n IN [1, 2, 3] | product * n)": 6
    }]
}

6. Float Multiplication:
RETURN reduce(product = 1.0, n IN [1.5, 2.5, 3.5] | product * n)
{
  "results": [{
      "reduce(product = 1.0, n IN [1.5, 2.5, 3.5] | product * n)": 13.125
    }]
}

7. Long Overflow (Exception):
RETURN reduce(s = 9223372036854775807, x IN [2, 3] | s * x) AS result
{
"results": [{
    "reduce(s = 9223372036854775807, x IN [2, 3] | s * x) AS result": long overflow
    }]
}

8. Float Overflow:
RETURN reduce(s = 9.0e307, x IN [8.0e307, 1.0e307] | s + x) AS result
{
"results": [{
    "reduce(s = 9.0e307, x IN [8.0e307, 1.0e307] | s + x) AS result": INF
    }]
}

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Ausnahmen

neptune.read ()

OpenCypher-Erweiterungen in Amazon Neptune

Query-time S3-Datenzugriff

Die Funktion Neptune-specific join ()

Die Neptune-specific Funktion remove () KeyFromMap

Benutzerdefinierte ID-Werte für Knoten- und Beziehungseigenschaften

Warnung

Was ist zu tun, wenn Sie derzeit ~id als Eigenschaft verwenden

CALL-Unterstützung für Unterabfragen in Neptune

Umfang der Variablen in der CALL-Unterabfrage

Von der CALL-Unterabfrage zurückgegebene Variablen

Einschränkungen

Neptune OpenCypher funktioniert

Funktionen zum Sortieren

Zeitliche Funktionen

Tag

Monat

Jahr

Neptune OpenCypher funktioniert

reduzieren ()

Technische Daten des Typs:

Einschränkungen:

Behandlung von Überläufen:

Beispiele:

Die `Funktion Neptune-specific` join ()

Die Neptune-specific `Funktion remove () KeyFromMap`

Was ist zu tun, wenn Sie derzeit `~id als Eigenschaft` verwenden