GQL-taalhandleiding

Opmerking

Deze functie is momenteel beschikbaar als openbare preview-versie. Deze preview wordt geleverd zonder een service level agreement en wordt niet aanbevolen voor productieworkloads. Bepaalde functies worden mogelijk niet ondersteund of hebben mogelijk beperkte mogelijkheden. Voor meer informatie, zie Aanvullende Gebruiksvoorwaarden voor Microsoft Azure Previews.

De GQL Graph Query Language is de ISO-gestandaardiseerde querytaal voor grafiekdatabases. Hiermee kunt u efficiënt query's uitvoeren en werken met grafiekgegevens.

GQL wordt ontwikkeld door dezelfde ISO-werkgroep die SQL standaardiseert, wat zorgt voor consistentie en strengheid. Als je bekend bent met SQL, zul je veel overeenkomsten in GQL vinden (expressies, predicaten, types) - waardoor het makkelijker is om te beginnen. Deze handleiding biedt zowel nieuwkomers die GQL fundamentals leren en ervaren gebruikers die op zoek zijn naar geavanceerde technieken en uitgebreide referentie-informatie.

Opmerking

De officiële Internationale Standaard voor GQL is ISO/IEC 39075 Information Technology - Database Languages - GQL.

Vereiste voorwaarden

Voordat u ingaat op GQL, moet u bekend zijn met deze concepten:

• Basiskennis van databases - Ervaring met elk databasesysteem (zoals relationeel (SQL), NoSQL of graf) is nuttig
• Grafiekconcepten - Inzicht in knooppunten, randen en relaties in verbonden gegevens
• Basisprincipes van query's - Kennis van basisconcepten voor query's, zoals filteren, sorteren en aggregatie

Aanbevolen achtergrond:

• Ervaring met SQL of openCypher-talen maakt het leren van GQL-syntaxis makkelijker (ze zijn de oorsprong van GQL)
• Bekendheid met gegevensmodellering helpt bij het ontwerpen van grafiekschema's
• Inzicht in uw specifieke use-case voor grafiekgegevens

Wat u nodig hebt:

• Toegang tot Microsoft Fabric met grafiekmogelijkheden
• Voorbeeldgegevens of bereidheid om te werken met onze voorbeelden van sociale netwerken
• Eenvoudige teksteditor voor het schrijven van query's

Aanbeveling

Als u geen toegang hebt tot grafiekdatabases, begint u met het overzicht van grafiekgegevensmodellen voordat u verdergaat met deze handleiding.

Wat GQL speciaal maakt

GQL is speciaal ontworpen voor grafiekgegevens. Dit maakt het natuurlijk en intuïtief om te werken met verbonden informatie.

In tegenstelling tot SQL, dat vertrouwt op tabeljoins om relaties uit te drukken, gebruikt GQL visuele grafiekpatronen, die direct weerspiegelen hoe entiteiten verbonden zijn, waardoor queries makkelijker te lezen en te redeneren zijn.

Stel dat je mensen en hun vrienden (mensen die elkaar kennen) wilt vinden die allebei vóór 1999 zijn geboren. Zo drukt GQL dat uit met een visueel grafiekpatroon:

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

Deze query vindt vrienden (mensen die elkaar kennen) die beiden vóór 1999 zijn geboren. Het patroon (person:Person)-[:knows]-(friend:Person) toont visueel de relatiestructuur die u zoekt, net zoals het tekenen van een diagram van uw gegevens.

Basisprincipes van GQL

Voordat u ingaat op query's, moet u deze kernconcepten begrijpen die de basis vormen van GQL:

• Grafieken slaan je data op als knooppunten (entiteiten) en randen (relaties), elk met labels en eigenschappen
• Grafiektypen fungeren als schema's en definiëren welke knooppunten en randen in uw grafiek kunnen bestaan
• Beperkingen zijn aanvullende regels en beperkingen die door graftypen op grafen worden opgelegd om gegevensintegriteit af te dwingen
• Query's gebruiken instructies zoals MATCH, FILTERen RETURN om gegevens te verwerken en resultaten weer te geven
• Patronen beschrijven de grafiekstructuren die u wilt vinden met behulp van intuïtieve visuele syntaxis
• Expressies voeren berekeningen en vergelijkingen uit op uw gegevens, vergelijkbaar met SQL-expressies
• Predicaten zijn booleaanse waarde-expressies die worden gebruikt om resultaten binnen queries te filteren
• Waardetypen bepalen welke soorten waarden u kunt verwerken en opslaan

Informatie over grafiekgegevens

Als u effectief met GQL wilt werken, moet u begrijpen hoe grafiekgegevens zijn gestructureerd. Deze basis helpt u bij het schrijven van betere query's en het effectief modelleren van uw gegevens.

Knooppunten en randen: de bouwstenen

