Lección 7.1 · OVER: calcular sin agrupar

modulo-7SQL · SQL intermedio
Explorador
▸ modulo-6 · reportes
▾ modulo-7
over-calcular-sin-agrupar.sql
row-number-rank-y-dense-rank.sql
ventanas-en-la-practica.sql
evaluacion-7
▸ modulo-8 · calidad-de-datos-y-transacciones
-- módulo 7 de 10

Funciones de ventana

El resumen junto a cada fila: totales, rankings y acumulados.

OVER: calcular sin agrupar7.1 · El resumen junto a cada fila.
ROW_NUMBER, RANK y DENSE_RANK7.2 · Numerar, rankear y quedarse con los primeros.
Ventanas en la práctica7.3 · La primera compra, una fila por llave y el acumulado.
Módulo 7
1 / 22
over-calcular-sin-agrupar.sqlSQL · 7.1
1 2 3 4 5 6 7
-- SQL intermedio · módulo 7 · Funciones de ventana

OVER: calcular sin agrupar

El resumen junto a cada fila.

-- Poner junto a cada fila un resumen de todas las filas o de su grupo, con OVER y PARTITION BY, sin perder el detalle como pasa con GROUP BY, y saber dónde se puede usar una ventana y dónde no.
Mensajes
15 láminas · ejemplo resuelto · 8 ejercicios · 5 preguntas · tarea
OVER: calcular sin agrupar
2 / 22
Lo que dice la voz

La gerencia quiere saber cuánto aporta cada vendedor a la venta de su propia sucursal, en porcentaje, para comparar equipos de distinto tamaño. Muchas preguntas son así: comparan una fila con el total de su grupo: qué parte de la venta del mes fue esta boleta, cuánto se aleja este precio del promedio de su categoría, qué peso tiene cada vendedor en su sucursal. Group by responde con una fila por grupo y pierde el detalle, y una subconsulta sirve, pero se alarga. Este módulo trata de las funciones de ventana, que calculan un resumen y lo dejan junto a cada fila, sin juntar nada. Hoy vas a aprender over y partition by. En la siete punto dos vienen los rankings, y en la siete punto tres, casos prácticos.

lo-que-ya-sabes-hacer.sqlSQL · 7.1
1SELECT nombre, precio,
2 (SELECT AVG(precio) FROM productos) AS promedio
3FROM productos
4ORDER BY id_producto
5LIMIT 4;
Resultado
nombre | precio | promedio ---------------------+--------+----------------- Resma de papel carta | 4990 | 27847.1428571429 Mouse inalámbrico | 12990 | 27847.1428571429 Silla de escritorio | 89990 | 27847.1428571429 Monitor 24 pulgadas | 119990 | 27847.1428571429 (4 filas)
Lo que ya sabes hacer
3 / 22
Lo que dice la voz

Partamos por lo conocido. Avg del precio, sin más, da una sola fila, el promedio del catálogo. ¿Y para verlo al lado de cada producto? En el curso básico usaste una subconsulta de un valor dentro del select, y funciona: cada fila trae su nombre, su precio y el mismo promedio. El problema aparece cuando quieres el promedio de su categoría en vez del de todo. La subconsulta tiene que ser correlacionada, como en la lección dos punto uno, y la consulta se alarga. Las ventanas resuelven las dos cosas con la misma idea.

predice.sqlSQL · 7.1
¿Qué crees que muestra? Piénsalo antes de seguir.
1SELECT nombre, precio,
2 AVG(precio) OVER () AS promedio
3FROM productos;
Resultado
?
Antes de seguir, predice
4 / 22
Lo que dice la voz

Es la misma pregunta, pero ahora avg va seguido de la palabra over y un par de paréntesis vacíos, sin subconsulta y sin group by. ¿Cuántas filas crees que salen, y qué trae la columna promedio?

avg-con-over.sqlSQL · 7.1
1SELECT nombre, precio,
2 AVG(precio) OVER () AS promedio
3FROM productos;
Resultado
nombre | precio | promedio ------------------------+--------+----------------- Resma de papel carta | 4990 | 27847.1428571429 Mouse inalámbrico | 12990 | 27847.1428571429 Silla de escritorio | 89990 | 27847.1428571429 Monitor 24 pulgadas | 119990 | 27847.1428571429 Archivador | 6490 | 27847.1428571429 Lámpara de escritorio | 19990 | 27847.1428571429 Teclado | 24990 | 27847.1428571429 Cuaderno universitario | 2490 | 27847.1428571429 Audífonos con micrófono | 18990 | 27847.1428571429 Carpeta con elástico | 1990 | 27847.1428571429 Repisa de madera | 34990 | 27847.1428571429 Cable HDMI 2 metros | 7990 | 27847.1428571429 Calculadora científica | 15990 | 27847.1428571429 Pizarra blanca | 27990 | 27847.1428571429 (14 filas)
AVG con OVER
5 / 22
Lo que dice la voz

