Filtrar y agregar datos de grafos en Microsoft Fabric

El filtrado limita los resultados a las filas que importan. La agregación resume esas filas en recuentos, totales y promedios. En este artículo se muestra cómo aplicar ambas técnicas en consultas GQL contra el gráfico de Microsoft Fabric.

En los ejemplos se usa el conjunto de datos de ejemplo de red social. Para una explicación de extremo a extremo del flujo de consultas y las sentencias, consulte la guía del lenguaje GQL.

Utiliza este artículo para filtrado de filas y patrones, agregación agrupada y no agrupada, filtros específicos de agregados y enrutamiento condicional. Para construir patrones de múltiples saltos y seleccionar caminos, véase Escribir consultas de patrones de grafos. Para tareas empresariales listas para adaptar, véase Escribir consultas GQL comunes.

Prerequisites

Filtrar filas con FILTER

Use FILTER para mantener solo las filas que cumplen una condición. Coloque FILTER después de MATCH para restringir los resultados coincidentes.

La consulta siguiente devuelve todas las mujeres con su nombre y cumpleaños:

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

Combine varias condiciones con AND y OR. Por ejemplo, la consulta siguiente devuelve los nombres de todas las mujeres nacidas antes de 1990:

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

Sugerencia

Utiliza una cláusula en línea WHERE cuando la condición defina qué nodo o arista puede participar en la coincidencia. Úsalo FILTER cuando la condición se aplica a la fila producida por una sentencia anterior. La colocación de predicados puede cambiar los resultados del camino más corto; véase Colocar predicados antes o después de la selección de caminos.

Filtrar durante la coincidencia de patrones

Las cláusulas en línea WHERE dentro de un patrón MATCH restringen qué nodos y aristas cumplen los requisitos para la coincidencia. El optimizador de consultas puede aplicar predicados equivalentes durante el examen, por lo que la sintaxis en línea no es intrínsecamente más rápida que un elemento FILTER independiente. Elige la forma que exprese la semántica pretendida.

Por ejemplo, para buscar personas nacidas antes de 1994 junto con la empresa donde trabajan, limitando los resultados a las empresas cuyo nombre comienza 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

Filtre las propiedades perimetrales de la misma manera. Por ejemplo, para devolver únicamente a las personas que comenzaron a trabajar en una empresa en 2000 en adelante:

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

Para más información sobre cómo elegir entre filtrado en línea y post-match, consulte Optimizar el rendimiento de consultas GQL.

Manejo de valores NULL en filtros

GQL usa lógica con tres valores: los predicados se evalúan como TRUE, FALSEo UNKNOWN. Cuando un valor de propiedad es NULL, las comparaciones devuelven UNKNOWN. FILTER trata UNKNOWN como no coincidente, por lo que se excluye la fila.

Use IS NULL y IS NOT NULL para probar los valores NULL explícitamente:

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

Use coalesce() para sustituir un valor predeterminado cuando una propiedad podría ser NULL:

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

Caution

NULL = NULL se evalúa como UNKNOWN, no TRUE. IS NULL Use siempre para probar los valores NULL, no para la igualdad.

Agregar resultados con la función RETURN

Use funciones de agregado en RETURN para resumir los resultados. Graph soporta las siguientes funciones agregadas: COUNT, SUM, AVG, MIN, MAX, COLLECT_LIST, COLLECT_ONE, , y COLLECT_ELEMENTS.

Por ejemplo, para contar todas las personas del gráfico:

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

Para contar valores distintos, como el número de empresas distintas que emplean personas:

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

Entrada de filtro para un agregado

Añade FILTER (WHERE predicate) después de un agregado para filtrar solo la entrada de ese agregado. Otros agregados en el mismo RETURN aún reciben todas las filas de entrada.

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

Añade LIMIT dentro del filtro de agregado para usar como máximo esa cantidad de filas que cumplan los requisitos. La consulta aplica el predicado antes del límite específico del agregado.

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

Los elementos FILTER y LIMIT específicos de agregación no eliminan filas del resto de la consulta. Usa una FILTER sentencia o cláusula de nivel WHERE de coincidencia cuando quieras filtrar el flujo de fila.

Recopilar valores

Úsase COLLECT_LIST para devolver un elemento de lista para cada valor de entrada, incluyendo valores nulos. Añadir DISTINCT para eliminar duplicados.

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

COLLECT_ONE devuelve un valor de entrada no nulo. El valor seleccionado no es determinista, así que úsalo solo cuando cualquier valor del grupo sea aceptable.

COLLECT_ELEMENTS acepta entradas con valores de lista y concatena sus elementos en una sola lista:

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

Sin agrupar columnas, una consulta agregada sin filas de entrada devuelve una lista vacía de COLLECT_LIST y COLLECT_ELEMENTS y nula de COLLECT_ONE.

Agrupar resultados con GROUP BY

Usar GROUP BY en RETURN para agrupar filas por valores compartidos y calcular agregados dentro de cada grupo. Esta agrupación es el equivalente GQL de SQL GROUP BY.

Por ejemplo, para contar empleados 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 varias columnas y calcule varios agregados a la vez. Por ejemplo, desglosa el número de personas y el intervalo de cumpleaños por género y explorador, devolviendo las 10 combinaciones más comunes:

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 las expresiones no agregadas de RETURN deben aparecer en GROUP BY. Las expresiones que no están en GROUP BY deben usar una función de agregado.

Ordenar y limitar los resultados agregados

Use ORDER BY y LIMIT junto con GROUP BY para obtener los N mejores resultados.

Por ejemplo, para encontrar las cinco ciudades principales por número de residentes:

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 de LIMIT. LIMIT siempre se aplica al conjunto de resultados ya ordenado.

Dirigir filas con instrucciones condicionales

Utiliza una sentencia condicional para enrutar cada fila entrante a la primera rama correspondiente. La entrada puede provenir de cualquier etapa de consulta anterior, no solo de una agregación. Por ejemplo, la siguiente consulta categoriza las empresas tras calcular el número de empleados:

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

Las ramas pueden ejecutar instrucciones de consulta completas y procedimientos anidados, en lugar de limitarse a devolver expresiones. El siguiente ejemplo envía tres filas de entrada a través de diferentes formas de rama. Una rama ejecuta un MATCH, se combinan dos agregados con UNION ALL y luego agregan sus resultados, y la rama de respaldo devuelve una 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

El motor de consulta evalúa los predicados en orden de cada fila. Solo funciona con la primera rama correspondiente. Si un predicado se evalúa como UNKNOWN, se continúa con la siguiente rama. Sin un ELSE, se omiten las filas que no coinciden con una WHEN rama.

Las sentencias condicionales son diferentes de CASE expresiones. Graph admite expresiones simples CASE <expression> WHEN <value> para la selección de valores basada en igualdad. No se admiten expresiones buscadas CASE WHEN <predicate> . Para más información, consulte Sentencias condicionales.

Contenido relacionado

  • Last updated on