Escrever consultas de padrões de grafo no Microsoft Fabric

A correspondência de padrões em grafos permite-te descrever a estrutura dos dados que queres encontrar usando sintaxe intuitiva e visual. Em vez de juntar tabelas, escreve-se padrões que se assemelham às próprias relações – nós ligados por arestas. Este artigo mostra-lhe como escrever consultas de padrões GQL para cenários comuns em grafos no Microsoft Fabric.

Os exemplos utilizam o conjunto de dados de amostras das redes sociais. Para uma referência completa de sintaxe de padrões, veja padrões de grafos GQL.

Pré-requisitos

• Um item de grafo com dados carregados. Se és novo no Graph, faz primeiro o tutorial .
• Familiaridade com consultas básicas MATCH e RETURN. Consulte o guia de linguagem GQL.

Combinar relações diretas

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

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

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

Usa um padrão de arestas não direcionadas quando não sabes ou não te importas com a direção. Por exemplo, encontrar até 100 conhecidos em comum independentemente de quem iniciou a ligação:

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

Padrões de filtro com WHERE em linha

Coloca WHERE dentro do padrão para filtrar os nós e arestas à medida que forem combinados. Esta abordagem é mais eficiente do que filtrar depois do facto.

Por exemplo, para encontrar pessoas nascidas antes de 1990 que trabalham numa empresa cujo nome começa por '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 das arestas para restringir quais relações correspondem. Por exemplo, para devolver apenas pessoas que começaram a trabalhar numa empresa em 2010 ou depois:

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

Combinar relações de múltiplos saltos

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

Por exemplo, encontrar até 100 pessoas acessíveis dentro de dois a quatro graus de amizade através da 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

Controlo de percurso com modos de percurso

Por defeito, o GQL usa o modo TRAIL, que impede que a mesma aresta seja percorrida mais do que uma vez. Usa modos de caminho explicitamente quando precisares 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 apenas quando o seu caso de uso o exigir.

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

• CAMINHAR — permite este caminho. Os nós e as ligações podem repetir-se livremente.
• CAMINHO — permite este caminho. Bob aparece duas vezes, mas cada aresta usada tem uma relação diferente (Alice→Bob e Carol→Bob são arestas distintas), pelo que nenhuma aresta é repetida.
• SIMPLES — bloqueia este caminho. Bob aparece mais do que uma vez, e o sistema SIMPLE só permite que um nó se repita se for tanto o início quanto o fim do caminho (um ciclo fechado). Aqui a Alice é o início e o Bob é o fim, por isso não há exceção.
• ACYCLIC — bloqueia este caminho. Bob aparece mais do que uma vez em qualquer lugar do caminho.

O exemplo seguinte mostra como usar TRAIL para contar quantos caminhos distintos levam a cada uma das primeiras 100 pessoas acessíveis na rede da Alice num raio de 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

Use ACYCLIC para obter até 100 pessoas acessí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

Use a reutilização de variáveis para expressar entidades partilhadas

Reutilizar a mesma variável em duas partes de um padrão cria uma restrição implícita de igualdade – ambas as referências devem corresponder ao mesmo nó. Esta técnica permite-lhe expressar "encontrar entidades ligadas através de uma terceira entidade partilhada."

Por exemplo, 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 workAt os alvos, por isso a consulta só devolve pares onde 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 múltiplos padrões

Liste múltiplos padrões num único MATCH, separados por vírgulas. Todos os padrões devem partilhar pelo menos uma variável para se unirem corretamente.

Por exemplo, encontrar até 100 pessoas juntamente com o local de trabalho e a cidade onde 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 partilhada liga os dois padrões. Cada linha de resultados representa uma pessoa com a sua empresa e cidade.

Relações opcionais de correspondência

Utilize OPTIONAL MATCH quando uma relação pode não existir para todos os nós. Linhas sem correspondência são mantidas com NULL valores, semelhante a um SQL LEFT JOIN.

Por exemplo, retorne até 100 pessoas com o nome da empresa, incluindo pessoas sem empregador (ou seja, que tenham 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 grafos GQL
• Guia de idiomas do GQL
• Filtrar e agregar dados de grafos
• Escrever consultas GQL comuns
• Otimizar o desempenho das consultas GQL
• Limitações atuais