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 usano il dataset di esempio del social network. Per una spiegazione completa del flusso delle query e delle istruzioni, consulta la guida al linguaggio GQL. Usa questo articolo quando conosci il compito grafico che vuoi realizzare. Per istruzioni sistematiche sulla costruzione di pattern di nodi, archi e percorsi, vedi Write graph pattern queries. Per flussi di lavoro dettagliati di filtraggio e aggregazione, vedi Filtra e aggrega dati di grafico.

Prerequisiti

• Un elemento grafo costruito a partire dal dataset campione del social network, con i tipi di nodo, i tipi di spigoli e le proprietà descritti nell'esempio dello schema del social network.
• 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.

Trova le persone raggiungibili da Alice tramite esattamente due knows archi:

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

Trova un percorso più breve da Alice a ciascuna persona raggiungibile entro quattro salti:

MATCH p = ANY SHORTEST
  (src:Person WHERE src.firstName = 'Alice')-[:knows]->{1,4}(dst:Person)
RETURN dst.firstName, dst.lastName, path_length(p) AS hopCount
ORDER BY hopCount, dst.lastName
LIMIT 100

Se esistono più percorsi minimi che raggiungono la stessa persona con lo stesso numero di salti, ANY SHORTEST ne restituisce uno senza applicare un criterio deterministico di scelta in caso di parità.

I predicati in linea limitano quali percorsi sono idonei a ANY SHORTEST. I postfiltri si applicano dopo che è stato selezionato il percorso più breve. Per esempi, vedi Posiziona predicati prima o dopo la selezione del percorso.

Conteggio delle relazioni per entità

Usare GROUP BY con count(*) per contare il numero di relazioni di ogni entità. Per raggruppamenti dettagliati, filtraggio aggregato e pattern di instradamento condizionato, vedi Filtra e aggrega dati di grafici.

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

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

Calcola un valore per ogni entità

Usa una sottoquery correlata CALL per calcolare un valore per ogni riga di input. Le variabili della query esterna sono implicitamente disponibili all'interno della sottoquery.

Calcola il numero di amici per ogni persona:

MATCH (p:Person)
CALL {
  MATCH (p)-[:knows]->(friend:Person)
  RETURN count(*) AS friendCount
}
RETURN p.firstName, p.lastName, friendCount
ORDER BY friendCount DESC

Le variabili esterne rimangono disponibili dopo CALL. Delle variabili create all'interno della sottoquery, solo le colonne restituite diventano disponibili al di fuori di essa. Un count(*) non raggruppato restituisce 0 quando non esistono amici corrispondenti, quindi questa query mantiene le persone che non hanno amici.

Ordinary CALL elimina una riga esterna quando la sottoquery non restituisce righe e produce una riga di output per ciascuna riga di sottoquery quando restituisce più righe. Usa OPTIONAL CALL quando devi mantenere una riga esterna che non ha una riga corrispondente nella sottoquery.

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 NOT EXISTS per trovare nodi per i quali una sottoquery correlata non restituisce righe.

Trovare persone che non lavorano in nessuna azienda:

MATCH (p:Person)
WHERE NOT EXISTS {
  MATCH (p)-[:workAt]->(c:Company)
  RETURN c
}
RETURN p.firstName, p.lastName
LIMIT 100

Trova post senza commenti:

MATCH (post:Post)
WHERE NOT EXISTS {
  MATCH (comment:Comment)-[:replyOf]->(post)
  RETURN comment
}
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 personId = p.id, name = p.firstName || ' ' || p.lastName
RETURN personId, name, count(*) AS friendCount
GROUP BY personId, name
FILTER friendCount > 10
ORDER BY friendCount DESC

Contenuti correlati

• Guida al linguaggio GQL
• Modelli di grafo GQL
• Filtrare e aggregare i dati del grafo
• Ottimizzare le prestazioni delle query GQL