GQL-Sprachhandbuch

Hinweis

Dieses Feature ist zurzeit als öffentliche Preview verfügbar. Diese Vorschauversion wird ohne Vereinbarung zum Servicelevel bereitgestellt und ist nicht für Produktionsworkloads vorgesehen. Manche Features werden möglicherweise nicht unterstützt oder sind nur eingeschränkt verwendbar. Weitere Informationen finden Sie unter Zusätzliche Nutzungsbestimmungen für Microsoft Azure-Vorschauen.

Die GQL Graph-Abfragesprache ist die ISO-standardisierte Abfragesprache für Graphdatenbanken. Es hilft Ihnen, Diagrammdaten effizient zu abfragen und zu arbeiten.

GQL wird von derselben ISO-Arbeitsgruppe entwickelt, die SQL standardisiert und so Konsistenz und Strenge gewährleistet. Wenn du mit SQL vertraut bist, findest du viele Ähnlichkeiten in GQL (Ausdrücke, Prädikate, Typen) – was den Einstieg erleichtert. Dieser Leitfaden dient sowohl Neuankömmlingen beim Lernen von GQL-Grundlagen als auch erfahrenen Benutzern, die fortgeschrittene Techniken und umfassende Referenzinformationen suchen.

Hinweis

Der offizielle internationale Standard für GQL ist ISO/IEC 39075 Information Technology - Database Languages - GQL.

Voraussetzungen

Bevor Sie sich mit GQL vertraut machen, sollten Sie mit diesen Konzepten vertraut sein:

• Grundlegendes Verständnis von Datenbanken – Erfahrung mit Datenbanksystemen (wie relationalem (SQL), NoSQL oder Graph) ist hilfreich
• Diagrammkonzepte – Grundlegendes zu Knoten, Kanten und Beziehungen in verbundenen Daten
• Grundlagen von Abfragen – Kenntnisse grundlegender Abfragekonzepte wie Filtern, Sortieren und Aggregation

Empfohlener Hintergrund:

• Erfahrungen mit SQL- oder OpenCypher-Sprachen erleichtern das Erlernen der GQL-Syntax (sie sind die Wurzeln von GQL).
• Vertrautheit mit der Datenmodellierung hilft beim Diagrammschemaentwurf
• Grundlegendes zu Ihrem spezifischen Anwendungsfall für Diagrammdaten

Was Sie benötigen:

• Zugriff auf Microsoft Fabric mit Graph-Funktionen
• Beispieldaten oder Bereitschaft, mit unseren Beispielen für soziale Netzwerke zu arbeiten
• Einfacher Text-Editor zum Schreiben von Abfragen

Tipp

Wenn Sie noch nicht mit Diagrammdatenbanken vertraut sind, beginnen Sie mit der Übersicht über Diagrammdatenmodelle , bevor Sie mit diesem Leitfaden fortfahren.

Was macht GQL besonders

GQL wurde speziell für Diagrammdaten entwickelt. Dies macht es natürlich und intuitiv, mit verbundenen Informationen zu arbeiten.

Im Gegensatz zu SQL, das auf Tabellen-Joins zur Darstellung von Beziehungen setzt, verwendet GQL visuelle Graphenmuster, die direkt widerspiegeln, wie Entitäten verbunden sind, was Abfragen leichter lesbar und logisch macht.

Angenommen, du möchtest Menschen und ihre Freunde (Menschen, die sich kennen) finden, die beide vor 1999 geboren wurden. So drückt GQL das mit einem visuellen Graphenmuster aus:

MATCH (person:Person)-[:knows]-(friend:Person)
WHERE person.birthday < 19990101 
  AND friend.birthday < 19990101
RETURN person.firstName || ' ' || person.lastName AS person_name, 
       friend.firstName || ' ' || friend.lastName AS friend_name

Diese Abfrage findet Freunde (Personen, die einander kennen), die beide vor 1999 geboren wurden. Das Muster (person:Person)-[:knows]-(friend:Person) zeigt visuell die gewünschte Beziehungsstruktur – ähnlich wie das Zeichnen eines Diagramms Ihrer Daten.

GQL-Grundlagen

Bevor Sie sich mit Abfragen vertraut machen, verstehen Sie diese Kernkonzepte, die die Grundlage von GQL bilden:

• Graphen speichern deine Daten als Knoten (Entitäten) und Kanten (Beziehungen), jeweils mit Labels und Eigenschaften
• Graph-Typen funktionieren wie Schemas, definieren, welche Knoten und Kanten in Ihrem Diagramm vorhanden sein können
• Einschränkungen sind zusätzliche Regeln und Einschränkungen, die von Graphtypen auf Graphen auferlegt werden, um die Datenintegrität zu gewährleisten
• Abfragen verwenden Anweisungen wie MATCH, FILTERund RETURN zum Verarbeiten von Daten und Zum Anzeigen von Ergebnissen
• Muster beschreiben die Diagrammstrukturen, die Sie mithilfe intuitiver visueller Syntax finden möchten
• Ausdrücke führen Berechnungen und Vergleiche für Ihre Daten aus, ähnlich wie SQL-Ausdrücke
• Prädikate sind boolesche Wertausdrücke, die verwendet werden, um Ergebnisse innerhalb von Abfragen zu filtern
• Werttypen definieren, welche Arten von Werten Sie verarbeiten und speichern können.

Grundlegendes zu Diagrammdaten

Um effektiv mit GQL zu arbeiten, müssen Sie verstehen, wie Diagrammdaten strukturiert sind. Diese Grundlage hilft Ihnen, bessere Abfragen zu schreiben und Ihre Daten effektiv zu modellieren.

Knoten und Kanten: die Bausteine

In GQL arbeiten Sie mit beschrifteten Eigenschaftendiagrammen. Ein Diagramm besteht aus zwei Arten von Elementen:

Knoten stellen in der Regel die Entitäten (die "Nomen") in Ihrem System dar – z. B. Personen, Organisationen, Beiträge oder Produkte. Sie sind unabhängige Objekte, die in Ihrer Domäne vorhanden sind. Knoten werden manchmal auch als Scheitelpunkte bezeichnet.

Edges stellen Beziehungen zwischen Entitäten (die "Verben") dar – wie Ihre Entitäten eine Verbindung herstellen und interagieren. Zum Beispiel kennen sich Menschen (:knows), Organisationen, die in bestimmten Regionen tätig sind (:operates), oder Kunden, die Produkte gekauft haben (:purchased).
Ränder werden manchmal auch als Beziehungen bezeichnet.

Jedes Diagrammelement weist die folgenden Merkmale auf:

• Eine interne ID , die sie eindeutig identifiziert
• Eine oder mehrere Bezeichnungen – beschreibende Namen wie Person oder knows. In Microsoft Fabric haben Graph-Kanten immer genau ein Label.
• Eigenschaften – Name-Wert-Paare, die Daten über das Element speichern (wie firstName: "Alice" oder birthday: "19730108").

Struktur von Diagrammen

Jeder Rand verbindet genau zwei Knoten: eine Quelle und ein Ziel. Diese Verbindung erstellt die Struktur des Diagramms und zeigt, wie Entitäten miteinander in Beziehung stehen. Die Richtung der Kanten ist wichtig – ein Personfollows anderer Person erstellt eine gerichtete Beziehung.

Hinweis

