Skriva vanliga GQL-frågor i Microsoft Fabric

Den här artikeln innehåller praktiska GQL-frågemönster för vanliga grafuppgifter i Microsoft Fabric: hitta grannar, bläddra i multihop-anslutningar, identifiera delade anslutningar, räkna relationer och hitta entiteter utan anslutningar.

I exemplen används exempeldatauppsättningen för sociala nätverk. För en helhetsförklaring av frågeflöde och satser, se GQL-språkguiden. Använd den här artikeln när du vet vilken grafuppgift du vill utföra. För systematisk instruktion i att konstruera nod-, kant- och vägmönster, se Skriv grafmönsterfrågor. För detaljerade filtrerings- och aggregeringsarbetsflöden, se Filtrera och aggregera grafdata.

Förutsättningar

• Ett grafobjekt byggt från det sociala nätverkets exempeldataset, med nodtyper, kanttyper och egenskaper som beskrivs i exemplet med sociala nätverksschema.
• Kunskaper om grundläggande MATCH- och RETURN-sökfrågor. Se språkguiden för GQL.

Hitta direkta grannar

Returnera alla noder som är anslutna till en startnod med ett hopp.

Hitta alla som en specifik person känner:

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

Hitta alla företag som en person arbetade på:

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

Hitta vänner till vänner (flera steg)

Använd mönster med variabel längd med {min,max} för att navigera flera hopp.

Hitta personer som kan nås från Alice via exakt två knows kanter:

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

Hitta alla som kan nås inom tre grader:

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

Hitta en kortaste väg från Alice till varje person som är tillgänglig inom fyra hopp:

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

Om flera kortaste vägar når samma person med samma antal hopp returnerar ANY SHORTEST en av dem utan någon deterministisk regel för att välja mellan dem.

Inline-predikat begränsar vilka vägar som är berättigade till ANY SHORTEST. Postfilter tillämpas efter att en kortaste väg har valts. För exempel, se Platspredikat före eller efter vägval.

Räkna relationer per entitet

Använd GROUP BY med count(*) för att räkna hur många relationer varje entitet har. För detaljerad gruppering, aggregerad filtrering och villkorliga routningsmönster, se Filter och aggregerad grafdata.

Räkna hur många vänner varje person har, ordnade från flest till färst.

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

Beräkna ett värde för varje enhet

Använd en korrelerad CALL delfråga för att beräkna ett värde för varje inmatningsrad. Variabler från den yttre frågan är implicit tillgängliga inom delfrågan.

Beräkna antalet vänner för varje person:

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

Yttre variabler förblir tillgängliga efter CALL. Av de variabler som skapas i delförfrågan blir endast returnerade kolumner tillgängliga utanför den. Ett ogrupperat count(*) returnerar 0 när inga matchande vänner finns, så den här frågan behåller personer som inte har några vänner.

Ordinary CALL tar bort en yttre rad när delfrågan inte returnerar några rader och producerar en utgångsrad för varje underfrågerad när den returnerar flera rader. Använd OPTIONAL CALL när du behöver behålla en rad i den yttre frågan som inte har någon matchande rad i underfrågan.

Hitta delade anslutningar

Om du återanvänder en variabel i två delar av ett mönster skapas en implicit "samma nod"-begränsning. Använd den här begränsningen för att hitta entiteter som är anslutna via en delad tredje entitet.

Hitta par med personer som båda känner samma 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

Hitta par med personer som arbetar på samma företag:

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

Hitta entiteter utan relationer

Använd NOT EXISTS för att hitta noder där en korrelerad delfråga inte ger några rader.

Hitta personer som inte arbetar på något företag:

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

Hitta inlägg utan kommentarer:

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

Hitta entiteter med många anslutningar

Kombinera GROUP BY och FILTER identifiera höganslutna noder. Den här metoden är användbar för att hitta hubbar eller extremvärden.

Hitta personer med fler än 10 vänner:

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

Relaterat innehåll

• Språkguide för GQL
• GQL-grafmönster
• Filtrera och aggregera grafdata
• Optimera GQL-frågeprestanda