Grundlagen der Graph-Erkundung

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

Diese Seite bietet wiederverwendbare Kusto Query Language (KQL)-Muster zum schnellen Untersuchen von Graph-Datasets und beantworten häufig gestellte Fragen zu Struktur, Knoten, Kanten und Eigenschaften.

Allgemeine Analyseabfragen

Diese wiederverwendbaren Abfragemuster funktionieren in allen Diagrammmodellen und helfen Ihnen, die Struktur und Merkmale eines beliebigen Graph-Datasets zu verstehen. Im folgenden Beispiel werden Beispieldiagramme verwendet, die in unserem Hilfecluster in der Beispieldatenbank zur Verfügung stehen. Ausführliche Informationen zu diesen Diagrammen finden Sie unter Graph-Beispiel-Datasets und -Beispiele. Verwenden Sie diese Abfragen, um neue Diagramme zu untersuchen, grundlegende Analysen durchzuführen oder als Ausgangspunkte für komplexere Graph-Untersuchungen.

Graph-Übersicht und -Statistiken

Das Verständnis der grundlegenden Merkmale Ihres Diagramms ist für die Analyseplanung und Leistungsoptimierung unerlässlich. Diese Abfragen stellen grundlegende Metriken zur Diagrammgröße und -struktur bereit.

Anzahl der Gesamtknoten und Kanten:

Verwenden Sie diese Abfragen, um den Umfang Ihres Graph-Datasets zu verstehen. Knoten- und Edgeanzahl helfen dabei, geeignete Abfragestrategien zu ermitteln und potenzielle Leistungsüberlegungen zu identifizieren. In diesen Beispielen wird das Simple Diagramm verwendet, das ideal zum Erlernen grundlegender Diagrammvorgänge ist.

// Get node count
graph('Simple')
| graph-match (node)
    project node
| count

// Get edge count
graph('Simple')
| graph-match (source)-[edge]->(target)
    project edge
| count

Abrufen von Diagrammzusammenfassungsstatistiken:

Diese kombinierte Abfrage stellt beide Metriken in einem einzigen Ergebnis effizient bereit, nützlich für die anfängliche Diagrammbewertung und -berichterstellung. In diesem Beispiel wird die Technik mithilfe des DiagrammsSimple veranschaulicht.

let nodes = view() { graph('Simple') | graph-match (node) project node | count }; 
let edges = view() { graph('Simple') | graph-match (source)-[edge]->(target) project edge | count };
union withsource=['Graph element'] nodes, edges

Alternative Verwendung von Graph-zu-Tabelle:

Für die einfache Zählung kann der graph-to-table Operator effizienter sein, da er Diagrammelemente ohne Musterüberlastung direkt exportiert. In diesem Beispiel wird der alternative Ansatz mithilfe desselben Simple Diagramms veranschaulicht.

let nodes = view() { graph('Simple') | graph-to-table nodes | count };
let edges = view() { graph('Simple') | graph-to-table edges | count };
union nodes, edges

Knotenanalyse

Die Knotenanalyse hilft Ihnen, die Entitäten in Ihrem Diagramm, deren Typen und Verteilung zu verstehen. Diese Muster sind für die Datenqualitätsbewertung und das Schemaverständnis von wesentlicher Bedeutung.

Entdecken Sie alle Knotentypen (Bezeichnungen):

Diese Abfrage zeigt die verschiedenen Entitätstypen in Ihrem Diagramm und deren Frequenzen an. Verwenden Sie es, um Ihr Datenmodell zu verstehen, die am häufigsten verwendeten Entitätstypen zu identifizieren und potenzielle Probleme mit der Datenqualität zu erkennen. In diesem Beispiel wird das Simple Diagramm verwendet, das Person-, Company- und City-Entitäten enthält.

graph('Simple')
| graph-match (node) 
    project labels = labels(node)
| mv-expand label = labels to typeof(string)
| summarize count() by label
| order by count_ desc

Suchen von Knoten mit mehreren Bezeichnungen:

Identifiziert Knoten, die gleichzeitig zu mehreren Kategorien gehören. Dies ist nützlich, um überlappende Klassifizierungen und komplexe Entitätsbeziehungen in Ihrem Datenmodell zu verstehen. In diesem Beispiel wird das BloodHound_Entra Diagramm verwendet, das Microsoft Entra-Objekte mit mehreren Bezeichnungsklassifizierungen enthält.

graph('BloodHound_Entra')
| graph-match (node) 
    project node_id = node.id, labels = labels(node), label_count = array_length(labels(node))
| where label_count > 1
| take 3

Beispielknoten nach Typ:

Ruft repräsentative Beispiele bestimmter Knotentypen ab, um deren Struktur und Eigenschaften zu verstehen. Wichtig für die Datensuche und Abfrageentwicklung. In diesem Beispiel wird das BloodHound_Entra Diagramm verwendet, um AZUser-Knoteneigenschaften in Microsoft Entra-Umgebungen zu untersuchen.

