Filtrar e agregar dados de grafo em Microsoft Fabric

A filtragem restringe seus resultados às linhas que importam. A agregação resume essas linhas em contagens, totais e médias. Este artigo mostra como aplicar ambas as técnicas em consultas GQL contra o grafo no Microsoft Fabric.

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 para filtragem de linhas e padrões, agregação agrupada e não agrupada, filtros específicos de agregados e roteamento condicional. Para construir padrões de vários saltos e selecionar caminhos, consulte Escrever consultas de padrão de grafo. Para tarefas de negócios prontas para adaptação, veja Como escrever consultas GQL comuns.

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.

Filtrar linhas com FILTER

Use FILTER para manter apenas as linhas que atendem a uma condição. Coloque FILTER depois MATCH para restringir os resultados correspondentes.

A consulta a seguir retorna todas as mulheres com seu nome e aniversário:

MATCH (p:Person)
FILTER p.gender = 'female'
RETURN p.firstName, p.lastName, p.birthday

Combine várias condições com AND e OR. Por exemplo, a consulta a seguir retorna os nomes de todas as mulheres nascidas antes de 1990:

MATCH (p:Person)
FILTER p.gender = 'female' AND p.birthday < 19900101
RETURN p.firstName, p.lastName

Filtrar durante a correspondência de padrões

Cláusulas inline WHERE dentro de um MATCH padrão restringem quais nós e arestas se qualificam para a correspondência. O otimizador de consultas pode aplicar predicados equivalentes durante a leitura, portanto a sintaxe inline não é inerentemente mais rápida do que uma cláusula FILTER separada. Escolha a forma que expressa a semântica pretendida.

Por exemplo, para encontrar pessoas nascidas antes de 1994 junto com a empresa em que trabalham, limitando os resultados a empresas cujo nome começa com 'A':

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

Filtrar propriedades de borda da mesma maneira. Por exemplo, para retornar somente as pessoas que começaram a trabalhar em uma empresa em 2000 ou depois:

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

Para mais informações sobre como escolher entre filtragem inline e pós-partida, veja Otimizar o desempenho da consulta GQL.

Manipular valores nulos em filtros

O GQL usa lógica de três valores: predicados são avaliados como TRUE, FALSEou UNKNOWN. Quando um valor de propriedade é nulo, as comparações retornam UNKNOWN. FILTER trata UNKNOWN como não correspondente, portanto, a linha é excluída.

Use IS NULL e IS NOT NULL para testar explicitamente valores nulos:

-- Only include people whose browser is known
MATCH (p:Person)
FILTER p.browserUsed IS NOT NULL
RETURN p.firstName, p.browserUsed

Use coalesce() para substituir um valor padrão quando uma propriedade pode ser nula:

MATCH (p:Person)
RETURN p.firstName, coalesce(p.browserUsed, 'Unknown browser') AS browser

Agregar resultados com RETURN

Use funções RETURN de agregação para resumir seus resultados. Graph suporta as seguintes funções de agregação: COLLECT_ONE, COLLECT_ELEMENTS, MAX, COLLECT_LIST, MIN, AVG, SUM e COUNT.

Por exemplo, para contar todas as pessoas no grafo:

MATCH (p:Person)
RETURN count(*) AS totalPeople

Para contar valores distintos, como quantas empresas distintas empregam pessoas:

MATCH (p:Person)-[:workAt]->(c:Company)
RETURN count(DISTINCT c) AS companyCount

Entrada de filtro para um agregado

Adicione FILTER (WHERE predicate) após um agregado para filtrar apenas a entrada desse agregado. Outros agregados no mesmo RETURN ainda recebem todas as linhas de entrada.

MATCH (p:Person)
RETURN count(*) AS allPeople,
       count(*) FILTER (WHERE p.birthday < 19900101) AS peopleBornBefore1990

Adicione LIMIT dentro do filtro agregado para usar no máximo esse número de linhas qualificadas. A consulta aplica o predicado antes do limite específico do agregado.

MATCH (p:Person)
RETURN count(*) FILTER (WHERE p.birthday < 19900101 LIMIT 100) AS sampleCount

FILTER e LIMIT específicos para agregação não removem linhas do resto da consulta. Use uma instrução FILTER ou uma cláusula WHERE no nível de correspondência quando quiser filtrar o fluxo de linhas.

Coletar valores

Use COLLECT_LIST para retornar um elemento de lista para cada valor de entrada, incluindo valores nulos. Adicionar DISTINCT para remover duplicatas.

MATCH (p:Person)
RETURN collect_list(DISTINCT p.browserUsed) AS browsers

