Grafiekgegevens filteren en aggregeren in Microsoft Fabric

Als u filtert, worden de resultaten beperkt tot de rijen die belangrijk zijn. Met aggregatie worden deze rijen samengevat in aantallen, totalen en gemiddelden. In dit artikel leest u hoe u beide technieken in GQL-query's toepast op grafiek in Microsoft Fabric.

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 voor rij- en patroonfiltering, gegroepeerde en niet-gegroepeerde aggregatie, aggregate-specifieke filters en conditionele routing. Voor het construeren van multihoppatronen en het selecteren van paden, zie Write graph pattern queries. Voor kant-en-klare bedrijfstaken om aan te passen, zie Veelvoorkomende GQL-query's schrijven.

Prerequisites

Rijen filteren met FILTER

Gebruik FILTER deze functie om alleen de rijen te behouden die voldoen aan een voorwaarde. Plaats FILTER erna MATCH om de overeenkomende resultaten te beperken.

De volgende query retourneert alle vrouwen met hun naam en verjaardag:

MATCH (p:Person)
FILTER p.gender = 'female'
RETURN p.firstName, p.lastName, p.birthday

Meerdere voorwaarden combineren met AND en OR. De volgende query retourneert bijvoorbeeld de namen van alle vrouwen die vóór 1990 zijn geboren:

MATCH (p:Person)
FILTER p.gender = 'female' AND p.birthday < 19900101
RETURN p.firstName, p.lastName

Tip

Gebruik een inline-clausule WHERE wanneer de voorwaarde bepaalt welke node of edge aan de match mag deelnemen. Gebruik FILTER wanneer de voorwaarde van toepassing is op de rij die door een eerdere uitspraak wordt geproduceerd. Predicaatplaatsing kan de resultaten van het kortste pad veranderen; zie Plaats predicaten vóór of na padselectie.

Filteren tijdens het vergelijken van patronen

Inline WHERE clausules binnen een MATCH patroon beperken welke knooppunten en randen in aanmerking komen voor de match. De query-optimizer kan equivalente predicaten toepassen tijdens het scannen, dus de inline-syntaxis is niet per definitie sneller dan een aparte FILTER. Kies de vorm die de bedoelde semantiek uitdrukt.

Als u bijvoorbeeld personen wilt vinden die vóór 1994 zijn geboren, samen met het bedrijf waar ze werken, beperkt u de resultaten tot bedrijven waarvan de naam begint met 'A':

MATCH (p:Person WHERE p.birthday < 19940101)-[:workAt]->(c:Company WHERE c.name STARTS WITH 'A')
RETURN p.firstName, p.lastName, c.name

Eigenschappen van de grafiekranden op dezelfde manier filteren. Als u bijvoorbeeld alleen personen wilt weergeven die in 2000 of later bij een bedrijf zijn begonnen te werken:

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

Voor meer informatie over de keuze tussen inline en post-match filtering, zie Optimaliseer GQL-queryprestaties.

Omgaan met nulwaarden in filters

GQL maakt gebruik van driewaardelogica: predicaten evalueren naar TRUE, FALSE of UNKNOWN. Wanneer een eigenschapswaarde null is, worden vergelijkingen geretourneerd UNKNOWN. FILTER UNKNOWN wordt behandeld als niet-overeenkomend, dus de rij wordt uitgesloten.

Gebruik IS NULL en IS NOT NULL test expliciet op null-waarden:

-- Only include people whose browser is known
MATCH (p:Person)
FILTER p.browserUsed IS NOT NULL
RETURN p.firstName, p.browserUsed

Gebruik coalesce() dit om een standaardwaarde te vervangen wanneer een eigenschap null kan zijn:

MATCH (p:Person)
RETURN p.firstName, coalesce(p.browserUsed, 'Unknown browser') AS browser

Caution

NULL = NULL resulteert in UNKNOWN, niet TRUE. IS NULL Gebruik altijd om te testen op null-waarden, niet gelijkheid.

Resultaten aggregeren met RETURN

Gebruik samengevoegde functies in RETURN om uw resultaten samen te vatten. De graaf ondersteunt de volgende aggregate functies: COUNT, , , AVG, MINMAX, COLLECT_LIST, , COLLECT_ONE, en COLLECT_ELEMENTSSUM.

Als u bijvoorbeeld alle personen in de grafiek wilt tellen:

MATCH (p:Person)
RETURN count(*) AS totalPeople

Als u afzonderlijke waarden wilt tellen, zoals het aantal afzonderlijke bedrijven dat mensen in dienst heeft:

MATCH (p:Person)-[:workAt]->(c:Company)
RETURN count(DISTINCT c) AS companyCount

Filterinvoer voor één aggregaat

Voeg na een aggregaat toe FILTER (WHERE predicate) om alleen de input van dat aggregaat te filteren. Andere aggregaten in dezelfde RETURN groep ontvangen nog steeds alle invoerrijen.

MATCH (p:Person)
RETURN count(*) AS allPeople,
       count(*) FILTER (WHERE p.birthday < 19900101) AS peopleBornBefore1990

Voeg LIMIT toe binnen het aggregatiefilter om hoogstens zoveel kwalificerende rijen te gebruiken. De query past het predicaat toe vóór de aggregaatspecifieke limiet.

MATCH (p:Person)
RETURN count(*) FILTER (WHERE p.birthday < 19900101 LIMIT 100) AS sampleCount

