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.

Consulte este artigo para saber como construir e combinar padrões de nós, arestas e caminhos. Para tarefas prontas a adaptar, como encontrar vizinhos ou entidades sem relações, veja Escrever consultas GQL comuns. Para fluxos de trabalho de filtragem, agrupamento e agregação, veja Filtrar e agregar dados de grafos.

Pré-requisitos

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

Note

Atualmente, o graph não suporta a criação de arestas não direcionadas, mas pode consultar arestas em qualquer direção usando a sintaxe -[:label]-.

Padrões de filtro com WHERE em linha

Coloque WHERE dentro do padrão quando uma condição define qual nó ou aresta pode participar na correspondência. Utilize uma condição MATCH ... WHERE ao nível da instrução para pós-filtrar a correspondência concluída, ou uma condição separada FILTER quando a condição se aplica à linha gerada por uma instrução anterior. A colocação de predicados pode alterar os resultados do caminho mais curto. Para mais informações, veja Colocar predicados antes ou depois da seleção do caminho.

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 WALK, que permite repetição de nós e arestas. Usa outro modo de caminho quando precisares de uma unicidade mais rigorosa dos elementos.

Modo de trajecto Comportamento Utilize quando...
WALK Permite repetição de nós e arestas (por defeito) Queres todas as caminhadas correspondentes dentro de um limite finito.
TRAIL Sem arestas repetidas Queres evitar refazer a mesma aresta, mas o mesmo nó pode aparecer através de arestas diferentes.
SIMPLE Não há nós repetidos, exceto um nó inicial e final partilhado, nem arestas repetidas Não queres que nenhum nó apareça mais do que uma vez no meio de um caminho, mas permite caminhos que voltam ao início. Útil para detetar ciclos.
ACYCLIC Sem nós ou arestas repetidas Tens de garantir que nenhum nó aparece em qualquer parte do caminho mais do que uma vez. Utilizar para hierarquias rigorosas, linhagem, ou em qualquer percurso onde revisitar um nó possa resultar em resultados incorretos.

WALK é o modo mais permissivo e ACYCLIC o mais restritivo.

Para SIMPLE e ACYCLIC, a unicidade das arestas decorre da unicidade dos nós. Um SIMPLE caminho pode fechar ao regressar ao seu primeiro nó, mas ainda assim não pode reutilizar uma aresta.

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)
LET personId = dst.id
RETURN personId, dst.firstName, dst.lastName, count(*) AS pathCount
GROUP BY personId, dst.firstName, dst.lastName
ORDER BY pathCount DESC
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

O modo de correspondência por defeito REPEATABLE ELEMENTS permite que uma aresta seja reutilizada por caminhos separados no mesmo padrão gráfico. Utilize DIFFERENT EDGES ou DIFFERENT RELATIONSHIPS quando cada vinculação de arestas ao longo de todos os caminhos tiver de ser diferente:

MATCH DIFFERENT EDGES
  (p:Person)-[:knows]->(friend:Person),
  (p)-[:knows]->(other:Person)
RETURN p.firstName, friend.firstName, other.firstName
LIMIT 100

Retorne um caminho mais curto

ALL corresponde à procura de caminhos predefinida e retorna todos os caminhos correspondentes. Use ANY SHORTEST para devolver um caminho mais curto para cada par origem-destino. A seguinte consulta encontra um caminho mais curto de Alice para Bob:

MATCH p = ANY SHORTEST
  (src:Person WHERE src.firstName = 'Alice')-[:knows]->{1,4}
  (dst:Person WHERE dst.firstName = 'Bob')
RETURN p, path_length(p) AS hopCount

Quando vários caminhos mais curtos empatam, qual caminho é devolvido não é determinístico. As pesquisas de caminho ALL SHORTEST e ANY não são suportadas.

A colocação de predicados pode alterar o resultado de ANY SHORTEST. Os predicados inline de nó e de aresta restringem que caminhos são elegíveis, enquanto um pós-filtro pode remover o caminho selecionado sem, em vez disso, escolher um caminho mais longo. Ver Predicados de Lugar antes ou depois da seleção do caminho.

Tip

Prefiro um limite superior finito para o custo de consulta previsível. Padrões ilimitados ALL WALK não são suportados. Padrões ilimitados com TRAIL, SIMPLE, ou ACYCLIC terminam por unicidade de elemento, mas ainda podem devolver muitos caminhos. O Unbounded ANY SHORTEST WALK suporta apenas formas específicas de consulta. Ver Limitações atuais.

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

Tip

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

Combinar múltiplos padrões

Liste múltiplos padrões num único MATCH, separados por vírgulas. Reutilize uma variável quando os padrões tiverem de associar o mesmo elemento do grafo.

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.

Padrões desconectados também são válidos, mas formam um produto cartesiano das suas correspondências. Usa-os apenas quando precisares intencionalmente de todas as combinações. Para obter orientações sobre desempenho, consulte Utilizar variáveis partilhadas para junções eficientes.

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

  • Last updated on