Skriva diagrammönsterfrågor i Microsoft Fabric

Med matchning av grafmönster kan du beskriva strukturen för de data som du vill hitta med hjälp av intuitiv, visuell syntax. I stället för att koppla tabeller skriver du mönster som ser ut som själva relationerna – noder som är anslutna via kanter. Den här artikeln visar hur du skriver GQL-mönsterfrågor för vanliga scenarier i grafen i Microsoft Fabric.

I exemplen används exempeldatauppsättningen för sociala nätverk. En fullständig mönstersyntaxreferens finns i GQL-grafmönster.

Använd den här artikeln för att lära dig hur man konstruerar och kombinerar nod-, kant- och banmönster. För färdiga uppgifter som att hitta grannar eller entiteter utan relationer, se Skriv vanliga GQL-frågor. För filtrering, gruppering och aggregerade arbetsflöden, se Filter och aggregera grafdata.

Förutsättningar

Matcha direkta relationer

Ett grundläggande mönster matchar en nodtyp, en specifik kanttyp och en annan nodtyp. Syntaxen ser ut som ett diagram över relationen.

Om du till exempel vill hitta upp till 100 personer kopplade till företaget de arbetar på:

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

Använd ett oriktat kantmönster när du inte vet eller inte bryr dig om riktning. Om du till exempel vill hitta upp till 100 gemensamma bekanta oavsett vem som initierade anslutningen:

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

Note

Grafen stöder för närvarande inte att skapa oriktade kanter, men du kan fråga efter kanter i valfri riktning genom att använda syntaxen -[:label]-.

Filtrera mönster med inlinje WHERE

Placera WHERE i mönstret när ett villkor definierar vilken nod eller kant som kan delta i matchen. Använd ett satsnivåvillkor MATCH ... WHERE för att efterfiltrera den avslutade matchningen, eller ett separat FILTER när villkoret gäller för raden som producerats av ett tidigare påstående. Predikatplacering kan ändra resultat för kortaste vägen. För mer information, se Place-predikaten före eller efter val av väg.

Till exempel för att hitta personer födda före 1990 som arbetar på ett företag vars namn börjar 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

Filtrera på gränsegenskaper för att begränsa vilka relationer som matchar. Om du till exempel bara vill returnera personer som började arbeta på ett företag 2010 eller senare:

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

Matcha relationer med flera hopp

Använd mönster med variabel längd för att navigera flera hopp i ett uttryck. Ange det lägsta och högsta antalet hopp med {min,max} syntax.

Till exempel för att hitta upp till 100 personer som kan nås inom två till fyra grader av vänskap från Alice:

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

För att hitta upp till 100 omedelbara och andra gradens anslutningar (ett eller två hopp) från Alice:

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

Kontrollera bläddering med sökvägslägen

Som standard använder WALKGQL , vilket tillåter upprepade noder och kanter. Använd ett annat path-läge när du behöver striktare elementunikhet.

Sökvägsläge Behavior Använd när...
WALK Tillåter upprepade noder och kanter (standard) Du vill ha alla matchande promenader inom en ändlig gräns.
TRAIL Inga upprepade kanter Du vill undvika att följa samma kant igen, men samma nod kan dyka upp genom olika kanter.
SIMPLE Inga upprepade noder förutom en gemensam start- och slutnod, och inga upprepade kanter Du vill att ingen nod ska visas mer än en gång mitt i en sökväg, men tillåt sökvägar som närmar sig början igen. Användbart för att identifiera loopar.
ACYCLIC Inga upprepade noder eller kanter Du måste garantera att ingen nod visas någonstans i sökvägen mer än en gång. Använd för strikta hierarkier, släktskap eller någon traversering där ett återbesök av en nod skulle ge felaktiga resultat.

WALK är det mest tillåtande läget och ACYCLIC är det mest restriktiva.

För SIMPLE och ACYCLICföljer kantens unikhet från nodens unikhet. En SIMPLE väg kan stängas genom att återvända till sin första nod, men den kan fortfarande inte återanvända en kant.

