Skriv grafmønsterspørringer i Microsoft Fabric

Grafmønstergjenkjenning lar deg beskrive strukturen til dataene du ønsker å finne ved hjelp av intuitiv, visuell syntaks. I stedet for å koble sammen tabeller, skriver du mønstre som ligner selve relasjonene – noder koblet sammen av kanter. Denne artikkelen viser deg hvordan du skriver GQL-mønsterspørringer for vanlige scenarier i graf i Microsoft Fabric.

Eksemplene bruker datasett fra sosiale nettverk. For en fullstendig mønstersyntaksreferanse, se GQL-grafmønstre.

Bruk denne artikkelen for å lære hvordan du konstruerer og kombinerer node-, kant- og stimønstre. For oppgaver som er klare til å tilpasses, som å finne naboer eller enheter uten relasjoner, se Skriv vanlige GQL-spørringer. For filtrering, gruppering og aggregering av arbeidsflyter, se Filter og aggregere grafdata.

Forutsetninger

Match-direkte relasjoner

Et grunnleggende mønster matcher en nodetype, en spesifikk kanttype og en annen nodetype. Syntaksen ser ut som et diagram over relasjonen.

For eksempel, for å finne opptil 100 personer som er koblet til selskapet de jobber i:

MATCH (p:Person)-[:workAt]->(c:Company)
RETURN p.firstName, p.lastName, c.name
LIMIT 100

Bruk et urettet kantmønster når du ikke vet eller ikke bryr deg om retningen. For eksempel, for å finne opptil 100 felles bekjente uavhengig av hvem som startet forbindelsen:

MATCH (a:Person)-[:knows]-(b:Person)
RETURN a.firstName, b.firstName
LIMIT 100

Note

Graph støtter for øyeblikket ikke å lage urettede kanter, men du kan spørre kanter i hvilken som helst retning ved å bruke -[:label]- syntaks.

Filtrer mønstre med innebygd HVOR

Plasser WHERE inne i mønsteret når en betingelse definerer hvilken node eller kant som kan delta i matchen. Bruk en betingelse på setningsnivå MATCH ... WHERE for å etterfiltrere den fullførte matchen, eller en separat FILTER når betingelsen gjelder for raden som produseres av en tidligere setning. Plassering av predikater kan endre resultater for korteste-veien. For mer informasjon, se Plasser-predikater før eller etter valg av sti.

For eksempel, for å finne folk født før 1990 som jobber i et selskap hvis navn begynner med 'A':

MATCH (p:Person WHERE p.birthday < 19900101)-[:workAt]->(c:Company WHERE c.name STARTS WITH 'A')
RETURN p.firstName, p.lastName, c.name

Filtrer på kantegenskaper for å begrense hvilke relasjoner som matcher. For eksempel, å returnere kun personer som begynte å jobbe i et selskap i 2010 eller senere:

MATCH (p:Person)-[w:workAt WHERE w.workFrom >= 2010]->(c:Company)
RETURN p.firstName, c.name, w.workFrom

Match multi-hop-relasjoner

Bruk mønstre med variabel lengde for å krysse flere hopp i ett uttrykk. Spesifiser minimums- og maksimumsantall hopp med {min,max} syntaks.

For eksempel, for å finne opptil 100 personer som er tilgjengelige innen to til fire grader av vennskap fra Alice:

MATCH (src:Person WHERE src.firstName = 'Alice')-[:knows]->{2,4}(dst:Person)
RETURN dst.firstName, dst.lastName
LIMIT 100

For å finne opptil 100 umiddelbare og andregrads forbindelser (ett eller to hopp) fra Alice:

MATCH (src:Person WHERE src.firstName = 'Alice')-[:knows]->{1,2}(dst:Person)
RETURN DISTINCT dst.firstName, dst.lastName
LIMIT 100

Kontrolltraversering med stimoduser

Som standard bruker WALKGQL , som tillater gjentatte noder og kanter. Bruk en annen sti-modus når du trenger strengere elementunikhet.

Banemodus Virkemåte Bruk når...
WALK Tillater gjentatte noder og kanter (standard) Du vil ha alle matchende vandringer innenfor en endelig grense.
TRAIL Ingen gjentatte kanter Du vil unngå å følge samme kant på nytt, men samme node kan dukke opp gjennom forskjellige kanter.
SIMPLE Ingen gjentatte noder bortsett fra en delt start- og sluttnode, og ingen gjentatte kanter Du vil ikke at noen node skal dukke opp mer enn én gang midt i en sti, men tillate stier som lukker seg tilbake til starten. Nyttig for å oppdage løkker.
ACYCLIC Ingen gjentatte noder eller kanter Du må være sikker på at ingen node dukker opp noe sted i stien mer enn én gang. Bruk for strenge hierarkier, slektslinjer eller enhver traversering der et nytt besøk av en node ville gi feil resultater.

WALK er den mest tillatende modusen og ACYCLIC den mest restriktive.

For SIMPLE og ACYCLIC, følger kantens unikhet fra nodens unikhet. En SIMPLE sti kan lukke seg ved å returnere til sin første node, men den kan fortsatt ikke gjenbruke en kant.

For å illustrere forskjellen, se på veien Alice → Bob → Carol → Bob:

  • WALK — tillater denne veien. Noder og kanter kan gjentas fritt.
  • TRAIL — tillater denne stien. Bob dukker opp to ganger, men hver kant som brukes har et annet forhold (Alice→Bob og Carol→Bob er distinkte kanter), så ingen kant gjentas.
  • ENKELT — blokkerer denne veien. Bob dukker opp mer enn én gang, og SIMPLE tillater bare at en node gjentas hvis det er både starten og slutten av stien (en lukket syklus). Her er Alice starten og Bob er slutten, så det gjelder ikke noe unntak.
  • ACYCLIC — blokkerer denne veien. Bob dukker opp mer enn én gang hvor som helst i stien.