Graph in Microsoft Fabric unterstützt derzeit keine ungerichteten Kanten.

Eigenschaftsgraphen, wie sie in Microsoft Fabric unterstützt werden, sind immer gut geformt, das heißt, jede Kante verbindet zwei gültige Knoten. Wenn ein Rand in einem Diagramm angezeigt wird, sind beide Endpunkte im selben Diagramm vorhanden.

Diagrammmodelle und Diagrammtypen

Die Struktur eines Diagramms in Microsoft Fabric wird durch sein Diagrammmodell beschrieben, das wie ein Datenbankschema für Ihre Anwendungsdomäne fungiert. Diagrammmodelle definieren:

• Welche Knoten und Kanten vorhanden sein können
• Welche Bezeichnungen und Eigenschaften sie haben können
• So können Knoten und Kanten eine Verbindung herstellen

Graph-Modelle stellen auch die Datenintegrität durch Einschränkungen sicher, insbesondere Knotenschlüsseleinschränkungen , die angeben, welche Eigenschaften die einzelnen Knoten eindeutig identifizieren.

Hinweis

Diagrammmodelle können mithilfe der GQL-Standardsyntax angegeben werden, in diesem Fall werden sie als Graphtypen bezeichnet.

Ein praktisches Beispiel: soziales Netzwerk

In dieser Dokumentation verwenden wir ein Beispiel für soziale Netzwerke, um GQL-Konzepte zu veranschaulichen. Wenn Sie diese Domäne verstehen, können Sie die Beispiele befolgen und ähnliche Muster auf Ihre eigenen Daten anwenden.

Hinweis

Das soziale Netzwerk ist beispiel für den LDBC SNB (LDBC Social Network Benchmark) abgeleitet, der vom GDC (Graph Data Council) veröffentlicht wurde. Weitere Details finden Sie im Artikel "The LDBC Social Network Benchmark" .

Die Entitäten des sozialen Netzwerks

Unser soziales Netzwerk umfasst die folgenden Hauptarten von Knoten, die Entitäten der Domäne darstellen:

Personen haben persönliche Informationen wie Namen, Geburtstage und Geschlechter. Sie leben in Städten und bilden soziale Verbindungen.

Orte bilden eine geografische Hierarchie:

• Städte wie "New York" oder "London"
• Länder/Regionen wie "Vereinigte Staaten" oder "Vereinigtes Königreich"
• Kontinente wie "Nordamerika" oder "Europa"

Organisationen , in denen Personen Zeit verbringen:

• Universitäten , an denen Menschen studieren
• Unternehmen , in denen Menschen arbeiten

Inhalt und Diskussionen:

• Foren mit Titeln, die Beiträge enthalten
• Beiträge mit Inhalten, Sprachen und optionalen Bildern
• Kommentare , die auf Beiträge oder andere Kommentare antworten
• Kategorien , die Inhalte kategorisieren und Interessen vertreten

Wie alles verbindet

Die Verbindungen zwischen Entitäten machen das Netzwerk interessant:

• Menschen kennen sich (Freundschaften, :knows)
• Menschen arbeiten in Unternehmen (:workAt) oder studieren an Universitäten (:studyAt)
• Leute erstellen Beiträge und Kommentare (:hasCreator)
• Menschen likken Beiträge und Kommentare (:likes)
• Beiträge, Foren, Kommentare können Tags haben (:hasTag)
• Menschen haben Interessen an bestimmten Tags (:hasInterest)
• Foren enthalten Beiträge (:containerOf) und haben Mitglieder (:hasMember) und Moderatoren (:hasModerator)

Graph-Kanten stellen Domänenbeziehungen dar. Dieses umfangreiche Netzwerk schafft viele Möglichkeiten für interessante Abfragen und Analysen.

Vollständige Schemaspezifikation anzeigen

Ihre ersten GQL-Abfragen

Nachdem Sie nun die Grundlagen von Diagrammen verstanden haben, sehen wir uns an, wie Sie Diagrammdaten mit GQL abfragen. Diese Beispiele erstellen von einfach bis komplex und zeigen Ihnen, wie der Ansatz von GQL Graph-Abfragen intuitiv und leistungsfähig macht.

Einfaches Start: Suchen aller Personen

Beginnen wir mit der einfachsten Abfrage, die möglich ist: Finden Sie die Namen (Vorname, Nachname) aller Personen im:Person Graphen.

MATCH (p:Person)
RETURN p.firstName, p.lastName

Diese Abfrage wird wie folgt ausgeführt:

1. MATCH findet alle Knoten, die mit Bezeichnung versehen sind. Person
2. RETURN zeigt ihre Vor- und Nachnamen an.

Filter hinzufügen: Bestimmte Personen suchen

Jetzt finden wir Personen mit bestimmten Merkmalen, in diesem Fall alle mit dem Namen Alice, und zeigen ihre Namen und Geburtstage.

MATCH (p:Person)
FILTER p.firstName = 'Annemarie'
RETURN p.firstName, p.lastName, p.birthday

Diese Abfrage wird wie folgt ausgeführt:

1. MATCH findet alle Knoten (p) mit Person beschriftet
2. FILTER Knoten (p), deren Vorname Alice ist
3. RETURN zeigt Vor- und Nachnamen und Geburtstag

Grundlegende Abfragestruktur

Grundlegende GQL-Abfragen folgen einem konsistenten Muster: eine Abfolge von Anweisungen, die zusammen arbeiten, um Daten zu suchen, zu filtern und zurückzugeben. Die meisten Abfragen beginnen damit MATCH , Muster im Graphen zu finden, und enden damit RETURN , um das Ergebnis zu spezifizieren.

Hier ist eine einfache Abfrage, die Paare von Menschen findet, die sich kennen und denselben Geburtstag haben, und dann die Gesamtzahl dieser Freundespaare zurückgibt.

MATCH (n:Person)-[:knows]-(m:Person)
FILTER n.birthday = m.birthday
RETURN count(*) AS same_age_friends

Diese Abfrage wird wie folgt ausgeführt:

1. MATCH findet alle Knotenpaare Person , die einander kennen
2. FILTER hält nur die Paare, bei denen beide Personen denselben Geburtstag haben
3. RETURN zählt, wie viele solche Freundpaare vorhanden sind.

Tipp

Das Filtern kann auch direkt als Teil eines Musters ausgeführt werden, indem eine WHERE Klausel angefügt wird. Entspricht beispielsweise nur MATCH (n:Person WHERE n.age > 23) Knoten, Person deren age Eigenschaft größer als 23 ist.

Hinweis

GQL unterstützt Linienkommentare im C-Stil // , ZEILENkommentare im SQL-Stil -- und Blockkommentare im C-Stil /* */ .

Häufige Aussagen

• MATCH: Identifiziert das zu suchende Graphenmuster – hier definieren Sie die Struktur der Daten, die Sie interessieren.
• LET: Zuweist neue Variablen oder berechnete Werte basierend auf abgestimmten Daten zu – fügt abgeleitete Spalten zum Ergebnis hinzu.
• FILTER: Begrenzt die Ergebnisse durch Anwendung von Bedingungen – entfernt Zeilen, die die Kriterien nicht erfüllen.
• ORDER BY: Sortiert die gefilterten Daten – hilft, die Ausgabe basierend auf einem oder mehreren Feldern zu organisieren.
• OFFSET und LIMIT: Begrenze die Anzahl der zurückgegebenen Zeilen – nützlich für Paginierung oder Top-K-Abfragen.
• RETURN: Spezifiziert die Endausgabe – definiert, welche Daten in den Ergebnissatz aufgenommen werden sollen, und führt die Aggregation durch.