In GQL werkt u met gelabelde eigenschapsgrafieken. Een grafiek bestaat uit twee typen elementen:

Knooppunten vertegenwoordigen doorgaans de entiteiten (de zelfstandige naamwoorden) in uw systeem, zoals personen, organisaties, berichten of producten. Het zijn onafhankelijke objecten die in uw domein aanwezig zijn. Knooppunten worden ook wel hoekpunten genoemd.

Randen vertegenwoordigen relaties tussen entiteiten (de 'werkwoorden'): hoe uw entiteiten verbinding maken en communiceren. Bijvoorbeeld, mensen kennen elkaar (:knows), organisaties die in specifieke regio's opereren (:operates), of klanten die producten hebben gekocht (:purchased).
Randen worden ook wel relaties genoemd.

Elk grafiekelement heeft deze kenmerken:

• Een interne id die deze uniek identificeert
• Een of meer labels: beschrijvende namen zoals Person of knows. In Microsoft Fabric hebben grafiekranden altijd precies één label.
• Eigenschappen—naam-waardeparen die gegevens over het element opslaan (zoals firstName: "Alice" of birthday: "19730108").

Hoe grafieken zijn gestructureerd

Elke rand verbindt precies twee knooppunten: een bron en een bestemming. Deze verbinding maakt de structuur van de grafiek en laat zien hoe entiteiten zich met elkaar verhouden. De richting van randen is belangrijk: een Person wie follows een andere Person een gerichte relatie creëert.

Opmerking

Graph in Microsoft Fabric ondersteunt momenteel geen ongerichte randen.

Eigenschapsgrafieken zoals ondersteund in Microsoft Fabric zijn altijd goed gevormd, wat betekent dat elke rand twee geldige knooppunten verbindt. Als u een rand in een grafiek ziet, bevinden beide eindpunten zich in dezelfde grafiek.

Grafiekmodellen en grafiektypen

De structuur van een grafiek in Microsoft Fabric wordt beschreven door het grafiekmodel, dat fungeert als een databaseschema voor uw toepassingsdomein. Grafiekmodellen definiëren:

• Welke knooppunten en randen kunnen bestaan
• Welke labels en eigenschappen ze kunnen hebben
• Hoe knooppunten en randen verbinding kunnen maken

Grafiekmodellen zorgen ook voor gegevensintegriteit via beperkingen, met name knooppuntsleutelbeperkingen die aangeven welke eigenschappen elk knooppunt uniek identificeren.

Opmerking

Grafiekmodellen kunnen worden opgegeven met behulp van GQL-standaardsyntaxis. In dat geval worden ze grafiektypen genoemd.

Een praktisch voorbeeld: sociaal netwerk

In deze documentatie gebruiken we een voorbeeld van een sociaal netwerk om GQL-concepten te illustreren. Als u dit domein begrijpt, kunt u de voorbeelden volgen en vergelijkbare patronen toepassen op uw eigen gegevens.

Opmerking

Het sociale netwerk is een voorbeeld dat is afgeleid van de LDBC SNB (LDBC Social Network Benchmark) die is gepubliceerd door de GDC (Graph Data Council). Zie het artikel 'The LDBC Social Network Benchmark' voor meer informatie.

De sociale netwerkentiteiten

Ons sociale netwerk bevat de volgende soorten knooppunten, die entiteiten van het domein vertegenwoordigen:

Personen hebben persoonlijke gegevens, zoals namen, verjaardagen en geslachten. Ze leven in steden en vormen sociale connecties.

Locaties vormen een geografische hiërarchie:

• Steden zoals "New York" of "Londen"
• Landen/regio's zoals "Verenigde Staten" of "Verenigd Koninkrijk"
• Continenten zoals 'Noord-Amerika' of 'Europa'

Organisaties waar mensen tijd besteden:

• Universiteiten waar mensen studeren
• Bedrijven waar mensen werken

Inhoud en discussies:

• Forums met titels die berichten bevatten
• Berichten met inhoud, taal en optionele afbeeldingen
• Opmerkingen die reageren op berichten of andere opmerkingen
• Tags die inhoud categoriseren en interesses vertegenwoordigen

Hoe alles verbinding maakt

De verbindingen tussen entiteiten maken het netwerk interessant:

• Mensen kennen elkaar (vriendschappen, :knows)
• Mensen werken bij bedrijven (:workAt) of studeren aan universiteiten (:studyAt)
• Mensen maken berichten en reacties (:hasCreator)
• Mensen liken berichten en reacties (:likes)
• Berichten, forums, reacties kunnen tags hebben (:hasTag)
• Mensen hebben interesse in specifieke tags (:hasInterest)
• Forums bevatten berichten (:containerOf) en hebben leden (:hasMember) en moderators (:hasModerator)

Grafiekranden vertegenwoordigen domeinrelaties. Dit uitgebreide netwerk biedt veel mogelijkheden voor interessante query's en analyses.

