Algemene GQL-query's schrijven in Microsoft Fabric

Dit artikel bevat praktische GQL-querypatronen voor algemene grafiektaken in Microsoft Fabric: buren zoeken, multihop-verbindingen doorlopen, gedeelde verbindingen identificeren, relaties tellen en entiteiten zonder verbindingen zoeken.

In de voorbeelden wordt de voorbeeldgegevensset van het sociale netwerk gebruikt. Voor een end-to-end uitleg van queryflow en statements, zie de GQL-taalgids. Gebruik dit artikel als je weet welke grafiektaak je wilt uitvoeren. Voor systematische instructies over het construeren van knoop-, rand- en padpatronen, zie Write graph pattern queries. Voor gedetailleerde filter- en aggregatieworkflows, zie Filter- en aggregatiegrafiekgegevens.

Prerequisites

• Een graafitem opgebouwd uit de voorbeelddataset van sociale netwerken, met de knooptypes, randtypes en eigenschappen beschreven in het voorbeeld van het sociale netwerkschema.
• Bekendheid met basis MATCH en RETURN query's. Zie de GQL-taalhandleiding.

Directe buren zoeken

Retourneer alle knooppunten die zijn verbonden met een beginknooppunt met één hop.

Zoek iedereen die een specifieke persoon kent:

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

Zoek alle bedrijven op bij wie een persoon heeft gewerkt:

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

Vrienden van vrienden zoeken (multihop)

Gebruik patronen met variabele lengte met {min,max} om meer dan één hop te doorlopen.

Vind mensen die via precies twee knows kanten van Alice bereikbaar zijn:

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

Iedereen vinden die bereikbaar is binnen drie graden:

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

Vind één kortste route van Alice naar elke persoon die binnen vier sprongen bereikbaar is:

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

Als meerdere kortste paden dezelfde persoon bereiken met hetzelfde aantal sprongen, geeft ANY SHORTEST er één terug zonder een deterministische keuze tussen die paden.

Inline predicaten beperken welke paden in aanmerking komen voor ANY SHORTEST. Postfilters worden toegepast nadat een kortste pad is geselecteerd. Zie voor voorbeelden Predicaten vóór of na padselectie plaatsen.

Relaties per entiteit tellen

Gebruik GROUP BY met count(*) om te tellen hoeveel relaties elke entiteit heeft. Voor gedetailleerde groepering, aggregatiefiltering en conditionele routeringspatronen, zie Filter- en aggregatiegrafiekgegevens.

Tel hoeveel vrienden elke persoon heeft, van de meeste naar de minste:

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

Bereken een waarde voor elke entiteit

Gebruik een gecorreleerde CALL subquery om een waarde te berekenen voor elke invoerrij. Variabelen van de buitenste query zijn impliciet beschikbaar binnen de subquery.

Bereken het aantal vrienden per persoon:

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

Buitenvariabelen blijven beschikbaar na CALL. Van de variabelen die binnen de subquery worden aangemaakt, worden alleen teruggestuurde kolommen buiten deze functie beschikbaar. Een niet-gegroepeerde count(*) komt terug 0 wanneer er geen matchende vrienden zijn, dus deze zoekopdracht behoudt mensen die geen vrienden hebben.

Ordinary CALL laat een buitenste rij vallen wanneer de subquery geen rijen teruggeeft en produceert één uitvoerrij voor elke subqueryrij wanneer het meerdere rijen teruggeeft. Gebruik OPTIONAL CALL wanneer je een buitenste rij wilt behouden die geen overeenkomende subquery-rij heeft.

Gedeelde verbindingen zoeken

Als u een variabele in twee delen van een patroon opnieuw gebruikt, wordt een impliciete beperking voor hetzelfde knooppunt gemaakt. Gebruik deze beperking om entiteiten te vinden die zijn verbonden via een gedeelde derde entiteit.

Zoek paren van personen die beide dezelfde persoon kennen:

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

Zoek paren van personen die bij hetzelfde bedrijf werken:

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

Entiteiten zonder relaties zoeken

Gebruik NOT EXISTS om knopen te vinden waarvoor een gecorreleerde subquery geen rijen teruggeeft.

Personen zoeken die niet werken bij een enkel bedrijf:

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

Berichten zoeken zonder opmerkingen:

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

Entiteiten zoeken met veel verbindingen

Combineer GROUP BY en FILTER identificeer sterk verbonden knooppunten. Deze methode is nuttig voor het vinden van hubs of uitschieters.

Personen zoeken met meer dan 10 vrienden:

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

Verwante inhoud

• GQL-taalhandleiding
• GQL-grafiekpatronen
• Grafiekgegevens filteren en aggregeren
• Prestaties van GQL-query's optimaliseren