GQL-Sprachhandbuch für Fabric Graph

GQL (Graph Query Language) ist die ISO-standardisierte Abfragesprache für Graphdatenbanken. Verwenden Sie GQL zum effizienten Abfragen, Analysieren und Arbeiten mit Diagrammdaten in Fabric Graph.

Dieselbe ISO-Arbeitsgruppe, die SQL standardisiert, entwickelt GQL. Daher teilt GQL viele Konzepte mit SQL, einschließlich Ausdrücken, Prädikaten und Datentypen. Wenn Sie über SQL-Erfahrung verfügen, können Sie viele dieser Kenntnisse auf GQL anwenden.

Dieser Artikel enthält eine umfassende Referenz für GQL in Fabric Graph. Es umfasst:

• Kernkonzepte: Graph-Datenstrukturen, Muster und Abfragegrundlagen
• Wesentliche Aussagen: MATCH, , FILTER, LET, ORDER BY, und LIMITRETURN
• Datentypen und Ausdrücke: Werttypen, Operatoren und integrierte Funktionen
• Erweiterte Techniken: Kompositions-, Variablen-Bereichs- und Aggregationsstrategien mit mehreren Anweisungen

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie mit diesen Konzepten vertraut sind:

• Basic Understanding of databases – Experience with any database system such as relational (SQL), NoSQL, or graph is helpful.
• Diagrammkonzepte – Grundlegendes zu Knoten, Kanten und Beziehungen in verbundenen Daten.
• Abfragegrundlagen – Kenntnisse grundlegender Abfragekonzepte wie Filtern, Sortieren und Aggregation.

Empfohlener Hintergrund:

• Die Erfahrung mit SQL- oder OpenCypher-Sprachen erleichtert 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 Fabric Graph mit Graph-Funktionen.
• Beispieldaten oder Bereitschaft, mit unseren Beispielen für soziale Netzwerke zu arbeiten.
• Einfacher Text-Editor zum Schreiben von Abfragen.

Was macht GQL besonders

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

Im Gegensatz zu SQL, das auf Tabellenverknnungen basiert, um Beziehungen auszudrücken, verwendet GQL visuelle Diagrammmuster. Diese Muster spiegeln direkt, wie Entitäten verbunden sind, wodurch Abfragen einfacher zu lesen und einfacher zu finden sind.

Angenommen, Sie möchten Personen und ihre Freunde (Personen, die einander kennen) finden, die beide vor 1999 geboren wurden. So drückt GQL diese Bedingung mithilfe eines visuellen Diagrammmusters 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:

• Diagramme speichern Ihre Daten als Knoten (Entitäten) und Kanten (Beziehungen), jeweils mit Bezeichnungen und Eigenschaften.
• Graph-Typen funktionieren wie Schemas, definieren, welche Knoten und Kanten in Ihrem Diagramm vorhanden sein können.
• Einschränkungen sind andere Regeln und Einschränkungen, die Diagrammtypen graphen auferlegen, um die Datenintegrität zu erzwingen.
• 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 Ergebnisse innerhalb von Abfragen 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 "Substantive") in Ihrem System dar – z. B. Personen, Organisationen, Beiträge oder Produkte. Sie sind unabhängige Objekte, die in Ihrer Domäne vorhanden sind. Manchmal rufen Sie auch Knotenvertizes auf.

• Kanten 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).
Manchmal rufen Sie auch Edgebeziehungen auf.

Jedes Diagrammelement weist die folgenden Merkmale auf:

• Eine interne ID , die sie eindeutig identifiziert
• Mindestens eine Beschriftung – beschreibende Namen wie Person oder knows. In Graph weisen Graph-Kanten immer genau eine Beschriftung auf.
• Eigenschaften - Name-Wert-Paare, die Daten über das Element speichern (z firstName: "Alice" . B. 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 von Rändern ist wichtig – ein Personfollows anderer Person erstellt eine gerichtete Beziehung.

Eigenschaftendiagramme, die in Graph unterstützt werden, sind immer wohlgeformt, was bedeutet, dass jeder Rand zwei gültige Knoten verbindet. Wenn ein Rand in einem Diagramm angezeigt wird, sind beide Endpunkte im selben Diagramm vorhanden.

Diagrammmodelle und Diagrammtypen

Das Diagrammmodell beschreibt die Struktur eines Diagramms in Graph. Es fungiert wie ein Datenbankschema für Ihre Anwendungsdomäne. Diagrammmodelle definieren:

• Welche Knoten und Kanten vorhanden sein können
• Welche Bezeichnungen und Eigenschaften sie haben können
• Verbinden von Knoten und Kanten

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

Ein praktisches Beispiel: soziales Netzwerk

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

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"
• Countries/regions wie "United States" 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 einander (Freundschaften, :knows).
• Menschen arbeiten an Unternehmen (:workAt) oder studieren an Universitäten (:studyAt).
• Personen erstellen Beiträge und Kommentare (:hasCreator).
• Personen wie Beiträge und Kommentare (:likes).
• Beiträge, Foren und Kommentare können Tags (:hasTag) enthalten.
• Personen haben Interessen an bestimmten Tags (:hasInterest).
• Foren enthalten Beiträge (:containerOf) und Mitglieder (:hasMember) und Moderatoren (:hasModerator).

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

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 Sie mit der einfachsten Abfrage, die möglich ist. Suchen Sie die Namen (Vorname, Nachname) aller Personen (:Personn) im Diagramm.

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

Diese Abfrage wird wie folgt ausgeführt:

1. MATCH findet alle Knoten mit Personder Bezeichnung .
2. RETURN zeigt ihre Vor- und Nachnamen an.

Filter hinzufügen: Bestimmte Personen suchen

Suchen Sie nun Personen mit bestimmten Merkmalen. In diesem Fall finden Sie alle namens Alice und zeigen ihre Namen und Geburtstage an.

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 der Bezeichnung "Person".
2. FILTER Knoten (p), deren Vorname Alice ist.
3. RETURN zeigt ihren Vor-, Nachnamen und Geburtstag an.

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.

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.
• Dieser Prozess erstellt einen klaren, vorhersehbaren Datenfluss, der komplexe Abfragen vereinfacht.

Beispiel für die Komposition von Anweisungen

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 Personen, die mit "Air" in ihrem Namen bei Unternehmen arbeiten.
2. LET erstellt vollständige Namen durch Kombinieren von Vor- und Familiennamen.
3. FILTER behält nur Contoso-Mitarbeiter bei.
4. ORDER BY sortiert nach vollständigem Namen.
5. LIMIT die ersten 10 Ergebnisse.
6. RETURN gibt Namen und Firmenstandorte zurück.

Variablen verbinden Ihre Daten

Variablen, z p. B. , cund fullName in den vorherigen Beispielen, tragen 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.

Sie können Variablen auf unterschiedliche Weise kategorisieren:

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 anzeigen, 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.

Statusinformationen

Während der Abfrageausführung erkennt der Prozess verschiedene notwürdige Bedingungen, z. B. Fehler oder Warnungen. Jede 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 anderer 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 fünfstelligen Statuscode (GQLSTATUS), der die aufgezeichnete Bedingung und eine Meldung identifiziert, die sie beschreibt.

Erfolgsstatuscodes:

Andere Statuscodes deuten auf weitere Fehler oder Warnungen hin, die der Abfrageausführungsprozess erkennt.

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 es Ihnen, die gesuchte Datenstruktur mithilfe intuitiver visueller Syntax zu beschreiben, 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 !

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".

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.

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. Es verknüpft Eingabevariablen mit Mustervariablen und gibt alle übereinstimmenen 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 mithilfe von WHERE:

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

Sie können alle Übereinstimmungen nach dem Filtern mithilfe von WHERE. Bei diesem Ansatz wird eine separate FILTER Anweisung vermieden.

Verknüpfen mithilfe von 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)