Volledige schemaspecificatie weergeven

Uw eerste GQL-query's

Nu u de basisbeginselen van grafieken begrijpt, gaan we kijken hoe u query's kunt uitvoeren op grafiekgegevens met behulp van GQL. Deze voorbeelden zijn opgebouwd van eenvoudig tot complex en laten zien hoe de benadering van GQL grafiekquery's intuïtief en krachtig maakt.

Eenvoudig starten: alle personen zoeken

Laten we beginnen met de meest basale zoekopdracht mogelijk: zoek de namen (voornaam, achternaam) van alle personen (:Personen) in de grafiek.

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

Deze zoekopdracht wordt als volgt uitgevoerd:

1. MATCH zoekt naar alle knooppunten met het label Person
2. RETURN toont hun voor- en achternamen

Filteren toevoegen: specifieke personen zoeken

Laten we nu mensen zoeken met specifieke kenmerken, in dit geval iedereen met de naam Alice, en hun namen en verjaardagen tonen.

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

Deze zoekopdracht wordt als volgt uitgevoerd:

1. MATCH vindt alle knooppunten (p) gelabeld Persoon
2. FILTER knopen (p) waarvan de voornaam Alice is
3. RETURN toont hun voor- en achternaam en geboortedatum

Basisquerystructuur

Eenvoudige GQL-query's volgen allemaal een consistent patroon: een reeks instructies die samenwerken om gegevens te zoeken, filteren en retourneren. De meeste zoekopdrachten beginnen met MATCH het vinden van patronen in de grafiek en eindigen met RETURN het specificeren van de uitvoer.

Hier is een eenvoudige zoekopdracht die paren vindt van mensen die elkaar kennen en dezelfde verjaardag hebben, en vervolgens het totale aantal vrienden teruggeeft.

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

Deze zoekopdracht wordt als volgt uitgevoerd:

1. MATCH zoekt naar alle paren Person knooppunten die elkaar kennen
2. FILTER houdt alleen de paren waarbij beide personen dezelfde verjaardag hebben
3. RETURN telt hoeveel dergelijke vriendparen bestaan

Aanbeveling

Filteren kan ook rechtstreeks worden uitgevoerd als onderdeel van een patroon door een WHERE component toe te voegen. Komt bijvoorbeeld MATCH (n:Person WHERE n.age > 23) alleen overeen met Person knooppunten waarvan age de eigenschap groter is dan 23.

Opmerking

GQL ondersteunt lijnopmerkingen in C-stijl // , lijnopmerkingen in SQL-stijl -- en C-stijl /* */ blokopmerkingen.

Veelvoorkomende uitspraken

• MATCH: Identificeert het grafiekpatroon waar je naar moet zoeken—hier definieer je de structuur van de data waarin je geïnteresseerd bent.
• LET: Wijst nieuwe variabelen of berekende waarden toe op basis van gematchte gegevens—voegt afgeleide kolommen toe aan het resultaat.
• FILTER: Beperkt de resultaten door condities toe te passen—verwijdert rijen die niet aan de criteria voldoen.
• ORDER BY: Sorteert de gefilterde data—helpt de output te organiseren op basis van één of meer velden.
• OFFSET en LIMIT: Beperk het aantal teruggegeven rijen—nuttig voor paginering of top-k zoekopdrachten.
• RETURN: Specificeert de uiteindelijke output—bepaalt welke data in de resultaatset moet worden opgenomen en voert aggregatie uit.

Hoe instructies samenwerken

GQL-statements vormen een pijplijn, waarbij elke instructie de output van de vorige verwerkt. Deze sequentiële uitvoering maakt queries gemakkelijk te lezen en te debuggen omdat de uitvoeringsvolgorde overeenkomt met de leesvolgorde.

Belangrijke punten:

• Statements worden effectief achtereenvolgens uitgevoerd.
• Elke verklaring transformeert data en geeft deze door aan de volgende.
• Dit creëert een duidelijke, voorspelbare datastroom die complexe zoekopdrachten vereenvoudigt.

Belangrijk

Intern kan de uitvoering van statements worden herschikt en individuele statements parallel worden uitgevoerd door Microsoft Fabric om de prestaties te maximaliseren. Dit zal echter geen invloed hebben op de correctheid van de resultaten.

Voorbeeld

De volgende GQL-zoekopdracht vindt de eerste 10 mensen die bij bedrijven werken met "Air" in hun naam, sorteert ze op volledige naam en geeft hun volledige naam samen met de naam van hun bedrijf terug.

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

Deze zoekopdracht wordt als volgt uitgevoerd:

1. MATCH vindt mensen die werken bij bedrijven met "Air" in hun naam
2. LET maakt volledige namen door voor- en familienamen te combineren
3. FILTER houdt alleen Contoso-medewerkers
4. ORDER BY sorteert op volledige naam
5. LIMIT Neemt de eerste 10 resultaten
6. RETURN retouren, namen en bedrijfslocaties

