Übersicht über Graph-Modelle (Vorschau)

Gilt für: ✅Microsoft Fabric✅Azure Data Explorer

Hinweis

Dieses Feature ist zurzeit als öffentliche Preview verfügbar. Funktionalität und Syntax können vor der allgemeinen Verfügbarkeit geändert werden.

Mithilfe von Graph-Modellen im Azure-Daten-Explorer können Sie persistente Diagrammstrukturen in Ihrer Datenbank definieren, verwalten und effizient abfragen. Im Gegensatz zu vorübergehenden Diagrammen, die mit dem Make-Graph-Operator erstellt wurden, werden Diagrammmodelle gespeichert, die wiederholt abgefragt werden können, ohne das Diagramm für jede Abfrage neu zu erstellen, was die Leistung für komplexe beziehungsbasierte Analysen erheblich verbessert.

Überblick

Ein Diagrammmodell ist ein Datenbankobjekt, das ein beschriftetes Eigenschaftendiagramm (LPG) im Azure Data Explorer darstellt. Es besteht aus Knoten, auch als Scheitelpunkte bezeichnet, und Kanten, auch als Beziehungen bezeichnet. Sowohl Knoten als auch Kanten können Eigenschaften aufweisen, die sie beschreiben. Das Modell definiert das Schema des Diagramms, einschließlich Knoten- und Edgetypen mit ihren Eigenschaften. Außerdem wird der Prozess zum Erstellen des Diagramms aus tabellarischen Daten definiert, die in KQL-Datenbanktabellen und aus tabellarischen Ausdrücken gespeichert sind.

Wichtige Merkmale

Graph-Modelle bieten:

• Persistenz von Metadaten: Speichern von Diagrammspezifikationen in Datenbankmetadaten zur Dauerhaftigkeit und Wiederverwertbarkeit
• Materialisierte Momentaufnahmen: Vermeiden Sie die Notwendigkeit, Diagramme für jede Abfrage neu zu erstellen, wodurch die Abfrageleistung erheblich verbessert wird.
• Schemadefinition: Unterstützung optionaler, aber empfohlener definierter Schemas für Knoten und Kanten, sicherstellung der Datenkonsistenz
• Umfassende KQL-Integration: Nahtlose Integration in die Graphsemantik
• Optimierte Traversale: Fügen Sie spezielle Indizierung für effiziente Graph-Traversalvorgänge ein, wodurch komplexe Musterabgleichs- und Pfadsuche-Abfragen erheblich schneller werden.

Gründe für die Verwendung von Diagrammmodellen

Graph-Modelle bieten erhebliche Vorteile für die beziehungsbasierte Analyse, erfordern jedoch eine zusätzliche Einrichtung im Vergleich zu Ad-hoc-Diagrammabfragen. Erwägen Sie die Verwendung von Diagrammmodellen in folgenden Fällen:

• Die Leistung ist wichtig: Sie führen wiederholt Diagrammabfragen mit denselben zugrunde liegenden Daten aus und benötigen eine optimierte Leistung.
• Komplexe Beziehungsdaten: Sie verfügen über Daten mit vielen miteinander verbundenen Beziehungen, die von einer Graphdarstellung profitieren
• Stabile Struktur: Ihre Diagrammstruktur ist relativ stabil, mit regelmäßigen, aber nicht konstanten Aktualisierungen
• Erweiterte Diagrammvorgänge: Sie müssen komplexe Traversale, Pfadsuche, Musterabgleich oder Communityerkennung für Ihre Daten ausführen.
• Konsistentes Schema: Für die Diagrammanalyse ist eine klar definierte Struktur mit konsistenten Knoten- und Edgetypen erforderlich.

Für eine einfachere Einmaldiagrammanalyse auf kleineren Datasets ist der Make-Graph-Operator möglicherweise besser geeignet.

Graph-Modellkomponenten

Ein Diagrammmodell besteht aus zwei Hauptkomponenten:

Schema (optional)

