Schreiben allgemeiner GQL-Abfragen in Microsoft Fabric

Dieser Artikel enthält praktische GQL-Abfragemuster für allgemeine Diagrammaufgaben in Microsoft Fabric: Suchen von Nachbarn, Durchlaufen von Multihopverbindungen, Identifizieren freigegebener Verbindungen, Zählen von Beziehungen und Suchen von Entitäten ohne Verbindungen.

In den Beispielen wird das Beispiel-Dataset für soziale Netzwerke verwendet. Für eine vollständige Erklärung des Abfrageflusses und der Anweisungen siehe GQL-Sprachleitfaden. Verwenden Sie diesen Artikel, wenn Sie wissen, welche Graphenaufgabe Sie erfüllen möchten. Für systematische Anweisungen zum Aufbau von Knoten-, Kanten- und Pfadmustern siehe Schreib Graphenmuster-Abfragen. Für detaillierte Filter- und Aggregations-Workflows siehe Filter- und aggregierende Graphdaten.

Voraussetzungen

Direkte Nachbarn finden

Gibt alle Knoten zurück, die durch einen Hop mit einem Startknoten verbunden sind.

Suchen Sie alle Personen, die eine bestimmte Person kennt:

MATCH (p:Person WHERE p.firstName = 'Alice')-[:knows]->(friend:Person)
RETURN friend.firstName, friend.lastName

Suchen Sie alle Unternehmen, an der eine Person gearbeitet hat:

MATCH (p:Person WHERE p.firstName = 'Alice')-[:workAt]->(c:Company)
RETURN c.name, c.url

Freunde von Freunden suchen (Multi-Hop)

Verwenden Sie {min,max} mit Mustern variabler Länge, um mehrere Sprünge zu durchlaufen.

Finden Sie Personen, die von Alice aus über genau zwei knows Kanten erreichbar sind:

MATCH (alice:Person WHERE alice.firstName = 'Alice')-[:knows]->{2,2}(fof:Person)
RETURN DISTINCT fof.firstName, fof.lastName
LIMIT 100

Finden Sie alle innerhalb von drei Grad erreichbaren Personen:

MATCH (src:Person WHERE src.firstName = 'Alice')-[:knows]->{1,3}(dst:Person)
RETURN DISTINCT dst.firstName, dst.lastName
LIMIT 100

Finde einen kürzesten Weg von Alice zu jeder Person, der innerhalb von vier Sprüngen erreichbar ist:

MATCH p = ANY SHORTEST
  (src:Person WHERE src.firstName = 'Alice')-[:knows]->{1,4}(dst:Person)
RETURN dst.firstName, dst.lastName, path_length(p) AS hopCount
ORDER BY hopCount, dst.lastName
LIMIT 100

Wenn mehrere kürzeste Wege dieselbe Person in gleicher Anzahl von Sprüngen erreichen, ANY SHORTEST gibt einer davon ohne deterministische Tie-Wahl zurück.

Inline-Prädikate schränken ein, welche Pfade für ANY SHORTEST infrage kommen. Postfilter werden angewendet, nachdem ein kürzester Pfad ausgewählt wurde. Beispiele finden sich unter Platzprädikate vor oder nach der Pfadauswahl.

Tip

Verwenden Sie eine endliche obere Schranke für vorhersehbare Abfragekosten. Unbegrenzte ALL WALK Durchquerung wird nicht unterstützt. Andere unbeschränkte Pfadmodi können dennoch große Ergebnisse liefern. Weitere Informationen finden Sie unter "Aktuelle Einschränkungen".

Zählen von Beziehungen pro Entität

Verwenden Sie GROUP BY zusammen mit count(*), um zu zählen, wie viele Beziehungen jede Entität hat. Für detaillierte Gruppierung, aggregierte Filterung und bedingte Routing-Muster siehe Filter- und aggregierte Graphendaten.

Zählen Sie, wie viele Freunde jede Person hat, sortiert von den meisten bis zu wenigen:

MATCH (p:Person)-[:knows]->(friend:Person)
LET personId = p.id, name = p.firstName || ' ' || p.lastName
RETURN personId, name, count(*) AS friendCount
GROUP BY personId, name
ORDER BY friendCount DESC
LIMIT 20