Zusammenarbeit von Anweisungen

GQL-Anweisungen bilden eine Pipeline, in der jede Anweisung die Ausgabe der vorherigen verarbeitet. Diese sequentielle Ausführung macht Abfragen leicht lesbar und fehlerfrei, da die Ausführungsreihenfolge mit der Lesereihenfolge übereinstimmt.

Wichtige Punkte:

• Anweisungen werden effektiv sequenziell ausgeführt.
• Jede Anweisung transformiert Daten und übergibt sie an die nächste.
• Dies schafft einen klaren, vorhersehbaren Datenfluss, der komplexe Abfragen vereinfacht.

Von Bedeutung

Intern kann die Ausführung von Anweisungen neu geordnet und einzelne Anweisungen parallel von Microsoft Fabric ausgeführt werden, um die Leistung zu maximieren. Dies beeinträchtigt jedoch nicht die Korrektheit der Ergebnisse.

Beispiel

Die folgende GQL-Abfrage findet die ersten 10 Personen, die bei Unternehmen mit "Air" im Namen arbeiten, sortiert sie nach vollständigem Namen und gibt ihren vollständigen Namen zusammen mit dem Namen ihrer Unternehmen zurück.

-- Data flows: Match → Let → Filter → Order → Limit → Return
MATCH (p:Person)-[:workAt]->(c:Company)           -- Input: unit table, Output: (p, c) table
LET fullName = p.firstName || ' ' || p.lastName   -- Input: (p, c) table, Output: (p, c, fullName) table
FILTER c.name CONTAINS 'Air'                      -- Input: (p, c, fullName) table, Output: filtered table
ORDER BY fullName                                 -- Input: filtered table, Output: sorted table
LIMIT 10                                          -- Input: sorted table, Output: top 10 rows table
RETURN fullName, c.name AS companyName            -- Input: top 10 rows table
                                                  -- Output: projected (fullName, companyName) result table

Diese Abfrage wird wie folgt ausgeführt:

1. MATCH findet Leute, die in Unternehmen arbeiten, die "Air" im Namen haben
2. LET Vollständige Namen entstehen, indem Vor- und Familiennamen kombiniert werden
3. FILTER behält nur Contoso-Mitarbeiter
4. ORDER BY sortiert nach vollständigem Namen
5. LIMIT nimmt die ersten 10 Ergebnisse
6. RETURN Rückgabenamen, Namen und Firmenstandorte

Variablen verbinden Ihre Daten

Variablen (z p. B. , cund fullName in den vorherigen Beispielen) enthalten Daten zwischen Anweisungen. Wenn Sie einen Variablennamen wiederverwenden, stellt GQL automatisch sicher, dass er sich auf dieselben Daten bezieht und leistungsstarke Verknüpfungsbedingungen erstellt. Variablen werden manchmal auch als Bindungsvariablen bezeichnet.

Variablen können auf unterschiedliche Weise kategorisiert werden:

Durch Bindungsquelle:

• Mustervariablen – gebunden durch übereinstimmende Diagrammmuster
• Reguläre Variablen – gebunden an andere Sprachkonstrukte

Mustervariablentypen:

• Elementvariablen – Binden an Diagrammelementverweiswerte
  • Knotenvariablen – Binden an einzelne Knoten
  • Edgevariablen – Binden an einzelne Kanten
• Pfadvariablen – Binden an Pfadwerte, die übereinstimmende Pfade darstellen

Nach Referenzgrad:

• Singleton-Variablen – Binden an einzelne Elementverweiswerte aus Mustern
• Gruppenvariablen – Binden an Listen von Elementverweiswerten aus Mustern mit variabler Länge (siehe Erweiterte Aggregationstechniken)

Ausführungsergebnisse und Ergebnisse

Wenn Sie eine Abfrage ausführen, erhalten Sie ein Ausführungsergebnis , das aus:

• Eine (optionale) Ergebnistabelle mit den Daten aus Ihrer RETURN Anweisung.
• Statusinformationen , die zeigen, ob die Abfrage erfolgreich war oder nicht.

Ergebnistabellen

Die Ergebnistabelle (sofern vorhanden) ist das tatsächliche Ergebnis der Abfrageausführung.

Eine Ergebnistabelle enthält Informationen über den Namen und den Typ der Spalten, eine bevorzugte Spaltennamensequenz, die zum Anzeigen von Ergebnissen verwendet werden soll, ob die Tabelle sortiert ist, und die tatsächlichen Zeilen selbst.

Hinweis

Bei Ausführungsfehlern ist keine Ergebnistabelle im Ausführungsergebnis enthalten.

Statusinformationen

Verschiedene beachtenswerte Bedingungen (z. B. Fehler oder Warnungen) werden während der Ausführung der Abfrage erkannt. Jede solche Bedingung wird von einem Statusobjekt in den Statusinformationen des Ausführungsergebnisses aufgezeichnet.

Die Statusinformationen bestehen aus einem primären Statusobjekt und einer (möglicherweise leeren) Liste zusätzlicher Statusobjekte. Das primäre Statusobjekt ist immer vorhanden und gibt an, ob die Abfrageausführung erfolgreich war oder fehlgeschlagen ist.

Jedes Statusobjekt enthält einen 5-stelligen Statuscode (GQLSTATUS), der die aufgezeichnete Bedingung identifiziert, sowie eine Meldung, die sie beschreibt.

Erfolgsstatuscodes:

GQLSTATUS	Nachricht	Wann
00000	Hinweis: Erfolgreicher Abschluss	Erfolg mit mindestens einer Zeile
00001	Hinweis: Erfolgreicher Abschluss - Ausgelassenes Ergebnis	Erfolg ohne Tabelle (derzeit nicht verwendet)
02000	Hinweis: Keine Daten	Erfolg mit Nullzeilen

Andere Statuscodes deuten auf weitere Fehler oder Warnungen hin, die während der Abfrageausführung erkannt wurden.

Vollständige GQLSTATUS-Codesreferenz anzeigen

Von Bedeutung

Verlassen Sie sich im Anwendungscode immer auf Statuscodes, um auf bestimmte Bedingungen zu testen. Statuscodes sind garantiert stabil und ihre allgemeine Bedeutung wird sich in Zukunft nicht ändern. Testen Sie nicht auf den Inhalt von Nachrichten, da die konkrete Nachricht, die für einen Statuscode gemeldet wird, sich in Zukunft je nach Abfrage oder sogar zwischen Ausführungen derselben Abfrage ändern kann.

Darüber hinaus können Statusobjekte ein zugrunde liegendes Ursachenstatusobjekt und einen Diagnosedatensatz mit weiteren Informationen enthalten, die die aufgezeichnete Bedingung kennzeichnen.

Wesentliche Konzepte und Anweisungen

In diesem Abschnitt werden die wichtigsten Bausteine behandelt, die Sie zum Schreiben effektiver GQL-Abfragen benötigen. Jedes Konzept baut auf praktische Fähigkeiten zum Schreiben von Abfragen auf.

Diagrammmuster: Struktur suchen