graph('BloodHound_Entra')
| graph-match (node) 
    where labels(node) has "AZUser"
    project node_id = node.id, properties = node.properties
| sample 2

Edgeanalyse

Das Verständnis von Beziehungen in Ihrem Diagramm ist entscheidend für die Identifizierung von Mustern, Datenqualitätsproblemen und potenzielle Analyserichtungen.

Entdecken Sie alle Edgetypen (funktioniert mit verschiedenen Diagrammschemas):

Diese Abfrage identifiziert alle Beziehungstypen in Ihrem Diagramm und hilft Ihnen dabei, die für die Analyse verfügbaren Verbindungen zu verstehen. Verschiedene Diagramme verwenden unterschiedliche Eigenschaftsnamen für Edgetypen, sodass mehrere Variationen bereitgestellt werden. In diesem Beispiel wird das BloodHound_Entra Diagramm verwendet, um Berechtigungsbeziehungen in Microsoft Entra-Umgebungen anzuzeigen.

graph('BloodHound_Entra')
| graph-match (source)-[edge]->(target)
    project edge_labels = labels(edge)
| mv-expand label = edge_labels to typeof(string)
| summarize count() by label
| top 5 by count_ desc

Suchen der meisten verbundenen Knoten (höchster Grad):

Die Knotengradanalyse zeigt die einflussreichsten oder zentralen Entitäten in Ihrem Diagramm an. Knoten mit hohem Grad stellen häufig wichtige Akteure, Engpässe oder wichtige Infrastrukturkomponenten dar. In diesem Beispiel wird das LDBC_SNB_Interactive Diagramm verwendet, ein Dataset für soziale Netzwerke ideal zum Analysieren von Verbindungsmustern und Einfluss.

// Find nodes with highest total degree (in + out)
graph('LDBC_SNB_Interactive')
| graph-match (node)
    project node_id = node.id, 
            in_degree = node_degree_in(node),
            out_degree = node_degree_out(node),
            total_degree = node_degree_in(node) + node_degree_out(node)
| order by total_degree desc
| take 5

Suchen von Knoten mit dem höchsten Grad (die meisten eingehenden Verbindungen):

Hohe In-Grad-Knoten sind häufig Ziele von Einfluss, beliebten Zielen oder zentralen Ressourcen. In sozialen Netzwerken könnten diese einflussreiche Menschen sein; in Infrastrukturdiagrammen könnten diese kritische Dienste sein. In diesem Beispiel wird das LDBC_Financial Diagramm verwendet, um Konten zu identifizieren, die die meisten Transaktionen erhalten.

graph('LDBC_Financial')
| graph-match (node)
    project node_id = node.node_id, 
            node_labels = labels(node),
            in_degree = node_degree_in(node)
| order by in_degree desc
| take 3

Suchen von Knoten mit dem höchsten Grad (die meisten ausgehenden Verbindungen):

Knoten mit hohem Grad sind häufig Quellen von Einfluss, Distributoren oder Verbinderhubs. Diese Entitäten initiieren in der Regel viele Beziehungen oder verteilen Ressourcen an andere. In diesem Beispiel wird das LDBC_Financial Diagramm verwendet, um Konten zu identifizieren, die die meisten Transaktionen tätigen.

graph('LDBC_Financial')
| graph-match (node)
    project node_id = node.node_id, 
            node_labels = labels(node),
            out_degree = node_degree_out(node)
| order by out_degree desc
| take 3

Beziehungsmusteranalyse

Diese Abfragen helfen bei der Identifizierung struktureller Muster und komplexer Beziehungen, die auf wichtige Verhaltensweisen oder Anomalien in Ihren Daten hinweisen können.

Entdecken Sie dreieckige Beziehungen (Knoten, die in einem Dreieck verbunden sind):

Dreieckige Muster deuten häufig auf enge Zusammenarbeit, gegenseitige Abhängigkeiten oder geschlossene Prozesse hin. In sozialen Netzwerken vertreten diese Gruppen von Freunden; in Geschäftsprozessen können sie Genehmigungsketten oder Redundanzmuster angeben. In diesem Beispiel wird das BloodHound_AD Diagramm verwendet, um Zirkelberechtigungsbeziehungen in Active Directory-Umgebungen zu identifizieren.

graph('BloodHound_AD')
| graph-match (a)-->(b)-->(c)-->(a)
    where a.id != b.id and b.id != c.id and c.id != a.id
    project node1 = a.name, node2 = b.name, node3 = c.name
| take 3

Eigenschaftenanalyse

Wenn Sie die auf Ihren Knoten verfügbaren Eigenschaften verstehen, können Sie komplexere Abfragen erstellen und Probleme mit der Datenqualität identifizieren.

Erkunden von Knoteneigenschaften:

Diese Abfrage zeigt an, welche Informationen mit Ihren Knoten gespeichert werden, sodass Sie die verfügbaren Attribute zum Filtern und Analysieren verstehen können. In diesem Beispiel wird das BloodHound_Entra Diagramm verwendet, um das Schema von AZUser-Knoten zu untersuchen und zu verstehen, welche Eigenschaften für Microsoft Entra-Benutzerobjekte verfügbar sind.

