GQL språkguide

Note

Denne funksjonen er for øyeblikket i offentlig forhåndsversjon. Denne forhåndsvisningen leveres uten en tjenesteavtale, og anbefales ikke for produksjonsarbeidsbelastninger. Enkelte funksjoner støttes kanskje ikke eller kan ha begrensede funksjoner. Hvis du vil ha mer informasjon, kan du se Supplerende vilkår for bruk for Microsoft Azure Previews.

GQL Graph Query Language er det ISO-standardiserte spørringsspråket for grafdatabaser. Det hjelper deg med å spørre og arbeide effektivt med grafdata.

GQL er utviklet av den samme ISO-arbeidsgruppen som standardiserer SQL, og sikrer konsistens og grundighet. Hvis du er kjent med SQL, vil du finne mange likheter i GQL (uttrykk, predikater, typer) – noe som gjør det enklere å komme i gang. Denne veiledningen serverer både nykommere som lærer GQL grunnleggende og erfarne brukere som søker avanserte teknikker og omfattende referanseinformasjon.

Note

Den offisielle internasjonale standarden for GQL er ISO/IEC 39075 Information Technology - Database Languages - GQL.

Forutsetninger

Før du dykker ned i GQL, bør du være kjent med disse konseptene:

Grunnleggende forståelse av databaser – Erfaring med ethvert databasesystem (som relasjonssystemer (SQL), NoSQL eller graf) er nyttig
Grafkonsepter – Forståelse av noder, kanter og relasjoner i tilkoblede data
Grunnleggende spørringer – Kunnskap om grunnleggende spørringskonsepter som filtrering, sortering og aggregasjon

Anbefalt bakgrunn:

Erfaring med SQL eller openCypher-språk gjør det lettere å lære GQL-syntaks (de er røttene til GQL)
Kjennskap til datamodellering hjelper med diagramskjemautforming
Forståelse av det spesifikke brukstilfellet for grafdata

Det du trenger:

Tilgang til Microsoft Fabric med graffunksjoner
Eksempeldata eller vilje til å arbeide med eksempler på sosiale nettverk
Grunnleggende tekstredigeringsprogram for å skrive spørringer

Tips

Hvis du ikke har brukt grafdatabaser før du fortsetter med denne veiledningen, begynner du med oversikten over grafdatamodeller .

Hva gjør GQL spesielt

GQL er utformet spesielt for grafdata. Dette gjør det naturlig og intuitivt å arbeide med tilkoblet informasjon.

I motsetning til SQL, som er avhengig av tabellkoblinger for å uttrykke relasjoner, bruker GQL visuelle grafmønstre, som direkte speiler hvordan entiteter er koblet sammen, noe som gjør spørringer enklere å lese og resonnere om.

La oss si at du ønsker å finne folk og deres venner (folk som kjenner hverandre) som begge er født før 1999. Slik uttrykker GQL dette ved hjelp av et visuelt grafmønster:

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

Denne spørringen finner venner (personer som kjenner hverandre) som begge ble født før 1999. Mønsteret (person:Person)-[:knows]-(friend:Person) viser visuelt relasjonsstrukturen du leter etter – omtrent som å tegne et diagram over dataene.

GQL grunnleggende

Før du dykker inn i spørringer, må du forstå disse kjernekonseptene som danner grunnlaget for GQL:

Grafer lagrer dataene dine som noder (enheter) og kanter (relasjoner), hver med etiketter og egenskaper
Graftyper fungerer som skjemaer, og definerer hvilke noder og kanter som kan finnes i grafen
Begrensninger er tilleggsregler og restriksjoner pålagt av graftyper på grafer for å håndheve dataintegritet
Spørringer bruker setninger som MATCH, FILTERog RETURN til å behandle data og vise resultater
Mønstre beskriver grafstrukturene du vil finne ved hjelp av intuitiv visuell syntaks
Uttrykk utfører beregninger og sammenligninger på dataene dine, på samme måte som SQL-uttrykk
Predikater er boolske verdiuttrykk som brukes til å filtrere resultater i spørringer
Verdityper definerer hvilke typer verdier du kan behandle og lagre

Forstå grafdata

Hvis du vil arbeide effektivt med GQL, må du forstå hvordan grafdata er strukturert. Dette grunnlaget hjelper deg med å skrive bedre spørringer og modellere dataene effektivt.

Noder og kanter: byggesteinene

I GQL arbeider du med merkede egenskapsgrafer. En graf består av to typer elementer:

Noder representerer vanligvis enhetene ("substantiv") i systemet – ting som personer, organisasjoner, innlegg eller produkter. De er uavhengige objekter som finnes i domenet ditt. Noder kalles noen ganger også toppunkter.

