Filtrer og aggreger grafdata i Microsoft Fabric

Filtrering indsnævrer dine resultater til de rækker, der betyder noget. Aggregering opsummerer disse rækker i tællinger, totaler og gennemsnit. Denne artikel viser dig, hvordan du anvender begge teknikker i GQL-forespørgsler mod grafer i Microsoft Fabric.

Eksemplerne bruger det sociale netværks eksempeldatasæt. For en ende-til-ende forklaring af forespørgselsflow og sætninger, se GQL sprogvejledning.

Brug denne artikel til række- og mønsterfiltrering, grupperet og ugrupperet aggregering, aggregatespecifikke filtre og betinget routing. For at konstruere multihop-mønstre og vælge stier, se Write graph pattern queries. For forretningsopgaver, der er klar til at tilpasse, se Skriv almindelige GQL-forespørgsler.

Forudsætninger

Filterrækker med FILTER

Brug FILTER kun de rækker, der opfylder en betingelse. Placer FILTER efter MATCH for at indsnævre de matchede resultater.

Følgende søgning returnerer alle kvinder med deres 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 forespørgsel navnene på alle kvinder født før 1990:

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

Tip

Brug en inline-klausul WHERE , når betingelsen definerer, hvilken node eller kant der kan deltage i matchen. Brug FILTER når betingelsen gælder for den række, der er produceret af en tidligere sætning. Placering af prædikater kan ændre resultaterne for korteste sti; se Placer prædikater før eller efter stivalg.

Filter under mønstergenkendelse

Inline-klausuler WHERE inden for et MATCH mønster begrænser, hvilke noder og kanter der kvalificerer til matchet. Forespørgselsoptimereren kan anvende ækvivalente prædikater under scanning, så inline-syntaksen er ikke automatisk hurtigere end en separat FILTER. Vælg den form, der udtrykker den tilsigtede semantik.

For eksempel at finde personer født før 1994 sammen med den virksomhed, hvor de arbejder, og begrænser resultaterne til virksomheder, hvis navn starter 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 kantegenskaber på samme måde. For eksempel kun at returnere personer, der begyndte at arbejde i en virksomhed 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 mere information om valg mellem inline og post-match filtrering, se Optimer GQL-forespørgselsydelse.

Håndter nullværdier i filtre

GQL bruger tre-værdi logik: prædikater evaluerer til TRUE, FALSE, eller UNKNOWN. Når en egenskabsværdi er nul, returnerer UNKNOWNsammenligninger . FILTER behandler UNKNOWN som ikke matchende, så rækken udelukkes.

Brug IS NULL og IS NOT NULL til eksplicit at teste for nullværdier:

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

Brug coalesce() til at erstatte en standardværdi, når en egenskab kan være null:

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

Advarsel!

NULL = NULL vurderer til UNKNOWN, ikke TRUE. Brug den altid IS NULL til at teste for nullværdier, ikke lighed.

Samlede resultater med RETURN

Brug aggregerede funktioner til RETURN at opsummere dine resultater. Grafen understøtter følgende samlede funktioner: , , , , MIN, MAXCOLLECT_LIST, COLLECT_ONEog COLLECT_ELEMENTS. AVGSUMCOUNT

For eksempel, for at tælle alle personer i grafen:

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

For at tælle forskellige værdier som hvor mange forskellige virksomheder der ansætter folk:

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

Filterinput for ét aggregat

Tilføj FILTER (WHERE predicate) efter et aggregat for kun at filtrere inputtet til det aggregat. Andre aggregater i samme RETURN kategori modtager stadig alle inputrækker.

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

Tilføj LIMIT i aggregationsfilteret for at bruge højst så mange kvalificerende rækker. Forespørgslen anvender prædikatet før den aggregationsspecifikke grænse.

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

Aggreger-specifik FILTER og LIMIT fjern ikke rækker fra resten af forespørgslen. Brug en FILTER sætning eller en match-level WHERE klausul, når du vil filtrere rækkestrømmen.

Samleværdier

Brug COLLECT_LIST til at returnere ét listeelement for hver inputværdi, inklusive nullværdier. Tilføj DISTINCT for at fjerne dubletter.

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

COLLECT_ONE returnerer én ikke-nul inputværdi. Den valgte værdi er ikke deterministisk, så brug den kun, når enhver værdi fra gruppen er acceptabel.

COLLECT_ELEMENTS accepterer listeværdiede input og sammenkæder deres elementer til én liste:

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

Uden at gruppere kolonner returnerer en aggregeret forespørgsel uden inputrækker en tom liste fra COLLECT_LIST og COLLECT_ELEMENTS og null fra COLLECT_ONE.

Grupperesultater med GROUP BY

Brug GROUP BY i RETURN til at gruppere rækker efter fælles værdier og beregne aggregater inden for hver gruppe. Denne gruppering er GQL-ækvivalenten til SQL GROUP BY.

For eksempel, for at tælle medarbejdere pr. virksomhed:

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

Gruppere i flere kolonner og beregne flere aggregater på én gang. For eksempel, opdel antal personer og fødselsdato efter køn og browser, og giv de 10 mest almindelige kombinationer:

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

Bemærkning

Alle ikke-aggregerede udtryk i RETURN skal forekomme i GROUP BY. Udtryk, der ikke er i GROUP BY , skal bruge en aggregeret funktion.

Sorter og begræns aggregerede resultater

Brug ORDER BY og LIMIT sammen med GROUP BY at finde top-N resultater.

For eksempel for at finde de fem største byer efter antal indbyggere:

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

Vigtige oplysninger

Stedet ORDER BY før LIMIT. LIMIT gælder altid for det allerede sorterede resultatsæt.

Ruter rækker med betingede sætninger

Brug en betinget sætning til at rute hver indkommende række til den første matchende gren. Inputtet kan komme fra ethvert forudgående forespørgselstrin, ikke kun fra en aggregering. For eksempel kategoriserer følgende forespørgsel virksomheder efter at have beregnet deres medarbejderantal:

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 kan køre komplette forespørgselssætninger og indlejrede procedurer i stedet for kun at returnere udtryk. Følgende eksempel sender tre inputrækker gennem forskellige grenformer. En gren kører en MATCH, én kombinerer to aggregater med UNION ALL og aggregerer derefter deres resultater, 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

Forespørgselsmotoren evaluerer prædikaterne i rækkefølge for hver række. Den kører kun den første matchende gren. Hvis et prædikat evaluerer til UNKNOWN, fortsætter evalueringen med næste gren. Uden en ELSE, udelades rækker, der ikke matcher en WHEN gren.

Betingede udsagn adskiller sig fra CASE udtryk. Grafen understøtter simple CASE <expression> WHEN <value> udtryk for lighedsbaseret værdivalg. Søgte CASE WHEN <predicate> udtryk understøttes ikke. For mere information, se Betingede sætninger.

Relateret indhold

  • Sidst opdateret den