Gravar consultas de padrão de grafo no Microsoft Fabric

A correspondência de padrões de grafo permite descrever a estrutura dos dados que você deseja encontrar usando sintaxe visual intuitiva. Em vez de unir tabelas, você escreve padrões que se parecem com as próprias relações - nós conectados por bordas. Este artigo mostra como escrever consultas de padrão GQL para cenários comuns no grafo em Microsoft Fabric.

Os exemplos usam o conjunto de dados de exemplo de rede social. Para uma referência completa da sintaxe de padrões, consulte padrões de grafo GQL.

Pré-requisitos

• Um item de grafo com dados carregados. Se você não estiver familiarizado com o grafo, conclua o tutorial primeiro.
• Familiaridade com MATCH e RETURN consultas básicas. Consulte o guia de linguagem GQL.

Relacionar relações diretas

Um padrão básico corresponde a um tipo de nó, um tipo de borda específico e outro tipo de nó. A sintaxe se parece com um diagrama da relação.

Por exemplo, para encontrar até 100 pessoas emparelhadas com a empresa em que trabalham:

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

Use um padrão de borda não redirecionado quando você não souber ou não se importar com a direção. Por exemplo, para encontrar até 100 conhecidos mútuos, independentemente de quem iniciou a conexão:

MATCH (a:Person)-[:knows]-(b:Person)
RETURN a.firstName, b.firstName
LIMIT 100

Filtrar padrões com WHERE integrado

Coloque WHERE dentro do padrão para filtrar nós e bordas conforme eles são correspondidos. Essa abordagem é mais eficiente do que filtrar após o fato.

Por exemplo, para encontrar pessoas nascidas antes de 1990 que trabalham em uma empresa cujo nome começa com 'A':

MATCH (p:Person WHERE p.birthday < 19900101)-[:workAt]->(c:Company WHERE c.name STARTS WITH 'A')
RETURN p.firstName, p.lastName, c.name

Filtre as propriedades de borda para restringir quais relações correspondem. Por exemplo, para retornar somente as pessoas que começaram a trabalhar em uma empresa em 2010 ou depois:

MATCH (p:Person)-[w:workAt WHERE w.workFrom >= 2010]->(c:Company)
RETURN p.firstName, c.name, w.workFrom

Corresponder relações de vários saltos

Use padrões de comprimento variável para percorrer vários saltos em uma expressão. Especifique o número mínimo e máximo de saltos com a sintaxe {min,max}.

Por exemplo, para encontrar até 100 pessoas acessíveis dentro de dois a quatro graus de amizade de Alice:

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

Para encontrar até 100 conexões imediatas e de segundo grau (um ou dois saltos) de Alice:

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

Controle de travessia com modos de caminho

Por padrão, o GQL usa o modo TRAIL, que impede que a mesma borda seja percorrida mais de uma vez. Use os modos de caminho explicitamente quando precisar de garantias diferentes.

WALK é o modo mais permissivo e ACYCLIC é o mais restritivo. TRAIL é o padrão e funciona bem para a maioria das consultas. Use um modo mais restritivo somente quando o caso de uso exigir.

Para ilustrar a diferença, considere o percurso Alice → Bob → Carol → Bob:

• WALK – permite esse caminho. Nodos e arestas podem ser repetidos livremente.
• TRAIL – permite esse caminho. Bob aparece duas vezes, mas cada borda usada é uma relação diferente (Alice→Bob e Carol→Bob são bordas distintas), portanto, nenhuma borda é repetida.
• SIMPLE – bloqueia esse caminho. Bob aparece mais de uma vez, e "SIMPLE" só permite que um nó se repita se esse mesmo nó for o início e o fim do caminho (um ciclo fechado). Aqui alice é o início e Bob é o fim, então nenhuma exceção se aplica.
• ACYCLIC – bloqueia esse caminho. Bob aparece mais de uma vez em qualquer lugar no caminho.

O exemplo a seguir mostra como usar TRAIL para contar quantos caminhos distintos levam a cada uma das 100 primeiras pessoas acessíveis na rede de Alice em quatro saltos:

MATCH TRAIL (src:Person WHERE src.firstName = 'Alice')-[:knows]->{1,4}(dst:Person)
RETURN dst.firstName, dst.lastName, count(*) AS pathCount
LIMIT 100

Utilize ACYCLIC para retornar até 100 pessoas alcançáveis a partir de Alice dentro de quatro saltos, onde cada pessoa no caminho é única.

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

Usar a reutilização de variável para expressar entidades compartilhadas

Reutilização da mesma variável em duas partes de um padrão cria uma restrição de igualdade implícita – ambas as referências devem corresponder ao mesmo nó. Essa técnica permite que você expresse "localizar entidades conectadas por meio de uma terceira entidade compartilhada".

Por exemplo, para encontrar até 100 pares de pessoas que se conhecem e trabalham na mesma empresa:

MATCH (c:Company)<-[:workAt]-(a:Person)-[:knows]-(b:Person)-[:workAt]->(c)
RETURN a.firstName, b.firstName, c.name
LIMIT 100

A variável c é reutilizada para ambos os workAt alvos, portanto, a consulta retorna apenas pares em que ambas as pessoas se conhecem e trabalham na mesma empresa.

Para encontrar até 100 pares de pessoas que gostaram do mesmo post:

MATCH (a:Person)-[:likes]->(post:Post)<-[:likes]-(b:Person)
WHERE a.id < b.id
RETURN a.firstName, b.firstName, post.id
LIMIT 100

Combinar vários padrões

Listar vários padrões em um único MATCH, separados por vírgulas. Todos os padrões devem compartilhar pelo menos uma variável para que se unam corretamente.

Por exemplo, para encontrar até 100 pessoas, juntamente com seu local de trabalho e a cidade em que vivem:

MATCH (p:Person)-[:workAt]->(c:Company),
      (p)-[:isLocatedIn]->(city:City)
RETURN p.firstName, c.name AS company, city.name AS city
LIMIT 100

A variável p compartilhada conecta os dois padrões. Cada linha de resultado representa uma pessoa com sua empresa e cidade.

Associar relações opcionais

Use OPTIONAL MATCH quando uma relação pode não existir para cada nó. As linhas sem correspondência são retidas com NULL valores, semelhantes a um SQL LEFT JOIN.

Por exemplo, retorne até 100 pessoas com o nome da empresa, incluindo pessoas sem empregador (ou seja, que retornam NULL para a coluna da empresa):

MATCH (p:Person)
OPTIONAL MATCH (p)-[:workAt]->(c:Company)
RETURN p.firstName, p.lastName, c.name AS company
LIMIT 100

Use IS NULL depois OPTIONAL MATCH para encontrar até 100 pessoas que não trabalham em nenhuma empresa:

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

Conteúdo relacionado

• Padrões de grafo GQL
• Guia de idioma GQL
• Filtrar e agregar dados de grafo
• Escrever consultas GQL comuns
• Otimizar o desempenho da consulta GQL
• Limitações atuais