Diagrammmuster sind das Herzstück von GQL-Abfragen. Sie ermöglichen ihnen die Beschreibung der datenstruktur, nach der Sie suchen, indem Sie intuitive visuelle Syntax verwenden, die wie die beziehungen aussieht, die Sie finden möchten.

Einfache Muster:

Beginnen Sie mit grundlegenden Beziehungsmustern:

-- Find direct friendships
(p:Person)-[:knows]->(f:Person)

-- Find people working at any company
(p:Person)-[:workAt]->(c:Company)

-- Find cities in any country/region
(ci:City)-[:isPartOf]->(co:Country)  

Muster mit bestimmten Daten:

-- Find who works at Microsoft specifically
(p:Person)-[:workAt]->(c:Company)
WHERE p.firstName = 'Annemarie'

-- Find friends who are both young
(p:Person)-[:knows]->(f:Person)  
WHERE p.birthday > 19950101 AND f.birthday > 19950101

Bezeichnungsausdrücke für flexible Entitätsauswahl:

(:Person|Company)-[:isLocatedIn]->(p:City|Country)  -- OR with |
(:Place&City)                                       -- AND with &  
(:Person&!Company)                                  -- NOT with !

Hinweis

Graphenmodelle mit mehreren Elementlabels werden noch nicht unterstützt (bekanntes Problem).

Mit Bezeichnungsausdrücken können Sie verschiedene Arten von Knoten in einem einzelnen Muster abgleichen, sodass Ihre Abfragen flexibler sind.

Die Wiederverwendung von Variablen erstellt leistungsstarke Verknüpfungen:

-- Find coworkers: people who work at the same company
(c:Company)<-[:workAt]-(x:Person)-[:knows]-(y:Person)-[:workAt]->(c)

Durch die Wiederverwendung von Variablen c wird sichergestellt, dass beide Personen im selben Unternehmen arbeiten und eine automatische Verknüpfungseinschränkung erstellen. Dieses Muster ist ein Schlüsselmuster zum Ausdrücken von Beziehungen zwischen "derselben Entität".

Von Bedeutung

Kritische Einblicke: Die Wiederverwendung von Variablen in Mustern schafft strukturelle Einschränkungen. Diese Technik zeigt, wie Sie komplexe Graph-Beziehungen wie "Freunde, die am gleichen Unternehmen arbeiten" oder "Menschen in derselben Stadt" ausdrücken.

Filterung auf Musterebene mit WHERE:

-- Filter during pattern matching (more efficient)
(p:Person WHERE p.birthday < 19940101)-[:workAt]->(c:Company WHERE c.id > 1000)

-- Filter edges during matching  
(p:Person)-[w:workAt WHERE w.workFrom >= 2000]->(c:Company)

Gebundene Muster mit variabler Länge:

(:Person)-[:knows]->{1,3}(:Person)  -- Friends up to 3 degrees away

TRAIL-Muster für zyklusfreie Traversal:

Verwenden Sie TRAIL Muster, um Zyklen während der Graph-Traversal zu verhindern, um sicherzustellen, dass jede Kante höchstens einmal besucht wird:

-- Find paths without visiting the same :knows edge twice
MATCH TRAIL (src:Person)-[:knows]->{1,4}(dst:Person)
WHERE src.firstName = 'Alice' AND dst.firstName = 'Bob'
RETURN count(*) AS num_connections

-- Find acyclic paths in social networks
MATCH TRAIL (p:Person)-[e:knows]->{,3}(celebrity:Person)
RETURN 
  p.firstName || ' ' || p.lastName AS person_name, 
  celebrity.firstName || ' ' || celebrity.lastName AS celebrity_name, 
  count(e) AS distance
LIMIT 1000

Edgebindung variabler Länge:

In Mustern mit variabler Länge erfassen Edgevariablen unterschiedliche Informationen basierend auf dem Kontext:

-- Edge variable 'e' binds to a single edge for each result row
MATCH (p:Person)-[e:knows]->(friend:Person)
RETURN p.firstName, e.creationDate, friend.firstName  -- e refers to one specific relationship
LIMIT 1000

-- Edge variable 'e' binds to a group list of all edges in the path
MATCH (p:Person)-[e:knows]->{2,4}(friend:Person)  
RETURN 
  p.firstName || ' ' || p.lastName AS person_name, 
  friend.firstName || ' ' || friend.lastName AS friend_name, 
  -- e is a list
  size(e) AS num_edges
LIMIT 1000

Diese Unterscheidung ist entscheidend für die ordnungsgemäße Verwendung von Edgevariablen.

Komplexe Muster mit mehreren Beziehungen:

MATCH (p:Person), (p)-[:workAt]->(c:Company), (p)-[:isLocatedIn]->(city:City)
RETURN p.firstName, p.lastName, c.name AS company_name, city.name AS city_name
LIMIT 1000

Dieses Muster findet Personen zusammen mit ihrem Arbeitsplatz und Ihrem Wohnsitz und zeigt, wie eine Person eine Verbindung mit mehreren anderen Entitäten herstellt.

Umfassende Mustersyntax und erweiterte Techniken

Kernanweisungen

GQL stellt bestimmte Anweisungstypen bereit, die schritt für Schritt zusammenarbeiten, um Ihre Diagrammdaten zu verarbeiten. Das Verständnis dieser Anweisungen ist für die Erstellung effektiver Abfragen unerlässlich.

MATCH-Anweisung

Syntax:

MATCH <graph pattern>, <graph pattern>, ... [ WHERE <predicate> ]

Die MATCH Anweisung verwendet Eingabedaten und findet Diagrammmuster, fügt Eingabevariablen mit Mustervariablen zusammen und gibt alle übereinstimmende Kombinationen aus.

Eingabe- und Ausgabevariablen:

-- Input: unit table (no columns, one row)
-- Pattern variables: p, c  
-- Output: table with (p, c) columns for each person-company match
MATCH (p:Person)-[:workAt]->(c:Company)

Filterung auf Anweisungsebene mit WHERE:

-- Filter pattern matches
MATCH (p:Person)-[:workAt]->(c:Company) WHERE p.lastName = c.name

Alle Übereinstimmungen können nach dem Filtern mithilfe WHEREeiner separaten FILTER Anweisung vermieden werden.

Verknüpfen mit Eingabevariablen:

Wenn MATCH es sich nicht um die erste Anweisung handelt, verknüpft sie Eingabedaten mit Mustervergleichen:

...
-- Input: table with 'targetCompany' column
-- Implicit join: targetCompany (equality join)
-- Output: table with (targetCompany, p, r) columns
MATCH (p:Person)-[r:workAt]->(targetCompany)

Von Bedeutung

Graph in Microsoft Fabric unterstützt noch keine beliebige Anweisungskomposition. Weitere Informationen finden Sie im Artikel zu den aktuellen Einschränkungen.

Wichtige Verknüpfungsverhalten:

So MATCH wird's gehandhabt:

• Variable Gleichheit: Eingabevariablen mit Mustervariablen mithilfe des Gleichheitsabgleichs verknüpft
• Innere Verknüpfung: Eingabezeilen ohne Mustervergleiche werden verworfen (keine Links-/Rechts-Verknüpfungen)
• Filterreihenfolge: Filter auf Anweisungsebene WHERE nach Abschluss des Musterabgleichs
• Musterkonnektivität: Mehrere Muster müssen mindestens eine Variable für die ordnungsgemäße Verknüpfung freigeben.
• Leistung: Freigegebene Variablen erstellen effiziente Verknüpfungseinschränkungen