Tänk på vägen Alice → Bob → Carol → Bob för att illustrera skillnaden.

  • WALK – ger tillgång till den här sökvägen. Noder och kanter kan upprepas fritt.
  • TRAIL – tillåter den här sökvägen. Bob visas två gånger, men varje kant som används är en annan relation (Alice→Bob och Carol→Bob är distinkta kanter), så ingen kant upprepas.
  • SIMPLE – blockerar den här sökvägen. Bob visas mer än en gång och SIMPLE tillåter bara att en nod upprepas om det är både början och slutet av sökvägen (en stängd cykel). Här är Alice början och Bob är slutet, så inget undantag gäller.
  • ACYCLIC – blockerar den här sökvägen. Bob visas mer än en gång någonstans i sökvägen.

I följande exempel visas hur du använder TRAIL för att räkna hur många distinkta sökvägar som leder till var och en av de första 100 personer som kan nås i Alices nätverk inom fyra 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

Använd ACYCLIC för att returnera upp till 100 personer som kan nås från Alice inom fyra hopp, där varje person i sökvägen är unik:

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

Standardmatchningsläget REPEATABLE ELEMENTS tillåter att en kant återanvänds av separata vägar i samma grafmönster. Använd DIFFERENT EDGES eller DIFFERENT RELATIONSHIPS när varje kantbindning över alla vägar måste vara olika:

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

Återvänd en kortaste väg

ALL är standardsökvägen och returnerar varje matchande väg. Använd ANY SHORTEST för att returnera en kortaste väg för varje käll-destinationspar. Följande fråga hittar en kortaste väg från Alice till 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 flera kortaste vägar kopplas är det inte deterministiskt vilken väg som returneras. ALL SHORTEST och ANY sökningar efter sökvägar stöds inte.

Predikatplacering kan ändra resultatet av ANY SHORTEST. Predikat för inline-noder och -kanter begränsar vilka sökvägar som kan väljas, medan ett postfilter kan ta bort den valda sökvägen utan att i stället välja en längre sökväg. Se Place-predikaten före eller efter val av väg.

Tips/Råd

Föredra en ändlig övre gräns för förutsägbar frågekostnad. Obegränsade ALL WALK mönster stöds inte. Obegränsade mönster med TRAIL, SIMPLE, eller ACYCLIC avslutas genom elementets unikhet men kan ändå returnera många vägar. Unbounded ANY SHORTEST WALK stöder endast specifika frågeformer. Se Aktuella begränsningar.

Använd återanvändning av variabler för att representera delade entiteter

Om du återanvänder samma variabel i två delar av ett mönster skapas en implicit likhetsbegränsning – båda referenserna måste matcha samma nod. Med den här tekniken kan du uttrycka "hitta entiteter som är anslutna via en delad tredje entitet".

Om du till exempel vill hitta upp till 100 par personer som känner varandra och arbetar på samma företag:

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

Variabeln c återanvänds för båda workAt målen, så frågan returnerar bara par där båda känner varandra och arbetar på samma företag.

För att hitta upp till 100 par personer som båda gillade samma inlägg:

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

Tips/Råd

Villkoret WHERE a.id < b.id förhindrar att duplicerade par (Alice + Bob och Bob + Alice) visas i resultatet.

Kombinera flera mönster

Lista flera mönster i en enda MATCH, avgränsad med kommatecken. Återanvänd en variabel när mönstren måste binda samma grafelement.

För att till exempel hitta upp till 100 personer tillsammans med både deras arbetsplats och den stad 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 delade variabeln p ansluter de två mönstren. Varje resultatrad representerar en person med sitt företag och sin stad.

Osammanhängande mönster är också giltiga, men de bildar en kartesisk produkt av sina matchningar. Använd dem bara när du medvetet behöver varje kombination. För prestandaguidningar, se Använd delade variabler för effektiva joins.

Matcha valfria relationer

Använd OPTIONAL MATCH när en relation kanske inte finns för varje nod. Rader utan matchning behålls med NULL värden som liknar en SQL LEFT JOIN.

Visa till exempel upp till 100 personer med deras företagsnamn, inklusive personer utan arbetsgivare (det vill säga som har NULL för företagskolumnen):

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

Använd IS NULL efter OPTIONAL MATCH för att hitta upp till 100 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

Relaterat innehåll

  • Last updated on