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:

Vergleich mit Neptune Analytics

Ist in Neptune Analytics synchron. neptune.graph.pg_schema() 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 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:

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.

{
  "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:

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:

Schema-Objekt:

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 alsString), werden alle beobachteten Typen im datatypes Array aufgeführt.

Schema berechnen

Löst eine Schemaverrechnung im Hintergrund aus.

Syntax:

IAM-Aktionen erforderlich: und neptune-db:ReadDataViaQuery neptune-db:WriteDataViaQuery

Parameter:

Verhalten:

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:

Erforderliche IAM-Aktionen: und neptune-db:ReadDataViaQuery neptune-db:WriteDataViaQuery

Verhalten:

Antwort: Gibt das Statusobjekt zurück, das den Status anzeigt: "Stopped" mit dem aktuellenprogressPercentage.

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 aufrufenneptune.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 aufrufenneptune.graph.pg_schema(), der den aktuellen Status und progressPercentage zurückgibt.

Zustände

Die Schemaberechnung durchläuft die folgenden Phasen:

Persistenz und Neustartverhalten

Das berechnete Schema ist persistent und übersteht Engine-Neustarts. Das Neustartverhalten hängt vom Zustand zum Zeitpunkt des Neustarts ab:

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:

Bewährte Methoden

Einschränkungen

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