Kanter representerer relasjoner mellom enheter (verbene) – hvordan enhetene kobler sammen og samhandler. For eksempel kjenner folk hverandre (:knows), organisasjoner som opererer i bestemte regioner (:operates), eller kunder som har kjøpt produkter (:purchased).
Kanter kalles noen ganger også relasjoner.

Hvert grafelement har disse egenskapene:

En intern ID som unikt identifiserer den
Én eller flere etiketter – beskrivende navn som Person eller knows. I Microsoft Fabric har grafkanter alltid nøyaktig én etikett.
Egenskaper—navn-verdi-par som lagrer data om elementet (slik som firstName: "Alice" eller birthday: "19730108").

Slik struktureres grafer

Hver kant kobler sammen nøyaktig to noder: en kilde og et mål. Denne tilkoblingen oppretter grafens struktur og viser hvordan enheter er relatert til hverandre. Retningen på kanter er viktig – en som Person en follows annen Person oppretter en rettet relasjon.

Note

Graph i Microsoft Fabric støtter for øyeblikket ikke urettede kanter.

Egenskapsgrafer slik de støttes i Microsoft Fabric er alltid veldefinerte, noe som betyr at hver kant kobler to gyldige noder. Hvis du ser en kant i en graf, finnes begge endepunktene i samme graf.

Grafmodeller og graftyper

Strukturen til en graf i Microsoft Fabric beskrives av grafmodellen, som fungerer som et databaseskjema for programdomenet. Grafmodeller definerer:

Hvilke noder og kanter som kan finnes
Hvilke etiketter og egenskaper de kan ha
Slik kan noder og kanter koble til

Grafmodeller sikrer også dataintegritet gjennom begrensninger, spesielt nodenøkkelbetingelser som angir hvilke egenskaper som unikt identifiserer hver node.

Note

Grafmodeller kan angis ved hjelp av GQL-standardsyntaks, i så fall kalles de graftyper.

I denne dokumentasjonen bruker vi et sosialt nettverkseksempel for å illustrere GQL-konsepter. Når du forstår dette domenet, kan du følge eksemplene og bruke lignende mønstre på dine egne data.

Note

Det sosiale nettverket er eksempel er avledet fra LDBC SNB (LDBC Social Network Benchmark) publisert av GDC (Graph Data Council). Se artikkelen "LDBC Social Network Benchmark" for mer informasjon.

Vårt sosiale nettverk omfatter disse hovedtypene av noder, som representerer enheter i domenet:

Personer har personlige opplysninger som navn, fødselsdager og kjønn. De bor i byer og danner sosiale forbindelser.

Plasser danner et geografisk hierarki:

Byer som "New York" eller "London"
Land/områder som USA eller Storbritannia
Kontinenter som «Nord-Amerika» eller «Europa»

Organisasjoner der personer tilbringer tid:

Universiteter der folk studerer
Bedrifter der personer arbeider

Innhold og diskusjoner:

Fora med titler som inneholder innlegg
Innlegg med innhold, språk og valgfrie bilder
Kommentarer som svarer på innlegg eller andre kommentarer
Merker som kategoriserer innhold og representerer interesser

Slik kobler alt seg sammen

Tilkoblingene mellom enheter gjør nettverket interessant:

Folk kjenner hverandre (vennskap, :knows)
Folk jobber i selskaper (:workAt) eller studerer ved universiteter (:studyAt)
Folk lager innlegg og kommentarer (:hasCreator)
Folk liker innlegg og kommentarer (:likes)
Innlegg, forum, kommentarer kan ha tagger (:hasTag)
Folk har interesse for spesifikke tagger (:hasInterest)
Forum inneholder innlegg (:containerOf) og har medlemmer (:hasMember) og moderatorer (:hasModerator)

Grafkanter representerer domenerelasjoner. Dette rike nettverket oppretter mange muligheter for interessante spørringer og analyser.

Vis fullstendig skjemaspesifikasjon

Dine første GQL-spørringer

Nå som du forstår grunnleggende grafer, kan vi se hvordan du spør etter grafdata ved hjelp av GQL. Disse eksemplene bygger fra enkelt til komplekst, og viser deg hvordan GQLs tilnærming gjør grafspørringer intuitive og kraftige.

Start enkelt: finn alle personer

La oss begynne med den mest grunnleggende spørringen mulig, finn navnene (fornavn, etternavn) til alle personene i:Person grafen.

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

Denne spørringen utføres som følger:

MATCH finner alle noder merket Person
RETURN viser for- og etternavn

