Gravar consultas GQL comuns em Microsoft Fabric

Este artigo fornece padrões práticos de consulta GQL para tarefas comuns de grafo em Microsoft Fabric: localizar vizinhos, percorrer conexões multihop, identificar conexões compartilhadas, contar relações e localizar entidades sem conexões.

Os exemplos usam o conjunto de dados de exemplo de rede social. Para uma explicação de ponta a ponta do fluxo de consulta e das sentenças, veja o guia da linguagem GQL. Use este artigo quando souber qual tarefa de grafos deseja realizar. Para instruções sistemáticas sobre 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 grafos.

Pré-requisitos

• Um item de grafo construído a partir do conjunto de dados de amostra de rede social, com os tipos de nós, tipos de aresta e propriedades descritos no exemplo do esquema de rede social.
• Familiaridade com MATCH e RETURN consultas básicas. Consulte o guia de linguagem GQL.

Localizar vizinhos diretos

Retorne todos os nós conectados a um nó inicial por meio de um salto.

Encontre todos que uma pessoa específica conheça:

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

Encontre todas as empresas em que uma pessoa trabalhou:

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

Encontrar amigos de amigos (vários saltos)

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

Encontre pessoas alcançadas por exatamente duas knows arestas 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 dentro 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 que pode ser alcançada 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 múltiplos caminhos mais curtos alcançam a mesma pessoa no mesmo número de saltos, ANY SHORTEST retorna um deles sem uma escolha de ligação determinística.

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

Contar relações por entidade

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

Conte quantos amigos cada pessoa tem, ordenados da maioria para o menor:

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. 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

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 count(*) não agrupado retorna 0 quando não existem amigos correspondentes, então essa consulta preserva as pessoas que não têm amigos.

Ordinary CALL elimina uma linha externa quando a subconsulta não retorna linhas e produz uma linha de saída para cada linha de subconsulta quando retorna várias linhas. Use OPTIONAL CALL quando precisar preservar uma linha externa que não tenha sublinha correspondente.

Localizar conexões compartilhadas

Reutilizando uma variável em duas partes de um padrão cria uma restrição implícita de "mesmo nó". Use essa restrição para localizar entidades conectadas por meio de uma terceira entidade compartilhada.

Encontre pares de pessoas que conhecem 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

Localizar entidades sem relações

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

Encontre pessoas que não trabalham em nenhuma empresa:

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

Localize postagens sem comentários:

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

Localizar entidades com muitas conexões

Combine GROUP BY e FILTER para identificar nós altamente conectados. Esse método é útil para localizar hubs ou exceções.

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

Conteúdo relacionado

• Guia de idioma GQL
• Padrões de grafo GQL
• Filtrar e agregar dados de grafo
• Otimizar o desempenho da consulta GQL