Variabelen verbinden uw gegevens

Variabelen (zoals p, cen fullName in de vorige voorbeelden) bevatten gegevens tussen instructies. Wanneer u een variabelenaam opnieuw gebruikt, zorgt GQL er automatisch voor dat deze verwijst naar dezelfde gegevens, waardoor krachtige joinvoorwaarden worden gemaakt. Variabelen worden ook wel bindingsvariabelen genoemd.

Variabelen kunnen op verschillende manieren worden gecategoriseerd:

Door bindingsbron:

• Patroonvariabelen - gebonden door overeenkomende grafiekpatronen
• Reguliere variabelen - gebonden door andere taalconstructies

Typen patroonvariabele:

• Elementvariabelen - binden aan verwijzingswaarden voor grafiekelementen
  • Knooppuntvariabelen - binden aan afzonderlijke knooppunten
  • Edge-variabelen - binden aan afzonderlijke randen
• Padvariabelen : verbinden met padwaarden die overeenkomende paden vertegenwoordigen

Op referentiegraad:

• Singleton-variabelen - binden aan verwijzingswaarden van afzonderlijke elementen uit patronen
• Groepsvariabelen : binden aan lijsten met elementverwijzingswaarden uit patronen met variabele lengte (zie Geavanceerde aggregatietechnieken)

Resultaten en resultaten van de uitvoering

Wanneer u een query uitvoert, krijgt u een uitvoeringsresultaat dat bestaat uit:

• Een (optionele) resultaattabel met de gegevens uit uw RETURN instructie.
• Statusinformatie die aangeeft of de query is geslaagd of niet.

Resultaattabellen

De resultaattabel , indien aanwezig, is het werkelijke resultaat van de uitvoering van de query.

Een resultaattabel bevat informatie over de naam en het type van de kolommen, een voorkeurskolomnaamreeks die moet worden gebruikt voor het weergeven van resultaten, of de tabel is geordend en de werkelijke rijen zelf.

Opmerking

In het geval van een uitvoeringsfout wordt er geen resultatentabel opgenomen in het uitvoeringsresultaat.

Statusinformatie

Er worden verschillende opmerkelijke voorwaarden (zoals fouten of waarschuwingen) gedetecteerd tijdens de uitvoering van de query. Elke voorwaarde wordt vastgelegd door een statusobject in de statusinformatie van het uitvoeringsresultaat.

De statusinformatie bestaat uit een primair statusobject en een (mogelijk lege) lijst met aanvullende statusobjecten. Het primaire statusobject is altijd aanwezig en geeft aan of de uitvoering van de query is geslaagd of mislukt.

Elk statusobject bevat een statuscode van 5 cijfers (GQLSTATUS genoemd) die de opgenomen voorwaarde identificeert, evenals een bericht waarin het wordt beschreven.

Geslaagde statuscodes:

GQLSTATUS	Message	Wanneer
00000	opmerking: geslaagde voltooiing	Succes met ten minste één rij
00001	opmerking: geslaagde voltooiing - weggelaten resultaat	Geslaagd zonder tabel (momenteel niet gebruikt)
02000	opmerking: geen gegevens	Succes met nul rijen

Andere statuscodes geven verdere fouten of waarschuwingen aan die zijn gedetecteerd tijdens het uitvoeren van query's.

Volledige naslaginformatie over GQLSTATUS-codes weergeven

Belangrijk

In toepassingscode moet u altijd afhankelijk zijn van statuscodes om te testen op bepaalde voorwaarden. Statuscodes zijn gegarandeerd stabiel en hun algemene betekenis zal in de toekomst niet veranderen. Test niet op de inhoud van berichten, want het concrete bericht dat voor een statuscode wordt gerapporteerd kan in de toekomst veranderen afhankelijk van de query of zelfs tussen uitvoeringen van dezelfde query.

Daarnaast kunnen statusobjecten een onderliggend oorzaakstatusobject en een diagnostische record bevatten met meer informatie over de vastgelegde voorwaarde.

Essentiële concepten en instructies

In deze sectie worden de belangrijkste bouwstenen beschreven die u nodig hebt om effectieve GQL-query's te schrijven. Elk concept bouwt voort op praktische schrijfvaardigheden voor query's.

Grafiekpatronen: structuur zoeken

Grafiekpatronen vormen het hart van GQL-query's. Hiermee kunt u de gegevensstructuur beschrijven die u zoekt met behulp van intuïtieve, visuele syntaxis die lijkt op de relaties die u zoekt.

Eenvoudige patronen:

Begin met basisrelatiepatronen:

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

Patronen met specifieke gegevens:

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

Labelexpressies voor flexibele entiteitsselectie:

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

Opmerking