Legg til filtrering: finn bestemte personer

La oss nå finne folk med spesifikke egenskaper, i dette tilfellet alle som heter Alice, og vise navn og bursdager.

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

Denne spørringen utføres som følger:

MATCH finner alle noder (p) merket Person
FILTER noder (p) hvis fornavn er Alice
RETURN viser deres fornavn, etternavn og fødselsdag

Grunnleggende spørringsstruktur

Grunnleggende GQL-spørringer følger alle et konsekvent mønster: en sekvens av setninger som arbeider sammen for å finne, filtrere og returnere data. De fleste spørringer starter med MATCH å finne mønstre i grafen og avsluttes med RETURN for å spesifisere resultatet.

Her er et enkelt søk som finner par av personer som kjenner hverandre og har samme bursdag, og deretter returnerer det totale antallet vennepar.

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

Denne spørringen utføres som følger:

MATCH finner alle parene Person med noder som kjenner hverandre
FILTER beholder bare parene der begge personer har samme fødselsdag
RETURN teller hvor mange slike vennepar som finnes

Tips

Filtrering kan også utføres direkte som en del av et mønster ved å tilføye en setning WHERE . Vil for eksempel MATCH (n:Person WHERE n.age > 23) bare samsvare med Person noder som age har en egenskap som er større enn 23.

Note

GQL støtter linjekommentarer i C-stil // , linjekommentarer i SQL-stil -- og blokkeringskommentarer i C-stil /* */ .

Vanlige utsagn

MATCH: Identifiserer grafmønsteret du skal søke etter—her definerer du strukturen til dataene du er interessert i.
LET: Tildeler nye variabler eller beregnede verdier basert på matchede data—legger til avledede kolonner til resultatet.
FILTER: Snevrer inn resultatene ved å bruke betingelser—fjerner rader som ikke oppfyller kriteriene.
ORDER BY: Sorterer de filtrerte dataene – hjelper til med å organisere utdataene basert på ett eller flere felt.
OFFSET og LIMIT: Begrens antall rader som returneres—nyttig for paginering eller top-k spørringer.
RETURN: Spesifiserer den endelige utdataen—definerer hvilke data som skal inkluderes i resultatsettet og utfører aggregering.

Slik fungerer setninger sammen

GQL-setninger danner en pipeline, hvor hver setning behandler utdataene fra den forrige. Denne sekvensielle utførelsen gjør spørringer enkle å lese og feilsøke fordi utførelsesrekkefølgen samsvarer med leserekkefølgen.

Nøkkelpunkter:

Setninger utføres effektivt sekvensielt.
Hver setning transformerer data og sender dem videre til neste.
Dette skaper en klar, forutsigbar dataflyt som forenkler komplekse spørringer.

Viktig!

Internt kan utførelsen av setninger omorganiseres, og individuelle setninger kan kjøres parallelt av Microsoft Fabric for å maksimere ytelsen. Dette vil imidlertid ikke påvirke riktigheten av resultatene.

Eksempel

Følgende GQL-søk finner de første 10 personene som jobber i selskaper med "Air" i navnet, sorterer dem etter fullt navn, og returnerer deres fulle navn sammen med navnet på selskapene sine.

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

Denne spørringen utføres som følger:

MATCH finner folk som jobber i selskaper med "Air" i navnet sitt
LET Lager fullnavn ved å kombinere fornavn og familienavn
FILTER beholder kun Contoso-ansatte
ORDER BY sorterer etter fullt navn
LIMIT tar de første 10 resultatene
RETURN Returer, navn og selskapslokasjoner

Variabler kobler sammen dataene dine

Variabler (for eksempel p, cog fullName i de forrige eksemplene) inneholder data mellom setninger. Når du bruker et variabelnavn på nytt, sikrer GQL automatisk at det refererer til de samme dataene, noe som skaper kraftige sammenføyningsbetingelser. Variabler kalles noen ganger også bindingsvariabler.

Variabler kan kategoriseres på forskjellige måter:

Ved bindingskilde:

Mønstervariabler – bundet av samsvarende grafmønstre
Vanlige variabler – bundet av andre språkkonstruksjoner

Mønstervariabeltyper:

Elementvariabler – binde til referanseverdier for grafelement
- Nodevariabler – binde til individuelle noder
- Edge-variabler – binde til individuelle kanter
Banevariabler – binde til baneverdier som representerer samsvarende baner

Etter referansegrad:

Singleton-variabler – binde til individuelle elementreferanseverdier fra mønstre
Gruppevariabler – binde til lister over elementreferanseverdier fra mønstre med variabel lengde (se Avanserte aggregasjonsteknikker)

