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](feature-opencypher-compliance.md) 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.
## S3-Datenzugriff bei Abfrage
Verfügbar in Neptune Database 1.4.7.0 und höher.
Neptune unterstützt die `neptune.read()` Funktion, CSV- oder Parquet-Daten aus Amazon S3 direkt in OpenCypher-Abfragen zu lesen. Im Gegensatz zum Bulk-Loader, der Daten vor der Abfrage importiert, `neptune.read()` greift er bei der Ausführung der Abfrage auf Amazon S3 S3-Daten zu.
Eine vollständige Dokumentation finden Sie unter. [neptune.read ()](access-graph-opencypher-21-extensions-s3-read.md)
## 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:
+ 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-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:
+ 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 und Neptune Analytics.
Ab [Engine-Version 1.2.0.2](engine-releases-1.2.0.2.md) 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.
**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 Sie tun sollten, wenn Sie `~id` zurzeit als Eigenschaft verwenden](#opencypher-compliance-custom-ids-migrating).
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](engine-releases-1.2.0.2.md) 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 '\$1id' in die Eigenschaft 'newID'.
+ Sie entfernt die Eigenschaft '\$1id' 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
```
## Unterstützung für CALL-Unterabfragen in Neptune
Verfügbar in Neptune Database 1.4.1.0 und höher sowie 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`
Angenommen, 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 mit`DISTINCT`,,`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 sowie 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 fortgesetzt`text`. 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 and/or 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. `order`ist 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"
}
}]
}]
}
```
## Zeitliche Funktionen
Temporale Funktionen sind ab Neptune Version [1.4.5.0](https://docs.aws.amazon.com/releases/release-1.4.5.0.xml) 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ür`datetime`: Werte werden auf der Grundlage der Eingabe vor dem Extrahieren des Tages auf UTC normalisiert. Für`date`: Der Tag wird basierend auf 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 \$1 08:00 wieder auf den 2. Juni verschoben wird.
```
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
}]
}
```
Die Zeitzone wird `date` beibehalten, 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 aus einem `datetime` `date` OR-Wert (1—12) zurück. Für`datetime`: Werte werden auf der Grundlage der Eingabe vor dem Extrahieren des Monats auf UTC normalisiert. Für`date`: Der Monat wird basierend auf 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 \$1 08:00 wieder auf den 31. Mai verschoben wird.
```
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
}]
}
```
Die Zeitzone wird `date` beibehalten, 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 anhand eines Werts `datetime` oder `date` zurück. Für`datetime`: Die Werte werden auf der Grundlage der Eingabe auf UTC normalisiert, bevor das Jahr extrahiert wird. Für`date`: Das Jahr wird basierend auf 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, also \$1 08:00 verschiebt sich zurück auf den 31. Dezember 2020.
```
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
}]
}
```
Die Zeitzone wird `date` beibehalten, wobei Juni 2021 beibehalten wird.
```
RETURN year(date('2021-01-01+08:00'))
{
"results": [{
"year(date('2021-01-01+08:00'))": 2021
}]
}
```
### Neptune OpenCypher-Funktionen
Verfügbar in Neptune Database 1.4.6.0 und höher und Neptune Analytics.
#### reduzieren ()
Reduce verarbeitet jedes Listenelement sequentiell, indem es es mit einer laufenden Summe oder einem „Akkumulator“ kombiniert. 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 kumulierte Ergebnis zurückgegeben.
Eine typische Reduce () -Struktur wäre - `reduce(accumulator = initial , variable IN list | expression)`
**Typspezifikationen:**
`- 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 von Listen
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
}]
}
```