Grafiekmodellen met meerdere elementlabels worden nog niet ondersteund (bekend probleem).

Met labelexpressies kunt u verschillende soorten knooppunten in één patroon vergelijken, waardoor uw query's flexibeler worden.

Variabele hergebruik maakt krachtige joins:

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

Het hergebruik van variabelen c zorgt ervoor dat beide personen in hetzelfde bedrijf werken, waardoor een automatische joinbeperking wordt gemaakt. Dit patroon is een sleutelpatroon voor het uitdrukken van 'dezelfde entiteit'-relaties.

Belangrijk

Kritiek inzicht: variabel hergebruik in patronen creëert structurele beperkingen. Deze techniek is hoe u complexe grafiekrelaties uitdrukt, zoals 'vrienden die bij hetzelfde bedrijf werken' of 'mensen in dezelfde stad'.

Filteren op patroonniveau met 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)

Patronen met de lengte van afhankelijke variabelen:

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

TRAIL-patronen voor cyclusvrije doorkruising:

Gebruik TRAIL patronen om cycli tijdens het doorkruisen van grafieken te voorkomen, zodat elke rand maximaal één keer wordt bezocht:

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

Randbinding met variabele lengte:

In patronen met een variabele lengte leggen randvariabelen verschillende gegevens vast op basis van context:

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

Dit onderscheid is van cruciaal belang voor het correct gebruiken van randvariabelen.

Complexe patronen met meerdere relaties:

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

Met dit patroon worden personen samen met hun werkplek en woonplaats gevonden, waarin wordt getoond hoe één persoon verbinding maakt met meerdere andere entiteiten.

Uitgebreide patroonsyntaxis en geavanceerde technieken leren

Kerninstructies

GQL biedt specifieke instructietypen die samenwerken om uw grafiekgegevens stap voor stap te verwerken. Inzicht in deze instructies is essentieel voor het bouwen van effectieve query's.

MATCH verklaring

Syntaxis:

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

De MATCH instructie gebruikt invoergegevens en vindt grafiekpatronen, waarbij invoervariabelen worden gecombineerd met patroonvariabelen en alle overeenkomende combinaties worden uitgevoerd.

Invoer- en uitvoervariabelen:

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

Filteren op instructieniveau met WHERE:

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

Alle overeenkomsten kunnen nagefilterd worden met behulp van WHEREeen afzonderlijke FILTER instructie.

Samenvoegen met invoervariabelen:

Wanneer MATCH dit niet de eerste instructie is, worden invoergegevens samengevoegd met patroonovereenkomsten:

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

Belangrijk

Graph in Microsoft Fabric biedt nog geen ondersteuning voor willekeurige samenstelling van instructies. Zie het artikel over huidige beperkingen.

Gedrag van sleuteldeeling:

Hoe MATCH wordt het samenvoegen van gegevens verwerkt:

• Gelijkheid van variabelen: Invoervariabelen worden samengevoegd met patroonvariabelen met behulp van gelijkheidskoppeling
• Inner join: invoerrijen zonder patroonovereenkomsten worden verwijderd (geen links/rechts joins)
• Filtervolgorde: Filters op instructieniveau WHERE nadat het patroon is voltooid
• Patroonconnectiviteit: meerdere patronen moeten ten minste één variabele delen voor de juiste deelname
• Prestaties: Gedeelde variabelen maken efficiënte joinbeperkingen

Belangrijk

Beperking: Als dit MATCH niet de eerste instructie is, moet ten minste één invoervariabele worden samengevoegd met een patroonvariabele. Meerdere patronen moeten één variabele gemeen hebben.

Voor meerdere patronen zijn gedeelde variabelen vereist:

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

Syntaxis:

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

De LET instructie maakt berekende variabelen en maakt gegevenstransformatie mogelijk binnen uw querypijplijn.

Basisvariabele maken:

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

Complexe berekeningen:

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

Sleutelgedrag:

• Expressies worden geëvalueerd voor elke invoerrij
• Resultaten worden nieuwe kolommen in de uitvoertabel
• Variabelen kunnen alleen verwijzen naar bestaande variabelen uit eerdere instructies
• Meerdere toewijzingen in één LET worden parallel geëvalueerd (geen kruisverwijzingen)

FILTER verklaring

Syntaxis:

FILTER [ WHERE ] <predicate>

De FILTER instructie biedt nauwkeurige controle over welke gegevens worden uitgevoerd via uw querypijplijn.

Basisfiltering:

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

Complexe logische voorwaarden:

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

Null-bewuste filterpatronen:

Gebruik deze patronen om null-waarden veilig te verwerken:

• Controleer op waarden: p.firstName IS NOT NULL - heeft een voornaam
• Gegevens valideren: p.id > 0 - geldige id
• Ontbrekende gegevens verwerken: NOT coalesce(p.locationIP, '127.0.0.1') STARTS WITH '127.0.0' - heeft geen verbinding gemaakt vanuit het lokale netwerk
• Voorwaarden combineren: Gebruiken AND/OR met expliciete null-controles voor complexe logica