Das Schema definiert die Struktur und Eigenschaften von Knoten und Kanten im Diagrammmodell. Das Schema ist zwar optional, dient jedoch mehreren wichtigen Zwecken:

• Typsicherheit: Schemaeigenschaften definieren die erwarteten Datentypen für Knoten- und Edgeeigenschaften, wodurch die Typkonsistenz bei Diagrammabfragen sichergestellt wird
• Eigenschaftenüberprüfung: Alle im Schema definierten Eigenschaften werden zu gültigen Eigenschaften für Knoten/Kanten mit den entsprechenden Bezeichnungen, unabhängig davon, ob diese Eigenschaften in den Schrittabfragespalten angezeigt werden.
• Abfragekompatibilität: Schemaeigenschaften können in Diagramm-Abgleichsabfragen ohne Typkonflikte mit Schrittabfragespalten sicher referenziert werden.

Schemastruktur

• Knoten: Definiert Knotenbezeichnungstypen und deren typierte Eigenschaften (z. B. "Person": {"Name": "string", "Age": "long"})
• Kanten: Definiert Edgebezeichnungstypen und deren typierte Eigenschaften (z. B. "WORKS_AT": {"StartDate": "datetime", "Position": "string"})

Definition

Die Definition gibt an, wie das Diagramm aus tabellarischen Daten über eine Reihe sequenzieller Vorgänge erstellt wird. Dieser Abschnitt ist der Kern des Diagrammmodells, da es ihre relationalen Daten in eine Diagrammstruktur transformiert.

Wichtige Merkmale der Definition:

• Sequenzielle Ausführung: Schritte werden in der genauen Reihenfolge ausgeführt, in der sie im Definitionsarray angezeigt werden. Diese Reihenfolge ist wichtig, da:

  • Knoten müssen in der Regel vor den Rändern erstellt werden, die darauf verweisen
  • Spätere Schritte können auf den Ergebnissen früherer Schritte aufbauen oder ändern.
  • Die Sequenz wirkt sich auf die Leistung und speicherauslastung während der Diagrammerstellung aus

• Inkrementelle Konstruktion: Jeder Schritt fügt dem zu erstellenden Diagramm hinzu, sodass Sie:

  • Kombinieren von Daten aus mehreren Tabellen oder Quellen
  • Anwenden unterschiedlicher Logik für verschiedene Arten von Knoten oder Kanten
  • Erstellen komplexer Diagrammstrukturen inkrementell

Schritttypen:

• AddNodes: Schritte zum Erstellen von Knoten aus tabellarischen Daten

  • Kann mehrmals verwendet werden, um verschiedene Arten von Knoten hinzuzufügen.
  • Jeder Schritt kann aus verschiedenen Datenquellen ziehen oder unterschiedliche Filter anwenden.
  • Knoteneigenschaften werden von den Spalten im Abfrageergebnis abgeleitet.

• AddEdges: Schritte zum Erstellen von Kanten aus tabellarischen Daten

  • Kann auf Knoten verweisen, die noch nicht vorhanden sind (das System erstellt Platzhalterknoten und aktualisiert sie, wenn AddNodes-Schritte später verarbeitet werden)
  • Kann Beziehungen zwischen Knoten aus denselben oder verschiedenen AddNodes-Schritten erstellen
  • Edgeeigenschaften werden von den Spalten im Abfrageergebnis abgeleitet.
  • Es ist zwar möglich, vor Knoten Kanten hinzuzufügen, es wird jedoch empfohlen, zuerst Knoten hinzuzufügen, um die Lesbarkeit und das Verständnis zu verbessern.

Ausführungsflussbeispiel:

Step 1 (AddNodes): Create Person nodes from Employees table
Step 2 (AddNodes): Create Company nodes from Organizations table  
Step 3 (AddEdges): Create WORKS_AT edges between Person and Company nodes
Step 4 (AddEdges): Create KNOWS edges between Person nodes

