Escrever consultas GQL comuns no Microsoft Fabric

Este artigo fornece padrões práticos de consulta GQL para tarefas comuns de grafos no Microsoft Fabric: encontrar vizinhos, percorrer ligações multisaltos, identificar ligações partilhadas, contar relações e encontrar entidades sem ligações.

Os exemplos utilizam o conjunto de dados de amostras das redes sociais. Para uma explicação de ponta a ponta do fluxo de consultas e das sentenças, consulte o guia da linguagem GQL. Use este artigo quando souber qual a tarefa de gráficos que pretende realizar. Para instruções sistemáticas sobre a construção de padrões de nós, arestas e caminhos, veja Escrever consultas de padrões de grafo. Para fluxos de trabalho detalhados de filtragem e agregação, veja Filtrar e agregar dados de gráficos.

Pré-requisitos

Encontre vizinhos diretos

Devolva todos os nós ligados a um nó inicial dentro de um único salto.

Encontra todas as pessoas que uma pessoa específica conhece:

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

Encontre todas as empresas onde trabalhou:

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

Encontrar amigos de amigos (multi-hop)

Use padrões de comprimento variável com {min,max} para atravessar mais de um salto.

Encontre pessoas alcançadas exatamente por duas knows extremidades de Alice:

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

Encontre todos acessíveis num raio de três graus:

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

Encontre um dos caminhos mais curtos de Alice até cada pessoa alcançável em até quatro saltos:

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 vários caminhos mais curtos chegarem à mesma pessoa com o mesmo número de saltos, ANY SHORTEST devolve um deles sem um critério de desempate determinístico.

Predicados em linha restringem quais caminhos são elegíveis para ANY SHORTEST. Postfiltros aplicam-se depois de selecionar o caminho mais curto. Para exemplos, veja Colocar predicados antes ou depois da seleção de caminhos.

Tip

Use um limite superior finito para o custo de consulta previsível. O percurso sem limites ALL WALK não é suportado. Outros modos de caminho ilimitado ainda podem produzir resultados grandes. Ver Limitações atuais.

Contar relações por entidade

Use GROUP BY com count(*) para contar quantas relações cada entidade tem. Para agrupamento detalhado, filtragem agregada e padrões de roteamento condicional, veja Filtrar e agregar dados de grafos.

Conte quantos amigos cada pessoa tem, ordenados do maior ao pouco:

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

Calcule um valor para cada entidade

Use uma subconsulta correlacionada CALL para calcular um valor para cada linha de entrada. As variáveis da consulta externa estão implicitamente disponíveis dentro da subconsulta.

Calcule o número de amigos para cada pessoa:

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

As variáveis externas permanecem disponíveis após CALL. Das variáveis criadas dentro da subconsulta, apenas as colunas retornadas ficam disponíveis fora dela. Um elemento não agrupado count(*) retorna 0 quando não existem amigos que correspondam, pelo que esta consulta preserva as pessoas que não têm amigos.

Ordinary CALL elimina uma linha externa quando a subconsulta não devolve linhas e produz uma linha de saída por cada linha da subconsulta quando devolve várias linhas. Utilize OPTIONAL CALL quando precisar de preservar uma linha externa que não tenha uma linha correspondente na subconsulta.

Encontre ligações partilhadas

Reaproveitar uma variável em duas partes de um padrão cria uma restrição implícita de "nó idêntico". Use esta restrição para encontrar entidades ligadas através de uma terceira entidade partilhada.

Encontre pares de pessoas que conheçam a mesma pessoa:

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

Encontre pares de pessoas que trabalham na mesma empresa:

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

Tip

A WHERE a.id < b.id condição impede que pares duplicados (Alice–Bob e Bob–Alice) apareçam nos resultados.

Encontre entidades sem relações

Use NOT EXISTS para encontrar nós para os quais uma subconsulta correlacionada não retorna linhas.

Encontre pessoas que não trabalhem em nenhuma empresa:

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

Encontre publicações sem comentários:

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

Encontre entidades com muitas ligações

Combinar GROUP BY e FILTER para identificar nós altamente conectados. Este método é útil para encontrar hubs ou outliers.

Encontre pessoas com mais de 10 amigos:

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

Note

FILTER Depois GROUP BY funciona como HAVING em SQL. Filtra pelo resultado agregado, não pelas linhas individuais.

Conteúdo relacionado

  • Last updated on