Von Bedeutung

Einschränkung: Wenn dies MATCH nicht die erste Anweisung ist, muss mindestens eine Eingabevariable mit einer Mustervariable verknüpft werden. Mehrere Muster müssen eine Variable gemeinsam haben.

Für mehrere Muster sind freigegebene Variablen erforderlich:

-- Shared variable 'p' joins the two patterns
-- Output: people with both workplace and residence data
MATCH (p:Person)-[:workAt]->(c:Company), 
      (p)-[:isLocatedIn]->(city:City)

LET-Anweisung

Syntax:

LET <variable> = <expression>, <variable> = <expression>, ...

Die LET Anweisung erstellt berechnete Variablen und ermöglicht die Datentransformation in Ihrer Abfragepipeline.

Einfache Variablenerstellung:

MATCH (p:Person)
LET fullName = p.firstName || ' ' || p.lastName
RETURN *
LIMIT 1000

Komplexe Berechnungen:

MATCH (p:Person)
LET adjustedAge = 2000 - (p.birthday / 10000),
    fullProfile = p.firstName || ' ' || p.lastName || ' (' || p.gender || ')'
RETURN *
LIMIT 1000

Schlüsselverhalten:

• Ausdrücke werden für jede Eingabezeile ausgewertet.
• Ergebnisse werden zu neuen Spalten in der Ausgabetabelle
• Variablen können nur auf vorhandene Variablen aus vorherigen Anweisungen verweisen.
• Mehrere Zuordnungen in einer LET werden parallel ausgewertet (keine Querverweise)

FILTER-Anweisung

Syntax:

FILTER [ WHERE ] <predicate>

Die FILTER Anweisung bietet eine genaue Kontrolle darüber, welche Daten durch Ihre Abfragepipeline weitergeleitet werden.

Grundlegende Filterung:

MATCH (p:Person)
FILTER p.birthday < 19980101 AND p.gender = 'female'
RETURN *

Komplexe logische Bedingungen:

MATCH (p:Person)
FILTER (p.gender = 'male' AND p.birthday < 19940101) 
  OR (p.gender = 'female' AND p.birthday < 19990101)
  OR p.browserUsed = 'Edge'
RETURN *

Filtermuster mit Null-Berücksichtigung:

Verwenden Sie diese Muster, um Nullwerte sicher zu behandeln:

• Auf Werte überprüfen: p.firstName IS NOT NULL - hat einen Vornamen
• Validieren von Daten: p.id > 0 - gültige ID
• Behandeln fehlender Daten: NOT coalesce(p.locationIP, '127.0.0.1') STARTS WITH '127.0.0' - Keine Verbindung über das lokale Netzwerk hergestellt
• Kombinieren von Bedingungen: Verwenden mit AND/OR expliziten NULL-Prüfungen für komplexe Logik

Vorsicht

Denken Sie daran, dass Bedingungen mit Nullwerten zurückgegeben UNKNOWNwerden, die diese Zeilen herausfiltern. Verwenden Sie explizite IS NULL Prüfungen, wenn Sie null-inklusive Logik benötigen.

ORDER BY-Anweisung

Syntax:

ORDER BY <expression> [ ASC | DESC ], <expression> [ ASC | DESC ], ...

Sortierung auf mehreren Ebenen mit berechneten Ausdrücken:

MATCH (p:Person)
RETURN *
ORDER BY p.firstName DESC,               -- Primary: by first name (Z-A)
         p.birthday ASC,                 -- Secondary: by age (oldest first)
         p.id DESC                       -- Tertiary: by ID (highest first)

Nullbehandlung beim Sortieren:

ORDER BY coalesce(p.gender, 'not specified') DESC -- Treat NULL as 'not specified'

Details zum Sortierverhalten:

Grundlegendes zur ORDER BY Funktionsweise:

• Ausdrucksauswertung: Ausdrücke werden für jede Zeile ausgewertet, und die Ergebnisse bestimmen die Zeilenreihenfolge.
• Mehrere Sortierschlüssel: Hierarchische Sortierung erstellen (primär, sekundär, tertiär usw.)
• Nullbehandlung: NULL wird immer als kleinster Wert in Vergleichen behandelt.
• Standardreihenfolge: ASC (aufsteigend) ist standard, DESC (absteigend) muss explizit angegeben werden.
• Berechnete Sortierung: Sie können nach berechneten Werten und nicht nur nach gespeicherten Eigenschaften sortieren.

Vorsicht

Die festgelegte ORDER BY Sortierreihenfolge ist nur für die unmittelbar folgende Anweisung sichtbar. ORDER BY Gefolgt von RETURN * "Kein sortiertes Ergebnis".

Vergleichen:

MATCH (a:Person)-[r:knows]->(b:Person)
LET aName = a.firstName || ' ' || a.lastName
LET bName = b.firstName || ' ' || b.lastName
ORDER BY r.creationDate DESC
/* intermediary result _IS_ guaranteed to be ordered here */
RETURN aName, bName, r.creationDate AS since
/* final result _IS_ _NOT_ guaranteed to be ordered here  */

Durch:

MATCH (a:Person)-[r:knows]->(b:Person)
LET aName = a.firstName || ' ' || a.lastName
LET bName = b.firstName || ' ' || b.lastName
/* intermediary result _IS_ _NOT_ guaranteed to be ordered here */
RETURN aName, bName, r.creationDate AS since
ORDER BY r.creationDate DESC
/* final result _IS_ guaranteed to be ordered here              */

Dies hat unmittelbare Folgen für "Top-k"-Abfragen: LIMIT Muss immer der ORDER BY Anweisung folgen, die die beabsichtigte Sortierreihenfolge festgelegt hat.

OFFSET- und LIMIT-Anweisungen

Syntax:

  OFFSET <offset> [ LIMIT <limit> ]
| LIMIT <limit>

Häufige Muster:

-- Basic top-N query
MATCH (p:Person)
RETURN *
ORDER BY p.id DESC
LIMIT 10                                 -- Top 10 by ID

Von Bedeutung

Verwenden Sie ORDER BY für vorhersagbare Paginierungsergebnisse immer vorher OFFSET , und LIMIT stellen Sie eine konsistente Zeilenreihenfolge über Abfragen hinweg sicher.

RETURN: Grundlegende Ergebnisprojektion

Syntax:

RETURN [ DISTINCT ] <expression> [ AS <alias> ], <expression> [ AS <alias> ], ...
[ ORDER BY <expression> [ ASC | DESC ], <expression> [ ASC | DESC ], ... ]
[ OFFSET <offset> ]
[ LIMIT <limit> ]

Die RETURN Anweisung erzeugt die endgültige Ausgabe Ihrer Abfrage, indem angegeben wird, welche Daten in der Ergebnistabelle angezeigt werden.

Grundlegende Ausgabe:

MATCH (p:Person)-[:workAt]->(c:Company)
RETURN p.firstName || ' ' || p.lastName AS name, 
       p.birthday, 
       c.name

Verwenden von Aliasen zur Übersichtlichkeit:

MATCH (p:Person)-[:workAt]->(c:Company)
RETURN p.firstName AS first_name, 
       p.lastName AS last_name,
       c.name AS company_name

Kombinieren mit Sortierung und Top-k:

MATCH (p:Person)-[:workAt]->(c:Company)
RETURN p.firstName || ' ' || p.lastName AS name, 
       p.birthday AS birth_year, 
       c.name AS company
ORDER BY birth_year ASC
LIMIT 10

Duplikatbehandlung mit DISTINCT:

-- Remove duplicate combinations
MATCH (p:Person)-[:workAt]->(c:Company)
RETURN DISTINCT p.gender, p.browserUsed, p.birthday AS birth_year
ORDER BY p.gender, p.browserUsed, birth_year

Kombinieren mit Aggregation:

MATCH (p:Person)-[:workAt]->(c:Company)
RETURN count(DISTINCT p) AS employee_count

RETURN mit GROUP BY: gruppierte Ergebnisprojektion

Syntax:

RETURN [ DISTINCT ] <expression> [ AS <alias> ], <expression> [ AS <alias> ], ...
GROUP BY <variable>, <variable>, ...
[ ORDER BY <expression> [ ASC | DESC ], <expression> [ ASC | DESC ], ... ]
[ OFFSET <offset> ]
[ LIMIT <limit> ]

Wird GROUP BY verwendet, um Zeilen nach freigegebenen Werten zu gruppieren und Aggregatfunktionen innerhalb jeder Gruppe zu berechnen.

Grundlegende Gruppierung mit Aggregation:

MATCH (p:Person)-[:workAt]->(c:Company)
LET companyName = c.name
RETURN companyName, 
       count(*) AS employeeCount,
       avg(p.birthday) AS avg_birth_year
GROUP BY companyName
ORDER BY employeeCount DESC

Mehrspaltige Gruppierung:

MATCH (p:Person)
LET gender = p.gender
LET browser = p.browserUsed
RETURN gender,
       browser,
       count(*) AS person_count,
       avg(p.birthday) AS avg_birth_year,
       min(p.creationDate) AS first_joined,
       max(p.id) AS highest_id
GROUP BY gender, browser
ORDER BY avg_birth_year DESC
LIMIT 10

Hinweis

Erweiterte Aggregationstechniken, einschließlich horizontaler Aggregation über Muster mit variabler Länge, finden Sie unter Advanced Aggregation Techniques.

Datentypen: Arbeiten mit Werten

GQL unterstützt umfangreiche Datentypen zum Speichern und Bearbeiten verschiedener Arten von Informationen in Ihrem Diagramm.

Grundlegende Werttypen:

• Zahlen: INT64, UINT64für DOUBLE Berechnungen und Messungen
• Text: STRING für Namen, Beschreibungen und Textdaten
• Logik: BOOL mit drei Werten: WAHR, FALSCH und UNBEKANNT (für null-Behandlung)
• Zeit: ZONED DATETIME für Zeitstempel mit Zeitzoneninformationen
• Sammlungen: LIST<T> für mehrere Werte desselben Typs T, PATH für Graphdurchlauf-Ergebnisse
• Graph-Elemente: NODE und EDGE zum Verweisen auf Diagrammdaten

Von Bedeutung

Bestimmte Wertarten werden nicht als Immobilienwerte unterstützt. Insbesondere können nicht alle Werte mit Referenzwerten von Graphelementen als Eigenschaftswerte verwendet werden (wie Listen von Knoten oder Pfaden).

Beispielliterale:

42                                     -- Integer literal
"Hello, graph!"                        -- String  literal
TRUE                                   -- Boolean literal
ZONED_DATETIME('2024-01-15T10:30:00Z') -- DateTime with timezone literakl
[1, 2, 3]                              -- Literal list of integers

Kritische Nullbehandlungsmuster:

-- Equality predicates with NULL always returns UNKNOWN
5 = NULL                              -- Evaluates to UNKNOWN (not FALSE!)
NULL = NULL                           -- Evaluates to UNKNOWN (not TRUE!)

-- Use IS NULL predicates for explicit null testing
p.nickname IS NULL                    -- Evaluates to TRUE if nickname is null
p.nickname IS NOT NULL                -- Evaluates to TRUE if nickname has a value

-- Use the COALESCE function for null-safe value selection
coalesce(p.nickname, p.firstName, '???')  -- Evaluates to first non-null value

Dreiwertige Logikauswirkungen:

-- In FILTER statements, only TRUE values pass through
FILTER p.birthday > 0        -- Removes rows where birthday is null or missing or zero

-- It's important to understand that NOT UNKNOWN = UNKNOWN
FILTER NOT (p.birthday > 0)  -- Removes rows where birthday is null or missing or positive

-- Use explicit null handling for inclusive filtering
FILTER p.birthday < 19980101 OR p.birthday IS NULL -- Includes null birthdays

Vorsicht

Dreiwertige Logik bedeutet NULL = NULL Rückgaben UNKNOWN, nicht TRUE. Dieses Verhalten wirkt sich auf Filterung und Verknüpfungen aus. Wird immer für NULL-Tests verwendet IS NULL .

Erfahren Sie mehr über umfassende Systemdetails des Typs

Ausdrücke: Transformieren und Analysieren von Daten

Mit Ausdrücken können Sie Daten in Ihren Abfragen berechnen, vergleichen und transformieren. Sie ähneln Ausdrücken in SQL, verfügen aber über zusätzliche Features für die Behandlung von Diagrammdaten.

Allgemeine Ausdruckstypen:

p.birthday < 19980101   -- Birth year comparison  
p.firstName || ' ' || p.lastName               -- String concatenation
count(*)                                       -- Aggregation
p.firstName IN ['Alice', 'Bob']                -- List membership
coalesce(p.firstName, p.lastName)              -- Null handling

Komplexe Prädikatkomposition:

-- Combine conditions with proper precedence
FILTER (p.birthday > 19560101 AND p.birthday < 20061231) 
  AND ((p.gender IN ['male', 'female']) OR (p.browserUsed IS NOT NULL))

-- Use parentheses for clarity and correctness
FILTER p.gender = 'female' AND (p.firstName STARTS WITH 'A' OR p.id > 1000)

Zeichenfolgenmusterabgleich:

-- Pattern matching with different operators
p.locationIP CONTAINS '192.168'      -- Substring search
p.firstName STARTS WITH 'John'       -- Prefix matching  
p.lastName ENDS WITH 'son'           -- Suffix matching

-- Case-insensitive operations
upper(p.firstName) = 'ALICE'         -- Convert to uppercase for comparison

Integrierte Funktionen nach Kategorie:

GQL stellt diese Funktionskategorien für unterschiedliche Datenverarbeitungsanforderungen bereit:

• Aggregatfunktionen: count(), sum(), avg(), min()zum max() Zusammenfassen von Daten
• Zeichenfolgenfunktionen: char_length(), upper(), lower()trim()für die Textverarbeitung
• Graph-Funktionen: nodes(), edges()zum labels() Analysieren von Diagrammstrukturen
• Allgemeine Funktionen: coalesce() für die ordnungsgemäße Behandlung von NULL-Werten

Rangfolge des Operators für komplexe Ausdrücke:

1. Eigenschaftszugriff (.)
2. Multiplikation/Division (*, /)
3. Addition/Subtraktion (+, -)
4. Vergleich (=, <>, , <>, , <=, ) >=
5. Logische Negation (NOT)
6. Logische Verbindung (AND)
7. Logische Disjunktion (OR)