graph('BloodHound_Entra')
| graph-match (node)
    where labels(node) has "AZUser"  // Replace with actual label
    project properties = node.properties
| mv-apply properties on (
        mv-expand kind=array properties
        | where isnotempty(properties[1])
        | extend bag =bag_pack(tostring(properties[0]), properties[1])
        | summarize properties = make_bag(bag)
    )
| summarize buildschema(properties)

Suchen Sie alle Eigenschaften aller Knoten nach Beschriftung:

Diese erweiterte Schemaermittlungsabfrage identifiziert alle Eigenschaftsnamen, die über Knoten jedes Bezeichnungstyps vorhanden sind. Im Gegensatz zur vorherigen Abfrage, die die Schemastruktur anzeigt, aggregiert diese Abfrage Eigenschaftsnamen über alle Knoten desselben Typs, sodass Sie verstehen können, welche Eigenschaften konsistent verfügbar sind und welche optional oder selten sein können. In diesem Beispiel wird das LDBC_SNB_Interactive Diagramm verwendet, um die vollständige Eigenschaftslandschaft verschiedener Entitätstypen im Dataset für soziale Netzwerke zu untersuchen.

graph('LDBC_SNB_Interactive')
| graph-match (node)
    project properties = node, labels = labels(node)
| mv-apply properties on (
        mv-expand kind=array properties
        | where isnotempty(properties[1])
        | summarize properties = make_set(properties[0])
    )
| mv-expand label = labels to typeof(string)
| summarize properties =make_set(properties) by label
| take 3

Suchen Sie alle Eigenschaften aller Kanten nach Beschriftung:

Diese Abfrage führt die Schemaermittlung für Edgeeigenschaften (Beziehung) aus, die zeigt, welche Informationen mit jedem Beziehungstyp in Ihrem Diagramm gespeichert werden. Das Verständnis von Edgeeigenschaften ist entscheidend für die Analyse von Beziehungsmetadaten wie Zeitstempeln, Gewichtungen, Konfidenzbewertungen oder anderen Attributen, die Kontext zu Verbindungen bereitstellen. In diesem Beispiel wird das BloodHound_AD Diagramm verwendet, um die Eigenschaften zu untersuchen, die für verschiedene Typen von Active Directory-Berechtigungsbeziehungen verfügbar sind.

graph('BloodHound_AD')
| graph-match ()-[e]-()
    project properties = e, labels = labels(e)
| mv-apply properties on (
        mv-expand kind=array properties
        | where isnotempty(properties[1])
        | summarize properties = make_set(properties[0])
    )
| mv-expand label = labels to typeof(string)
| summarize properties =make_set(properties) by label
| take 3

Suchen von Knoten mit bestimmten Eigenschaftswerten:

Verwenden Sie dieses Muster, um Entitäten mit bestimmten Merkmalen zu suchen oder die Datenqualität zu überprüfen, indem Sie auf erwartete Eigenschaftswerte überprüfen. In diesem Beispiel wird das BloodHound_Entra Diagramm verwendet, um Knoten mit bestimmten Namenseigenschaften in Microsoft Entra-Umgebungen zu finden.

graph('BloodHound_Entra')
| graph-match (node)
    where isnotempty(node.properties.name)
    project node_id = node.id, property_value = node.properties.name
| take 3

Topologie des Diagramms

Wenn Sie die allgemeine Topologie Ihres Diagramms verstehen, werden die Typen von Verbindungen angezeigt, die zwischen verschiedenen Entitätstypen vorhanden sind. Diese Analyse hilft Ihnen, das Datenmodell zu verstehen, die am häufigsten verwendeten Beziehungsmuster zu identifizieren und potenzielle Pfade für Traversalabfragen zu ermitteln. Die Topologieabfrage zeigt an, welche Knotenbeschriftungen eine Verbindung mit den anderen Knotenbeschriftungen über bestimmte Edgetypen herstellen, wodurch eine umfassende Übersicht über die Struktur Ihres Diagramms bereitgestellt wird.

//Topology of the graph - What's connected to what?
graph('LDBC_Financial')
| graph-match (src)-[e]->(dst)
    project SourceLabels = labels(src), EdgeLabels = labels(e), DestinationLabels = labels(dst)
| mv-expand EdgeLabel = EdgeLabels to typeof(string)
| mv-expand SourceLabel = SourceLabels to typeof(string)
| mv-expand DestinationLabel = DestinationLabels to typeof(string)
| summarize Count = count() by SourceLabel, EdgeLabel, DestinationLabel

Verwandte Inhalte

• Übersicht über die Graph-Semantik
• Häufige Szenarien für die Verwendung der Graphsemantik
• Graph-Beispiel-Datasets und Beispiele
• Graph-Funktion
• Make-Graph-Operator