Mit diesem sequenziellen Ansatz wird sichergestellt, dass beim Erstellen WORKS_AT Kanten sowohl die Knoten "Person" (aus Schritt 1) als auch "Unternehmen" (aus Schritt 2) bereits im Diagramm vorhanden sind.

Beschriftungen in Graph-Modellen

Beschriftungen sind wichtige Bezeichner, die Knoten und Kanten im Diagramm kategorisieren und so eine effiziente Filter- und Musterabgleichung ermöglichen. Azure Data Explorer-Diagrammmodelle unterstützen zwei ergänzende Bezeichnungstypen:

Statische Bezeichnungen

• Explizit im Schemaabschnitt des Diagrammmodells definiert
• Darstellen von Knoten- oder Edgetypen mit vordefinierten Eigenschaften
• Bereitstellen eines konsistenten Schemas für die Diagrammelemente
• Referenziert im Array "Bezeichnungen" in den Schritten "AddNodes" und "AddEdges"
• Ideal für bekannte, stabile Entitäts- und Beziehungstypen

Dynamische Bezeichnungen

• Im Schemaabschnitt nicht vordefiniert
• Generiert zur Laufzeit aus Daten in den zugrunde liegenden Tabellen
• Mit "LabelsColumn" in den Schritten "AddNodes" oder "AddEdges" angegeben
• Kann eine einzelne Beschriftung (Zeichenfolgenspalte) oder mehrere Bezeichnungen (dynamische Arrayspalte) sein.
• Ermöglichen Sie flexiblere Diagrammstrukturen, die sich an Ihre Daten anpassen
• Nützlich für Systeme, bei denen sich Knoten-/Edgetypen im Laufe der Zeit entwickeln

Tipp

Sie können statische und dynamische Bezeichnungen kombinieren, um die Vorteile beider Ansätze zu erzielen: Die Schemaüberprüfung für Kernentitätstypen und gleichzeitig die Flexibilität bei sich entwickelnden Klassifizierungen.

Definitionsschritte im Detail

Der Abschnitt "Definition" eines Diagrammmodells enthält Schritte, mit denen definiert wird, wie das Diagramm aus tabellarischen Daten erstellt wird. Jeder Schritt weist je nach Art spezifische Parameter auf.

AddNodes-Schritte

AddNodes-Schritte definieren, wie Knoten im Diagramm aus tabellarischen Daten erstellt werden:

Parameter	Erforderlich	BESCHREIBUNG
Variante	Ja	Muss auf "AddNodes" festgelegt sein.
Abfrage	Ja	Eine KQL-Abfrage, die die Daten für Knoten abruft. Das Abfrageergebnis muss alle Spalten enthalten, die für Knoteneigenschaften und Bezeichner erforderlich sind.
NodeIdColumn	Ja	Die Spalte aus dem Abfrageergebnis, die als eindeutiger Bezeichner für jeden Knoten verwendet wird
Beschriftungen	Nein	Ein Array statischer Bezeichnungsnamen, die im Schemaabschnitt definiert sind, um sie auf diese Knoten anzuwenden
LabelsColumn	Nein	Eine Spalte aus dem Abfrageergebnis, die dynamische Beschriftungen für jeden Knoten bereitstellt. Kann eine Zeichenfolgenspalte (einzelne Beschriftung) oder dynamische Arrayspalte (mehrere Bezeichnungen) sein.

AddEdges-Schritte

AddEdges-Schritte definieren, wie Beziehungen zwischen Knoten im Diagramm erstellt werden:

Parameter	Erforderlich	BESCHREIBUNG
Variante	Ja	Muss auf "AddEdges" festgelegt sein.
Abfrage	Ja	Eine KQL-Abfrage, die die Daten für Kanten abruft. Das Abfrageergebnis muss Quell- und Zielknotenbezeichner und alle Edgeeigenschaften enthalten.
Quellspalte	Ja	Die Spalte aus dem Abfrageergebnis, die die Quellknotenbezeichner enthält
TargetColumn	Ja	Die Spalte aus dem Abfrageergebnis, die die Zielknotenbezeichner enthält
Beschriftungen	Nein	Ein Array statischer Bezeichnungsnamen, die im Schemaabschnitt definiert sind, um diese Kanten anzuwenden
LabelsColumn	Nein	Eine Spalte aus dem Abfrageergebnis, die dynamische Beschriftungen für jeden Rand bereitstellt. Kann eine Zeichenfolgenspalte (einzelne Beschriftung) oder dynamische Arrayspalte (mehrere Bezeichnungen) sein.