Salen los catorce productos, con el mismo promedio en todos, veintisiete mil ochocientos cuarenta y siete con decimales. Over, que significa sobre, convierte la función de resumen en una función de ventana. En vez de juntar las filas en una, calcula el promedio y lo pone en cada fila. A esto le llamamos ventana: el conjunto de filas que la función mira. Con los paréntesis vacíos, la ventana son todas las filas del resultado.

comparar-cada-fila-con-el-promedio.sqlSQL · 7.1
1SELECT nombre, precio,
2 precio - ROUND(AVG(precio) OVER ()) AS diferencia
3FROM productos
4ORDER BY diferencia DESC;
Resultado
nombre | precio | diferencia ------------------------+--------+----------- Monitor 24 pulgadas | 119990 | 92143 Silla de escritorio | 89990 | 62143 Repisa de madera | 34990 | 7143 Pizarra blanca | 27990 | 143 Teclado | 24990 | -2857 Lámpara de escritorio | 19990 | -7857 Audífonos con micrófono | 18990 | -8857 Calculadora científica | 15990 | -11857 Mouse inalámbrico | 12990 | -14857 Cable HDMI 2 metros | 7990 | -19857 Archivador | 6490 | -21357 Resma de papel carta | 4990 | -22857 Cuaderno universitario | 2490 | -25357 Carpeta con elástico | 1990 | -25857 (14 filas)
Comparar cada fila con el promedio
6 / 22
Lo que dice la voz

Como la ventana deja el promedio en la misma fila, ¿puedes hacer cuentas con él? Claro. Aquí se le resta al precio el promedio redondeado, y el resultado dice cuánto se aleja cada producto del promedio del catálogo. El monitor está noventa y dos mil pesos por encima, y la carpeta, casi veintiséis mil por debajo. Fíjate en que el order by usa el alias diferencia. Puede, porque el orden se aplica cuando la ventana ya está calculada.

la-participacion-de-cada-boleta.sqlSQL · 7.1
1WITH tb AS (
2 SELECT b.id_boleta, b.id_sucursal,
3 SUM(d.cantidad * d.precio_unitario) AS total
4 FROM boletas b
5 JOIN detalle_boleta d ON d.id_boleta = b.id_boleta
6 WHERE b.fecha LIKE '2026-09%'
7 GROUP BY b.id_boleta, b.id_sucursal
8)
9SELECT id_boleta, total,
10 SUM(total) OVER () AS total_mes,
11 ROUND(total * 100.0 / SUM(total) OVER (), 2) AS pct
12FROM tb
13ORDER BY id_boleta
14LIMIT 6;
Resultado
id_boleta | total | total_mes | pct ----------+--------+-----------+----- 1311 | 98910 | 5623620 | 1.76 1312 | 103810 | 5623620 | 1.85 1313 | 56970 | 5623620 | 1.01 1314 | 132720 | 5623620 | 2.36 1315 | 103870 | 5623620 | 1.85 1316 | 182920 | 5623620 | 3.25 (6 filas)
La participación de cada boleta
7 / 22
Lo que dice la voz

Un caso típico de reporte. La CTE, del módulo tres, calcula el total de cada boleta de septiembre. Afuera, una suma con over y los paréntesis vacíos junta las cincuenta y cuatro boletas del mes. Da cinco millones seiscientos veintitrés mil pesos. La última columna divide cada total por esa suma: la participación de la boleta en el mes. El cien escrito con decimal evita la división entera, como en el módulo cinco. Ahora un detalle importante. El limit muestra seis filas. ¿Cuántas sumó la ventana? Las cincuenta y cuatro, porque el limit se aplica al final.

