Scrivere query GQL comuni in Microsoft Fabric

Questo articolo fornisce modelli di query GQL pratici per le attività comuni del grafico in Microsoft Fabric: ricerca di vicini, attraversamento di connessioni multihop, identificazione di connessioni condivise, conteggio delle relazioni e ricerca di entità senza connessioni.

Gli esempi utilizzano il set di dati di esempio di social network. Per informazioni di riferimento sul linguaggio completo, vedere guida al linguaggio GQL.

Prerequisiti

• Elemento del grafo con dati caricati. Se non si ha familiarità con il grafico, completare prima l'esercitazione .
• Familiarità con MATCH e le query di baseRETURN. Vedere la guida al linguaggio GQL.

Trovare vicini diretti

Restituisce tutti i nodi connessi a un nodo iniziale con un salto.

Trovare tutte le persone che una persona specifica conosce:

MATCH (p:Person WHERE p.firstName = 'Alice')-[:knows]->(friend:Person)
RETURN friend.firstName, friend.lastName

Trova tutte le aziende a cui lavora una persona:

MATCH (p:Person WHERE p.firstName = 'Alice')-[:workAt]->(c:Company)
RETURN c.name, c.url

Trova amici di amici (multi-hop)

Usare modelli a lunghezza variabile con {min,max} per attraversare più hop.

Trovare persone a due gradi di separazione - amici degli amici di Alice che Alice non conosce direttamente.

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

Trova tutte le persone raggiungibili entro tre gradi:

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

Conteggio delle relazioni per entità

Usare GROUP BY con count(*) per contare il numero di relazioni di ogni entità.

Contare il numero di amici che ogni persona ha, ordinato da più a pochi:

MATCH (p:Person)-[:knows]->(friend:Person)
LET name = p.firstName || ' ' || p.lastName
RETURN name, count(*) AS friendCount
GROUP BY name
ORDER BY friendCount DESC
LIMIT 20

Contare il numero di dipendenti che lavorano in ogni azienda:

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

Trovare connessioni condivise

Il riutilizzo di una variabile in due parti di un modello crea un vincolo implicito di "stesso nodo". Usare questo vincolo per trovare le entità connesse tramite una terza entità condivisa.

Trovare coppie di persone che conoscono entrambe la stessa persona:

MATCH (a:Person)-[:knows]->(mutual:Person)<-[:knows]-(b:Person)
WHERE a.id < b.id
RETURN a.firstName, b.firstName, mutual.firstName AS sharedContact
LIMIT 100

Trovare coppie di persone che lavorano nella stessa azienda:

MATCH (c:Company)<-[:workAt]-(a:Person), (c)<-[:workAt]-(b:Person)
WHERE a.id < b.id
RETURN a.firstName, b.firstName, c.name AS company
LIMIT 100

Trovare entità senza relazioni

Usare OPTIONAL MATCH seguito da un controllo Null per trovare i nodi che non hanno alcuna relazione corrispondente.

Trovare persone che non lavorano in nessuna azienda:

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

Trova post senza commenti:

MATCH (post:Post)
OPTIONAL MATCH (comment:Comment)-[:replyOf]->(post)
FILTER comment IS NULL
RETURN post.id, post.content
LIMIT 100

Trovare entità con molte connessioni

Combinare GROUP BY e FILTER per identificare i nodi altamente connessi. Questo metodo è utile per trovare hub o outlier.

Trova persone con più di 10 amici:

MATCH (p:Person)-[:knows]->(friend:Person)
LET name = p.firstName || ' ' || p.lastName
RETURN name, count(*) AS friendCount
GROUP BY name
FILTER friendCount > 10
ORDER BY friendCount DESC

Contenuti correlati

• Scrivere query di criteri a grafo
• Filtrare e aggregare i dati del grafo
• Guida al linguaggio GQL
• Modelli di grafo GQL
• Ottimizzare le prestazioni delle query GQL
• Limitazioni correnti