Graph-Modellbeispiele

Einfaches Beispiel mit statischen und dynamischen Bezeichnungen

Im folgenden Beispiel wird ein professionelles Netzwerkdiagrammmodell erstellt, das statische Schemadefinitionen mit dynamischer Bezeichnung kombiniert:

.create-or-alter graph_model ProfessionalNetwork ```
{
  "Schema": {
    "Nodes": {
      "Person": {"Name": "string", "Age": "long", "Title": "string"},
      "Company": {"Name": "string", "Industry": "string", "FoundedYear": "int"}
    },
    "Edges": {
      "WORKS_AT": {"StartDate": "datetime", "Position": "string", "Department": "string"},
      "KNOWS": {"ConnectionDate": "datetime", "ConnectionStrength": "int"}
    }
  },
  "Definition": {
    "Steps": [
      {
        "Kind": "AddNodes",
        "Query": "Employees | project Id, Name, Age, Title, NodeType",
        "NodeIdColumn": "Id",
        "Labels": ["Person"],
        "LabelsColumn": "NodeType"
      },
      {
        "Kind": "AddNodes",
        "Query": "Organizations | project Id, Name, Industry, FoundedYear",
        "NodeIdColumn": "Id",
        "Labels": ["Company"]
      },
      {
        "Kind": "AddEdges",
        "Query": "EmploymentRecords | project EmployeeId, CompanyId, StartDate, Position, Department",
        "SourceColumn": "EmployeeId",
        "TargetColumn": "CompanyId",
        "Labels": ["WORKS_AT"]
      },
      {
        "Kind": "AddEdges",
        "Query": "Connections | project PersonA, PersonB, ConnectionDate, ConnectionType, ConnectionStrength",
        "SourceColumn": "PersonA",
        "TargetColumn": "PersonB",
        "Labels": ["KNOWS"],
        "LabelsColumn": "ConnectionType"
      }
    ]
  }
}
```

Dieses Modell würde Abfragen ermöglichen, z. B. das Auffinden von Kollegen, die durch mehrere Trenngrade verbunden sind, das Identifizieren von Personen, die in derselben Branche arbeiten, oder die Analyse von Organisationsbeziehungen.

Erstellen und Verwalten von Graph-Modellen

Azure Data Explorer bietet einen umfassenden Satz von Verwaltungsbefehlen zum Arbeiten mit Diagrammmodellen während des gesamten Lebenszyklus.

Befehlszusammenfassung

Befehl	Zweck	Schlüsselparameter
.create-or-alter graph_model	Erstellen eines neuen Diagrammmodells oder Ändern eines vorhandenen Diagrammmodells	Datenbank, Name, Schema, Definition
DROP-graph_model	Entfernen eines Diagrammmodells	Datenbank, Name
.show graph_models	Auflisten verfügbarer Diagrammmodelle	Datenbank [optional]

Graph-Modelllebenszyklus

Ein typischer Workflow für die Verwaltung von Diagrammmodellen umfasst:

1. Entwicklung – Erstellen eines ersten Diagrammmodells mit einem Schema und einer Definition, das Ihren Daten zugeordnet ist
2. Überprüfung – Abfragen des Modells, um die richtige Struktur und die erwarteten Ergebnisse zu überprüfen
3. Wartung – Aktualisieren Sie das Modell regelmäßig, wenn sich Ihre Datenstruktur weiterentwickelt
4. Snapshot-Verwaltung – Erstellen und Zurückziehen von Momentaufnahmen zum Ausgleich der Leistung und Aktualität

