Filtrer et agréger des données de graphique dans Microsoft Fabric

Le filtrage limite vos résultats aux lignes qui importent. L’agrégation récapitule ces lignes en nombres, totaux et moyennes. Cet article explique comment appliquer les deux techniques dans les requêtes GQL sur le graphique dans Microsoft Fabric.

Les exemples utilisent l’exemple de jeu de données de réseau social. Pour obtenir une référence complète des instructions et expressions GQL, consultez le guide de langage GQL.

Prerequisites

• Élément de graphe avec des données chargées. Si vous débutez avec le graphique, suivez d’abord le tutoriel .
• Connaissance des requêtes de base MATCH et RETURN. Consultez le guide de langue GQL.

Filtrer les lignes avec FILTER

Permet FILTER de conserver uniquement les lignes qui répondent à une condition. Placez-les FILTER après MATCH pour affiner les résultats correspondants.

La requête suivante affiche toutes les femmes avec leur nom et leur date de naissance.

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

Combinez plusieurs conditions avec AND et OR. Par exemple, la requête suivante retourne les noms de toutes les femmes nées avant 1990 :

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

Filtrer lors de la correspondance de motif

Les clauses inline WHERE à l’intérieur d’un MATCH modèle limitent les nœuds et les arêtes qui sont mis en correspondance avant la production de résultats. Cette approche est plus efficace qu'une clause après correspondance FILTER, car le moteur de requête supprime les lignes plus tôt.

Par exemple, pour trouver des personnes nées avant 1994 avec l’entreprise où elles travaillent, limitant les résultats aux entreprises dont le nom commence par « A » :

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

Filtrer les propriétés des arêtes de la même façon. Par exemple, pour afficher uniquement les personnes qui ont commencé à travailler dans une entreprise en 2000 ou après :

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

Pour plus d’informations sur la différence de performances entre le filtrage en ligne et après correspondance, consultez Optimiser les performances des requêtes GQL.

Gérer les valeurs Null dans les filtres

GQL utilise une logique à trois valeurs : les prédicats sont évalués à TRUE, FALSEou UNKNOWN. Lorsqu’une valeur de propriété est Null, les comparaisons retournent UNKNOWN. FILTER considère UNKNOWN comme ne correspondant pas, donc la ligne est exclue.

Utilisez IS NULL et IS NOT NULL testez explicitement les valeurs Null :

-- Only include people who have a nickname
MATCH (p:Person)
FILTER p.nickname IS NOT NULL
RETURN p.firstName, p.nickname

Permet coalesce() de remplacer une valeur par défaut lorsqu’une propriété peut être null :

MATCH (p:Person)
RETURN p.firstName, coalesce(p.nickname, p.firstName) AS displayName

Agréger les résultats avec RETURN

Utilisez des fonctions d’agrégation dans RETURN pour synthétiser vos résultats. GQL prend en charge count(), sum(), avg(), min() et max().

Par exemple, pour compter toutes les personnes du graphique :

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

Pour compter des valeurs distinctes telles que le nombre d’entreprises distinctes qui emploient des personnes :

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

Regrouper les résultats avec GROUP BY

Utilisez GROUP BY dans RETURN pour regrouper des lignes par valeurs communes et calculer des agrégats au sein de chaque groupe. Ce regroupement est l’équivalent GQL de SQL GROUP BY.

Par exemple, pour compter les employés par entreprise :

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

Regroupez plusieurs colonnes et calculez plusieurs agrégats à la fois. Par exemple, décomposez le nombre de personnes et la plage d’anniversaires par sexe et navigateur, en retournant les 10 combinaisons les plus courantes :

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

Trier et limiter les résultats agrégés

Utilisez ORDER BY et LIMIT ensemble avec GROUP BY pour trouver les meilleurs résultats N.

Par exemple, pour trouver les cinq premières villes par nombre de résidents :

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

Utiliser CASE pour les valeurs conditionnelles dans les résultats

Permet CASE/WHEN/THEN/ELSEde calculer des valeurs conditionnelles dans RETURN ou .LET

Par exemple, pour classer les personnes en ères en fonction de leur année de naissance :

MATCH (p:Person)
RETURN p.firstName,
       CASE WHEN p.birthday < 19800101 THEN 'Before 1980'
            WHEN p.birthday < 20000101 THEN '1980–1999'
            ELSE '2000 or later'
       END AS era

Contenu connexe

• Guide de langue GQL
• Expressions, prédicats et fonctions GQL
• Optimiser les performances des requêtes GQL
• Écrire des requêtes de modèle de graphique
• Écrire des requêtes GQL courantes