GQL-taalhandleiding voor grafiek in Microsoft Fabric

GQL (Graph Query Language) is de ISO-gestandaardiseerde querytaal voor grafiekdatabases. Gebruik GQL om efficiënt met grafiekgegevens query's uit te voeren, te analyseren en te werken met grafiekgegevens in Microsoft Fabric.

Dezelfde ISO-werkgroep die SQL standaardiseert, ontwikkelt GQL. Als gevolg hiervan deelt GQL veel concepten met SQL, waaronder expressies, predicaten en gegevenstypen. Als u sql-ervaring hebt, kunt u veel van die kennis toepassen op GQL.

Dit artikel is de end-to-end gids voor GQL in graph. Het legt uit hoe de taal in elkaar past en verlinkt naar gerichte referenties voor volledige syntaxis- en typedetails. Hierin wordt het volgende behandeld:

  • Kernconcepten: Grafiekgegevensstructuren, patronen en query grondbeginselen
  • Essentiële uitspraken: MATCH, FILTER, LET, , WHEN, ORDER BY, LIMIT, en RETURN
  • Gegevenstypen en expressies: Waardetypen, operators en ingebouwde functies
  • Geavanceerde technieken: samenstelling van meerdere instructies, variabele bereik- en aggregatiestrategieën

Opmerking

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

Als je op zoek bent naar taakgerichte begeleiding in plaats van een taalgids, bekijk dan de handleidingen:

Gebruik de gerichte referentieartikelen wanneer je volledige details nodig hebt:

Benodigde informatie Definitief artikel
Syntaxis in één oogopslag Snelzoekgids voor GQL
Syntaxis van knooppunt-, rand-, pad- en patrooncomposities GQL-grafiekpatronen
Operatoren, predicaten en functies GQL-expressies, predicaten en functies
Letterlijke syntaxis, waardegedrag en typeconversies GQL-waarden en -waardetypen
Graftypedefinities en beperkingen GQL-grafiektypen
Huidige ISO GQL-functiedekking GQL-standaardconformiteit
Huidige Fabric-specifieke beperkingen en limieten Huidige beperkingen

Vereiste voorwaarden