COLLECT_ONE retorna um valor de entrada não nulo. O valor selecionado não é determinístico, então use-o apenas quando qualquer valor do grupo for aceitável.

COLLECT_ELEMENTS aceita entradas do tipo lista e concatena seus elementos em uma única lista:

MATCH (p:Person)
RETURN collect_elements([p.firstName, p.lastName]) AS names

Sem agrupar colunas, uma consulta agregada sem linhas de entrada retorna uma lista vazia de COLLECT_LIST e COLLECT_ELEMENTS e nula de COLLECT_ONE.

Agrupar resultados com GROUP BY

Use GROUP BY no/na RETURN para agrupar linhas por valores compartilhados e calcular agregações em cada grupo. Esse agrupamento é o equivalente GQL do SQL GROUP BY.

Por exemplo, para contar funcionários por empresa:

MATCH (p:Person)-[:workAt]->(c:Company)
LET companyId = c.id, companyName = c.name
RETURN companyId, companyName, count(*) AS employeeCount
GROUP BY companyId, companyName
ORDER BY employeeCount DESC

Agrupe por várias colunas e compute várias agregações ao mesmo tempo. Por exemplo, divida a contagem de pessoas e a faixa de aniversário por gênero e navegador, retornando as 10 combinações mais comuns:

MATCH (p:Person)
LET gender = p.gender
LET browser = p.browserUsed
RETURN gender,
       browser,
       count(*) AS personCount,
       min(p.birthday) AS earliestBirthday,
       max(p.birthday) AS latestBirthday
GROUP BY gender, browser
ORDER BY personCount DESC
LIMIT 10

Classificar e limitar resultados agregados

Use ORDER BY e LIMIT juntamente com GROUP BY para encontrar os resultados top-N.

Por exemplo, para localizar as cinco principais cidades por número de moradores:

MATCH (p:Person)-[:isLocatedIn]->(city:City)
LET cityId = city.id, cityName = city.name
RETURN cityId, cityName, count(*) AS residentCount
GROUP BY cityId, cityName
ORDER BY residentCount DESC
LIMIT 5

Rotear linhas com instruções condicionais

Use uma instrução condicional para encaminhar cada linha de entrada para a primeira ramificação que corresponda. A entrada pode vir de qualquer estágio de consulta anterior, não apenas de uma agregação. Por exemplo, a consulta a seguir categoriza as empresas após calcular o número de funcionários:

MATCH (p:Person)-[:workAt]->(c:Company)
LET companyId = c.id, companyName = c.name
RETURN companyId, companyName, count(*) AS employeeCount
GROUP BY companyId, companyName
NEXT
WHEN employeeCount >= 100u THEN
  RETURN companyId, companyName, employeeCount, 'Large' AS category
WHEN employeeCount >= 10u THEN
  RETURN companyId, companyName, employeeCount, 'Medium' AS category
ELSE
  RETURN companyId, companyName, employeeCount, 'Small' AS category

Os ramos podem executar instruções completas de consulta e procedimentos aninhados, em vez de apenas retornar expressões. O exemplo a seguir envia três linhas de entrada por diferentes formas de ramos. Um ramo executa um MATCH, outro combina dois agregados com UNION ALL e então agrega seus resultados, e o ramo alternativo retorna uma constante:

FOR selector IN [1, 2, 3]
RETURN selector
NEXT
WHEN selector = 1 THEN
  MATCH (:Person)-[:knows]->(:Person)
  RETURN count(*) AS total, 'Knows edges' AS category
WHEN selector = 2 THEN {
  MATCH (:Person)-[:workAt]->(:Company)
  RETURN count(*) AS partialCount
  UNION ALL
  MATCH (:Person)-[:studyAt]->(:University)
  RETURN count(*) AS partialCount
  NEXT
  RETURN sum(partialCount) AS total, 'Affiliation edges' AS category
}
ELSE
  RETURN 0u AS total, 'No selected metric' AS category

O mecanismo de consulta avalia os predicados em ordem para cada linha. Ele opera apenas o primeiro ramo correspondente. Se um predicado é avaliado como UNKNOWN, a avaliação continua com o próximo ramo. Sem um ELSE, as linhas que não correspondem a um WHEN ramo são omitidas.

Sentenças condicionais são diferentes de CASE expressões. O Graph suporta expressões simples CASE <expression> WHEN <value> para seleção de valores baseada em igualdade. Expressões pesquisadas CASE WHEN <predicate> não são suportadas. Para mais informações, veja Sentenças condicionais.

Conteúdo relacionado

• Expressões, predicados e funções GQL
• Escrever consultas de padrão de grafo
• Escrever consultas GQL comuns
• Otimizar o desempenho da consulta GQL