In der obigen Liste "bindet" ein Operator mit niedrigerer Zahl "fester" als ein Operator mit einer höheren Nummer. Beispiel: ist(NOT n.prop) OR m.prop, NOT n.prop OR m.prop aber nicht 'NICHT (n.prop ODER m.prop)

Tipp

Verwenden Sie Klammern, um vorrang explizit zu machen. Komplexe Ausdrücke sind einfacher zu lesen und zu debuggen, wenn die Gruppierung klar ist.

Umfassende Ausdruckssyntax und alle integrierten Funktionen

Erweiterte Abfragetechniken

In diesem Abschnitt werden komplexe Muster und Techniken zum Erstellen komplexer, effizienter Diagrammabfragen behandelt. Diese Muster gehen über die grundlegende Verwendung von Anweisungen hinaus, damit Sie leistungsstarke analytische Abfragen erstellen können.

Komplexe Komposition mit mehreren Anweisungen

Von Bedeutung

Graph in Microsoft Fabric unterstützt noch keine beliebige Anweisungskomposition. Weitere Informationen finden Sie im Artikel zu den aktuellen Einschränkungen.

Das effiziente Erstellen komplexer Abfragen ist für die erweiterte Graph-Abfrage von entscheidender Bedeutung.

Mehrstufige Musterentwicklung:

-- Build complex analysis step by step
MATCH (company:Company)<-[:workAt]-(employee:Person)
LET companyName = company.name
MATCH (employee)-[:isLocatedIn]->(city:City)
FILTER employee.birthday < 19850101
LET cityName = city.name
RETURN companyName, cityName, avg(employee.birthday) AS avgBirthday, count(employee) AS employeeCount
GROUP BY companyName, cityName
ORDER BY avgBirthday DESC

Diese Abfrage erhöht schrittweise die Komplexität: Unternehmen finden, deren Mitarbeiter, Mitarbeiterstandorte, Unternehmen filtern, deren Mitarbeiter vor 1985 geboren wurden, den durchschnittlichen Geburtstag berechnen und Ergebnisse zusammenfassen und sortieren.

Verwendung der horizontalen Aggregation:

-- Find people and their minimum distance to people working at Microsoft
MATCH TRAIL (p:Person)-[e:knows]->{,5}(:Person)-[:workAt]->(:Company { name: 'Microsoft'})
LET p_name = p.lastName || ', ' || p.firstName
RETURN p_name, min(count(e)) AS minDistance 
GROUP BY p_name
ORDER BY minDistance DESC

Hinweis

Diese Abfrage wird noch nicht unterstützt (bekanntes Problem).

Variabler Bereich und erweiterte Flusssteuerung

Variablen verbinden Daten über Abfrageanweisungen hinweg und ermöglichen komplexe Graph-Traversale. Wenn Sie erweiterte Bereichsregeln verstehen, können Sie komplexe Abfragen mit mehreren Anweisungen schreiben.

Variablenbindungs- und Bereichsmuster:

-- Variables flow forward through subsequent statements 
MATCH (p:Person)                                    -- Bind p 
LET fullName = p.firstName || ' ' || p.lastName     -- Bind concatenation of p.firstName and p.lastName as fullNume
FILTER fullName CONTAINS 'Smith'                    -- Filter for fullNames with “Smith” substring (p is still bound)
RETURN p.id, fullName                               -- Only return p.id and fullName (p is dropped from scope) 

Variable Wiederverwendung für Verknüpfungen über Anweisungen hinweg:

-- Multi-statement joins using variable reuse
MATCH (p:Person)-[:workAt]->(:Company)          -- Find people with jobs
MATCH (p)-[:isLocatedIn]->(:City)               -- Same p: people with both job and residence
MATCH (p)-[:knows]->(friend:Person)             -- Same p: their social connections
RETURN *

Wichtige Bereichsregeln und Einschränkungen:

-- ✅ Backward references work
MATCH (p:Person)
LET adult = p.birthday < 20061231  -- Can reference p from previous statement
RETURN *

-- ❌ Forward references don't work  
LET adult = p.birthday < 20061231  -- Error: p not yet defined
MATCH (p:Person)
RETURN *

-- ❌ Variables in same LET statement can't reference each other
MATCH (p:Person)
LET name = p.firstName || ' ' || p.lastName,
    greeting = 'Hello, ' || name     -- Error: name not visible yet
RETURN *

-- ✅ Use separate statements for dependent variables
MATCH (p:Person)
LET name = p.firstName || ' ' || p.lastName
LET greeting = 'Hello, ' || name     -- Works: name now available
RETURN *

Variable Sichtbarkeit in komplexen Abfragen:

-- Variables remain visible until overridden or query ends
MATCH (p:Person)                     -- p available from here
LET gender = p.gender                -- gender available from here  
MATCH (p)-[:knows]->(e:Person)       -- p still refers to original person
                                     -- e is new variable for managed employee
RETURN p.firstName AS manager, e.firstName AS friend, gender

Vorsicht

Variablen in derselben Anweisung können nicht miteinander verweisen (außer in Diagrammmustern). Verwenden Sie separate Anweisungen für die abhängige Variablenerstellung.

Erweiterte Aggregationstechniken

GQL unterstützt zwei unterschiedliche Aggregationstypen zum Analysieren von Daten über Gruppen und Sammlungen: vertikale Aggregation mit GROUP BY und horizontaler Aggregation über Variablenlängenmuster.

Vertikale Aggregation mit GROUP BY

Vertikale Aggregation (abgedeckt mitRETURNGROUP BY) gruppiert Zeilen nach freigegebenen Werten und berechnet Aggregate innerhalb jeder Gruppe:

MATCH (p:Person)-[:workAt]->(c:Company)
RETURN c.name AS companyName, 
       count(*) AS employee_count, 
       avg(p.birthday) AS avg_birth_year
GROUP BY companyName

Dieser Ansatz erstellt eine Ergebniszeile pro Unternehmen und aggregiert alle Mitarbeiter innerhalb jeder Gruppe.

Horizontale Aggregation mit Gruppenlistenvariablen

Die horizontale Aggregation berechnet Aggregate über Sammlungen, die durch Muster mit variabler Länge gebunden sind. Wenn Sie Ränder mit variabler Länge verwenden, wird die Edgevariable zu einer Gruppenlistenvariable , die alle Kanten in jedem übereinstimmenden Pfad enthält:

-- Group list variable 'edges' enables horizontal aggregation
MATCH (p:Person)-[edges:knows]->{2,4}(friend:Person)
RETURN p.firstName || ' ' || p.lastName AS person_name, 
       friend.firstName || ' ' || friend.lastName AS friend_name,
       size(edges) AS degrees_of_separation,
       avg(edges.creationDate) AS avg_connection_age,
       min(edges.creationDate) AS oldest_connection

Hinweis

Diese Abfrage wird noch nicht unterstützt (bekanntes Problem).

Wichtige Unterschiede:

• Vertikale Aggregation fasst zeilenübergreifend oder gruppiert Zeilen und fasst zeilenübergreifend in jeder Gruppe zusammen.
• Horizontale Aggregation fasst Elemente innerhalb einzelner Edgeauflistungen zusammen
• Gruppenlistenvariablen stammen nur aus Randmustern variabler Länge

Randbindungskontexte mit variabler Länge

Grundlegendes zur Bindung von Edgevariablen in Variablenlängenmustern ist von entscheidender Bedeutung:

Während des Musterabgleichs (Singleton-Kontext):

-- Edge variable 'e' refers to each individual edge during filtering
MATCH (p:Person)-[e:knows WHERE e.creationDate > zoned_datetime('2000-01-01T00:00:00Z')]->{2,4}(friend:Person)
-- 'e' is evaluated for each edge in the path during matching
RETURN *

In Ergebnisausdrücken (Gruppenkontext):

-- Edge variable 'edges' becomes a list of all qualifying edges
MATCH (p:Person)-[e:knows]->{2,4}(friend:Person)
RETURN size(e) AS num_edges,                    -- Number of edges in path
       e[0].creationDate AS first_edge,         -- First edge in path
       avg(e.creationDate) AS avg_age           -- Horizontal aggregation

Hinweis

Diese Abfrage wird noch nicht unterstützt (bekanntes Problem).

Kombinieren der vertikalen und horizontalen Aggregation

Sie können beide Aggregationstypen in komplexen Analysemustern kombinieren:

-- Find average connection age by city pairs
MATCH (p1:Person)-[:isLocatedIn]->(c1:City)
MATCH (p2:Person)-[:isLocatedIn]->(c2:City)
MATCH (p1)-[e:knows]->{1,3}(p2)
RETURN c1.name AS city1,
       c2.name AS city2,
       count(*) AS connection_paths,                  -- Vertical: count paths per city pair
       avg(size(e)) AS avg_degrees,                   -- Horizontal then vertical: path lengths
       avg(avg(e.creationDate)) AS avg_connection_age -- Horizontal then vertical: connection ages
GROUP BY city1, city2

Hinweis

Diese Abfrage wird noch nicht unterstützt (bekanntes Problem).

Tipp

Horizontale Aggregation hat immer Vorrang vor vertikaler Aggregation. Um eine Gruppenliste in eine reguläre Liste zu konvertieren, verwenden Sie collect_list(edges).

Hinweis

Ausführliche Referenz zu Aggregatfunktionen finden Sie unter GQL-Ausdrücke und -Funktionen.

Strategien zur Fehlerbehandlung

Das Verständnis gängiger Fehlermuster hilft Ihnen beim Schreiben robuster Abfragen.

Behandeln Sie fehlende Daten ordnungsgemäß:

MATCH (p:Person)
-- Use COALESCE for missing properties
LET displayName = coalesce(p.firstName, p.lastName, 'Unknown')
LET contact = coalesce(p.locationIP, p.browserUsed, 'No info')
RETURN *

Verwenden Sie explizite NULL-Prüfungen:

MATCH (p:Person)
-- Be explicit about null handling
FILTER p.id IS NOT NULL AND p.id > 0
-- Instead of just: FILTER p.id > 0
RETURN *

Weitere Informationen

GQLSTATUS-Codes

Wie im Abschnitt zu Abfrageergebnissen erläutert, meldet GQL umfassende Statusinformationen im Zusammenhang mit dem Erfolg oder potenziellen Ausführungsfehlern. Die vollständige Liste finden Sie in der GQL-Statuscodesreferenz .

Reservierte Wörter

GQL reserviert bestimmte Schlüsselwörter, die Sie nicht als Bezeichner wie Variablen, Eigenschaftennamen oder Bezeichnungsnamen verwenden können. Die vollständige Liste finden Sie in der Referenz zu reservierten GQL-Wörtern .

Wenn Sie reservierte Wörter als Bezeichner verwenden müssen, escapeen Sie sie mit Backticks: `match`, `return`.

Verwenden Sie diese Benennungskonvention, um zu vermeiden, reservierte Wörter zu entfernen:

• Fügen Sie bei Bezeichnern mit einem Wort einen Unterstrich an: :Product_
• Verwenden Sie bei Mehrwort-IDs camelCase oder PascalCase: :MyEntity, :hasAttributetextColor

Nächste Schritte

Nachdem Sie nun die GQL-Grundlagen verstanden haben, finden Sie hier Ihren empfohlenen Lernpfad:

Setzen Sie ihre GQL-Fähigkeiten fort

Für Anfänger:

• Probieren Sie die Schnellstartanleitung aus – Folgen Sie unserem praktischen Lernprogramm für praktische Erfahrungen
• Einfache Abfragen üben – Probieren Sie die Beispiele aus diesem Leitfaden mit Ihren eigenen Daten aus.
• Erlernen von Diagrammmustern – Master der umfassenden Mustersyntax
• Erkunden von Datentypen – Grundlegendes zu GQL-Werten und Werttypen

Für erfahrene Benutzer:

• Erweiterte Ausdrücke – Master-GQL-Ausdrücke und -Funktionen
• Schemaentwurf – Lernen Sie GQL-Diagrammtypen und -einschränkungen kennen
• Erkunden von Datentypen – Grundlegendes zu GQL-Werten und Werttypen

Referenzmaterialien

Halten Sie diese Verweise für schnelle Nachschlagevorgänge praktisch:

• GQL-Kurzübersicht – Syntaxschnellübersicht
• GQL-Statuscodes – Vollständiger Fehlercodeverweis
• Reservierte GQL-Wörter – Vollständige Liste reservierter Schlüsselwörter

Erkunden von Microsoft Fabric

Lernen Sie die Plattform kennen:

• Graph-Datenmodelle – Grundlegendes zu Diagrammkonzepten und -modellierung
• Graph vs relationale Datenbanken – Wählen Sie den richtigen Ansatz aus.
• Testen Sie Microsoft Fabric kostenlos – Praktische Erfahrungen
• End-to-End-Lernprogramme – Vollständige Lernszenarien

Beteiligen

• Feedback teilen – Helfen Sie, unsere Dokumentation und Tools zu verbessern
• Treten Sie der Community bei – Verbinden Mit anderen Graph-Datenbankpraktikern
• Bleiben Sie auf dem neuesten Stand – Folgen Sie Microsoft Fabric-Ankündigungen für neue Features

Tipp

Beginnen Sie mit dem Schnellstart-Lernprogramm , wenn Sie lieber lernen möchten, oder tauchen Sie in Diagrammmuster ein , wenn Sie zuerst die Abfragesprache beherrschen möchten.

Verwandte Inhalte

Weitere Details zu wichtigen Themen:

• Beispiel für ein Schema für soziale Netzwerke – Vollständiges Arbeitsbeispiel des Diagrammschemas
• GQL-Diagrammmuster – Umfassende Mustersyntax und erweiterte Abgleichstechniken
• GQL-Ausdrücke und -Funktionen – Alle Ausdruckstypen und integrierten Funktionen
• GQL-Diagrammtypen – Graphtypen und Einschränkungen
• GQL-Werte und Werttypen – Vollständige Typsystemreferenz und Wertbehandlung

Kurzverweise:

• GQL-Kurzübersicht - Syntaxschnellübersicht
• GQL-Statuscodes – Vollständiger Fehlercodeverweis
• Reservierte GQL-Wörter – Vollständige Liste reservierter Schlüsselwörter

Grafik in Microsoft Fabric:

• Graph-Datenmodelle – Grundlegendes zu Diagrammkonzepten und -modellierung
• Graph- und relationale Datenbanken – Unterschiede und wann sie jeweils verwendet werden sollen
• Microsoft Fabric kostenlos testen
• End-to-End-Anleitungen in Microsoft Fabric