Følgende eksempel viser hvordan man kan telle TRAIL hvor mange forskjellige stier som leder til hver av de første 100 personene som kan nås i Alices nettverk innen fire hopp:

MATCH TRAIL (src:Person WHERE src.firstName = 'Alice')-[:knows]->{1,4}(dst:Person)
LET personId = dst.id
RETURN personId, dst.firstName, dst.lastName, count(*) AS pathCount
GROUP BY personId, dst.firstName, dst.lastName
ORDER BY pathCount DESC
LIMIT 100

Bruk ACYCLIC det til å returnere opptil 100 personer tilgjengelig fra Alice innen fire hopp, hvor hver person på stien er unik:

MATCH ACYCLIC (src:Person WHERE src.firstName = 'Alice')-[:knows]->{1,4}(dst:Person)
RETURN dst.firstName, dst.lastName
LIMIT 100

Standard REPEATABLE ELEMENTS match-modus lar en kant gjenbrukes av separate stier i samme grafmønster. Bruk DIFFERENT EDGES eller DIFFERENT RELATIONSHIPS når hver kantbinding over alle baner må være forskjellig:

MATCH DIFFERENT EDGES
  (p:Person)-[:knows]->(friend:Person),
  (p)-[:knows]->(other:Person)
RETURN p.firstName, friend.firstName, other.firstName
LIMIT 100

Returner én korteste vei

ALL er standard stisøk og returnerer alle matchende stier. Bruk ANY SHORTEST for å returnere én korteste vei for hvert kilde-destinasjonspar. Følgende spørring finner den korteste veien fra Alice til Bob:

MATCH p = ANY SHORTEST
  (src:Person WHERE src.firstName = 'Alice')-[:knows]->{1,4}
  (dst:Person WHERE dst.firstName = 'Bob')
RETURN p, path_length(p) AS hopCount

Når flere korteste stier knyttes sammen, er ikke hvilken vei som returneres deterministisk. ALL SHORTEST Og ANY stisøk støttes ikke.

Predikatplassering kan endre resultatet av ANY SHORTEST. Inline-node- og kantpredikater begrenser hvilke stier som er kvalifiserte, mens et postfilter kan fjerne den valgte stien uten å velge en lengre sti i stedet. Se plasseringspredikater før eller etter valg av sti.

Tips

Foretrekk en endelig øvre grense for forutsigbar spørringskostnad. Ubegrensede ALL WALK mønstre støttes ikke. Ubegrensede mønstre med TRAIL, SIMPLE, eller ACYCLIC avsluttes gjennom elementets unikhet, men kan fortsatt returnere mange stier. Unbounded ANY SHORTEST WALK støtter kun spesifikke spørringsformer. Se Nåværende begrensninger.

Bruk variabel gjenbruk for å uttrykke delte enheter

Å gjenbruke samme variabel i to deler av et mønster skaper en implisitt likhetsbegrensning – begge referansene må matche samme node. Denne teknikken lar deg uttrykke «finn enheter koblet sammen gjennom en delt tredje enhet.»

For eksempel, for å finne opptil 100 par mennesker som kjenner hverandre og jobber i samme selskap:

MATCH (c:Company)<-[:workAt]-(a:Person)-[:knows]-(b:Person)-[:workAt]->(c)
RETURN a.firstName, b.firstName, c.name
LIMIT 100

Variabelen c gjenbrukes for begge workAt målene, så spørringen returnerer kun par der begge kjenner hverandre og jobber i samme selskap.

For å finne opptil 100 par personer som begge likte det samme innlegget:

MATCH (a:Person)-[:likes]->(post:Post)<-[:likes]-(b:Person)
WHERE a.id < b.id
RETURN a.firstName, b.firstName, post.id
LIMIT 100

Tips

Betingelsen WHERE a.id < b.id forhindrer at duplikatpar (Alice + Bob og Bob + Alice) dukker opp i resultatene.

Kombiner flere mønstre

List opp flere mønstre i ett enkelt MATCH, adskilt med kommaer. Gjenbruk en variabel når mønstrene må binde det samme grafelementet.

For eksempel, for å finne opptil 100 personer sammen med både arbeidsplassen deres og byen de bor i:

MATCH (p:Person)-[:workAt]->(c:Company),
      (p)-[:isLocatedIn]->(city:City)
RETURN p.firstName, c.name AS company, city.name AS city
LIMIT 100

Den delte variabelen p forbinder de to mønstrene. Hver resultatrad representerer én person med deres selskap og by.

Usammenhengende mønstre er også gyldige, men de danner et kartesiansk produkt av sine matcher. Bruk dem bare når du bevisst trenger alle kombinasjonene. For ytelsesveiledning, se Bruk delte variabler for effektive joins.

Match-valgfrie forhold

Bruk OPTIONAL MATCH når en relasjon kanskje ikke eksisterer for hver node. Rader uten match beholdes med NULL verdier, likt en SQL LEFT JOIN.

For eksempel, returner opptil 100 personer med sitt firmanavn, inkludert personer uten arbeidsgiver (det vil si som returnerer NULL for selskapskolonnen):

MATCH (p:Person)
OPTIONAL MATCH (p)-[:workAt]->(c:Company)
RETURN p.firstName, p.lastName, c.name AS company
LIMIT 100

Bruk IS NULL After OPTIONAL MATCH for å finne opptil 100 personer som ikke jobber i noen bedrift:

MATCH (p:Person)
OPTIONAL MATCH (p)-[:workAt]->(c:Company)
FILTER c IS NULL
RETURN p.firstName, p.lastName
LIMIT 100

Relatert innhold

  • Last updated on