Voordat u begint, moet u ervoor zorgen dat u bekend bent met deze concepten:

  • Basic understanding of databases - Ervaring met elk databasesysteem, zoals relationele (SQL), NoSQL of grafiek, is handig.
  • 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 eenvoudiger (ze zijn de hoofdmappen 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 een grafiekwerkruimte met querymogelijkheden.
  • Voorbeeldgegevens of bereidheid om met onze voorbeelden van sociale netwerken te werken.
  • 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 specifiek ontworpen voor graafgegevens, dus de syntaxis drukt direct uit hoe entiteiten verbonden zijn. Waar SQL vaak relaties uitdrukt via joins tussen tabellen, gebruikt GQL grafiekpatronen die lijken op diagrammen van de data.

Bijvoorbeeld, de volgende zoekopdracht vindt paren mensen die elkaar kennen en beiden vóór 1999 zijn geboren:

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

Het patroon (person:Person)-[:knows]-(friend:Person) toont de relatiestructuur die overeenkomt. Variabelen binden de twee personen zodat de query kan filteren en hun eigenschappen kan teruggeven.

Basisprincipes van GQL

Deze concepten vormen de basis van GQL:

  • Grafen bevatten knooppunten en randen met labels en eigenschappen.
  • Graftypen definiëren formeel de knooptypes, randtypes en beperkingen die in een graaf zijn toegestaan.
  • Queries gebruiken statements zoals MATCH, FILTER, en RETURN om data te verwerken en resultaten te produceren.
  • Patronen beschrijven de grafiekstructuren die overeenkomen.
  • Expressies berekenen, transformeren en vergelijken waarden.
  • Predicaten zijn Booleaanse expressies die worden gebruikt om voorwaarden te testen.
  • Waardetypes definiëren de soorten waarden die queries kunnen verwerken en welke grafeigenschappen kunnen opslaan.

Begrijp graafgegevens

Om met GQL te werken, moet je de structuur van de gelabelde eigenschapsgrafiek begrijpen die de taal zoekt.

Knooppunten en randen: de bouwstenen

Een gelabelde eigenschapsgrafiek bevat twee soorten graafelementen:

  • Nodes vertegenwoordigen doorgaans entiteiten, zoals mensen, organisaties, berichten of producten.
  • Randen vertegenwoordigen verbindingen tussen knooppunten, zoals iemand die een ander kent of bij een bedrijf werkt.

Elk grafelement heeft een interne identiteit, één of meer labels, en een set eigenschappen. Labels classificeren elementen, zoals Person of knows. Eigenschappen zijn naam-waardeparen, zoals firstName: 'Alice' of birthday: 19730108u. In Graph heeft een rand altijd precies één label.

Elke rand verbindt precies twee knooppunten: een oorsprong en een doelwit. De zijrichting maakt deel uit van de structuur van de graaf. Een workAt rand kan bijvoorbeeld een Person oorsprong verbinden met een Company doelwit.

Opmerking

Graph ondersteunt momenteel geen ongerichte randen. Je kunt een bestaande gerichte rand in beide richtingen bevragen door een willekeurig gerichte randpatroon te gebruiken, -[:knows]-zoals .

Grafen zijn goed gevormd: elke zijde verbindt twee knopen die in dezelfde graaf bestaan.

Grafiekmodellen en grafiektypen

Een Fabric-grafiekmodel definieert de knooptypen, randtypes, eigenschappen, bronkaarten en sleutels die beschikbaar zijn in een graaf. Het specificeert welke bron-tabel rijen knooppunten en randen worden en hoe die elementen met elkaar verbonden zijn. Voor modelleerrichtlijnen, zie Design a graph schema.

De GQL-standaard gebruikt een graaftype om formeel toegestane knooppunttypes, randtypes, eigenschappen en beperkingen te beschrijven. Graftypen zijn het taalniveau tegenhanger van de structuur die wordt weergegeven door een Fabric-grafmodel, maar Graph accepteert momenteel geen GQL-graftype-declaraties direct. Voor de formele syntaxis en concepten, zie GQL-graftypes.

Voorbeeldgrafiek gebruikt in deze gids

Voorbeelden gebruiken de voorbeelddataset van sociale netwerken, die mensen, plaatsen, organisaties, berichten, tags en de randen die deze verbinden bevat.

De voorbeeldgrafiek verbindt deze gebieden:

  • Mensen kennen anderen, werken bij bedrijven en studeren aan universiteiten.
  • Steden, landen of regio's en continenten vormen een geografische hiërarchie.
  • Forums bevatten berichten, en mensen maken berichten en reacties.
  • Tags categoriseren inhoud en vertegenwoordigen de interesses van mensen.

Diagram met het schema van het sociale netwerk.

Voor de volledige voorbeeldstructuur, zie het voorbeeld van het sociale netwerkschema. Voor algemene grafconcepten, zie Gelabelde eigenschapsgrafieken.

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

Begin met de meest eenvoudige query die mogelijk is. Zoek de namen (voornaam, achternaam) van alle personen (:Persons) in de grafiek.

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

Deze query wordt als volgt uitgevoerd:

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

Filteren toevoegen: specifieke personen zoeken

Zoek nu personen met specifieke kenmerken. Zoek in dit geval iedereen met de naam Alice en geef hun namen en verjaardagen weer.

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

Deze query wordt als volgt uitgevoerd:

  1. MATCH zoekt naar alle knooppunten (p) met het label Persoon.
  2. FILTER knooppunten (p) waarvan de voornaam Alice is.
  3. RETURN toont hun voornaam, achternaam en verjaardag.

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 query wordt als volgt uitgevoerd:

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

Aanbeveling

Je kunt ook direct filteren in een patroon door een WHERE clausule toe te voegen. Bijvoorbeeld, MATCH (n:Person WHERE n.birthday < 19900101) alleen knopen matchen Person met een birthday waarde vóór 1990.

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.
  • FOR: Breidt een lijst uit tot rijen, met een optionele nul-gebaseerde offset of één-gebaseerde ordinaalpositie.
  • CALL: Voert een inline subquery uit voor elke invoerrij en voegt de kolommen op die door de subquery worden teruggegeven.
  • 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.
  • NEXT: Start een nieuwe queryfase door gebruik te maken van de kolommen die uit de vorige fase zijn teruggegeven.

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 proces maakt een duidelijke, voorspelbare gegevensstroom die complexe query's vereenvoudigt.
  • NEXT start een nieuwe queryfase. Alleen kolommen die door de voorgaande RETURN verklaring worden geprojecteerd, zijn beschikbaar in de volgende fase.
  • UNION, UNION DISTINCT, en UNION ALL de resultaten van volledige queryblokken combineren.

Opmerking

Uitspraken hebben een gedefinieerde logische volgorde. Schrijf queries volgens deze datastroom in plaats van te vertrouwen op een specifieke fysieke uitvoeringsstrategie.

Voorbeeld van de samenstelling van de instructie

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 query wordt als volgt uitgevoerd:

  1. MATCH Vindt mensen die bij bedrijven werken.
  2. LET maakt volledige namen door voor- en familienamen te combineren.
  3. FILTER houdt alleen werknemers van bedrijven met "Air" in hun bedrijfsnaam.
  4. ORDER BY sorteert op volledige naam.
  5. LIMIT neemt de eerste 10 resultaten.
  6. RETURN Retourneert volledige namen en bedrijfsnamen.

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.

U kunt variabelen op verschillende manieren categoriseren:

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
  • Groepvariabelen - bind aan lijsten van elementreferentiewaarden uit patronen met variabele lengte. Voor details, zie Aggregate functies.

Resultaten en resultaten van de uitvoering

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

  • Een resultaat, meestal een resultaattabel met de gegevens uit je RETURN statement.
  • Statusinformatie die laat zien 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

Als de uitvoering mislukt, wordt er geen resultatentabel opgenomen in het uitvoeringsresultaat.

Weggelaten resultaten

GQL definieert ook een weggelaten resultaat voor statements die nooit rijen produceren, onafhankelijk van de data of het evaluatieresultaat. Een weggelaten resultaat heeft de statuscode 00001succesvolle voltooiing .

Een weggelaten resultaat verschilt van een lege resultaattabel. Een lege tabel betekent dat een rij-producerende query is geëvalueerd maar geen rijen heeft opgeleverd. De Query API kan een weggelaten resultaat met resultaattype NOTHINGrepresenteren.

Grafiekreserves ontsloegen resultaten voor toekomstige ondersteuning van data definition language (DDL) en data manipulation language (DML) statements. Huidige query-statements leveren tabelresultaten, inclusief lege tabellen.

Statusinformatie

Tijdens het uitvoeren van query's detecteert het proces verschillende opmerkelijke voorwaarden, zoals fouten of waarschuwingen. 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 andere statusobjecten. Het primaire statusobject bestaat altijd en geeft aan of de uitvoering van de query is geslaagd of mislukt.

Elk statusobject bevat een alfanumerieke code van vijf tekens en een beschrijving van de geregistreerde conditie.

De Query API gebruikt de volgende primaire statuscodes:

API-statuscode Meaning
00000 Succesvolle voltooiing met ten minste één rij.
00001 Succesvolle voltooiing met een weggelaten resultaat. Gereserveerd voor toekomstige DDL- en DML-ondersteuning.
01000 Een waarschuwing of informatieve voorwaarde.
02000 Er zijn momenteel geen rijen beschikbaar voor een rij-producerende zoekopdracht.
42000 Een door de gebruiker corrigeerbare queryfout.
50000 Een systeem- of niet-geclassificeerde fout.

De API behoudt de canonieke GQLSTATUS die door de query-engine wordt gerapporteerd in het _graphaneGqlStatus lid van het diagnostische record. Bijvoorbeeld, numerieke overflow gebruikt canonieke GQLSTATUS 22003, terwijl deling door nul gebruikt 22012; beide worden weergegeven door 42000 in het publieke status.code veld.

Belangrijk

In applicatiecode, gebruik status.code het voor breed succes en foutafhandeling. Gebruik de canonieke GQLSTATUS-diagnose wanneer je een specifieke queryvoorwaarde moet onderscheiden. Test de beschrijving niet omdat die kan variëren.

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

Bekijk de referentie van GQL-statuscodes

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: vind structuur

Een grafiekpatroon beschrijft de knooppunten, ribben en paden die overeenkomen. Bind variabelen wanneer latere statements moeten verwijzen naar gematchte elementen:

MATCH (person:Person)-[employment:workAt]->(company:Company)
RETURN person.firstName, company.name, employment.workFrom

Plaats een predicaat in lijn wanneer het definieert welke knoop of rand aan het patroon kan deelnemen:

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

Hergebruik een variabele zodat twee patroonposities nodig zijn om hetzelfde element te binden. Scheid patronen met komma's om grotere graafstructuren samen te stellen. Gebruik een kwantor zoals {1,4} om een randpatroon te herhalen en paden met variabele lengte te matchen.

Padmodi regelen het hergebruik van elementen binnen een pad:

Padmodus Gedrag
WALK Staat herhaalde knooppunten en randen toe. Deze modus is de standaardinstelling.
TRAIL Voorkomt herhaalde randen.
SIMPLE Voorkomt herhaalde knooppunten behalve voor een gedeelde eerste en laatste knoop.
ACYCLIC Voorkomt alle herhaalde knooppunten.

Een padzoekprefix bepaalt welke overeenkomende paden worden teruggegeven. ALL is de standaardwaarde. ANY SHORTEST geeft één kortste pad terug voor elk bron-bestemmingspaar:

MATCH path = ANY SHORTEST
  (source:Person WHERE source.id = 123u)-[:knows]->{1,4}(target:Person)
RETURN target.id, path_length(path) AS hopCount

Inline predicaten beperken de padgeschiktheid vóór padselectie. Instructieniveau MATCH ... WHERE - en latere FILTER operaties zijn postfilters. Dit onderscheid kan de resultaten veranderen ANY SHORTEST .

Voor definitieve semantiek van knoop-, rand-, pad-, compositie-, kwantor- en predicaatplaatsing, zie GQL-grafiekpatronen. Voor huidige padbeperkingen, zie Huidige beperkingen.

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. Hiermee worden invoervariabelen samengevoegd met patroonvariabelen en worden alle overeenkomende combinaties 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 behulp van WHERE:

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

U kunt alle overeenkomsten nafilteren met behulp van WHERE. Deze aanpak voorkomt een afzonderlijke FILTER instructie. Bij een padzoekvoorvoegsel zoals ANY SHORTEST, geldt het statement-niveau WHERE na padselectie. Inline predicaten beperken in plaats daarvan welke paden in aanmerking komen voor selectie. Voor meer informatie, zie Plaats predicaten vóór of na padselectie.

Deelnemen met behulp van 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

Graaf ondersteunt basis- en volledige lineaire statementcompositie, inclusief NEXT. Je kunt ook queryblokken combineren met UNION, UNION DISTINCT, en UNION ALL. De EXCEPT, INTERSECT, en OTHERWISE set-operaties worden nog niet ondersteund. Zie het artikel over huidige beperkingen voor meer informatie.

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. Gebruik OPTIONAL MATCH dit voor left-outer-joingedrag.
  • Filtervolgorde: Filters op instructieniveau WHERE na patroonafstemming en padselectie voltooid
  • Patrooncompositie: Gedeelde variabelen beperken patronen tot hetzelfde element. Niet-samenhangende patronen vormen een Cartesiaans product.

Belangrijk

Een niet-samenhangend patroon is geldig, maar het Cartesische product ervan kan veel rijen creëren. Gebruik gedeelde variabelen wanneer de patronen naar dezelfde graafelementen zouden moeten verwijzen.

Join-patronen met gedeelde variabelen:

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

OPTIONAL MATCH verklaring

Syntaxis:

OPTIONAL MATCH <graph pattern> [ WHERE <predicate> ]

OPTIONAL MATCH werkt als MATCH , maar maakt gebruik van semantiek left-outer-join. Als het patroon geen overeenkomst vindt voor een invoerrij, behoudt de query de rij met NULL waarden voor niet-overeenkomende variabelen in plaats van deze te verwijderen.

Example:

-- Find all people and, if available, their workplace
MATCH (p:Person)
OPTIONAL MATCH (p)-[:workAt]->(c:Company)
RETURN p.firstName, p.lastName, c.name AS company_name

Mensen die niet in een bedrijf werken, worden nog steeds weergegeven in de resultaten voor NULLcompany_name.

Aanbeveling

Gebruik OPTIONAL MATCH deze functie als u entiteiten wilt opnemen die mogelijk geen bepaalde relatie hebben, vergelijkbaar met een SQL LEFT JOIN.

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:

  • De query-engine evalueert expressies voor elke invoerrij.
  • De resultaten worden nieuwe kolommen in de uitvoertabel.
  • Variabelen kunnen alleen verwijzen naar bestaande variabelen uit eerdere instructies.
  • Meerdere toewijzingen in één LET statement gebruiken dezelfde inputscope, dus een opdracht kan geen andere opdracht uit die instructie verwijzen.

FOR verklaring

Syntaxis:

FOR <variable> IN <list_expression>
  [ WITH OFFSET <offset_variable> | WITH ORDINALITY <ordinality_variable> ]

De FOR verklaring breidt een lijst uit tot rijen. Voor elke invoerrij wordt één uitvoerrij voor elk lijstelement verzonden en dat element gebonden aan de gespecificeerde variabele. Andere variabelen uit de invoerrij blijven beschikbaar.

Gebruik WITH OFFSET om een nul-gebaseerde index te binden, of gebruik WITH ORDINALITY om een één-gebaseerde positie te binden.

LET cities = ['Seattle', 'London', 'Tokyo']
FOR city IN cities WITH ORDINALITY position
RETURN city, position

Deze query geeft één rij voor elke stad terug. De position waarden zijn 1, 2, en 3. Als je vervangt WITH ORDINALITY position met WITH OFFSET position, zijn 0de waarden , 1, en 2.

De bronexpressie moet evalueren naar een lijst. Een niet-lijstwaarde veroorzaakt dat de query faalt.

CALL verklaring

Gebruik CALL om een inline subquery uit te voeren voor elke invoerrij:

CALL {
  <query statements>
  RETURN <columns>
}

Variabelen die al binnen de scope vallen, zijn impliciet beschikbaar binnen de subquery. Van de variabelen die binnen de subquery worden aangemaakt, zijn alleen kolommen uit de eindstatement RETURN buiten deze stelling beschikbaar. Variabelen die binnen de subquery worden aangemaakt maar niet worden teruggegeven, blijven lokaal.

De volgende gecorreleerde subquery berekent een aantal werkgevers voor elke persoon:

MATCH (p:Person)
CALL {
  MATCH (p)-[:workAt]->(company:Company)
  RETURN count(*) AS employerCount
}
RETURN p.firstName, p.lastName, employerCount
ORDER BY employerCount DESC

Een gewone CALL gedraagt zich als een afhankelijke innerlijke join. Het produceert één uitvoerrij voor elke rij die door de subquery wordt teruggegeven. Als de subquery geen rijen teruggeeft, wordt de overeenkomstige buitenste rij niet teruggegeven. Als er meerdere rijen worden teruggegeven, verschijnt de buitenste rij één keer voor elke subqueryrij.

Het voorgaande count(*) voorbeeld geeft altijd één subqueryrij terug omdat het een niet-gegroepeerd aggregaat gebruikt. Iemand zonder een passende werkgever heeft dus een employerCount van 0.

Gebruik OPTIONAL CALL als een afhankelijke linker join. Wanneer de subquery geen rijen teruggeeft, behoudt hij één buitenste rij en zet hij de teruggegeven subquerykolommen op NULL. Wanneer de subquery meerdere rijen teruggeeft, produceert deze één uitvoerrij voor elke subquery-rij.

MATCH (p:Person)
OPTIONAL CALL {
  MATCH (p)-[:workAt]->(company:Company)
  RETURN company.name AS companyName
}
RETURN p.firstName, p.lastName, companyName

Je kunt inline CALL subqueries nesten. Een geneste subquery kan variabelen verwijzen uit de omsluitende queryscopes.

Belangrijk

Beëindig elke inline CALL body met RETURN. Graph ondersteunt geen benoemde procedure-aanroepen of expliciete variabelenimportlijsten zoals CALL (p) { ... }.

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, '10.x.x.x') STARTS WITH '10.x.x.x' - 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 ] [ NULLS FIRST | NULLS LAST ],
         <expression> [ ASC | DESC ] [ NULLS FIRST | NULLS LAST ], ...

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:

MATCH (p:Person)
RETURN p.firstName, p.birthday
ORDER BY p.birthday DESC NULLS LAST, p.firstName ASC

Details van sorteergedrag:

Meer informatie over de werking ORDER BY :

  • De query-engine evalueert expressies voor elke rij en vervolgens bepalen de resultaten de rijvolgorde.
  • Meerdere sorteersleutels maken hiërarchische volgorde (primaire, secundaire, tertiaire enzovoort).
  • NULLS FIRST plaatst nulwaarden vóór niet-nul waarden. NULLS LAST plaatst ze na niet-nul waarden.
  • Nullplaatsing is onafhankelijk van de sorteerrichting. Als je null ordening niet specificeert, NULLS LAST is de standaard voor zowel ASC als DESC.
  • ASC (oplopend) is de standaardvolgorde en u moet expliciet opgeven DESC (aflopend).
  • U kunt sorteren op berekende waarden, niet alleen opgeslagen eigenschappen.
Sorteerspecificatie Resulterende orde
ASC of ASC NULLS LAST Niet-nulwaarden in oplopende volgorde, gevolgd door nulwaardes.
ASC NULLS FIRST Nullwaarden, gevolgd door niet-nulwaarden in oplopende volgorde.
DESC of DESC NULLS LAST Niet-nulwaarden in aflopende volgorde, gevolgd door nulwaarden.
DESC NULLS FIRST Null-waarden, gevolgd door niet-nul-waarden in aflopende volgorde.

