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.

Exempel använder exempeldatauppsättningen för sociala nätverk. Fullständig språkreferens finns i GQL-språkguiden.

Förutsättningar

• Ett diagramobjekt med data inlästa. Om du är ny inom grafteknologi, slutför först självstudien.
• 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 människor två hopp bort - vänner till Alices vänner som Alice inte direkt känner.

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

Räkna relationer per entitet

Använd GROUP BY med count(*) för att räkna hur många relationer varje entitet har.

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

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

Räkna hur många anställda som arbetar på varje företag:

MATCH (p:Person)-[:workAt]->(c:Company)
LET companyName = c.name
RETURN companyName, count(*) AS employeeCount
GROUP BY companyName
ORDER BY employeeCount DESC

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 OPTIONAL MATCH följt av en null-kontroll för att hitta noder som inte har någon matchande relation.

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

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

Hitta inlägg utan kommentarer:

MATCH (post:Post)
OPTIONAL MATCH (comment:Comment)-[:replyOf]->(post)
FILTER comment IS NULL
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 name = p.firstName || ' ' || p.lastName
RETURN name, count(*) AS friendCount
GROUP BY name
FILTER friendCount > 10
ORDER BY friendCount DESC

Relaterat innehåll

• Skriva diagrammönsterfrågor
• Filtrera och aggregera grafdata
• Språkguide för GQL
• GQL-grafmönster
• Optimera GQL-frågeprestanda
• Aktuella begränsningar