Filtrar e agregar dados de grafos no Microsoft Fabric

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

Os exemplos utilizam o conjunto de dados de amostras das redes sociais. Para uma explicação de ponta a ponta do fluxo de consultas e das sentenças, consulte 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 com vários saltos e selecionar caminhos, consulte Escrever consultas de padrões em grafos. Para tarefas de negócio prontas a serem adaptadas, veja Escrever consultas GQL comuns.

Pré-requisitos

Filtre linhas com o FILTER

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

A seguinte consulta devolve todas as mulheres com o seu nome e data de nascimento:

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

Combinem múltiplas condições com AND e OR. Por exemplo, a consulta seguinte devolve 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

Tip

Utilize uma cláusula em linha WHERE quando a condição define qual nó ou aresta pode participar na correspondência. Use FILTER quando a condição se aplica à linha produzida por uma afirmação anterior. A colocação dos predicados pode alterar os resultados do caminho mais curto; ver Colocar predicados antes ou depois da seleção do caminho.

Filtro durante a correspondência de padrões

As cláusulas em linha WHERE dentro de um MATCH padrão restringem quais nós e arestas qualificam para a correspondência. O otimizador de consultas pode aplicar predicados equivalentes durante a análise, pelo que a sintaxe inline não é inerentemente mais rápida do que um elemento FILTER separado. Escolha a forma que expressa a semântica pretendida.

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

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

As propriedades das bordas do filtro são da mesma forma. Por exemplo, para devolver apenas pessoas que começaram a trabalhar numa 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 a filtragem inline e a filtragem post-match, consulte Otimizar o desempenho das consultas GQL.

Lidar com valores nulos em filtros

O GQL utiliza lógica de três valores: os predicados avaliam até TRUE, FALSE, ou UNKNOWN. Quando o valor de uma propriedade é nulo, as comparações retornam UNKNOWN. FILTER trata UNKNOWN como não combinando, por isso a linha é excluída.

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

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

Atenção

NULL = NULL avalia-se como UNKNOWN, não TRUE. Use sempre IS NULL para testar valores nulos, não igualdade.

Resultados agregados com RETURN

Utilize funções agregadas em RETURN para resumir os seus resultados. O grafo suporta as seguintes funções agregadas: COUNT, SUM, AVG, MIN, MAX, COLLECT_LIST, COLLECT_ONE, , e COLLECT_ELEMENTS.

Por exemplo, para contar todas as pessoas no gráfico:

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

Adicionar FILTER (WHERE predicate) após um agregado para filtrar apenas a entrada desse agregado. Outros agregados na mesma RETURN continuam a receber 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

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

Recolher valores

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

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

COLLECT_ONE devolve um valor de entrada não nulo. O valor selecionado não é determinístico, por isso usa-o apenas quando qualquer valor do grupo for aceitável.

COLLECT_ELEMENTS aceita entradas de valor de lista e concatena os seus elementos numa só lista:

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

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

Agrupar resultados com GROUP BY

Use GROUP BY em RETURN para agrupar linhas por valores comuns e calcular agregados em cada grupo. Este agrupamento é o equivalente GQL ao SQL GROUP BY.

Por exemplo, para contar os 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 calcule vários agregados ao mesmo tempo. Por exemplo, divida o número de pessoas e o intervalo de datas de nascimento por género e browser, 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

Note

Todas as expressões não agregadas em RETURN devem aparecer em GROUP BY. Expressões que não estão em GROUP BY têm de usar uma função agregada.

Ordenar e limitar os resultados agregados

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

Por exemplo, para encontrar as cinco principais cidades por número de habitantes:

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

Importante

Coloque ORDER BY antes LIMITde . LIMIT aplica-se sempre ao conjunto de resultados já ordenado.

Linhas de roteamento com instruções condicionais

Use uma instrução condicional para encaminhar cada linha recebida para a primeira ramificação que corresponda. A entrada pode vir de qualquer etapa de consulta anterior, não apenas de uma agregação. Por exemplo, a seguinte consulta 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 devolver expressões. O exemplo seguinte envia três linhas de entrada através de diferentes formas de ramos. Um ramo executa um MATCH, outro combina dois agregados com UNION ALL e depois agrega os seus resultados, e o ramo de recurso devolve 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 motor de consulta avalia os predicados por ordem para cada linha. Funciona apenas com o primeiro ramal correspondente. Se um predicado for avaliado como UNKNOWN, a avaliação continua com a ramificação seguinte. Sem um ELSE, as linhas que não correspondem a um WHEN ramo são omitidas.

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

Conteúdo relacionado

  • Last updated on