partition-by-el-resumen-de-su-grupo.sqlSQL · 7.1
1SELECT id_categoria, nombre, precio,
2 ROUND(AVG(precio) OVER (PARTITION BY id_categoria)) AS prom_categoria
3FROM productos
4ORDER BY id_categoria, precio DESC;
Resultado
id_categoria | nombre | precio | prom_categoria -------------+-------------------------+--------+--------------- 1 | Pizarra blanca | 27990 | 9990 1 | Calculadora científica | 15990 | 9990 1 | Archivador | 6490 | 9990 1 | Resma de papel carta | 4990 | 9990 1 | Cuaderno universitario | 2490 | 9990 1 | Carpeta con elástico | 1990 | 9990 2 | Monitor 24 pulgadas | 119990 | 36990 2 | Teclado | 24990 | 36990 2 | Audífonos con micrófono | 18990 | 36990 2 | Mouse inalámbrico | 12990 | 36990 2 | Cable HDMI 2 metros | 7990 | 36990 3 | Silla de escritorio | 89990 | 48323 3 | Repisa de madera | 34990 | 48323 3 | Lámpara de escritorio | 19990 | 48323 (14 filas)
PARTITION BY: el resumen de su grupo
8 / 22
Lo que dice la voz

Ahora el promedio de cada categoría. Dentro del over se escribe partition by, que significa partir por, y la columna que forma los grupos. Ahora la ventana de cada fila mira solo las de su misma categoría. Oficina promedia nueve mil novecientos noventa; tecnología, treinta y seis mil novecientos noventa; hogar, cuarenta y ocho mil trescientos veintitrés. Mira la pizarra. ¿Está cara o barata? Casi en el promedio del catálogo, pero muy por encima del de su categoría. Es la misma respuesta que daba la correlacionada de la dos punto uno. Y siguen saliendo catorce filas.

la-participacion-dentro-de-su-sucursal.sqlSQL · 7.1
1WITH tb AS (
2 SELECT b.id_boleta, b.id_sucursal,
3 SUM(d.cantidad * d.precio_unitario) AS total
4 FROM boletas b
5 JOIN detalle_boleta d ON d.id_boleta = b.id_boleta
6 WHERE b.fecha LIKE '2026-09%'
7 GROUP BY b.id_boleta, b.id_sucursal
8)
9SELECT id_boleta, id_sucursal, total,
10 ROUND(total * 100.0 / SUM(total) OVER (PARTITION BY id_sucursal), 2) AS pct_sucursal
11FROM tb
12ORDER BY id_boleta
13LIMIT 6;
Resultado
id_boleta | id_sucursal | total | pct_sucursal ----------+-------------+--------+------------- 1311 | 1 | 98910 | 4.33 1312 | 2 | 103810 | 5.92 1313 | 2 | 56970 | 3.25 1314 | 3 | 132720 | 8.38 1315 | 1 | 103870 | 4.54 1316 | 1 | 182920 | 8 (6 filas)
La participación dentro de su sucursal
9 / 22
Lo que dice la voz

Volvamos a las boletas de septiembre. Si parto por la sucursal, la suma de la ventana pasa a ser la venta de la sucursal de cada boleta en el mes. Así, cada boleta se compara con las de su propia tienda. ¿Pesa igual una boleta de Antofagasta que una de Santiago del mismo monto? No: la de Antofagasta pesa más dentro de su sucursal, porque Antofagasta vende menos. Y en una consulta caben varias ventanas, una sin partición y otra con partición, cada una con su over.

ventana-sobre-un-resultado-agrupado.sqlSQL · 7.1
1SELECT b.id_sucursal,
2 SUM(d.cantidad * d.precio_unitario) AS ventas,
3 ROUND(SUM(d.cantidad * d.precio_unitario) * 100.0
4 / SUM(SUM(d.cantidad * d.precio_unitario)) OVER (), 1) AS pct
5FROM boletas b
6JOIN detalle_boleta d ON d.id_boleta = b.id_boleta
7GROUP BY b.id_sucursal;
Resultado
id_sucursal | ventas | pct ------------+----------+----- 1 | 19938400 | 49 2 | 11481510 | 28.2 3 | 9274190 | 22.8 (3 filas)
Ventana sobre un resultado agrupado
10 / 22
Lo que dice la voz

Group by y las ventanas se pueden usar juntos, porque la ventana se calcula después de agrupar. Aquí el group by deja tres filas, una por sucursal, con sus ventas. Esa expresión rara, una suma dentro de otra suma con over, se lee de adentro hacia afuera. El sum de adentro es la venta de cada sucursal, y el de afuera, con over, suma esas tres filas. El resultado es la participación, y Santiago vende el cuarenta y nueve por ciento de la tienda. En la seis punto tres lo hacías con una subconsulta del total. Esta forma no repite la consulta.