Resultater og resultater for kjøring

Når du kjører en spørring, får du tilbake et utførelsesresultat som består av:

En (valgfri) resultattabell med dataene fra setningen RETURN .
Statusinformasjon som viser om spørringen var vellykket eller ikke.

Resultattabeller

Resultattabellen – hvis den finnes – er det faktiske resultatet av kjøring av spørring.

En resultattabell inneholder informasjon om navnet og typen til kolonnene, en foretrukket kolonnenavnsekvens som skal brukes til å vise resultater, om tabellen er bestilt og selve radene.

Note

Ved kjøringsfeil inkluderes ingen resultattabell i utførelsesresultatet.

Statusinformasjon

Ulike bemerkelsesverdige betingelser (for eksempel feil eller advarsler) oppdages under kjøringen av spørringen. Hver slik betingelse registreres av et statusobjekt i statusinformasjonen for utførelsesresultatet.

Statusinformasjonen består av et primærstatusobjekt og en (muligens tom) liste over flere statusobjekter. Det primære statusobjektet finnes alltid, og angir om spørringskjøringen var vellykket eller mislykket.

Hvert statusobjekt inneholder en femsifret statuskode (kalt GQLSTATUS) som identifiserer den registrerte betingelsen samt en melding som beskriver den.

Statuskoder for vellykket:

GQLSTATUS	Melding	Når
00000	obs! Fullført	Vellykket med minst én rad
00001	obs! Vellykket fullføring – utelatt resultat	Vellykket uten tabell (ubrukt)
02000	obs! ingen data	Vellykket med null rader

Andre statuskoder angir ytterligere feil eller advarsler som ble oppdaget under kjøring av spørring.

Vis fullstendig referanse for GQLSTATUS-koder

Viktig!

I programkode må du alltid stole på statuskoder for å teste for bestemte betingelser. Statuskoder garanteres å være stabile, og deres generelle betydning endres ikke i fremtiden. Ikke test innholdet i meldingene, da den konkrete meldingen som rapporteres for en statuskode kan endres i fremtiden avhengig av spørringen eller til og med mellom utførelser av samme spørring.

I tillegg kan statusobjekter inneholde et underliggende årsaksstatusobjekt og en diagnosepost med ytterligere informasjon som karakteriserer den registrerte betingelsen.

Viktige konsepter og setninger

Denne delen dekker kjernebyggeblokkene du trenger for å skrive effektive GQL-spørringer. Hvert konsept bygger mot praktiske ferdigheter for spørringsskriving.

Grafmønstre: finne struktur

Grafmønstre er kjernen i GQL-spørringer. De lar deg beskrive datastrukturen du leter etter ved hjelp av intuitiv, visuell syntaks som ser ut som relasjonene du vil finne.

Enkle mønstre:

Start med grunnleggende relasjonsmønstre:

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

Mønstre med bestemte data:

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

Etikettuttrykk for fleksibel enhetsvalg:

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

Note

Grafmodeller med flere elementetiketter støttes ennå ikke (kjent problem).

Med etikettuttrykk kan du sammenligne ulike typer noder i ett enkelt mønster, noe som gjør spørringene mer fleksible.

Variabel gjenbruk oppretter kraftige sammenføyninger:

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

Gjenbruk av variabel c sikrer at begge personer jobber i samme firma, noe som oppretter en automatisk sammenføyningsbetingelse. Dette mønsteret er et viktig mønster for å uttrykke «samme enhet»-relasjoner.

Viktig!

Kritisk innsikt: Variabel gjenbruk i mønstre skaper strukturelle begrensninger. Denne teknikken er hvordan du uttrykker komplekse grafrelasjoner som «venner som jobber i samme selskap» eller «personer i samme by».

Filtrering på mønsternivå med 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)

Avgrensede mønstre med variabel lengde:

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

TRAIL-mønstre for sykkelfri traversering:

Bruk TRAIL mønstre for å forhindre sykluser under graf traversering, slik at hver kant besøkes maksimalt én gang:

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

Kantbinding med variabel lengde:

I mønstre med variabel lengde registrerer kantvariabler forskjellig informasjon basert på kontekst:

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

Dette skillet er avgjørende for å bruke kantvariabler på riktig måte.

Komplekse mønstre med flere relasjoner:

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

Dette mønsteret finner personer sammen med både arbeidsplassen og boligen sin, og viser hvordan én person kobler seg til flere andre enheter.

Lær omfattende mønstersyntaks og avanserte teknikker

Kjernesetninger

