Écrire des requêtes de modèle de graphique dans Microsoft Fabric

La mise en correspondance des modèles de graphique vous permet de décrire la structure des données que vous souhaitez trouver à l’aide d’une syntaxe visuelle intuitive. Au lieu de joindre des tables, vous écrivez des modèles qui ressemblent aux relations elles-mêmes : les nœuds connectés par des arêtes. Cet article explique comment écrire des requêtes de modèle GQL pour des scénarios courants dans 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 de syntaxe de modèle, consultez les modèles de graphique GQL.

Prerequisites

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

Mettre en correspondance les relations directes

Un modèle de base correspond à un type de nœud, à un type de périphérie spécifique et à un autre type de nœud. La syntaxe ressemble à un diagramme de la relation.

Par exemple, pour trouver jusqu’à 100 personnes associées à l’entreprise à laquelle ils travaillent :

MATCH (p:Person)-[:workAt]->(c:Company)
RETURN p.firstName, p.lastName, c.name
LIMIT 100

Utilisez un modèle d'arête non orienté quand vous ne connaissez pas ou ne vous souciez pas de la direction. Par exemple, pour trouver jusqu’à 100 connaissances mutuelles, quel que soit l’origine de la connexion :

MATCH (a:Person)-[:knows]-(b:Person)
RETURN a.firstName, b.firstName
LIMIT 100

Modèles de filtrage avec WHERE en ligne

Placez WHERE à l’intérieur du modèle pour filtrer les nœuds et les arêtes à mesure qu’ils sont mis en correspondance. Cette approche est plus efficace que le filtrage après le fait.

Par exemple, pour trouver des personnes nées avant 1990 qui travaillent dans une entreprise dont le nom commence par « A » :

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

Filtrez sur les propriétés de périphérie pour limiter les relations qui correspondent. Par exemple, pour ne retourner que les personnes qui ont commencé à travailler pour une entreprise en 2010 ou plus tard :

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

Mettre en correspondance les relations multi-tronçons

Utilisez des modèles de longueur variable pour parcourir plusieurs tronçons dans une seule expression. Spécifiez le nombre minimal et maximal de tronçons syntaxiquement avec {min,max}.

Par exemple, pour trouver jusqu’à 100 personnes accessibles dans les deux à quatre degrés d’amitié d’Alice :

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

Pour trouver jusqu’à 100 connexions immédiates et de second degré (un ou deux sauts) à partir d’Alice :

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

Contrôler la traversée avec les modes de chemin

Par défaut, GQL utilise TRAIL le mode, qui empêche le même bord d’être parcouru plusieurs fois. Utilisez explicitement les modes de chemin lorsque vous avez besoin de garanties différentes.

WALK est le mode le plus permissif et ACYCLIC est le plus restrictif. TRAIL est la valeur par défaut et fonctionne bien pour la plupart des requêtes. Utilisez un mode plus restrictif uniquement lorsque votre cas d’usage l’exige.

Pour illustrer la différence, considérez le chemin d’Alice → Bob → Carol → Bob :

• WALK : autorise ce chemin d’accès. Les nœuds et les arêtes peuvent se répéter librement.
• TRAIL : autorise ce chemin d’accès. Bob apparaît deux fois, mais chaque bord utilisé est une relation différente (Alice→Bob et Carol→Bob sont des bords distincts), donc aucun bord n’est répété.
• SIMPLE : bloque ce chemin d’accès. Bob apparaît plusieurs fois, et SIMPLE permet uniquement à un nœud de se répéter s’il s’agit à la fois du début et de la fin du chemin (un cycle fermé). Ici, Alice est le début et Bob est la fin, donc aucune exception ne s’applique.
• ACYCLIQUE : bloque ce chemin d’accès. Bob apparaît plus d’une fois n’importe où dans le chemin.

L’exemple suivant montre comment utiliser TRAIL pour compter combien de chemins distincts mènent à chacune des 100 premières personnes accessibles dans le réseau d’Alice en quatre sauts.

MATCH TRAIL (src:Person WHERE src.firstName = 'Alice')-[:knows]->{1,4}(dst:Person)
RETURN dst.firstName, dst.lastName, count(*) AS pathCount
LIMIT 100

Utilisez ACYCLIC pour retourner jusqu’à 100 personnes atteignables à partir d’Alice en quatre sauts, où chaque personne dans le chemin est unique :

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

Utiliser la réutilisation des variables pour exprimer des entités partagées

La réutilisation de la même variable dans deux parties d’un modèle crée une contrainte d’égalité implicite : les deux références doivent correspondre au même nœud. Cette technique vous permet d’exprimer « rechercher des entités connectées via une troisième entité partagée ».

Par exemple, pour trouver jusqu’à 100 paires de personnes qui se connaissent et travaillent dans la même entreprise :

MATCH (c:Company)<-[:workAt]-(a:Person)-[:knows]-(b:Person)-[:workAt]->(c)
RETURN a.firstName, b.firstName, c.name
LIMIT 100

La variable c est réutilisée pour les deux workAt cibles, de sorte que la requête retourne uniquement des paires où les deux personnes se connaissent et travaillent au même niveau d’entreprise.

Pour trouver jusqu’à 100 paires de personnes qui ont tous les deux aimé le même billet :

MATCH (a:Person)-[:likes]->(post:Post)<-[:likes]-(b:Person)
WHERE a.id < b.id
RETURN a.firstName, b.firstName, post.id
LIMIT 100

Combiner plusieurs modèles

Répertoriez plusieurs modèles dans un seul MATCHmodèle séparé par des virgules. Tous les modèles doivent partager au moins une variable afin qu’ils se joignent correctement.

Par exemple, pour trouver jusqu’à 100 personnes avec leur lieu de travail et la ville dans laquelle ils vivent :

MATCH (p:Person)-[:workAt]->(c:Company),
      (p)-[:isLocatedIn]->(city:City)
RETURN p.firstName, c.name AS company, city.name AS city
LIMIT 100

La variable p partagée connecte les deux modèles. Chaque ligne de résultat représente une personne avec sa société et sa ville.

Mettre en correspondance les relations facultatives

Utilisez OPTIONAL MATCH quand une relation n’existe peut-être pas pour chaque nœud. Les lignes sans correspondance sont conservées avec les valeurs NULL, semblable à une SQL LEFT JOIN.

Exemple : Renvoyer jusqu’à 100 personnes avec leur nom d’entreprise, y compris celles sans emploi (c'est-à-dire, qui renvoient NULL pour la colonne de l’entreprise)

MATCH (p:Person)
OPTIONAL MATCH (p)-[:workAt]->(c:Company)
RETURN p.firstName, p.lastName, c.name AS company
LIMIT 100

Utilisez IS NULL après OPTIONAL MATCH pour trouver jusqu’à 100 personnes qui ne travaillent à aucune entreprise :

MATCH (p:Person)
OPTIONAL MATCH (p)-[:workAt]->(c:Company)
FILTER c IS NULL
RETURN p.firstName, p.lastName
LIMIT 100

Contenu connexe

• Modèles de graphique GQL
• Guide de langue GQL
• Filtrer et agréger des données de graphique
• Écrire des requêtes GQL courantes
• Optimiser les performances des requêtes GQL
• Limites actuelles