Filtrer og aggreger grafdata i Microsoft Fabric

Filtrering begrenser resultatene dine til de radene som betyr noe. Aggregering oppsummerer disse radene i tellinger, totaler og gjennomsnitt. Denne artikkelen viser deg hvordan du kan bruke begge teknikkene i GQL-spørringer mot grafer i Microsoft Fabric.

Eksemplene bruker datasett fra sosiale nettverk. For en helhetlig forklaring av spørringsflyt og setninger, se GQL-språkguiden.

Bruk denne artikkelen for rad- og mønsterfiltrering, gruppert og ugruppert aggregering, aggregasjonsspesifikke filtre og betinget ruting. For å konstruere multihop-mønstre og velge stier, se Write graph pattern queries. For forretningsoppgaver som er klare til å tilpasses, se Skriv vanlige GQL-spørringer.

Forutsetninger

Filterrader med FILTER

Bruk FILTER å beholde kun radene som oppfyller en betingelse. Plassering FILTER etter MATCH for å begrense de matchede resultatene.

Følgende søk gir alle kvinner navn og fødselsdato:

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

Kombiner flere betingelser med AND og OR. For eksempel returnerer følgende søk navnene på alle kvinner født før 1990:

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

Tips

Bruk en inline-klausul WHERE når betingelsen definerer hvilken node eller kant som kan delta i matchen. Bruk FILTER når betingelsen gjelder for raden som produseres av en tidligere uttalelse. Plassering av predikater kan endre resultater for korteste vei; se Plasser predikater før eller etter valg av sti.

Filter under mønstergjengivelse

Inline-klausuler WHERE inne i et MATCH mønster begrenser hvilke noder og kanter som kvalifiserer for matchen. Spørringsoptimalisatoren kan bruke ekvivalente predikater under skanning, så inline-syntaksen er ikke iboende raskere enn en separat FILTER. Velg formen som uttrykker den tiltenkte semantikken.

For eksempel, for å finne personer født før 1994 sammen med selskapet de jobber i, og begrense resultatene til selskaper hvis navn begynner med 'A':

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

Filter kantegenskaper på samme måte. For eksempel, å returnere kun personer som begynte å jobbe i et selskap i 2000 eller senere:

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

For mer informasjon om valg mellom inline- og post-match-filtrering, se Optimaliser GQL-spørringsytelse.

Håndter nullverdier i filtre

GQL bruker treverdilogikk: predikater evaluerer til TRUE, FALSE, eller UNKNOWN. Når en egenskapsverdi er null, returnerer UNKNOWNsammenligninger . FILTER behandler UNKNOWN som ikke matchende, så raden er utelukket.

Bruk IS NULL og IS NOT NULL for å teste for nullverdier eksplisitt:

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

Bruk coalesce() for å erstatte en standardverdi når en egenskap kan være null:

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

Forsiktig!

NULL = NULL vurderer til UNKNOWN, ikke TRUE. Bruk den alltid IS NULL for å teste nullverdier, ikke likhet.

Samlede resultater med RETURN

Bruk aggregerte funksjoner for RETURN å oppsummere resultatene dine. Grafen støtter følgende aggregerte funksjoner: COUNT, SUM, , AVG, MIN, MAXCOLLECT_LIST, COLLECT_ONEog COLLECT_ELEMENTS.

For eksempel, for å telle alle personer i grafen:

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

For å telle ulike verdier som hvor mange forskjellige selskaper som ansetter folk:

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

Filterinput for ett aggregat

Legg til FILTER (WHERE predicate) etter et aggregat for å filtrere kun det aggregatets input. Andre aggregater i samme RETURN gruppe mottar fortsatt alle inngangsrader.

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

Legg til LIMIT i aggregasjonsfilteret for å bruke maksimalt like mange kvalifiserende rader. Spørringen anvender predikatet før den aggregasjonsspesifikke grensen.

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

Aggregasjonsspesifikt FILTER og LIMIT ikke fjern rader fra resten av spørringen. Bruk en FILTER setning eller en match-nivå-klausul WHERE når du vil filtrere radstrømmen.

Samle inn verdier

Bruk COLLECT_LIST for å returnere ett listeelement for hver inputverdi, inkludert nullverdier. Legg til DISTINCT for å fjerne duplikater.

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

COLLECT_ONE returnerer én ikke-null inngangsverdi. Den valgte verdien er ikke deterministisk, så bruk den bare når en hvilken som helst verdi fra gruppen er akseptabel.

COLLECT_ELEMENTS Godtar listeverdide input og sammenligner deres elementer til én liste:

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

Uten å gruppere kolonner returnerer en aggregert spørring uten inndatarader en tom liste fra COLLECT_LIST og COLLECT_ELEMENTS og null fra COLLECT_ONE.

Grupperesultater med GROUP BY

Bruk GROUP BY i RETURN for å gruppere rader etter delte verdier og beregne aggregater innenfor hver gruppe. Denne grupperingen er GQL-ekvivalenten til SQL GROUP BY.

For eksempel, for å telle ansatte per selskap:

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

Grupper etter flere kolonner og beregn flere aggregater samtidig. For eksempel, bryt ned antall personer og fødselsområde etter kjønn og nettleser, og gi de 10 vanligste kombinasjonene:

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 ikke-aggregerte uttrykk i RETURN må forekomme i GROUP BY. Uttrykk som ikke er i GROUP BY må bruke en aggregert funksjon.

Sorter og begrens aggregerte resultater

Bruk ORDER BY og LIMIT sammen GROUP BY for å finne topp-N resultater.

For eksempel, for å finne de fem største byene etter antall innbyggere:

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

Viktig!

Plasser ORDER BY før LIMIT. LIMIT gjelder alltid for det allerede sorterte resultatsettet.

Rute rader med betingede setninger

Bruk en betinget setning for å rute hver innkommende rad til den første matchende grenen. Inndata kan komme fra et hvilket som helst foregående spørringsstadium, ikke bare en aggregering. For eksempel kategoriserer følgende spørring selskaper etter å ha beregnet antall ansatte:

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

Grener kan kjøre komplette spørringssetninger og nestede prosedyrer, i stedet for bare å returnere uttrykk. Følgende eksempel sender tre inngangsrader gjennom forskjellige grenformer. En gren kjører en MATCH, en kombinerer to aggregater med UNION ALL og aggregerer deretter resultatene deres, og fallback-grenen returnerer en konstant:

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

Spørringsmotoren evaluerer predikatene i rekkefølge for hver rad. Den kjører kun den første matchende grenen. Hvis et predikat evaluerer til UNKNOWN, fortsetter evalueringen med neste gren. Uten en ELSE, utelates rader som ikke matcher en WHEN gren.

Betingede setninger er forskjellige fra CASE uttrykk. Graph støtter enkle CASE <expression> WHEN <value> uttrykk for likhetsbasert verdivalg. Søkte CASE WHEN <predicate> uttrykk støttes ikke. For mer informasjon, se Betingede setninger.

Relatert innhold

  • Last updated on