Skriv almindelige GQL-forespørgsler i Microsoft Fabric

Denne artikel giver praktiske GQL-forespørgselsmønstre for almindelige grafopgaver i Microsoft Fabric: at finde naboer, traversere multihop-forbindelser, identificere delte forbindelser, tælle relationer og finde enheder uden forbindelser.

Eksemplerne bruger det sociale netværks eksempeldatasæt. For en ende-til-ende forklaring af forespørgselsflow og sætninger, se GQL sprogvejledning. Brug denne artikel, når du ved, hvilken grafopgave du vil udføre. For systematisk instruktion i konstruktion af node-, kant- og stimønstre, se Write graph pattern queries. For detaljerede filtrerings- og aggregeringsarbejdsgange, se Filter og aggreger grafdata.

Forudsætninger

• Et grafelement bygget ud fra det sociale netværks eksempeldatasæt, med nodetyper, kanttyper og egenskaber beskrevet i eksemplet med sociale netværksskema.
• Fortrolighed med grundlæggende MATCH og RETURN forespørgsler. Se GQL-sprogvejledningen.

Find direkte naboer

Returner alle noder, der er forbundet til en startnode, med ét hop.

Find alle, en bestemt person kender:

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

Find alle de virksomheder, en person har arbejdet for:

MATCH (p:Person WHERE p.firstName = 'Alice')-[:workAt]->(c:Company)
RETURN c.name, c.url

Find venners venner (multi-hop)

Brug mønstre med variabel længde til {min,max} at krydse mere end ét hop.

Find folk, der kan nås præcis to knows sider fra Alice:

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

Find alle tilgængelige inden for tre grader:

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

Find den korteste vej fra Alice til hver person, der kan nås inden for fire hop:

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

Hvis flere korteste stier når den samme person i samme antal hop, ANY SHORTEST returnerer en af dem uden et deterministisk tie-valg.

Inline-prædikater begrænser, hvilke stier der er berettigede til ANY SHORTEST. Postfiltre aktiveres, efter at en korteste sti er valgt. For eksempler, se Place-prædikater før eller efter stivalg.

Optæl relationer pr. enhed

Brug GROUP BY med count(*) til at tælle, hvor mange relationer hver enhed har. For detaljeret gruppering, aggregeret filtrering og betingede routingmønstre, se Filter og aggregerede grafdata.

Tæl hvor mange venner hver person har, ordnet fra flest til færrest:

MATCH (p:Person)-[:knows]->(friend:Person)
LET personId = p.id, name = p.firstName || ' ' || p.lastName
RETURN personId, name, count(*) AS friendCount
GROUP BY personId, name
ORDER BY friendCount DESC
LIMIT 20

Beregn en værdi for hver enhed

Brug en korreleret CALL delforespørgsel til at beregne en værdi for hver input-række. Variabler fra den ydre forespørgsel er implicit tilgængelige inde i underforespørgslen.

Beregn antallet af venner for hver person:

MATCH (p:Person)
CALL {
  MATCH (p)-[:knows]->(friend:Person)
  RETURN count(*) AS friendCount
}
RETURN p.firstName, p.lastName, friendCount
ORDER BY friendCount DESC

Ydre variable forbliver tilgængelige efter CALL. Af de variable, der oprettes inde i underforespørgslen, bliver kun returnerede kolonner tilgængelige udenfor. En ugrupperet count(*) vender tilbage, 0 når der ikke findes matchende venner, så denne forespørgsel fastholder folk, der ikke har nogen venner.

Ordinary CALL fjerner en ydre række, når underforespørgslen ikke returnerer nogen rækker, og producerer én outputrække for hver underforespørgselsrække, når den returnerer flere rækker. Brug OPTIONAL CALL den, når du skal bevare en ydre række, der ikke har en matchende underforespørgselsrække.

Find fælles forbindelser

Genbrug af en variabel i to dele af et mønster skaber en implicit "samme node"-begrænsning. Brug denne begrænsning til at finde enheder, der er forbundet gennem en delt tredje enhed.

Find par af personer, der begge kender den samme person:

MATCH (a:Person)-[:knows]->(mutual:Person)<-[:knows]-(b:Person)
WHERE a.id < b.id
RETURN a.firstName, b.firstName, mutual.firstName AS sharedContact
LIMIT 100

Find par af personer, der arbejder i samme virksomhed:

MATCH (c:Company)<-[:workAt]-(a:Person), (c)<-[:workAt]-(b:Person)
WHERE a.id < b.id
RETURN a.firstName, b.firstName, c.name AS company
LIMIT 100

Find enheder uden relationer

Brug NOT EXISTS til at finde noder, hvor en korreleret underforespørgsel ikke returnerer nogen rækker.

Find folk, der ikke arbejder i nogen virksomhed:

MATCH (p:Person)
WHERE NOT EXISTS {
  MATCH (p)-[:workAt]->(c:Company)
  RETURN c
}
RETURN p.firstName, p.lastName
LIMIT 100

Find opslag uden kommentarer:

MATCH (post:Post)
WHERE NOT EXISTS {
  MATCH (comment:Comment)-[:replyOf]->(post)
  RETURN comment
}
RETURN post.id, post.content
LIMIT 100

Find enheder med mange forbindelser

Kombiner GROUP BY og FILTER identificer højt forbundne noder. Denne metode er nyttig til at finde knudepunkter eller outliers.

Find folk med mere end 10 venner:

MATCH (p:Person)-[:knows]->(friend:Person)
LET personId = p.id, name = p.firstName || ' ' || p.lastName
RETURN personId, name, count(*) AS friendCount
GROUP BY personId, name
FILTER friendCount > 10
ORDER BY friendCount DESC

Relateret indhold

• GQL-sprogvejledning
• GQL-grafmønstre
• Filter- og aggregeret grafdata
• Optimer ydeevnen for GQL-forespørgsler