Berechnen Sie für jede Entität einen Wert

Verwenden Sie eine korrelierte CALL Unterabfrage, um für jede Eingabezeile einen Wert zu berechnen. Variablen aus der äußeren Abfrage sind implizit innerhalb der Unteranfrage verfügbar.

Berechnen Sie die Anzahl der Freunde pro Person:

MATCH (p:Person)
CALL {
  MATCH (p)-[:knows]->(friend:Person)
  RETURN count(*) AS friendCount
}
RETURN p.firstName, p.lastName, friendCount
ORDER BY friendCount DESC

Äußere Variablen bleiben nach CALL verfügbar. Von den innerhalb der Unterabfrage erstellten Variablen sind außerhalb nur zurückgegebene Spalten verfügbar. Ein ungruppiertes count(*) gibt 0 zurück, wenn keine passenden Freunde vorhanden sind, sodass diese Abfrage auch Personen ohne Freunde beibehält.

Ordinary entfernt eine äußere Zeile CALL , wenn die Unterabfrage keine Zeilen zurückgibt, und erzeugt für jede Unterabfrage eine Ausgabezeile, wenn sie mehrere Zeilen zurückgibt. Verwenden Sie OPTIONAL CALL, wenn Sie eine Zeile der äußeren Abfrage beibehalten möchten, für die es keine passende Zeile in der Unterabfrage gibt.

Suchen nach gemeinsamen Verbindungen

Durch die Wiederverwendung einer Variablen in zwei Teilen eines Musters wird eine implizite Einschränkung "gleicher Knoten" erstellt. Verwenden Sie diese Bedingung, um Entitäten zu finden, die über eine gemeinsame dritte Entität verbunden sind.

Suchen Sie Paare von Personen, die beide die gleiche Person kennen:

MATCH (a:Person)-[:knows]->(mutual:Person)<-[:knows]-(b:Person)
WHERE a.id < b.id
RETURN a.firstName, b.firstName, mutual.firstName AS sharedContact
LIMIT 100

Suchen Sie Paare von Personen, die im selben Unternehmen arbeiten:

MATCH (c:Company)<-[:workAt]-(a:Person), (c)<-[:workAt]-(b:Person)
WHERE a.id < b.id
RETURN a.firstName, b.firstName, c.name AS company
LIMIT 100

Tip

Die WHERE a.id < b.id Bedingung verhindert, dass doppelte Paare (Alice-Bob und Bob-Alice) in Ergebnissen angezeigt werden.

Suchen nach Entitäten ohne Beziehungen

Verwenden Sie NOT EXISTS , um Knoten zu finden, für die eine korrelierte Unterabfrage keine Zeilen zurückgibt.

Suchen Sie Personen, die nicht in einem Unternehmen arbeiten:

MATCH (p:Person)
WHERE NOT EXISTS {
  MATCH (p)-[:workAt]->(c:Company)
  RETURN c
}
RETURN p.firstName, p.lastName
LIMIT 100

Beiträge ohne Kommentare suchen:

MATCH (post:Post)
WHERE NOT EXISTS {
  MATCH (comment:Comment)-[:replyOf]->(post)
  RETURN comment
}
RETURN post.id, post.content
LIMIT 100

Suchen nach Entitäten mit vielen Verbindungen

Kombinieren Sie GROUP BY und FILTER, um hoch verbundene Knoten zu identifizieren. Diese Methode ist nützlich, um Hubs oder Ausreißer zu finden.

Personen mit mehr als 10 Freunden finden:

MATCH (p:Person)-[:knows]->(friend:Person)
LET personId = p.id, name = p.firstName || ' ' || p.lastName
RETURN personId, name, count(*) AS friendCount
GROUP BY personId, name
FILTER friendCount > 10
ORDER BY friendCount DESC

Note

FILTER nach GROUP BY funktioniert wie HAVING in SQL. Sie filtert nach dem aggregierten Ergebnis, nicht nach den einzelnen Zeilen.

Verwandte Inhalte

  • Last updated on