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.

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.

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

Filtrera mönster med inlinje WHERE

Placera WHERE inuti mönstret för att filtrera noder och kanter när de matchas. Den här metoden är effektivare än att filtrera i efterhand.

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

GQL använder som standard TRAIL-läge, vilket förhindrar att samma kant traverseras mer än en gång. Använd sökvägslägen explicit när du behöver olika garantier.

WALK är det mest tillåtande läget och ACYCLIC är det mest restriktiva. TRAIL är standard och fungerar bra för de flesta frågor. Använd endast ett mer restriktivt läge när ditt användningsfall kräver det.

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)
RETURN dst.firstName, dst.lastName, count(*) AS pathCount
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

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

Kombinera flera mönster

Lista flera mönster i en enda MATCH, avgränsad med kommatecken. Alla mönster måste dela minst en variabel så att de ansluts korrekt.

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.

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

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