Waarschuwing

Alleen de direct volgende instructie kan de sorteervolgorde zien die ORDER BY wordt vastgesteld. ORDER BY Daarom produceert gevolgd door RETURN * geen geordende resultaten.

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 verschil heeft directe gevolgen voor top-k-query's: LIMIT moet altijd de ORDER BY instructie volgen waarmee de beoogde sorteervolgorde wordt 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 ] [ NULLS FIRST | NULLS LAST ], ... ]
[ 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 behulp van 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 companyId = c.id, companyName = c.name
RETURN companyId,
       companyName,
       count(*) AS employeeCount,
       avg(p.birthday) AS avg_birth_year
GROUP BY companyId, 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

Voor horizontale aggregatie over patronen met variabele lengte, zie Aggregate functies.

Waarden en waardetypen

GQL-waarden omvatten Booleaanse, string-, numeriek-, temporeel-, lijst-, node-, edge-, path-, null- en nothing-waarden. Types zijn ongeldig tenzij je specificeert NOT NULL. Eigenschappen gebruiken een ondersteunde subset van het volledige querywaardesysteem.

RETURN 42 AS integerValue,
       'Alice' AS stringValue,
       TRUE AS booleanValue,
       [1, 2, 3] AS listValue

Vergelijkingen met null evalueren naar UNKNOWN; gebruik IS NULL en IS NOT NULL voor null tests. Numerieke bewerkingen kunnen impliciete conversies toepassen tussen compatibele numerieke types.

Opmerking

Niet elk GQL-waardetype wordt in elke graafcontext ondersteund. Voor huidige eigenschaps- en querybeperkingen, zie Datatypes.

Voor letterlijke syntaxis, vergelijkingsgedrag, typeconversies en de typehiërarchie, zie GQL-waarden en waardetypes.

Expressions

Uitdrukkingen berekenen, vergelijken, aggregeren en transformeren waarden. Veelvoorkomende vormen zijn eigenschapsreferenties, rekenkundige en logische operatoren, predicaten, functieaanroepen, eenvoudige CASE expressies en subqueries:

MATCH (person:Person)
FILTER person.birthday < 19900101
RETURN person.firstName,
       CASE person.gender
         WHEN 'female' THEN 'F'
         WHEN 'male' THEN 'M'
         ELSE 'Other'
       END AS genderCode

GQL gebruikt driewaardige logica: Booleaanse expressies kunnen evalueren naar TRUE, FALSE, of UNKNOWN. A FILTER behoudt alleen rijen waarvoor het predicaat is TRUE.

Aggregeer functies zoals COUNT, SUM, AVG, , MINen MAX vat rijen samen. Lijstpredicaten zoals ALL, ANY, , NONEen SINGLE evalueer een predicaat voor lijstelementen. Procedure-vorm EXISTS subqueries testen of een geneste query een rij teruggeeft.

Voor volledig operator-, predicaat-, aggregate- en functiegedrag, zie GQL-expressies, predicaten en functies. Voor voorbeelden van taakgerichte filtering en groepering, zie Filter en aggregeer grafiekgegevens.

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 multistatementsamenstelling

Belangrijk

Graph ondersteunt de samenstelling van een eenvoudige en volledige lineaire instructie. De EXCEPT, INTERSECT, en OTHERWISE set-operaties worden nog niet ondersteund. Zie het artikel over huidige beperkingen voor meer informatie.

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

UNION en UNION ALL

Gebruik UNION, UNION DISTINCT, of UNION ALL om resultaten van twee of meer lineaire queryblokken te combineren:

<query block>
UNION [ DISTINCT | ALL ]
<query block>

-- Combine results from two separate pattern matches
MATCH (p:Person)-[:workAt]->(c:Company)
RETURN p.firstName AS name, c.name AS affiliation
UNION DISTINCT
MATCH (p:Person)-[:studyAt]->(u:University)
RETURN p.firstName AS name, u.name AS affiliation

Bare UNION is gelijk aan UNION DISTINCT; beide verwijderen dubbele rijen. UNION ALL bewaart alle rijen, inclusief duplicaten.

Elk queryblok moet dezelfde set kolomnamen teruggeven. De kolomvolgorde kan verschillen tussen blokken, en de datatypes moeten compatibel zijn.

NEXT

Gebruik NEXT om een andere queryfase uit te voeren tegen de tabel die door de vorige fase wordt teruggegeven:

<query stage>
RETURN <columns>
NEXT
<query stage>

De volgende zoekopdracht vindt werknemers en hun bedrijven, en gebruikt vervolgens de teruggestuurde werknemersknooppunten in een andere patroonovereenkomst:

MATCH (person:Person)-[:workAt]->(company:Company)
RETURN person, company.name AS companyName
NEXT
MATCH (person)-[:isLocatedIn]->(city:City)
RETURN person.firstName AS employee, companyName, city.name AS city

Alleen kolommen die door de voorgaande fase worden teruggegeven, vallen in scope na NEXT. Je kunt meerdere NEXT separatoren gebruiken om een langere reeks query-fasen te bouwen.

Beide fasen kunnen een unie van queryblokken bevatten. Een unie wordt binnen zijn fase geëvalueerd voordat de output van de fase de NEXT grens overschrijdt. Als , , en C queryblokken vertegenwoordigen, A UNION B NEXT C groeperen zij als (A UNION B) NEXT C, terwijl A NEXT B UNION C groepen als A NEXT (B UNION C). BA

Voorwaardelijke uitspraken

Gebruik een conditionele instructie om elke inkomende rij te routeren naar de eerste tak waarvan het predicaat evalueert naar TRUE:

WHEN <predicate> THEN <linear query statement or { query statements }>
[ WHEN <predicate> THEN <linear query statement or { query statements }> ... ]
[ ELSE <linear query statement or { query statements }> ]

Om rijen te routeren vanuit een voorafgaande queryfase, geef je de benodigde kolommen terug en gebruik NEXT je vóór de conditionele stelling:

MATCH (p:Person)
RETURN p.firstName AS name, p.birthday AS birthday
NEXT
WHEN birthday < 19800101u THEN
  RETURN name, 'Before 1980' AS era
WHEN birthday < 20000101u THEN
  RETURN name, '1980-1999' AS era
ELSE
  RETURN name, '2000 or later' AS era

Elk WHEN predicaat moet booleaans zijn. De query-engine evalueert de predicaten in volgorde voor elke invoerrij. Een predicaat dat evalueert naar FALSE of UNKNOWN niet zijn tak selecteert. Nadat een predicaat geëvalueert naar TRUE, worden latere predicaten en niet-geselecteerde taklichamen niet geëvalueerd. Als geen predicaat evalueert naar TRUE en er geen ELSEis, wordt de invoerrij niet teruggegeven.

Predicaten en vertakkingen kunnen kolommen uit de voorgaande fase verwijzen. Een branch kan één lineaire instructie zijn, of een geneste procedure die in haakjes is omsloten. Gebruik een geneste procedure wanneer een tak meerdere fasen of statements nodig heeft, zoals CALL:

MATCH (p:Person)
RETURN p, p.firstName AS name
NEXT
WHEN p.gender = 'female' THEN {
  CALL {
    MATCH (p)-[:knows]->(friend:Person)
    RETURN count(*) AS friendCount
  }
  RETURN name, friendCount
}
ELSE
  RETURN name, 0u AS friendCount

Elke tak heeft zijn eigen lokale reikwijdte. Broer-branchs zien geen variabelen die door een andere branch zijn aangemaakt, en alleen kolommen uit de definitieve RETURN continue van de geselecteerde branch na de conditionele stelling. Elke tak moet dezelfde kolomnamen teruggeven, en de bijbehorende resultaattypen moeten compatibel zijn. De query-engine dwingt compatibele types naar een gemeenschappelijk uitvoertype. Een teruggegeven vertakkingskolom kan dezelfde naam gebruiken als een inkomende kolom; de vertakkingswaarde vervangt de inkomende waarde in de voorwaardelijke uitvoer.

Conditionele statements verschillen van CASE expressies. Graph ondersteunt eenvoudige CASE <expression> WHEN <value>, maar niet doorzocht CASE WHEN <predicate> expressies. Voor meer informatie, zie Conditionele expressies.

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 fullName
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 tussen 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 a new variable for the friend
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.

Aggregaatrijen en padelementen

GQL ondersteunt twee aggregatiecontexten:

  • Verticale aggregatie vat invoerrijen samen, optioneel gepartitioneerd door GROUP BY variabelen.
  • Horizontale aggregatie vat een groepslijst samen die wordt begrensd door een randpatroon van variabele lengte binnen één gematcht pad.
MATCH (person:Person)-[:workAt]->(company:Company)
LET companyId = company.id, companyName = company.name
RETURN companyId, companyName, count(*) AS employeeCount
GROUP BY companyId, companyName

MATCH (:Person)-[connections:knows]->{1,4}(:Person)
RETURN count(connections) AS pathLength

Voor gegroepeerde queries, aggregate-specifieke filters, collectieaggregaten en conditionele routing, zie Filter en aggregate graph data. Voor volledige regels voor geaggregeerde resultaten, zie Aggregaatfuncties.

Behandel nullen en queryfouten

Gebruik expliciete nulltests wanneer ontbrekende waarden een aparte behandeling vereisen:

MATCH (person:Person)
FILTER person.browserUsed IS NULL
RETURN person.firstName

Een vergelijking met nul evalueert naar UNKNOWN, wat a FILTER niet behoudt. Gebruik coalesce() wanneer je een fallbackwaarde nodig hebt.

Zoekresultaten omvatten statusinformatie voor succes, waarschuwingen, datavrije condities, door de gebruiker te corrigeren fouten en systeemfouten. Gebruik de publieke statuscode voor brede controleflow en de canonieke GQLSTATUS-diagnose voor een specifieke aandoening. Zie Uitvoeringsuitkomsten en -resultaten en de referentie GQL-statuscodes.

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

Verwante inhoud

  • Laatst bijgewerkt om