Skriv grafmønsterforespørgsler i Microsoft Fabric

Grafmønster-matching lader dig beskrive strukturen af de data, du ønsker at finde, ved hjælp af intuitiv, visuel syntaks. I stedet for at forbinde tabeller skriver du mønstre, der ligner relationerne selv – noder forbundet af kanter. Denne artikel viser dig, hvordan du skriver GQL-mønsterforespørgsler for almindelige scenarier i graf i Microsoft Fabric.

Eksemplerne bruger det sociale netværks eksempeldatasæt. For en fuld mønstersyntaksreference, se GQL-grafmønstre.

Forudsætninger

• Et grafelement med data indlæst. Hvis du er ny til graf, så gennemfør tutorialen først.
• Fortrolighed med grundlæggende MATCH og RETURN forespørgsler. Se GQL-sprogvejledningen.

Match direkte relationer

Et grundlæggende mønster matcher en nodetype, en specifik kanttype og en anden nodetype. Syntaksen ligner et diagram over relationen.

For eksempel for at finde op til 100 personer parret med den virksomhed, de arbejder hos:

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

Brug et urettet kantmønster, når du ikke kender eller ikke bekymrer dig om retningen. For eksempel at finde op til 100 fælles bekendte, uanset hvem der tog initiativ til forbindelsen:

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

Filtrer mønstre med inline HVOR

Placer WHERE det inde i mønsteret for at filtrere noder og kanter, efterhånden som de matches. Denne tilgang er mere effektiv end at filtrere bagefter.

For eksempel at finde personer født før 1990, som arbejder i en virksomhed, hvis navn starter 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å kantegenskaber for at begrænse, hvilke relationer der matcher. For eksempel kun at returnere personer, der begyndte at arbejde i en virksomhed 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 relationer

Brug mønstre med variabel længde til at gennemgå flere hop i ét udtryk. Angiv minimums- og maksimumstal af hop med {min,max} syntaks.

For eksempel for at finde op til 100 personer, der kan nås inden for to til fire grader af venskab fra Alice:

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

For at finde op til 100 umiddelbare og andengradsforbindelser (et eller to hop) fra Alice:

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

Kontrolgennemgang med sti-tilstande

Som standard bruger TRAIL GQL tilstand, som forhindrer den samme kant i at blive krydset mere end én gang. Brug sti-tilstande eksplicit, når du har brug for forskellige garantier.

WALK er den mest tilladende tilstand og ACYCLIC den mest restriktive. TRAIL er standarden og fungerer godt til de fleste forespørgsler. Brug kun en mere restriktiv tilstand, når dit brugsscenarie kræver det.

For at illustrere forskellen, betragt stien Alice → Bob → Carol → Bob:

• WALK — tillader denne vej. Noder og kanter kan gentages frit.
• TRAIL — tillader denne sti. Bob optræder to gange, men hver kant har et forskelligt forhold (Alice→Bob og Carol→Bob er forskellige kanter), så ingen kant gentages.
• SIMPELT — blokerer denne vej. Bob optræder mere end én gang, og SIMPLE tillader kun, at en node gentager, hvis det både er starten og slutningen af stien (en lukket cyklus). Her er Alice starten, og Bob er slutningen, så der er ingen undtagelse.
• ACYCLIC — blokerer denne vej. Bob dukker op mere end én gang hvor som helst på stien.

Følgende eksempel viser, hvordan man kan tælle TRAIL , hvor mange forskellige stier der fører til hver af de første 100 personer, der kan nås i Alices netværk inden for fire hop:

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

Brug ACYCLIC det til at returnere op til 100 personer, der kan nås fra Alice inden for fire hop, 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

Brug variabel genbrug til at udtrykke delte enheder

Genbrug af den samme variabel i to dele af et mønster skaber en implicit lighedsbegrænsning – begge referencer skal matche den samme node. Denne teknik lader dig udtrykke "find entiteter forbundet gennem en delt tredje enhed."

For eksempel at finde op til 100 par mennesker, der kender hinanden og arbejder i samme virksomhed:

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

Variablen c genbruges for begge workAt mål, så forespørgslen kun returnerer par, hvor begge personer kender hinanden og arbejder i samme virksomhed.

For at finde op til 100 par personer, der begge kunne lide det samme opslag:

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

Kombiner flere mønstre

List flere mønstre i et enkelt MATCH, adskilt af kommaer. Alle mønstre skal have mindst én variabel til fælles for at kunne forbinde korrekt.

For eksempel for at finde op til 100 personer sammen med både deres arbejdsplads og den by, 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 variabel p forbinder de to mønstre. Hver resultatrække repræsenterer én person med deres firma og by.

Match-valgfrie relationer

Brug OPTIONAL MATCH når en relation måske ikke eksisterer for hver node. Rækker uden match bevares med NULL værdier, ligesom i SQL LEFT JOIN.

For eksempel, returner op til 100 personer med deres firmanavn, inklusive personer uden arbejdsgiver (dvs. som returnerer NULL for virksomhedskolonnen):

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

Brug IS NULL After OPTIONAL MATCH for at finde op til 100 personer, der ikke arbejder i nogen virksomhed:

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

Relateret indhold

• GQL-grafmønstre
• GQL-sprogvejledning
• Filter- og aggregeret grafdata
• Skriv almindelige GQL-forespørgsler
• Optimer ydeevnen for GQL-forespørgsler
• Nuværende begrænsninger