Aggregaatspecifieke FILTER en LIMIT verwijderen geen rijen uit de rest van de query. Gebruik een FILTER instructie of een WHERE clausule op matchniveau als je de rijenstroom wilt filteren.

Waarden verzamelen

Gebruik COLLECT_LIST om één lijstelement terug te geven voor elke invoerwaarde, inclusief null-waarden. Voeg toe DISTINCT om duplicaten te verwijderen.

MATCH (p:Person)
RETURN collect_list(DISTINCT p.browserUsed) AS browsers

COLLECT_ONE geeft één niet-nul invoerwaarde terug. De geselecteerde waarde is niet deterministisch, dus gebruik hem alleen wanneer een waarde uit de groep acceptabel is.

COLLECT_ELEMENTS accepteert lijstwaardige invoer en voegt hun elementen samen tot één lijst:

MATCH (p:Person)
RETURN collect_elements([p.firstName, p.lastName]) AS names

Zonder kolommen te groeperen, geeft een aggregatiequery zonder invoerrijen een lege lijst uit COLLECT_LIST en COLLECT_ELEMENTS en null uit COLLECT_ONEterug.

Groepsresultaten met GROUP BY

Gebruik GROUP BY in RETURN om rijen te groeperen op basis van gedeelde waarden en rekenaggregaties binnen elke groep. Deze groepering is het GQL-equivalent van SQL GROUP BY.

Als u bijvoorbeeld werknemers per bedrijf wilt tellen:

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

Groeperen op meerdere kolommen en meerdere aggregaties tegelijk berekenen. U kunt bijvoorbeeld het aantal personen en het verjaardagsbereik op geslacht en browser opsplitsen en de tien meest voorkomende combinaties retourneren:

MATCH (p:Person)
LET gender = p.gender
LET browser = p.browserUsed
RETURN gender,
       browser,
       count(*) AS personCount,
       min(p.birthday) AS earliestBirthday,
       max(p.birthday) AS latestBirthday
GROUP BY gender, browser
ORDER BY personCount DESC
LIMIT 10

Note

Alle niet-geaggregeerde expressies in RETURN moeten voorkomen in GROUP BY. Expressies die niet in GROUP BY staan, moeten een aggregatiefunctie gebruiken.

Geaggregeerde resultaten sorteren en beperken

Gebruik ORDER BY en LIMIT samen met GROUP BY om top-N-resultaten te vinden.

Als u bijvoorbeeld de vijf belangrijkste steden wilt vinden op basis van het aantal inwoners:

MATCH (p:Person)-[:isLocatedIn]->(city:City)
LET cityId = city.id, cityName = city.name
RETURN cityId, cityName, count(*) AS residentCount
GROUP BY cityId, cityName
ORDER BY residentCount DESC
LIMIT 5

Belangrijk

Plaats ORDER BY voor LIMIT. LIMIT is altijd van toepassing op de reeds gesorteerde resultatenset.

Routerijen met conditionele statements

Gebruik een conditionele instructie om elke binnenkomende rij naar de eerste overeenkomende tak te routeren. De invoer kan afkomstig zijn van elke voorafgaande queryfase, niet alleen van een aggregatie. De volgende query categoriseert bijvoorbeeld bedrijven na het berekenen van hun aantal medewerkers:

MATCH (p:Person)-[:workAt]->(c:Company)
LET companyId = c.id, companyName = c.name
RETURN companyId, companyName, count(*) AS employeeCount
GROUP BY companyId, companyName
NEXT
WHEN employeeCount >= 100u THEN
  RETURN companyId, companyName, employeeCount, 'Large' AS category
WHEN employeeCount >= 10u THEN
  RETURN companyId, companyName, employeeCount, 'Medium' AS category
ELSE
  RETURN companyId, companyName, employeeCount, 'Small' AS category

Branches kunnen volledige query-statements en geneste procedures uitvoeren, in plaats van niet alleen expressies terug te geven. Het volgende voorbeeld stuurt drie invoerrijen door verschillende takvormen. Eén tak voert een MATCH uit, een combineert twee aggregaten met UNION ALL en aggregeert vervolgens de resultaten daarvan, en de fallback-tak geeft een constante terug:

FOR selector IN [1, 2, 3]
RETURN selector
NEXT
WHEN selector = 1 THEN
  MATCH (:Person)-[:knows]->(:Person)
  RETURN count(*) AS total, 'Knows edges' AS category
WHEN selector = 2 THEN {
  MATCH (:Person)-[:workAt]->(:Company)
  RETURN count(*) AS partialCount
  UNION ALL
  MATCH (:Person)-[:studyAt]->(:University)
  RETURN count(*) AS partialCount
  NEXT
  RETURN sum(partialCount) AS total, 'Affiliation edges' AS category
}
ELSE
  RETURN 0u AS total, 'No selected metric' AS category

De query-engine evalueert de predicaten in volgorde voor elke rij. Voert alleen de eerste overeenkomende vertakking uit. Als een predicaat evalueert naar UNKNOWN, gaat de evaluatie verder met de volgende tak. Zonder een ELSE, worden rijen die niet overeenkomen met een WHEN tak weggelaten.

Conditionele statements verschillen van CASE expressies. Graph ondersteunt eenvoudige CASE <expression> WHEN <value> expressies voor gelijkheidsgebaseerde waardeselectie. Gezochte CASE WHEN <predicate> expressies worden niet ondersteund. Voor meer informatie, zie Voorwaardelijke instructies.

Verwante inhoud

  • Laatst bijgewerkt om