GQL inneholder bestemte setningstyper som arbeider sammen for å behandle grafdataene trinn for trinn. Det er viktig å forstå disse setningene for å bygge effektive spørringer.

`MATCH` uttalelse

Syntaks:

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

Setningen MATCH tar inndata og finner grafmønstre, slår sammen inndatavariabler med mønstervariabler og sender ut alle samsvarende kombinasjoner.

Inndata- og utdatavariabler:

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

Filtrering på setningsnivå med WHERE:

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

Alle treff kan filtreres etter filtrering ved å WHEREunngå en egen FILTER setning.

Sammenføyning med inndatavariabler:

Når MATCH det ikke er den første setningen, kobles inndata sammen med mønstersamsvar:

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

Viktig!

Graph i Microsoft Fabric støtter ennå ikke vilkårlig setningssammensetning. Se artikkelen om gjeldende begrensninger.

Virkemåter for nøkkelkobling:

Slik MATCH håndterer du datakobling:

Variabel likhet: Inndatavariabler sammenføyer med mønstervariabler ved hjelp av likhetssamsvar
Indre sammenføyning: Inndatarader uten mønstersamsvar forkastes (ingen koblinger til venstre/høyre)
Filtreringsrekkefølge: Filtre på setningsnivå WHERE etter at mønstersamsvar er fullført
Mønstertilkobling: Flere mønstre må dele minst én variabel for riktig sammenføyning
Ytelse: Delte variabler oppretter effektive sammenføyningsbetingelser

Viktig!

Begrensning: Hvis dette MATCH ikke er den første setningen, må minst én inndatavariabel bli med i en mønstervariabel. Flere mønstre må ha én variabel til felles.

Flere mønstre krever delte variabler:

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

Syntaks:

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

Setningen LET oppretter beregnede variabler og muliggjør datatransformasjon i spørringssamlebåndet.

Grunnleggende oppretting av variabel:

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

Komplekse beregninger:

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

Viktige virkemåter:

Uttrykk evalueres for hver inndatarad
Resultatene blir nye kolonner i utdatatabellen
Variabler kan bare referere til eksisterende variabler fra tidligere setninger
Flere tildelinger i én LET evalueres parallelt (ingen kryssreferanser)

`FILTER` uttalelse

Syntaks:

FILTER [ WHERE ] <predicate>

Erklæringen FILTER gir nøyaktig kontroll over hvilke data som går gjennom spørringssamlebåndet.

Grunnleggende filtrering:

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

Komplekse logiske betingelser:

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

Nullavhengige filtreringsmønstre:

Bruk disse mønstrene til å håndtere nullverdier på en trygg måte:

Se etter verdier: p.firstName IS NOT NULL - har et fornavn
Valider data: p.id > 0 – gyldig ID
Håndtere manglende data: NOT coalesce(p.locationIP, '127.0.0.1') STARTS WITH '127.0.0' – ble ikke koblet til fra lokalt nettverk
Kombiner betingelser: Bruk AND/OR med eksplisitte nullkontroller for kompleks logikk

Forsiktig!

Husk at betingelser som involverer nullverdier returnerer UNKNOWN, som filtrerer ut disse radene. Bruk eksplisitte IS NULL kontroller når du trenger null-inkluderende logikk.

`ORDER BY` uttalelse

Syntaks:

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

Sortering på flere nivåer med beregnede uttrykk:

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)

Nullhåndtering i sortering:

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

Detaljer for sorteringsvirkemåte:

Forstå hvordan ORDER BY fungerer:

Uttrykksevaluering: Uttrykk evalueres for hver rad, og deretter bestemmer resultatene radrekkefølgen
Flere sorteringstaster: Opprett hierarkisk rekkefølge (primær, sekundær, tertiær osv.)
Nullhåndtering: NULL behandles alltid som den minste verdien i sammenligninger
Standardrekkefølge: ASC (stigende) er standard, DESC (synkende) må angis eksplisitt
Beregnet sortering: Du kan sortere etter beregnede verdier, ikke bare lagrede egenskaper

Forsiktig!

Sorteringsrekkefølgen som er opprettet av ORDER BY , er bare synlig for den umiddelbart følgende setningen. ORDER BY Etterfulgt av RETURN * produserer derfor IKKE et bestilt resultat.

Sammenligne:

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

med:

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

Dette har umiddelbare konsekvenser for «Top-k»-spørringer: LIMIT må alltid følge setningen ORDER BY som etablerte den tiltenkte sorteringsrekkefølgen.

`OFFSET` og `LIMIT` setninger

Syntaks:

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

Vanlige mønstre:

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

Viktig!