predice.sqlSQL · 7.1
¿Qué crees que muestra? Piénsalo antes de seguir.
1SELECT id_categoria,
2 COUNT(*) OVER (PARTITION BY id_categoria) AS productos
3FROM productos
4GROUP BY id_categoria;
Resultado
?
Antes de seguir, predice
11 / 22
Lo que dice la voz

Se quiere contar los productos de cada categoría con una ventana partida por categoría, pero la consulta también agrupa por categoría. El catálogo tiene catorce productos. ¿Qué crees que dice cada categoría?

contar-con-una-ventana-despues-de-agrupa.sqlSQL · 7.1
1SELECT id_categoria,
2 COUNT(*) OVER (PARTITION BY id_categoria) AS productos
3FROM productos
4GROUP BY id_categoria;
Resultado
id_categoria | productos -------------+---------- 1 | 1 2 | 1 3 | 1 (3 filas)
Contar con una ventana después de agrupar
12 / 22
Lo que dice la voz

Uno, en las tres. Es un error que no avisa. El group by ya dejó una fila por categoría, y la ventana cuenta esas filas: en cada partición hay una sola. Si hubo group by, la ventana nunca ve las filas originales: ve lo que quedó. ¿Cómo cuentas productos, entonces? O agrupas con count sin over, o usas la ventana sin group by. Mezclarlas por costumbre da cifras que parecen razonables y están mal.

en-que-momento-se-calcula.mdSQL · 7.1

En qué momento se calcula

1FROM y JOIN, después WHERE, después GROUP BY y HAVING
2Luego las ventanas, sobre las filas que quedaron
3Al final ORDER BY y LIMIT
4Por eso la ventana va en el SELECT y en el ORDER BY, no en WHERE ni en HAVING
productos
nombreid_categoriaprecio
Silla de escritorio389990
Lámpara de escritorio319990
Repisa de madera334990
↓ después del WHERE: AVG(precio) OVER ()
resultado
nombrepreciopromedio
Silla de escritorio8999048323
Lámpara de escritorio1999048323
Repisa de madera3499048323
WHERE id_categoria = 3: la ventana promedia solo esas 3 filas
En qué momento se calcula
13 / 22
Lo que dice la voz

Todo lo anterior se explica con el orden de ejecución que conoces desde el curso básico, con un paso nuevo. Primero se arman las filas con from y los join; el where las filtra; el group by las agrupa y el having filtra los grupos. Las ventanas se calculan recién ahí, sobre las filas que sobrevivieron. Después viene el order by, y al final el limit. De esto sale que un where cambia lo que suma la ventana, y que, si hubo group by, la ventana ve los grupos. Y una ventana no puede ir en el where ni en el having, porque cuando esas cláusulas corren, todavía no existe.

en-el-where-no-se-puede.sqlSQL · 7.1
1SELECT nombre, precio
2FROM productos
3WHERE precio > AVG(precio) OVER (PARTITION BY id_categoria);
Mensajes
Error: misuse of window function AVG()
En el WHERE no se puede
14 / 22
Lo que dice la voz

Queremos los productos más caros que el promedio de su categoría. La primera idea es poner la ventana en el where, y el motor responde misuse of window function avg: mal uso de una función de ventana. No es una rareza de SQLite: MySQL tampoco lo permite. ¿Y si le doy un alias en el select y lo uso en el where? Tampoco sirve: el error cambia a misuse of aliased window function, pero es el mismo. En el having pasa igual.

primero-calcular-despues-filtrar.sqlSQL · 7.1
1WITH p AS (
2 SELECT nombre, precio,
3 AVG(precio) OVER (PARTITION BY id_categoria) AS prom
4 FROM productos
5)
6SELECT nombre, precio, ROUND(prom) AS prom_categoria
7FROM p
8WHERE precio > prom;
Resultado
nombre | precio | prom_categoria -----------------------+--------+--------------- Calculadora científica | 15990 | 9990 Pizarra blanca | 27990 | 9990 Monitor 24 pulgadas | 119990 | 36990 Silla de escritorio | 89990 | 48323 (4 filas)
Primero calcular, después filtrar
15 / 22
Lo que dice la voz

La solución es separar los pasos. La CTE calcula la ventana y le da un nombre a la columna, prom. Afuera, esa columna ya es un valor como cualquier otro, y el where la puede usar. Salen cuatro: la calculadora y la pizarra en oficina, el monitor en tecnología y la silla en hogar. Una subconsulta en el from hace lo mismo. Esta idea, calcular la ventana adentro y filtrar afuera, la vas a usar en todo el módulo, empezando por los rankings de la próxima lección.