Waarschuwing

Houd er rekening mee dat voorwaarden met betrekking tot null-waarden retourneren UNKNOWN, waarmee deze rijen worden gefilterd. Gebruik expliciete IS NULL controles wanneer u null-inclusive logica nodig hebt.

ORDER BY verklaring

Syntaxis:

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

Sorteren op meerdere niveaus met berekende expressies:

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)

Null-verwerking bij sorteren:

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

Details van sorteergedrag:

Meer informatie over de werking ORDER BY :

• Expressie-evaluatie: Expressies worden geëvalueerd voor elke rij en de resultaten bepalen de rijvolgorde
• Meerdere sorteersleutels: hiërarchische volgorde maken (primair, secundair, tertiair, enzovoort)
• Null-verwerking: NULL wordt altijd behandeld als de kleinste waarde in vergelijkingen
• Standaardvolgorde: ASC (oplopend) is standaard( DESC aflopend) moet expliciet worden opgegeven
• Berekende sortering: u kunt sorteren op berekende waarden, niet alleen opgeslagen eigenschappen

Waarschuwing

De sorteervolgorde die is ingesteld ORDER BY op, is alleen zichtbaar voor de direct volgende instructie. Dus, ORDER BY gevolgd door RETURN * , produceert GEEN geordende resultaat.

Vergelijken:

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

met:

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

Dit heeft onmiddellijke gevolgen voor top-k-query's: LIMIT moet altijd de ORDER BY instructie volgen waarmee de beoogde sorteervolgorde is vastgesteld.

OFFSET en LIMIT uitspraken

Syntaxis:

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

Algemene patronen:

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

Belangrijk

Voor voorspelbare pagineringsresultaten moet ORDER BY u altijd vóór OFFSET en LIMIT voor een consistente rijvolgorde voor query's zorgen.

RETURN: basisresultaatprojectie

Syntaxis:

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

De RETURN instructie produceert de uiteindelijke uitvoer van uw query door op te geven welke gegevens worden weergegeven in de resultatentabel.

Basisuitvoer:

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

Aliassen gebruiken voor duidelijkheid:

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

Combineren met sorteren en 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

Dubbele verwerking met 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

Combineren met aggregatie:

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

RETURN met GROUP BY: gegroepeerde resultaatprojectie

Syntaxis:

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

Hiermee GROUP BY kunt u rijen groeperen op basis van gedeelde waarden en statistische rekenfuncties binnen elke groep.

Basisgroepering met aggregatie:

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

Groeperen met meerdere kolommen:

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

Opmerking

Zie Geavanceerde aggregatietechnieken voor geavanceerde aggregatietechnieken, waaronder horizontale aggregatie over patronen met variabele lengte.

Gegevenstypen: werken met waarden

GQL ondersteunt uitgebreide gegevenstypen voor het opslaan en bewerken van verschillende soorten informatie in uw grafiek.

Basiswaardetypen:

• Getallen: INT64, UINT64voor DOUBLE berekeningen en metingen
• Tekst: STRING voor namen, beschrijvingen en tekstuele gegevens
• Logica: BOOL met drie waarden: TRUE, FALSE en UNKNOWN (voor null-verwerking)
• Tijd: ZONED DATETIME voor tijdstempels met tijdzone-informatie
• Verzamelingen: LIST<T> voor meerdere waarden van hetzelfde type T, PATH voor resultaten van graafdoorloop.
• Grafiekelementen: NODE en EDGE voor het verwijzen naar grafiekgegevens

Belangrijk

Bepaalde waardetypes worden niet ondersteund als de soorten vastgoedwaarden. In het bijzonder kunnen alle waarden met referentiewaarden van graafelementen niet als eigenschapswaarden worden gebruikt (zoals lijsten van knopen of paden).

Voorbeeld van letterlijke waarden:

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

Kritieke null-verwerkingspatronen:

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

Gevolgen voor logica met drie waarden:

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

Waarschuwing

Logica met drie waarden betekent NULL = NULL retourneert UNKNOWN, niet TRUE. Dit gedrag is van invloed op filteren en samenvoegen. Altijd gebruiken IS NULL voor null-tests.

Meer informatie over uitgebreide systeemdetails van het type

Expressies: gegevens transformeren en analyseren

Met expressies kunt u gegevens in uw query's berekenen, vergelijken en transformeren. Ze zijn vergelijkbaar met expressies in SQL, maar hebben extra functies voor het verwerken van grafiekgegevens.

Algemene expressietypen:

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

Complexe predicaatsamenstelling:

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

Tekenreekspatroonovereenkomst:

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

Ingebouwde functies per categorie:

GQL biedt deze functiecategorieën voor verschillende gegevensverwerkingsbehoeften:

• Statistische functies: count(), sum(), avg(), , min()voor max() het samenvatten van gegevens
• Tekenreeksfuncties: char_length(), upper(), lower(), voor trim() tekstverwerking
• Grafiekfuncties: nodes(), edges(), labels() voor het analyseren van grafiekstructuren
• Algemene functies: voor het coalesce() correct verwerken van null-waarden

Operatorprioriteit voor complexe expressies:

1. Toegang tot eigenschappen (.)
2. Vermenigvuldiging/deling (*, /)
3. Optellen/aftrekken (+, -)
4. Vergelijking (=, <>, <, >, , <=) >=
5. Logische negatie (NOT)
6. Logische combinatie (AND)
7. Logische scheiding (OR)

In bovenstaande lijst bindt een operator met een lager nummer "strakker" dan een operator met een hoger nummer. Voorbeeld: NOT n.prop OR m.prop is (NOT n.prop) OR m.prop maar niet 'NIET (n.prop OF m.prop)

Aanbeveling

Gebruik haakjes om prioriteit expliciet te maken. Complexe expressies zijn gemakkelijker te lezen en fouten op te sporen wanneer groepering duidelijk is.

Uitgebreide expressiesyntaxis en alle ingebouwde functies leren

Geavanceerde querytechnieken

In deze sectie worden geavanceerde patronen en technieken beschreven voor het bouwen van complexe, efficiënte grafiekquery's. Deze patronen gaan verder dan het gebruik van basisinstructie om u te helpen krachtige analytische query's op te stellen.

Complexe samenstelling met meerdere instructies

Belangrijk

Graph in Microsoft Fabric biedt nog geen ondersteuning voor willekeurige samenstelling van instructies. Zie het artikel over huidige beperkingen.

Inzicht in het efficiënt opstellen van complexe query's is cruciaal voor geavanceerde grafiekquery's.

Voortgang van patroon met meerdere stappen:

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

Deze zoekopdracht bouwt geleidelijk complexiteit op: zoek bedrijven, hun medewerkers, werknemerslocaties, filter bedrijven met werknemers die vóór 1985 zijn geboren, bereken de gemiddelde verjaardag en vat de resultaten samen en sorteer.

Gebruik van horizontale aggregatie:

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

Opmerking

Deze query wordt nog niet ondersteund (bekend probleem).

Variabel bereik en geavanceerd stroombeheer

Variabelen verbinden gegevens tussen query-instructies en maken complexe grafiekkruisingen mogelijk. Door geavanceerde bereikregels te begrijpen, kunt u geavanceerde query's met meerdere instructies schrijven.

Variabele bindings- en bereikpatronen:

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

Variabele hergebruik voor joins in instructies:

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

Kritieke bereikregels en -beperkingen:

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

Variabele zichtbaarheid in complexe query's:

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

Waarschuwing

Variabelen in dezelfde instructie kunnen niet naar elkaar verwijzen (behalve in grafiekpatronen). Gebruik afzonderlijke instructies voor het maken van afhankelijke variabelen.

Geavanceerde aggregatietechnieken

GQL ondersteunt twee verschillende typen aggregatie voor het analyseren van gegevens in groepen en verzamelingen: verticale aggregatie met GROUP BY en horizontale aggregatie over patronen met variabele lengte.

Verticale aggregatie met GROUP BY

Verticale aggregatie (bedekt metRETURNGROUP BY) groepeert rijen op gedeelde waarden en berekeningen in elke groep:

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

Met deze benadering wordt één resultaatrij per bedrijf gemaakt, waarbij alle werknemers binnen elke groep worden samengevoegd.

Horizontale aggregatie met groepslijstvariabelen

Horizontale aggregatie berekent aggregaties over verzamelingen die afhankelijk zijn van patronen met een variabele lengte. Wanneer u randen met een variabele lengte gebruikt, wordt de randvariabele een groepslijstvariabele met alle randen in elk overeenkomend pad:

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

Opmerking

Deze query wordt nog niet ondersteund (bekend probleem).

Belangrijkste verschillen:

• Verticale aggregatie geeft een overzicht van rijen - of - groepeert rijen en geeft een overzicht van rijen in elke groep
• Horizontale aggregatie bevat een overzicht van elementen binnen afzonderlijke randverzamelingen
• Groepslijstvariabelen zijn alleen afkomstig van randpatronen met variabele lengte

Contexten voor randbinding met variabele lengte

Informatie over hoe randvariabelen worden verbonden in patronen met een variabele lengte, is van cruciaal belang:

Tijdens patroonkoppeling (singletoncontext):

-- 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 resultaatexpressies (groepscontext):

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

Opmerking

Deze query wordt nog niet ondersteund (bekend probleem).

Verticale en horizontale aggregatie combineren