Bruk alltid ORDER BY før OFFSET og LIMIT for å sikre konsekvent radrekkefølge på tvers av spørringer for forutsigbare pagineringsresultater.

`RETURN`: grunnleggende resultatprojeksjon

Syntaks:

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

Setningen RETURN produserer spørringens endelige utdata ved å angi hvilke data som vises i resultattabellen.

Grunnleggende utdata:

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

Bruke aliaser for klarhet:

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

Kombiner med sortering og topp-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

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

Kombiner med aggregasjon:

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

`RETURN` med `GROUP BY`: gruppert resultatprojeksjon

Syntaks:

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

Brukes GROUP BY til å gruppere rader etter delte verdier og beregne mengdefunksjoner i hver gruppe.

Grunnleggende gruppering med aggregasjon:

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

Gruppering med flere kolonner:

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

Note

Hvis du vil ha avanserte aggregasjonsteknikker, inkludert vannrett aggregasjon over mønstre med variabel lengde, kan du se Avanserte aggregasjonsteknikker.

Datatyper: arbeide med verdier

GQL støtter rike datatyper for lagring og manipulering av ulike typer informasjon i grafen.

Grunnleggende verdityper:

Tall: INT64, UINT64for DOUBLE beregninger og målinger
Tekst: STRING for navn, beskrivelser og tekstdata
Logikk: BOOL med tre verdier: SANN, USANN og UKJENT (for nullhåndtering)
Tid: ZONED DATETIME for tidsstempler med tidssoneinformasjon
Samlinger: LIST<T> for flere verdier av samme type T, PATH for grafgjennomkjøringsresultater
Grafelementer: NODE og EDGE for å referere til grafdata

Viktig!

Visse verdityper støttes ikke som typer eiendomsverdier. Spesielt kan ikke alle verdier som involverer referanseverdier for grafelementer brukes som egenskapsverdier (som lister over noder eller stier).

Eksempellitteraler:

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

Kritiske mønstre for nullhåndtering:

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

Logikkimplikasjoner med tre verdier:

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

Forsiktig!

Logikk med tre verdier betyr NULL = NULL returer UNKNOWN, ikke TRUE. Denne virkemåten påvirker filtrering og sammenføyninger. IS NULL Bruk alltid for nulltester.

Lær omfattende systemdetaljer for type

Uttrykk: transformere og analysere data

Med uttrykk kan du beregne, sammenligne og transformere data i spørringene. De ligner på uttrykk i SQL, men har ekstra funksjoner for håndtering av grafdata.

Vanlige uttrykkstyper:

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

Kompleks predikatsammensetning:

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

Strengmønstersamsvar:

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

Innebygde funksjoner etter kategori:

GQL inneholder disse funksjonskategoriene for ulike behov for databehandling:

Mengdefunksjoner: count(), , sum(), avg(), min()for max() oppsummering av data
Strengfunksjoner: char_length(), upper(), , lower()trim() for tekstbehandling
Graffunksjoner: nodes(), edges(), labels() for å analysere grafstrukturer
Generelle funksjoner: coalesce() for å håndtere nullverdier på en grasiøst måte

Operatorprioritet for komplekse uttrykk:

Egenskapstilgang (.)
Multiplikasjon/divisjon (*, /)
Addisjon/subtraksjon (+, -)
Sammenligning (=, <>, , <, >, <=>=)
Logisk negasjon (NOT)
Logisk konjunksjon (AND)
Logisk disjunction (OR)

I listen ovenfor binder en operatør med lavere tall «strammere» enn en operatør med høyere tall. Eksempel: NOT n.prop OR m.prop er (NOT n.prop) OR m.prop men ikke 'IKKE (n.prop ELLER m.prop)

Tips

Bruk parenteser til å gjøre prioritet eksplisitt. Komplekse uttrykk er enklere å lese og feilsøke når gruppering er klart.

Lær omfattende uttrykkssyntaks og alle innebygde funksjoner

Avanserte spørringsteknikker

Denne delen dekker avanserte mønstre og teknikker for å bygge komplekse, effektive grafspørringer. Disse mønstrene går utover grunnleggende uttrykksbruk for å hjelpe deg med å skrive kraftige analytiske spørringer.

Kompleks komposisjon med flere setninger

Viktig!

Graph i Microsoft Fabric støtter ennå ikke vilkårlig setningssammensetning. Se artikkelen om gjeldende begrensninger.

Å forstå hvordan du oppretter komplekse spørringer effektivt er avgjørende for avansert grafspørring.

Mønsterfremdrift med flere trinn:

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