Tipp

Beginnen Sie beim Starten mit Diagrammmodellen mit einer kleinen Teilmenge Ihrer Daten, um Den Entwurf zu überprüfen, bevor Sie auf größere Datasets skalieren.

Graph-Momentaufnahmen

Graph-Momentaufnahmen sind Datenbankentitäten, die Instanzen von Diagrammmodellen zu bestimmten Zeitpunkten darstellen. Während ein Diagrammmodell die Struktur und Datenquellen für ein Diagramm definiert, ist eine Momentaufnahme das tatsächliche materialisierte Diagramm, das abgefragt werden kann.

Wichtige Aspekte von Diagrammmomentaufnahmen:

• Jede Momentaufnahme ist mit einem bestimmten Diagrammmodell verknüpft.
• Ein einzelnes Diagrammmodell kann mehrere Momentaufnahmen zugeordnet sein.
• Momentaufnahmen werden mit dem .make graph_snapshot Befehl erstellt.
• Momentaufnahmen umfassen Metadaten wie die Erstellungszeit und das Quelldiagrammmodell.
• Momentaufnahmen ermöglichen das Abfragen des Diagramms, wie es zu einem bestimmten Zeitpunkt vorhanden ist.

Ausführlichere Informationen zum Arbeiten mit Diagrammmomentaufnahmen finden Sie in der Übersicht über Graph-Momentaufnahmen.

Abfragen von Graph-Modellen

Graph-Modelle werden mithilfe der graph() Funktion abgefragt, die Zugriff auf die Graphentität ermöglicht. Diese Funktion unterstützt das Abrufen der letzten Momentaufnahme des Diagramms oder das Erstellen des Diagramms zur Abfragezeit, wenn Momentaufnahmen nicht verfügbar sind.

Grundlegende Abfragestruktur

graph("GraphModelName")
| graph-match <pattern>
    where <filters>
    project <output fields>

Abfragebeispiele

1. Grundlegendes Knoten-Edge-Knotenmuster

// Find people who commented on posts by employees in the last week
graph("SocialNetwork") 
| graph-match (person)-[comments]->(post)<-[authored]-(employee)
    where person.age > 30 
      and comments.createTime > ago(7d)
    project person.name, post.title, employee.userName

2. Mehrere Beziehungsmuster

// Find people who both work with and are friends with each other
graph("ProfessionalNetwork") 
| graph-match (p1)-[worksWith]->(p2)-[friendsWith]->(p1)
    where labels(worksWith) has "WORKS_WITH" and labels(friendsWith) has "FRIENDS_WITH" and
      labels(p1) has "Person" and labels(p2) has "Person"
    project p1.name, p2.name, p1.department

3. Pfade mit variabler Länge

// Find potential influence paths up to 3 hops away
graph("InfluenceNetwork") 
| graph-match (influencer)-[influences*1..3]->(target)
    where influencer.id == "user123" and all(influences, labels() has "INFLUENCES")
    project influencePath = influences, 
         pathLength = array_length(influences), 
         target.name

Die graph() Funktion bietet eine konsistente Möglichkeit, auf Diagrammdaten zuzugreifen, ohne das Diagramm für jede Abfrage explizit erstellen zu müssen.

Hinweis

Die vollständige Referenz zu Graph-Abfragesyntax und -funktionen finden Sie unter Graph-Operatoren .

Häufig gestellte Fragen

Wer ist für die Aktualisierung des Diagramms verantwortlich?

Benutzer oder Prozesse müssen das Diagramm selbst aktualisieren. Anfänglich sind keine richtlinien für automatische Aktualisierungen für neue Graphentitäten vorhanden. Das Diagramm kann jedoch weiterhin abgefragt werden, auch wenn die Momentaufnahme erstellt oder noch nicht erstellt wurde.

Wie kann ein Diagramm aktualisiert werden?

So aktualisieren Sie ein Diagramm:

1. Erstellen einer neuen Momentaufnahme mithilfe eines asynchronen Vorgangs (.make graph_snapshot)
2. Nach der Erstellung verwenden eingehende Diagrammabfragen automatisch die neue Momentaufnahme.
3. Optional: Ablegen der alten Momentaufnahme zum Freigeben von Ressourcen (.drop graph_snapshot)

Was geschieht, wenn unterschiedliche Schritte doppelte Kanten oder Knoten erstellen?

Die Definitionsschritte werden sequenziell ausgeführt, und die doppelte Behandlung unterscheidet sich zwischen Knoten und Kanten:

• Kanten: Duplikate bleiben standardmäßig als Duplikate, da Ränder keine eindeutigen Bezeichner aufweisen. Wenn mehrere Schritte identische Quellzielbeziehungen erstellen, wird jeder eine separate Kante im Diagramm. Dieses Verhalten ist beabsichtigt, da mehrere Beziehungen zwischen denselben Knoten unterschiedliche Interaktionen oder Ereignisse im Laufe der Zeit darstellen können.

• Knoten: "Duplikate" werden automatisch basierend auf dem NodeIdColumn-Wert zusammengeführt – das System geht davon aus, dass sie dieselbe Entität darstellen. Wenn mehrere Schritte Knoten mit demselben Bezeichner erstellen:

  • Alle Eigenschaften aus verschiedenen Schritten werden in einem einzelnen Knoten kombiniert.
  • Wenn konfliktende Eigenschaftswerte für denselben Eigenschaftsnamen vorhanden sind, hat der Wert aus dem Schritt, der zuletzt ausgeführt wurde, Vorrang.
  • Eigenschaften, die in einem Schritt vorhanden sind, aber keine andere beibehalten werden

Mit diesem Zusammenführungsverhalten können Sie Knoten inkrementell über Schritte hinweg erstellen, z. B. grundlegende Informationen in einem Schritt hinzufügen und in nachfolgenden Schritten mit zusätzlichen Eigenschaften bereichern.

Wie behandeln Diagrammmodelle Schemaänderungen?

Wenn sich das Schema Ihrer zugrunde liegenden Daten ändert:

1. Ändern des Diagrammmodells mithilfe des .create-or-alter graph_model Befehls zum Aktualisieren des Schemas oder der Definition
2. Um diese Änderungen zu materialisieren, erstellen Sie eine neue Momentaufnahme
3. Ältere Momentaufnahmen bleiben bis zum expliziten Löschen zugänglich.

Kann ich mehrere Diagrammmodelle abfragen?

Ja, Sie können mehrere Diagrammmodelle in einer einzelnen Abfrage mithilfe der Komposition abfragen:

• Verwenden der Ausgabe eines graph() Operators als Eingabe für einen anderen graph() Operator
• Verarbeiten und Transformieren von Ergebnissen aus einem Diagramm vor dem Einfüttern in eine andere Diagrammabfrage
• Verketten mehrerer Diagrammvorgänge für domänenübergreifende Analysen ohne Erstellen eines einheitlichen Modells

Beispiel:

// Query the first graph model
graph("EmployeeNetwork") 
| graph-match (person)-[manages]->(team)
    where labels(manages) has "MANAGES" and labels(person) has "Employee"
    project manager=person.name, teamId=team.id
// Use these results to query another graph model
| join (
	graph("ProjectNetwork")
	| graph-match (project)-[assignedTo]->(team)
        where labels(assignedTo) has "ASSIGNED_TO"
	    project projectName=project.name, teamId=team.id
) on teamId

Was ist der Unterschied zwischen Bezeichnungen und Eigenschaften?

• Beschriftungen: Kategorisieren von Knoten und Kanten für den Strukturmusterabgleich
• Eigenschaften: Speichern von Datenwerten, die Knoten und Kanten zugeordnet sind (in Filterung und Ausgabe verwendet)

Verwandte Inhalte

• .create-or-alter graph_model
• DROP-graph_model
• .show graph_models
• Wichtige Überlegungen
• Graph-Operatoren
• Bewährte Methoden für Graph