en-el-order-by-si.sqlSQL · 7.1
1SELECT nombre, precio
2FROM productos
3ORDER BY precio - AVG(precio) OVER (PARTITION BY id_categoria) DESC
4LIMIT 3;
Resultado
nombre | precio --------------------+------- Monitor 24 pulgadas | 119990 Silla de escritorio | 89990 Pizarra blanca | 27990 (3 filas)
En el ORDER BY sí
16 / 22
Lo que dice la voz

En el order by sí se puede, porque se ejecuta después de las ventanas, aunque la ventana no aparezca en el select. Sirve cuando el orden depende de un cálculo que el lector no necesita ver. Por ejemplo, compras pide revisar los tres productos más caros en comparación con su propia categoría, y la lista lleva solo el nombre y el precio. Esta consulta ordena por cuánto supera cada precio al promedio de su categoría, sin mostrar ese promedio. Salen el monitor, la silla y la pizarra. ¿Y si la diferencia sí se va a mostrar? Yo la calculo en el select y ordeno por su alias. Fuera del select, el order by es el único lugar donde una ventana es válida.

group-by-subconsulta-o-ventana.mdSQL · 7.1

¿GROUP BY, subconsulta o ventana?

1GROUP BY: quieres una fila por grupo
2Ventana: quieres cada fila, con el resumen de su grupo al lado
3Subconsulta: sigue sirviendo, y es lo que usan los motores sin ventanas
4COUNT(DISTINCT ...) OVER no existe en SQLite, MySQL ni SQL Server
productos
nombreid_categoriaprecio
Silla de escritorio389990
Lámpara de escritorio319990
Repisa de madera334990
↓ AVG OVER (PARTITION BY id_categoria)
resultado
nombreid_categoriaprecioprom
Silla de escritorio38999048323
Lámpara de escritorio31999048323
Repisa de madera33499048323
las 3 filas siguen ahí; GROUP BY las juntaría en una
En otros motores
MySQLLas ventanas existen desde MySQL 8.0; en 5.7 no. La forma es la misma: AVG(precio) OVER (PARTITION BY id_categoria) No admite OVER con COUNT(DISTINCT ...).
SQL ServerLa misma forma: AVG(precio) OVER (PARTITION BY id_categoria). No admite OVER con COUNT(DISTINCT ...).
¿GROUP BY, subconsulta o ventana?
17 / 22
Lo que dice la voz

¿Cómo eliges? Si el reporte tiene una fila por grupo, como las ventas por sucursal, es un group by. Si necesitas cada fila con el resumen de su grupo al lado, una ventana. La subconsulta sigue siendo válida, y la vas a ver en consultas antiguas, porque MySQL recién tiene ventanas desde la versión ocho; en una base con MySQL cinco punto siete no existen. Y un límite: count distinct no se puede usar con over, ni en SQLite, ni en MySQL, ni en SQL Server. Si lo intentas, SQLite responde distinct is not supported for window functions.

resumen.mdSQL · 7.1

Lo que te llevas de esta lección

AVG(x) OVER () pone el resumen de todas las filas en cada fila
OVER (PARTITION BY col) lo calcula dentro de su grupo
La ventana no junta filas: salen todas
Se calcula después de WHERE, GROUP BY y HAVING, y antes de ORDER BY y LIMIT
Para filtrar por una ventana: CTE o subconsulta, y el WHERE afuera
Ahora te toca
1Ejemplo resueltoEl peso de cada vendedor en su sucursal
8EjerciciosSe corrigen al instante
5PreguntasComprueba lo que aprendiste
1TareaEl peso de cada producto en su categoría
Siguiente7.2 ROW_NUMBER, RANK y DENSE_RANK
Lo que te llevas de esta lección
18 / 22
Lo que dice la voz

Una función de resumen seguida de over con paréntesis vacíos calcula sobre todas las filas y deja el resultado en cada una, y con partition by, el cálculo se hace dentro del grupo de cada fila. No se junta ninguna fila, como en group by. La ventana se calcula después del where, del group by y del having, así que ve lo que ellos dejaron, y antes del order by y del limit. Por eso va en el select o en el order by, y para filtrar por ella la calculas en una CTE y filtras afuera. En la próxima lección vienen los rankings: numerar las filas y quedarte con las primeras de cada grupo.

ejemplo.mdSQL · 7.1

El peso de cada vendedor en su sucursal

La gerencia quiere saber cuánto aporta cada vendedor a las ventas de su propia sucursal, en porcentaje, para comparar equipos de distinto tamaño.