Denne spørringen bygger gradvis opp kompleksitet: finn selskaper, deres ansatte, ansattes lokasjoner, filtrer selskaper med ansatte født før 1985, beregne gjennomsnittlig fødselsdato, og oppsummere og sortere resultater.

Bruk av vannrett aggregasjon:

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

Note

Denne forespørselen støttes ennå ikke (kjent problem).

Variabel omfang og avansert flytkontroll

Variabler kobler sammen data på tvers av spørringssetninger og aktiverer komplekse graf-traverseringer. Ved å forstå avanserte omfangsregler kan du skrive avanserte spørringer med flere setninger.

Variable bindings- og omfangsmønstre:

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

Variabel gjenbruk for sammenføyninger på tvers av setninger:

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

Kritiske omfangsregler og begrensninger:

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

Variabel synlighet i komplekse spørringer:

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

Forsiktig!

Variabler i samme setning kan ikke referere til hverandre (unntatt i grafmønstre). Bruk separate setninger for oppretting av avhengig variabel.

Avanserte aggregasjonsteknikker

GQL støtter to forskjellige typer aggregasjon for analyse av data på tvers av grupper og samlinger: loddrett aggregasjon med og vannrett aggregasjon over mønstre med GROUP BY variabel lengde.

Loddrett aggregasjon med GROUP BY

Loddrett aggregasjon (dekket med RETURN) grupperer rader etter delte verdier og beregner aggregater iGROUP BY hver gruppe:

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

Denne tilnærmingen oppretter én resultatrad per firma, og samler alle ansatte i hver gruppe.

Vannrett aggregasjon med gruppelistevariabler

Vannrett aggregasjon beregner aggregater over samlinger som er bundet av mønstre med variabel lengde. Når du bruker kanter med variabel lengde, blir kantvariabelen en gruppelistevariabel som inneholder alle kanter i hver samsvarende bane:

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

Note

Denne forespørselen støttes ennå ikke (kjent problem).

Viktige forskjeller:

Loddrett aggregasjon oppsummerer på tvers av rader – eller – grupperer rader og oppsummerer på tvers av rader i hver gruppe
Vannrett aggregasjon oppsummerer elementer i individuelle kantsamlinger
Gruppelistevariabler kommer bare fra kantmønstre med variabel lengde

Bindingskontekster for kant med variabel lengde

Det er avgjørende å forstå hvordan kantvariabler binder seg i mønstre med variabel lengde:

Under mønstersamsvar (singleton-kontekst):

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

I resultatuttrykk (gruppekontekst):

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

Note

Denne forespørselen støttes ennå ikke (kjent problem).

Kombinerer loddrett og vannrett aggregasjon

Du kan kombinere begge aggregasjonstypene i avanserte analysemønstre:

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

Note

Denne forespørselen støttes ennå ikke (kjent problem).

Tips

Vannrett aggregasjon har alltid prioritet over loddrett aggregasjon. Hvis du vil konvertere en gruppeliste til en vanlig liste, bruker collect_list(edges)du .

Note

Hvis du vil ha detaljert mengdefunksjonsreferanse, kan du se GQL-uttrykk og -funksjoner.

Feilbehandlingsstrategier

Når du forstår vanlige feilmønstre, kan du skrive robuste spørringer.

Håndter manglende data på en grasiøs måte:

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 *

Bruk eksplisitte nullkontroller:

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 *

Mer informasjon

GQLSTATUS-koder

Som forklart i delen om spørringsresultater rapporterer GQL rik statusinformasjon relatert til vellykket eller potensiell mislykket kjøring. Se referansen for GQL-statuskoder for den fullstendige listen.

Reserverte ord

GQL forbeholder seg bestemte nøkkelord som du ikke kan bruke som identifikatorer som variabler, egenskapsnavn eller etikettnavn. Se referansen for reserverte ord for GQL for den fullstendige listen.

Hvis du trenger å bruke reserverte ord som identifikatorer, kan du unnslippe dem med backticks: `match`, `return`.

Hvis du vil unngå å fjerne reserverte ord, kan du bruke denne navnekonvensjonen:

For enkeltordidentifikatorer tilføyer du et understrekingstegn: :Product_
Bruk camelCase eller PascalCase for flerordsidentifikatorer: :MyEntity, , :hasAttributetextColor

Neste trinn

Nå som du forstår gql grunnleggende, her er din anbefalte læringsbane:

Fortsett å bygge gql-ferdighetene dine

For nybegynnere:

Prøv hurtigstarten – følg vår praktiske opplæring for praktisk erfaring
Øv på grunnleggende spørringer – Prøv eksemplene fra denne veiledningen med dine egne data
Lær grafmønstre – Mestre den omfattende mønstersyntaksen
Utforsk datatyper – Forstå GQL-verdier og verdityper