U kunt beide aggregatietypen combineren in geavanceerde analysepatronen:

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

Opmerking

Deze query wordt nog niet ondersteund (bekend probleem).

Aanbeveling

Horizontale aggregatie heeft altijd voorrang op verticale aggregatie. Als u een groepslijst wilt converteren naar een gewone lijst, gebruikt u collect_list(edges).

Opmerking

Zie GQL-expressies en -functies voor gedetailleerde naslaginformatie over statistische functies.

Strategieën voor foutafhandeling

Inzicht in veelvoorkomende foutpatronen helpt u bij het schrijven van robuuste query's.

Ontbrekende gegevens probleemloos verwerken:

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 *

Expliciete null-controles gebruiken:

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 *

Aanvullende informatie

GQLSTATUS-codes

Zoals uitgelegd in de sectie over queryresultaten, rapporteert GQL uitgebreide statusinformatie met betrekking tot het slagen of mogelijke mislukken van de uitvoering. Zie de referentie voor GQL-statuscodes voor de volledige lijst.

Gereserveerde woorden

GQL behoudt bepaalde trefwoorden voor die u niet kunt gebruiken als id's, zoals variabelen, eigenschapsnamen of labelnamen. Zie de referentie voor gereserveerde GQL-woorden voor de volledige lijst.

Als u gereserveerde woorden als id's wilt gebruiken, escapet u deze met backticks: `match`, `return`.

Gebruik deze naamconventie om te voorkomen dat gereserveerde woorden worden gebruikt:

• Voeg voor id's met één woord een onderstrepingsteken toe: :Product_
• Voor id's met meerdere woorden gebruikt u camelCase of PascalCase: :MyEntity, , :hasAttributetextColor

Volgende stappen

Nu u de basisprincipes van GQL begrijpt, is dit uw aanbevolen leertraject:

Ga door met het bouwen van uw GQL-vaardigheden

Voor beginners:

• De quickstart uitproberen - Volg onze praktische zelfstudie voor praktische ervaring
• Basisquery's oefenen - Probeer de voorbeelden uit deze handleiding met uw eigen gegevens
• Grafiekpatronen leren - De uitgebreide patroonsyntaxis beheren
• Gegevenstypen verkennen - Inzicht in GQL-waarden en -waardetypen

Voor ervaren gebruikers:

• Geavanceerde expressies - Hoofd-GQL-expressies en -functies
• Schemaontwerp - Meer informatie over GQL-grafiektypen en -beperkingen
• Gegevenstypen verkennen - Inzicht in GQL-waarden en -waardetypen

Referentiemateriaal

Houd deze verwijzingen bij de hand voor snelle zoekopdrachten:

• GQL-snelzoekgids - Snelzoekgids voor syntaxis
• GQL-statuscodes - Naslaginformatie over foutcodes voltooien
• Gereserveerde GQL-woorden - Volledige lijst met gereserveerde trefwoorden

Microsoft Fabric verkennen

Meer informatie over het platform:

• Grafiekgegevensmodellen - Inzicht in grafiekconcepten en -modellering
• Grafiek versus relationele databases - De juiste benadering kiezen
• Microsoft Fabric gratis uitproberen - Krijg praktische ervaring
• End-to-end zelfstudies - Volledige leerscenario's

Doe mee

• Feedback delen - Help onze documentatie en hulpprogramma's te verbeteren
• Deelnemen aan de community - Verbinding maken met andere grafiekdatabasebeoefenaars
• Blijf op de hoogte - Volg aankondigingen van Microsoft Fabric voor nieuwe functies

Aanbeveling

Begin met de quickstart-zelfstudie als u liever leert door te doen of duik eerst in grafiekpatronen als u de querytaal wilt beheersen.

Verwante inhoud

Meer informatie over belangrijke onderwerpen:

• Voorbeeld van schema voor sociaal netwerk - Werkvoorbeeld van grafiekschema voltooien
• GQL-grafiekpatronen - Uitgebreide patroonsyntaxis en geavanceerde overeenkomende technieken
• GQL-expressies en -functies - Alle expressietypen en ingebouwde functies
• GQL-grafiektypen - Grafiektypen en -beperkingen
• GQL-waarden en -waardetypen - Volledige typesysteemverwijzing en -waardeafhandeling

Snelle verwijzingen:

• GQL verkorte verwijzing - Snelzoekgids voor syntaxis
• GQL-statuscodes - Naslaginformatie over foutcodes voltooien
• Gereserveerde GQL-woorden - Volledige lijst met gereserveerde trefwoorden

Grafiek in Microsoft Fabric:

• Grafiekgegevensmodellen - Inzicht in grafiekconcepten en -modellering
• Grafiek- en relationele databases : verschillen en wanneer u elk van deze databases wilt gebruiken
• Microsoft Fabric gratis uitproberen
• End-to-end handleidingen in Microsoft Fabric