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. # Schema des Eigenschaftsdiagramms Das `neptune.graph.pg_schema()` Verfahren bietet einen umfassenden Überblick über die Struktur Ihres Eigenschaftsdiagramms. Es gibt alle Knotenbeschriftungen, Kantenbeschriftungen, Eigenschaften mit ihren Datentypen und Label-Tripel zurück (`{~from, ~type, ~to}`Muster, die beschreiben, wie Knotentypen durch Kantentypen miteinander verbunden sind). Dieses Verfahren ist derzeit nur über den OpenCypher-Endpunkt verfügbar und ermittelt das Schema für alle Eigenschaftsdiagrammdaten. Verwenden Sie dieses Verfahren für Aufgaben wie: + **Generierung von KI- und LLM-Abfragen ** — Geben Sie LLMs die Graphstruktur, die sie benötigen, um gültige Cypher-Abfragen aus natürlicher Sprache (Text-to-CypherGraphRag-Anwendungen) zu generieren. + **Visualisierung und Erkundung von Graphen ** — Tools wie [ Graph Explorer ](visualization-graph-explorer.md) verwenden Schemainformationen, um interaktive visuelle Darstellungen von Graphdaten zu rendern, ohne die gesamte Datenbank zu scannen. + **Erkennung von Anwendungsschemas ** — Anwendungen, die die Graphstruktur beim Start verstehen müssen, wie GraphQL-Schemagenatoren oder Datenvalidierungstools. ## Vergleich mit Neptune Analytics Ist in Neptune Analytics synchron. [`neptune.graph.pg_schema()`](https://docs.aws.amazon.com/neptune-analytics/latest/userguide/custom-algorithms-property-graph-schema.html) Es berechnet das Schema bei jedem Aufruf. In Neptune Database lösen Sie explizit eine asynchrone Schemaverrechnung durch einen Aufruf aus, der sofort zurückgegeben wird. `neptune.graph.pg_schema.compute()` Die Berechnung läuft im Hintergrund, während Sie mit Hilfe von abfragen, ob der Vorgang abgeschlossen ist. `neptune.graph.pg_schema()` Nach der Berechnung behält Neptune das Schema bei und gibt es bei nachfolgenden Lesevorgängen sofort ohne Neuberechnung zurück. Teilergebnisse sind auch verfügbar, während die Berechnung noch läuft. Sie können eine laufende Berechnung auch anhalten und später fortsetzen. ## Vergleich mit der Graph Summary API Die [ Graph Summary API ](neptune-graph-summary.md) bietet keine Label-Tripel oder Eigenschaftsdatentypen. Das Property Graph Schema-Verfahren füllt diese Lücke. Label-Tripel zeigen die spezifischen Beziehungsmuster in Ihrem Diagramm. Beispiel: A stellt `Company` über eine `worksAt` Kante eine `Person` Verbindung zu A her. Diese Informationen sind für LLMs von entscheidender Bedeutung, um semantisch korrekte Abfragen zu generieren. ## Voraussetzungen ### Engine-Version Für das Property Graph Schema-Verfahren ist die Neptune-Engine-Version 1.4.8.0 oder höher erforderlich. ### IAM-Berechtigungen Die folgenden IAM-Aktionen sind für jeden Schemavorgang erforderlich: + `CALL neptune.graph.pg_schema()`— erfordert`neptune-db:ReadDataViaQuery`. + `CALL neptune.graph.pg_schema.compute()`— benötigt `neptune-db:ReadDataViaQuery` und`neptune-db:WriteDataViaQuery`. + `CALL neptune.graph.pg_schema.stop()`— benötigt `neptune-db:ReadDataViaQuery` und`neptune-db:WriteDataViaQuery`. Für die `stop()` Operationen `compute()` und sind Schreibberechtigungen erforderlich, da sie den internen Status ändern, der zum Zwischenspeichern und Beibehalten des Schemas verwendet wird. **Example Beispiel für eine IAM-Richtlinie** Die folgende Richtlinie gewährt die Mindestberechtigungen, die für alle Schemaoperationen erforderlich sind: ``` { "Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Action": [ "neptune-db:ReadDataViaQuery", "neptune-db:WriteDataViaQuery" ], "Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-resource-id/*" }] } ``` Um schreibgeschützten Zugriff auf das Schema zu gewähren (ohne die Möglichkeit, Berechnungen auszulösen), verwenden Sie nur. `neptune-db:ReadDataViaQuery` ### Writer- und Reader-Instanzen Sie können die Schemaberechnung nur auf der Writer-Instanz auslösen. Read Replica-Instanzen können das Schema (das vom Writer repliziert wird) lesen, können aber nicht ausführen oder. `compute()` `stop()` ## API-Referenz ### Schema lesen Ruft das aktuelle Schema und den aktuellen Berechnungsstatus ab. **Syntax:** ------ #### [ AWS CLI ] ``` aws neptunedata execute-open-cypher-query \ --endpoint-url https://{{your-neptune-endpoint}}:{{port}} \ --open-cypher-query "CALL neptune.graph.pg_schema()" ``` ------ #### [ SDK ] ``` import boto3 from botocore.config import Config client = boto3.client( 'neptunedata', endpoint_url='https://{{your-neptune-endpoint}}:{{port}}', config=Config(read_timeout=None, retries={'total_max_attempts': 1}) ) response = client.execute_open_cypher_query( openCypherQuery='CALL neptune.graph.pg_schema()' ) print(response) ``` ------ #### [ awscurl ] ``` awscurl -X POST https://{{your-neptune-endpoint}}:{{port}}/openCypher \ -H "Content-Type: application/x-www-form-urlencoded" \ --region {{us-east-1}} --service neptune-db \ -d 'query=CALL neptune.graph.pg_schema()' ``` ------ **Verhalten: ** Kehrt sofort mit dem aktuellen Schema und Status zurück. Immer nicht blockierend. Wenn kein Schema berechnet wurde, gibt state: `"NotStarted"` mit leeren Schemafeldern zurück. Wenn eine Berechnung im Gange ist, werden Teilergebnisse mit dem Status: zurückgegeben. `"InProgress"` **Format der Antwort: ** Die Antwort enthält ein Schemaobjekt mit den folgenden Feldern: **Status-Objekt: ** + `state`(String) — Aktueller Lebenszyklusstatus: `NotStarted``InProgress`,`Completed`,`Stopped`, `Failed` + `concurrency`(String) — Anzahl der für die Berechnung verwendeten Threads. 0 bedeutet automatisch (abhängig von der Hardware). Bereich: 1 (niedrigster Wert) bis 16 (höchster Wert). + `lastComputedTimestamp`(String) — ISO-8601 UTC-Zeitstempel der letzten erfolgreichen Berechnung (z. B.) `2026-05-29T08:00:00Z` + `progressPercentage`(String) — Fortschritt der Berechnung: 0, wenn sie nicht gestartet wurde, 0—99 während der Berechnung, 100, wenn sie abgeschlossen ist + `errorMessage`(String) — Nur vorhanden, wenn eine Anfrage abgelehnt wird oder die Berechnung fehlschlägt. Erklärt den Grund. **Schema-Objekt: ** + `nodeLabels`— Array aller eindeutigen Knotenbezeichnungen im Diagramm + `edgeLabels`— Array aller eindeutigen Kantenbeschriftungen im Diagramm + `nodeLabelDetails`— Für jedes Node-Label: Eigenschaften und ihre Datentypen + `edgeLabelDetails`— Für jedes Edge-Label: Eigenschaften und ihre Datentypen + `labelTriples`— Reihe von Beziehungsmustern: `{~from, ~type, ~to}` Beschreibt, welche Knotentypen über welche Kantentypen miteinander verbunden sind **Unterstützte Datentypen: **`String`,`Int`,`Long`,`Double`,`Bool`, `Date` Wenn eine Eigenschaft über mehrere Datentypen auf verschiedenen Knoten verfügt (z. B. speichern einige Knoten `age` als `Int` und andere als`String`), werden alle beobachteten Typen im `datatypes` Array aufgeführt. ### Schema berechnen Löst eine Schemaverrechnung im Hintergrund aus. **Syntax:** ------ #### [ AWS CLI ] ``` aws neptunedata execute-open-cypher-query \ --endpoint-url https://{{your-neptune-endpoint}}:{{port}} \ --open-cypher-query "CALL neptune.graph.pg_schema.compute()" ``` Mit optionalem Parallelitätsparameter: ``` aws neptunedata execute-open-cypher-query \ --endpoint-url https://{{your-neptune-endpoint}}:{{port}} \ --open-cypher-query "CALL neptune.graph.pg_schema.compute({concurrency: 2})" ``` ------ #### [ SDK ] ``` import boto3 from botocore.config import Config client = boto3.client( 'neptunedata', endpoint_url='https://{{your-neptune-endpoint}}:{{port}}', config=Config(read_timeout=None, retries={'total_max_attempts': 1}) ) response = client.execute_open_cypher_query( openCypherQuery='CALL neptune.graph.pg_schema.compute()' ) print(response) ``` ------ #### [ awscurl ] ``` awscurl -X POST https://{{your-neptune-endpoint}}:{{port}}/openCypher \ -H "Content-Type: application/x-www-form-urlencoded" \ --region {{us-east-1}} --service neptune-db \ -d 'query=CALL neptune.graph.pg_schema.compute()' ``` Mit optionalem Parallelitätsparameter: ``` awscurl -X POST https://{{your-neptune-endpoint}}:{{port}}/openCypher \ -H "Content-Type: application/x-www-form-urlencoded" \ --region {{us-east-1}} --service neptune-db \ -d 'query=CALL neptune.graph.pg_schema.compute({concurrency: 2})' ``` ------ **IAM-Aktionen erforderlich: und ** `neptune-db:ReadDataViaQuery` `neptune-db:WriteDataViaQuery` **Parameter:** + `concurrency`(Integer, optional) — Anzahl der Threads für die Hintergrundberechnung. 0 (Standard) = wird automatisch basierend auf der Hardware bestimmt. Bereich: 1 (niedrigster Wert) bis 16 (höchster Wert). Verwenden Sie bei kleineren Instanzen niedrigere Werte, um die Ressourcenbelastung zu reduzieren. **Verhalten: ** + Kehrt sofort mit dem aktuellen Status zurück. Die Berechnung läuft asynchron im Hintergrund. + Wenn der Befehl aufgerufen wird, wenn der Status erreicht ist`Stopped`, wird die Berechnung an der Stelle fortgesetzt, an der sie aufgehört hat. + Wird aufgerufen, wenn der Status aktiviert ist`Completed`, wird eine neue Neuberechnung gestartet. Das vorherige Schema verarbeitet weiterhin Lesevorgänge, bis die neue Berechnung abgeschlossen ist. + Wenn Neptune aufgerufen wird, obwohl bereits eine Berechnung durchgeführt wurde`InProgress`, lehnt Neptune die Anfrage mit einer Fehlermeldung ab. + Wird Neptune während eines aktiven Massenladens aufgerufen, lehnt Neptune die Anfrage mit einer Fehlermeldung ab. **Antwort: ** Gibt das Statusobjekt zurück, das den Status anzeigt: `"InProgress"` mit den `concurrency` Feldern und. `progressPercentage` ### Stoppen Sie die Schemaberechnung Stoppt eine laufende Hintergrundberechnung. **Syntax:** ------ #### [ AWS CLI ] ``` aws neptunedata execute-open-cypher-query \ --endpoint-url https://{{your-neptune-endpoint}}:{{port}} \ --open-cypher-query "CALL neptune.graph.pg_schema.stop()" ``` ------ #### [ SDK ] ``` import boto3 from botocore.config import Config client = boto3.client( 'neptunedata', endpoint_url='https://{{your-neptune-endpoint}}:{{port}}', config=Config(read_timeout=None, retries={'total_max_attempts': 1}) ) response = client.execute_open_cypher_query( openCypherQuery='CALL neptune.graph.pg_schema.stop()' ) print(response) ``` ------ #### [ awscurl ] ``` awscurl -X POST https://{{your-neptune-endpoint}}:{{port}}/openCypher \ -H "Content-Type: application/x-www-form-urlencoded" \ --region {{us-east-1}} --service neptune-db \ -d 'query=CALL neptune.graph.pg_schema.stop()' ``` ------ **Erforderliche IAM-Aktionen: und ** `neptune-db:ReadDataViaQuery` `neptune-db:WriteDataViaQuery` **Verhalten: ** + Stoppt die laufende Berechnung. Der Fortschritt wird gespeichert, sodass er an der Stelle fortgesetzt werden kann, an der er aufgehört hat, wenn Sie `compute()` erneut anrufen. + Eine gestoppte Berechnung wird beim Motorneustart * nicht * automatisch fortgesetzt. Sie müssen explizit anrufen. `compute()` **Antwort: ** Gibt das Statusobjekt zurück, das den Status anzeigt: `"Stopped"` mit dem aktuellen`progressPercentage`. ## Verwendung von YIELD mit Schemaergebnissen Sie können `YIELD` es verwenden, um Schemafelder zu extrahieren und sie mit anderen Abfragen zu kombinieren. Im folgenden Beispiel werden alle Knotenbezeichnungen abgerufen und die Anzahl der Knoten für jedes Label gezählt. Die `collSort()` Funktion sortiert die Liste alphabetisch: ``` CALL neptune.graph.pg_schema() YIELD schema WITH schema.nodeLabels as nl UNWIND collSort(nl) as label MATCH (n) WHERE label in labels(n) RETURN label, COUNT(n) as count ``` Beispielausgabe: ``` { "results": [{ "label": "airport", "count": 3503 }, { "label": "continent", "count": 7 }, { "label": "country", "count": 237 }, { "label": "version", "count": 1 }] } ``` ## Lebenszyklus der Schema-Berechnung ### Asynchroner Betrieb Die Schemaberechnung ist ein asynchroner Vorgang. Wenn Sie aufrufen`neptune.graph.pg_schema.compute()`, kehrt es sofort mit dem aktuellen Status zurück. Die Berechnung läuft im Hintergrund. Sie fragen den Fortschritt und den Abschluss ab, indem Sie den Aufruf aufrufen`neptune.graph.pg_schema()`, der den aktuellen Status und `progressPercentage` zurückgibt. ### Zustände Die Schemaberechnung durchläuft die folgenden Phasen: + `NotStarted`— Es wurde noch kein Schema berechnet. `pg_schema()`gibt ein leeres Schema zurück. + `InProgress`— Eine Hintergrundberechnung läuft. `pg_schema()`gibt Teilergebnisse zurück (eine Vereinigung des letzten vollständigen Schemas und der Erkenntnisse aus der aktuellen Berechnung). + `Completed`— Die Berechnung wurde erfolgreich abgeschlossen. Das vollständige Schema ist verfügbar. + `Stopped`— Die Berechnung wurde gestoppt, entweder durch einen Aufruf `stop()` oder weil sie durch einen Motorneustart unterbrochen wurde. Teilergebnisse sind verfügbar. Der Fortschritt wird gespeichert, sodass die Berechnung an der Stelle fortgesetzt werden kann, an der sie beim Aufruf `compute()` aufgehört hat. + `Failed`— Bei der Berechnung ist ein Fehler aufgetreten. Das letzte erfolgreich berechnete Schema (falls vorhanden) ist weiterhin verfügbar. ### Persistenz und Neustartverhalten Das berechnete Schema ist persistent und übersteht Engine-Neustarts. Das Neustartverhalten hängt vom Zustand zum Zeitpunkt des Neustarts ab: + `InProgress`— Wenn der Motor während der Berechnung neu startet, wechselt die Berechnung zu. `Stopped` Rufen Sie an`compute()`, um dort weiterzumachen, wo es aufgehört hat. Der Fortschritt wird beibehalten und die Berechnung wird vom letzten Checkpoint aus fortgesetzt. + `Stopped`— Die Berechnung wird * nicht * automatisch fortgesetzt. Sie müssen anrufen`compute()`, um an der Stelle fortzufahren, an der es aufgehört hat. + `Completed`— Das Schema ist geladen und sofort verfügbar. ### Teilergebnisse `pg_schema()`Gibt Teilergebnisse zurück, während eine Berechnung läuft. Dazu gehören alle zuvor abgeschlossenen Schemas, die mit den Bezeichnungen, Eigenschaften und Tripeln zusammengeführt wurden, die bisher in der aktuellen Berechnung entdeckt wurden. Das bedeutet, dass Sie nicht warten müssen, bis eine vollständige Berechnung abgeschlossen ist, bevor Sie nützliche Schemainformationen abrufen. ### Read Replicas Read Replica-Instanzen können das Schema mit Hilfe von lesen. `CALL neptune.graph.pg_schema()` Neptune repliziert das Schema aus der Writer-Instanz und macht es fast sofort auf Replikaten verfügbar, sobald Schemaelemente im Writer entdeckt werden. Read Replicas können nicht ausgeführt werden oder. `compute()` `stop()` Diese Aufrufe geben einen Fehler zurück: + `compute()` – `"Schema cannot be computed on read replica"` + `stop()` – `"Schema compute cannot be stopped on read replica"` ## Bewährte Methoden + **Nach Mutationen neu berechnen ** — Das Schema wird nicht automatisch aktualisiert, wenn sich Daten ändern. Das Schema nach Massenladungen oder signifikanten Datenmutationen neu berechnen. Verwenden Sie das `lastComputedTimestamp` Feld, um zu ermitteln, ob das Schema im Vergleich zu den letzten Änderungen in Ihrem Diagramm veraltet ist. + **Parallelität ** — Der Standardwert für Parallelität (0) passt sich automatisch an Ihre Instance-Hardware an. Für die meisten Workloads ist dies die empfohlene Einstellung. Wenn sich die Hintergrundberechnung auf Ihren Abfrage-Workload auswirkt, geben Sie einen niedrigeren Wert an (z. B. 1 oder 2), um den Ressourcenverbrauch zu reduzieren. + **Stoppen und fortsetzen ** — Wenn sich die Hintergrundberechnung auf Ihre Abfrage-Arbeitslast auswirkt, beenden Sie sie mit `stop()` und setzen Sie sie zu einem späteren Zeitpunkt in einer Zeit mit geringem Datenverkehr fort, indem Sie erneut aufrufen. `compute()` Die Berechnung wird an der Stelle fortgesetzt, an der sie aufgehört hat. + **Neustarts ordnungsgemäß verarbeiten ** — Wenn die Engine während einer Schemaberechnung neu gestartet wird, geht die Berechnung zu. `Stopped` Rufen Sie `compute()` auf, um dort weiterzumachen, wo es aufgehört hat. Der Fortschritt bleibt erhalten. + **Große Datenbanken ** — Bei Datenbanken mit großen Speichervolumen (mehrere TB) kann eine vollständige Schemaberechnung längere Zeit in Anspruch nehmen. Sie können eine Berechnung starten, sie so lange laufen lassen, bis ein Fortschritt von 10— 20% erreicht ist, und sie dann beenden. Die in diesem Fenster gesammelten Teilergebnisse bieten ein nützliches Schemabeispiel mit vielen bereits erkannten Bezeichnungen, Eigenschaften und Tripelwerten. Lesen Sie das Teilschema mit, `pg_schema()` während die Berechnung läuft oder nachdem Sie sie beendet haben. Fahren Sie später fort, wenn Ihre Arbeitslast es zulässt. ## Einschränkungen + **Löschungen müssen neu berechnet werden ** — Gelöschte Bezeichnungen, Eigenschaften und Tripel werden erst nach der nächsten vollständigen Neuberechnung aus dem Schema entfernt. Bis dahin erscheinen gelöschte Elemente möglicherweise immer noch in den Schemaergebnissen. + **OpenCypher nur ** — Sie können diese Prozedur nur über den OpenCypher-Abfrageendpunkt aufrufen. + **Beim Massenladen kann nicht gerechnet werden ** — Neptune lehnt die Schemaberechnung ab, während ein Massenladevorgang aktiv ist. Löst die Berechnung aus, nachdem der Massenladevorgang abgeschlossen ist. ## Beispielausgabe für Das folgende Beispiel zeigt die Schemaausgabe für das Air-Routes-Dataset: ``` awscurl -X POST https://{{your-neptune-endpoint}}:{{port}}/openCypher \ -H "Content-Type: application/x-www-form-urlencoded" \ --region {{us-east-1}} --service neptune-db \ -d 'query=CALL neptune.graph.pg_schema()' ``` ``` { "results": [{ "schema": { "edgeLabelDetails": { "route": { "properties": { "dist": ["Int"] } }, "contains": { "properties": {} } }, "edgeLabels": ["route", "contains"], "status": { "concurrency": "16", "lastComputedTimestamp": "2026-06-04T23:58:17Z", "state": "Completed", "progressPercentage": "100" }, "nodeLabels": ["version", "continent", "airport", "country"], "labelTriples": [{ "~type": "route", "~from": "airport", "~to": "airport" }, { "~type": "contains", "~from": "country", "~to": "airport" }, { "~type": "contains", "~from": "continent", "~to": "airport" }], "nodeLabelDetails": { "continent": { "properties": { "type": ["String"], "code": ["String"], "desc": ["String"] } }, "airport": { "properties": { "type": ["String"], "city": ["String"], "icao": ["String"], "code": ["String"], "country": ["String"], "lat": ["Double"], "longest": ["Int"], "runways": ["Int"], "desc": ["String"], "lon": ["Double"], "region": ["String"], "elev": ["Int"] } }, "country": { "properties": { "type": ["String"], "code": ["String"], "desc": ["String"] } }, "version": { "properties": { "date": ["String"], "desc": ["String"], "author": ["String"], "type": ["String"], "code": ["String"] } } } } }] } ```