For erfarne brukere:

Avanserte uttrykk – Master GQL-uttrykk og -funksjoner
Skjemautforming – Finn ut GQL-graftyper og -begrensninger
Utforsk datatyper – Forstå GQL-verdier og verdityper

Referansemateriale

Hold disse referansene nyttige for hurtigoppslag:

HURTIGREFERANSE FOR GQL – hurtigreferanse for Syntaks
GQL-statuskoder – fullstendig feilkodereferanse
GQL reserverte ord – fullstendig liste over reserverte nøkkelord

Utforsk Microsoft Fabric

Lær plattformen:

Grafdatamodeller – Forstå grafkonsepter og modellering
Graf kontra relasjonsdatabaser – Velg riktig fremgangsmåte
Prøv Microsoft Fabric gratis – få praktisk opplevelse
Opplæringer fra ende til ende – fullstendige læringsscenarioer

Involver deg

Del tilbakemelding – Hjelp til med å forbedre dokumentasjonen og verktøyene våre
Bli med i fellesskapet – Kom i kontakt med andre grafdatabaseutøvere
Hold deg oppdatert – Følg Microsoft Fabric-kunngjøringer for nye funksjoner

Tips

Start med hurtigstartopplæringen hvis du foretrekker å lære ved å gjøre det, eller gå ned i grafmønstre hvis du vil mestre spørringsspråket først.

Ytterligere detaljer om viktige emner:

Eksempel på skjema for sosialt nettverk – komplett eksempel på grafskjema
GQL-grafmønstre – omfattende mønstersyntaks og avanserte samsvarsteknikker
GQL-uttrykk og -funksjoner – alle uttrykkstyper og innebygde funksjoner
GQL-graftyper – graftyper og begrensninger
GQL-verdier og verdityper – fullstendig systemreferanse og verdihåndtering

Hurtigreferanser:

GQL forkortet referanse - Hurtigreferanse for Syntaks
GQL-statuskoder – fullstendig feilkodereferanse
GQL reserverte ord – fullstendig liste over reserverte nøkkelord

Graph i Microsoft Fabric:

Grafdatamodeller – Forstå grafkonsepter og modellering
Graf- og relasjonsdatabaser – forskjeller og når du skal bruke hver
Prøv Microsoft Fabric gratis
Opplæringer fra ende til ende i Microsoft Fabric

Tilbakemeldinger

Var denne siden nyttig?

Last updated on 2025-12-12

Del via

GQL språkguide

Forutsetninger

Hva gjør GQL spesielt

GQL grunnleggende

Forstå grafdata

Noder og kanter: byggesteinene

Slik struktureres grafer

Grafmodeller og graftyper

Et praktisk eksempel: sosialt nettverk

Enhetene i det sosiale nettverket

Slik kobler alt seg sammen

Dine første GQL-spørringer

Start enkelt: finn alle personer

Legg til filtrering: finn bestemte personer

Grunnleggende spørringsstruktur

Vanlige utsagn

Slik fungerer setninger sammen

Variabler kobler sammen dataene dine

Resultater og resultater for kjøring

Resultattabeller

Statusinformasjon

Viktige konsepter og setninger

Grafmønstre: finne struktur

Kjernesetninger

MATCH uttalelse

LET uttalelse

FILTER uttalelse

ORDER BY uttalelse

OFFSET og LIMIT setninger

RETURN: grunnleggende resultatprojeksjon

RETURN med GROUP BY: gruppert resultatprojeksjon

Datatyper: arbeide med verdier

Uttrykk: transformere og analysere data

Avanserte spørringsteknikker

Kompleks komposisjon med flere setninger

Variabel omfang og avansert flytkontroll

Avanserte aggregasjonsteknikker

Loddrett aggregasjon med GROUP BY

Vannrett aggregasjon med gruppelistevariabler

Bindingskontekster for kant med variabel lengde

Kombinerer loddrett og vannrett aggregasjon

Feilbehandlingsstrategier

Mer informasjon

GQLSTATUS-koder

Reserverte ord

Neste trinn

Fortsett å bygge gql-ferdighetene dine

Referansemateriale

Utforsk Microsoft Fabric

Involver deg

Beslektet innhold

Tilbakemeldinger

Flere ressurser

`MATCH` uttalelse

`LET` uttalelse

`FILTER` uttalelse

`ORDER BY` uttalelse

`OFFSET` og `LIMIT` setninger

`RETURN`: grunnleggende resultatprojeksjon

`RETURN` med `GROUP BY`: gruppert resultatprojeksjon