El peso de cada vendedor en su sucursal
19 / 22
ejemplo-paso-1.sqlSQL · 7.1
Paso 1 de 3 · Primero, las ventas de cada vendedor con GROUP BY. Una fila por vendedor.
1SELECT v.nombre, v.id_sucursal,
2 SUM(d.cantidad * d.precio_unitario) AS ventas
3FROM vendedores v
4JOIN boletas b ON b.id_vendedor = v.id_vendedor
5JOIN detalle_boleta d ON d.id_boleta = b.id_boleta
6GROUP BY v.id_vendedor, v.nombre, v.id_sucursal;
Resultado
nombre | id_sucursal | ventas ------------------+-------------+-------- Rodrigo Castro | 1 | 5347240 Matías González | 1 | 6099010 Fernanda Castillo | 1 | 3480770 Carolina Martínez | 1 | 5011380 Agustín Hernández | 2 | 4012770 Nicolás Castillo | 2 | 4376920 Felipe Reyes | 2 | 3091820 Francisca Pérez | 3 | 2950620 Joaquín Contreras | 3 | 3485310 Daniela Rojas | 3 | 2838260 (10 filas)
Ejemplo resuelto · El peso de cada vendedor en su sucursal
20 / 22
ejemplo-paso-2.sqlSQL · 7.1
Paso 2 de 3 · Agregamos la venta de su sucursal con una ventana sobre el resultado agrupado: el SUM de adentro es la venta del vendedor, y el de afuera suma a los vendedores de la misma sucursal.
1SELECT v.nombre, v.id_sucursal,
2 SUM(d.cantidad * d.precio_unitario) AS ventas,
3 SUM(SUM(d.cantidad * d.precio_unitario))
4 OVER (PARTITION BY v.id_sucursal) AS ventas_sucursal
5FROM vendedores v
6JOIN boletas b ON b.id_vendedor = v.id_vendedor
7JOIN detalle_boleta d ON d.id_boleta = b.id_boleta
8GROUP BY v.id_vendedor, v.nombre, v.id_sucursal;
Resultado
nombre | id_sucursal | ventas | ventas_sucursal ------------------+-------------+---------+---------------- Rodrigo Castro | 1 | 5347240 | 19938400 Matías González | 1 | 6099010 | 19938400 Fernanda Castillo | 1 | 3480770 | 19938400 Carolina Martínez | 1 | 5011380 | 19938400 Agustín Hernández | 2 | 4012770 | 11481510 Nicolás Castillo | 2 | 4376920 | 11481510 Felipe Reyes | 2 | 3091820 | 11481510 Francisca Pérez | 3 | 2950620 | 9274190 Joaquín Contreras | 3 | 3485310 | 9274190 Daniela Rojas | 3 | 2838260 | 9274190 (10 filas)
Ejemplo resuelto · El peso de cada vendedor en su sucursal
21 / 22
ejemplo-paso-3.sqlSQL · 7.1
Paso 3 de 3 · Dividimos para tener el porcentaje y ordenamos por sucursal y, dentro de cada una, de mayor a menor. En Santiago, con cuatro vendedores, el que más vende aporta el 30,6 %; en Concepción y Antofagasta, con tres vendedores, el primero pasa del 37 %.
1SELECT v.nombre, v.id_sucursal,
2 ROUND(SUM(d.cantidad * d.precio_unitario) * 100.0
3 / SUM(SUM(d.cantidad * d.precio_unitario))
4 OVER (PARTITION BY v.id_sucursal), 1) AS pct_sucursal
5FROM vendedores v
6JOIN boletas b ON b.id_vendedor = v.id_vendedor
7JOIN detalle_boleta d ON d.id_boleta = b.id_boleta
8GROUP BY v.id_vendedor, v.nombre, v.id_sucursal
9ORDER BY v.id_sucursal, pct_sucursal DESC;
Resultado
nombre | id_sucursal | pct_sucursal ------------------+-------------+------------- Matías González | 1 | 30.6 Rodrigo Castro | 1 | 26.8 Carolina Martínez | 1 | 25.1 Fernanda Castillo | 1 | 17.5 Nicolás Castillo | 2 | 38.1 Agustín Hernández | 2 | 34.9 Felipe Reyes | 2 | 26.9 Joaquín Contreras | 3 | 37.6 Francisca Pérez | 3 | 31.8 Daniela Rojas | 3 | 30.6 (10 filas)
Ejemplo resuelto · El peso de cada vendedor en su sucursal
22 / 22