Wichtige Verknüpfungsverhalten:

So MATCH wird's gehandhabt:

• Variable Gleichheit: Eingabevariablen werden mit Mustervariablen mithilfe des Gleichheitsabgleichs verknüpft
• Innere Verknüpfung: Eingabezeilen ohne Mustervergleiche werden verworfen (keine links- oder rechtsbündigen 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

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:

• Das Abfragemodul wertet Ausdrücke für jede Eingabezeile aus.
• Die Ergebnisse werden zu neuen Spalten in der Ausgabetabelle.
• Variablen können nur auf vorhandene Variablen aus vorherigen Anweisungen verweisen.
• Das Abfragemodul wertet mehrere Zuordnungen in einer LET Anweisung parallel aus (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, '10.x.x.x') STARTS WITH '10.x.x.x' - Keine Verbindung über das lokale Netzwerk hergestellt
• Kombinieren von Bedingungen: Verwenden mit AND/OR expliziten NULL-Prüfungen für komplexe Logik

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:

• Das Abfragemodul wertet Ausdrücke für jede Zeile aus und ermittelt dann die Zeilenreihenfolge.
• Mehrere Sortierschlüssel erstellen hierarchische Sortierung (primär, sekundär, tertiär usw.).
• NULL ist immer der kleinste Wert in Vergleichen.
• ASC (aufsteigend) ist die Standardreihenfolge, und Sie müssen explizit (absteigend) angeben DESC .
• Sie können nach berechneten Werten sortieren, nicht nur nach gespeicherten Eigenschaften.

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  */

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              */

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

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 mithilfe von 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

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

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

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 zum Behandeln 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 und Division (*, /)
3. Addition und Subtraktion (+, -)
4. Vergleich (=, <>, , <>, , <=, ) >=
5. Logische Negation (NOT)
6. Logische Verbindung (AND)
7. Logische Disjunktion (OR)

In der vorherigen Liste wird ein Operator mit einer niedrigeren Zahl "binds enger" als ein Operator mit einer höheren Zahl. Beispiel: ist, NOT n.prop OR m.prop ist (NOT n.prop) OR m.prop aber nicht NOT (n.prop OR m.prop).

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 Multistatementkomposition

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

Entwicklung des mehrstufigen Musters

-- 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

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.

Variable Bindungs- 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

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

Die wichtigsten Unterschiede zwischen vertikaler und horizontaler Aggregation sind:

• Vertikale Aggregation fasst zeilen- oder gruppenübergreifende Zeilen zusammen 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

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

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 der praktischen Schnellstartanleitung und dem Lernprogramm , um praktische Erfahrungen zu erhalten
• Einfache Abfragen üben – Probieren Sie die Beispiele aus diesem Leitfaden mit Ihren eigenen Daten aus.
• Erlernen von Diagrammmustern – Erkunden der umfassenden Mustersyntax
• Erkunden von Datentypen – Grundlegendes zu GQL-Werten und Werttypen

Für erfahrene Benutzer:

• Erweiterte Ausdrücke – Lernen Sie GQL-Ausdrücke und -Funktionen kennen
• 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

Graph erkunden

Lernen Sie die Plattform kennen:

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

Beteiligen

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

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.
• Optimieren der GQL-Abfrageleistung in Fabric Graph – Bewährte Methoden zum Schreiben effizienter GQL-Abfragen.

Kurzverweise:

• GQL abridged reference - Syntax quick reference.
• GQL-Statuscodes – Vollständiger Fehlercodeverweis.
• Reservierte GQL-Wörter – Vollständige Liste reservierter Schlüsselwörter.

Fabric Graph:

• Graph-Datenmodelle – Grundlegendes zu Diagrammkonzepten und -modellierungen.
• Graph- und relationale Datenbanken – Unterschiede und wann sie verwendet werden sollen.
• Try Microsoft Fabric kostenlos.
• End-to-End-Lernprogramme in Microsoft Fabric.