Skriv vanlige GQL-spørringer i Microsoft Fabric

Denne artikkelen gir praktiske GQL-spørringsmønstre for vanlige grafoppgaver i Microsoft Fabric: å finne naboer, traversere multihop-forbindelser, identifisere delte forbindelser, telle relasjoner og finne enheter uten forbindelser.

Eksemplene bruker datasett fra sosiale nettverk. For en helhetlig forklaring av spørringsflyt og setninger, se GQL-språkguiden. Bruk denne artikkelen når du vet hvilken grafoppgave du vil utføre. For systematisk instruksjon i konstruksjon av node-, kant- og stimønstre, se Write graph pattern queries. For detaljerte filtrerings- og aggregeringsarbeidsflyter, se Filter og aggreger grafdata.

Forutsetninger

• Et grafelement bygget fra det sosiale nettverkets eksempeldatasett, med nodetyper, kanttyper og egenskaper beskrevet i eksempelet på sosialt nettverksskjema.
• Kjennskap til grunnleggende MATCH og RETURN spørringer. Se GQL-språkguiden.

Finn direkte naboer

Returner alle noder som er koblet til en startnode med ett hopp.

Finn alle en bestemt person kjenner:

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

Finn alle selskaper en person har jobbet i:

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

Finn venner av venner (multi-hop)

Bruk mønstre med variabel lengde for {min,max} å krysse mer enn ett hopp.

Finn folk som nås via nøyaktig to knows kanter fra Alice:

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

Finn alle tilgjengelige innen tre grader:

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

Finn den korteste veien fra Alice til hver person, tilgjengelig innen fire hopp:

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

Hvis flere korteste stier når samme person i samme antall hopp, ANY SHORTEST returnerer en av dem uten deterministisk tie-valg.

Inline-predikater begrenser hvilke stier som er kvalifisert for ANY SHORTEST. Postfiltre gjelder etter at korteste sti er valgt. For eksempler, se Sted-predikater før eller etter stivalg.

Tell relasjoner per enhet

Bruk GROUP BY den count(*) til å telle hvor mange relasjoner hver enhet har. For detaljert gruppering, aggregert filtrering og betingede rutingmønstre, se Filter og aggregert grafdata.

Tell hvor mange venner hver person har, ordnet fra flest til færrest:

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

Beregn en verdi for hver enhet

Bruk en korrelert CALL delspørring for å beregne en verdi for hver inndatarad. Variabler fra den ytre spørringen er implisitt tilgjengelige inne i delspørringen.

Beregn antall venner for hver person:

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

Ytre variabler forblir tilgjengelige etter CALL. Av variablene som opprettes inne i underspørringen, blir kun returnerte kolonner tilgjengelige utenfor den. En ugruppert returnerer count(*)0 når det ikke finnes noen matchende venner, så dette spørsmålet beholder folk som ikke har noen venner.

Ordinary CALL fjerner en ytre rad når underspørringen returnerer ingen rader, og produserer én utdatarad for hver underspørringsrad når den returnerer flere rader. Bruk OPTIONAL CALL når du trenger å bevare en ytre rad som ikke har en tilsvarende underspørringsrad.

Finn felles forbindelser

Å gjenbruke en variabel i to deler av et mønster skaper en implisitt «samme node»-begrensning. Bruk denne begrensningen for å finne enheter som er koblet sammen gjennom en delt tredje enhet.

Finn par av personer som begge kjenner samme person:

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

Finn par av personer som jobber i samme selskap:

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

Finn entiteter uten relasjoner

Bruk NOT EXISTS for å finne noder hvor en korrelert delspørring ikke gir noen rader.

Finn folk som ikke jobber i noe selskap:

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

Finn innlegg uten kommentarer:

MATCH (post:Post)
WHERE NOT EXISTS {
  MATCH (comment:Comment)-[:replyOf]->(post)
  RETURN comment
}
RETURN post.id, post.content
LIMIT 100

Finn enheter med mange forbindelser

Kombiner GROUP BY og FILTER identifiser svært sammenkoblede noder. Denne metoden er nyttig for å finne hubs eller avvik.

Finn folk med mer enn 10 venner:

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

Relatert innhold

• GQL-språkveiledning
• GQL-grafmønstre
• Filter- og aggregerte grafdata
• Optimaliser GQL-spørringsytelse