Amazon Redshift dejará de admitir la creación de nuevas UDF de Python a partir del parche 198. Las UDF de Python existentes seguirán funcionando hasta el 30 de junio de 2026. Para obtener más información, consulte la [publicación del blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
# Funciones de agregación
**Topics**
+ [Función ANY\$1VALUE](r_ANY_VALUE.md)
+ [Función APPROXIMATE PERCENTILE\$1DISC](r_APPROXIMATE_PERCENTILE_DISC.md)
+ [Función AVG](r_AVG.md)
+ [Función COUNT](r_COUNT.md)
+ [Función LISTAGG](r_LISTAGG.md)
+ [Función MAX](r_MAX.md)
+ [Función MEDIAN](r_MEDIAN.md)
+ [Función MIN](r_MIN.md)
+ [Función PERCENTILE\$1CONT](r_PERCENTILE_CONT.md)
+ [Funciones STDDEV\$1SAMP y STDDEV\$1POP](r_STDDEV_functions.md)
+ [Función SUM](r_SUM.md)
+ [Funciones VAR\$1SAMP y VAR\$1POP](r_VARIANCE_functions.md)
Las funciones de agregación computan un valor de resultado único correspondiente a un conjunto de valores de entrada.
Las instrucciones SELECT que utilizan funciones de agregación pueden incluir dos cláusulas opcionales: GROUP BY y HAVING. La sintaxis para estas cláusulas es la siguiente (utilizando la función COUNT como ejemplo):
```
SELECT count (*) expression FROM table_reference
WHERE condition [GROUP BY expression ] [ HAVING condition]
```
La cláusula GROUP BY agrega y agrupa resultados por valores únicos en columnas específicas. La cláusula HAVING restringe los resultados de retorno en filas donde una condición de agregación en particular es true, como por ejemplo count (\$1) > 1. La cláusula HAVING se usa de la misma manera que WHERE: para restringir filas según el valor de una columna. Consulte para ver un ejemplo de estas cláusulas adicionales [COUNT](r_COUNT.md).
Las funciones de agregación no aceptan como argumentos funciones de agregación anidadas ni funciones de ventana.
# Función ANY\$1VALUE
La función ANY\$1VALUE devuelve cualquier valor de los valores de expresión de entrada de una manera que no sea determinista. Esta función devuelve `NULL` si la expresión de entrada no implica que se devuelva alguna fila. La función también puede devolver `NULL` si hay valores `NULL` en la expresión de entrada. Si la entrada contiene valores `NULL` mezclados con valores que no sean `NULL`, `NULL` se podría devolver. Si todos los valores son `NULL`, se devuelve `NULL`. Si ninguna fila coincide con la condición, se devuelve `NULL`.
## Sintaxis
```
ANY_VALUE( [ DISTINCT | ALL ] expression )
```
## Argumentos
DISTINCT \$1 ALL
Especifique DISTINCT u ALL para devolver cualquier valor de los valores de expresión de entrada. El argumento DISTINCT no tiene ningún efecto y se pasa por alto.
*expresión *
La columna o la expresión de destino en la que opera la función. La *expresión* corresponde a uno de los siguientes tipos de datos:
+ SMALLINT
+ INTEGER
+ BIGINT
+ DECIMAL
+ REAL
+ DOUBLE PRECISION
+ BOOLEANO
+ CHAR
+ VARCHAR
+ DATE
+ TIMESTAMP
+ TIMESTAMPTZ
+ TIME
+ TIMETZ
+ INTERVALO AÑO A MES
+ INTERVALO DÍA A SEGUNDO
+ VARBYTE
+ SUPER
+ HLLSKETCH
+ GEOMETRY
+ GEOGRAPHY
## Devuelve
Devuelve el mismo tipo de datos que *expresión*.
## Notas de uso
Si una instrucción que especifica la función ANY\$1VALUE para una columna también incluye una segunda referencia de columna, la segunda columna debe aparecer en una cláusula GROUP BY o debe incluirse en una función de agrupación.
## Ejemplos
En los ejemplos, se utiliza la tabla de eventos que se crea en el [Paso 4: Cargar datos de muestra desde Amazon S3](https://docs.aws.amazon.com/redshift/latest/gsg/rs-gsg-create-sample-db.html) en la *Guía de introducción a Amazon Redshift*. El siguiente ejemplo devuelve una instancia de cualquier DATEID donde el nombre del evento es Eagles.
```
select any_value(dateid) as dateid, eventname from event where eventname ='Eagles' group by eventname;
```
A continuación, se muestran los resultados.
```
dateid | eventname
-------+---------------
1878 | Eagles
```
El siguiente ejemplo devuelve una instancia de cualquier DATEID donde el nombre del evento es Eagles o Cold War Kids.
```
select any_value(dateid) as dateid, eventname from event where eventname in('Eagles', 'Cold War Kids') group by eventname;
```
A continuación, se muestran los resultados.
```
dateid | eventname
-------+---------------
1922 | Cold War Kids
1878 | Eagles
```
# Función APPROXIMATE PERCENTILE\$1DISC
APPROXIMATE PERCENTILE\$1DISC es una función de distribución inversa que asume un modelo de distribución discreta. Toma un valor percentil y una especificación de ordenación, y devuelve un elemento del conjunto dado. La aproximación permite que la función se ejecute mucho más rápido, con un margen de error relativamente bajo de alrededor del 0,5 %.
En un *percentil* dado, APPROXIMATE PERCENTILE\$1DISC utiliza un algoritmo de resumen de cuartiles para aproximar el percentil discreto de la expresión en la cláusula ORDER BY. APPROXIMATE PERCENTILE\$1DISC devuelve el menor valor de distribución acumulado (con respecto a la misma especificación de ordenación) que sea mayor o igual que el *percentil*.
## Sintaxis
```
APPROXIMATE PERCENTILE_DISC ( percentile )
WITHIN GROUP (ORDER BY expr)
```
## Argumentos
*percentil*
Constante numérica entre 0 y 1. Los valores nulos se ignoran en el cálculo.
WITHIN GROUP ( ORDER BY *expr*)
Cláusula que especifica valores numéricos o de fecha/hora para ordenar y calcular el percentil.
## Devuelve
El mismo tipo de datos que la expresión ORDER BY en la cláusula WITHIN GROUP.
## Notas de uso
Si la instrucción APPROXIMATE PERCENTILE\$1DISC incluye una cláusula GROUP BY, el conjunto de resultados es limitado. El límite varía según el tipo de nodo y la cantidad de nodos. Si se supera el límite, la función falla y devuelve el siguiente mensaje de error.
```
GROUP BY limit for approximate percentile_disc exceeded.
```
Si necesita evaluar más grupos que los permitidos, considere usar [Función PERCENTILE\$1CONT](r_PERCENTILE_CONT.md).
## Ejemplos
El siguiente ejemplo devuelve la cantidad de ventas, las ventas totales y el valor del décimo quinto percentil para las 10 primeras fechas.
```
select top 10 date.caldate,
count(totalprice), sum(totalprice),
approximate percentile_disc(0.5)
within group (order by totalprice)
from listing
join date on listing.dateid = date.dateid
group by date.caldate
order by 3 desc;
caldate | count | sum | percentile_disc
-----------+-------+------------+----------------
2008-01-07 | 658 | 2081400.00 | 2020.00
2008-01-02 | 614 | 2064840.00 | 2178.00
2008-07-22 | 593 | 1994256.00 | 2214.00
2008-01-26 | 595 | 1993188.00 | 2272.00
2008-02-24 | 655 | 1975345.00 | 2070.00
2008-02-04 | 616 | 1972491.00 | 1995.00
2008-02-14 | 628 | 1971759.00 | 2184.00
2008-09-01 | 600 | 1944976.00 | 2100.00
2008-07-29 | 597 | 1944488.00 | 2106.00
2008-07-23 | 592 | 1943265.00 | 1974.00
```
# Función AVG
La función AVG devuelve el promedio (media aritmética) de los valores de la expresión de entrada. La función AVG funciona con valores numéricos e ignora los valores NULL.
## Sintaxis
```
AVG ( [ DISTINCT | ALL ] expression )
```
## Argumentos
*expresión *
La columna o expresión de destino sobre la que opera la función. La *expresión* corresponde a uno de los siguientes tipos de datos:
+ SMALLINT
+ INTEGER
+ BIGINT
+ NUMERIC
+ DECIMAL
+ REAL
+ DOUBLE PRECISION
+ SUPER
DISTINCT \$1 ALL
Con el argumento DISTINCT, la función elimina todos los valores duplicados de la expresión especificada antes de calcular el promedio. Con el argumento ALL, la función retiene todos los valores duplicados de la expresión especificada para calcular el promedio. El valor predeterminado es ALL.
## Tipos de datos
Los tipos de argumento compatibles con la función AVG son SMALLINT, INTEGER, BIGINT, NUMERIC, DECIMAL, REAL, DOUBLE PRECISION y SUPER.
Los tipos de retorno compatibles con la función AVG son los siguientes:
+ BIGINT para cualquier argumento de tipo entero
+ DOUBLE PRECISION para un argumento de punto flotante
+ Devuelve el mismo tipo de datos como expresión para cualquier otro tipo de argumento.
La precisión predeterminada para un resultado de la función AVG con un argumento NUMERIC o DECIMAL de es 38. La escala del resultado es la misma que la escala del argumento. Por ejemplo, una función AVG de una columna DEC(5,2) devuelve un tipo de datos DEC(38,2).
## Ejemplos
Encontrar la cantidad promedio vendida por transacción de la tabla SALES:
```
select avg(qtysold)from sales;
avg
-----
2
(1 row)
```
Encontrar el precio total promedio en lista para todas las listas:
```
select avg(numtickets*priceperticket) as avg_total_price from listing;
avg_total_price
-----------------
3034.41
(1 row)
```
Encontrar el precio promedio pagado, agrupado por mes en orden descendiente:
```
select avg(pricepaid) as avg_price, month
from sales, date
where sales.dateid = date.dateid
group by month
order by avg_price desc;
avg_price | month
-----------+-------
659.34 | MAR
655.06 | APR
645.82 | JAN
643.10 | MAY
642.72 | JUN
642.37 | SEP
640.72 | OCT
640.57 | DEC
635.34 | JUL
635.24 | FEB
634.24 | NOV
632.78 | AUG
(12 rows)
```
# Función COUNT
La función COUNT cuenta las filas definidas por la expresión.
La función COUNT tiene las siguientes variaciones.
+ COUNT ( \$1 ) cuenta todas las filas en la tabla destino, incluya o no valores nulos.
+ COUNT ( *expresión* ) calcula el número de filas con valores no NULL de una determinada columna o expresión.
+ COUNT ( DISTINCT *expresión* ) calcula el número de valores no NULL diferentes de una columna o expresión.
+ APPROXIMATE COUNT DISTINCT realiza un cálculo aproximado del número de valores distintos de NULL diferentes de una columna o una expresión.
## Sintaxis
```
COUNT( * | expression )
```
```
COUNT ( [ DISTINCT | ALL ] expression )
```
```
APPROXIMATE COUNT ( DISTINCT expression )
```
## Argumentos
*expresión *
La columna o expresión de destino sobre la que opera la función. La función COUNT admite todos los tipos de datos de argumentos.
DISTINCT \$1 ALL
Con el argumento DISTINCT, la función elimina todos los valores duplicados de la expresión especificada antes de hacer el conteo. Con el argumento ALL, la función retiene todos los valores duplicados de la expresión para el conteo. El valor predeterminado es ALL.
APPROXIMATE
Cuando se usa con APPROXIMATE, la función COUNT DISTINCT utiliza un algoritmo HyperLogLog para realizar un cálculo aproximado del número de valores distintos de NULL de una columna o una expresión. Las consultas que utilizan la palabra clave APPROXIMATE se ejecutan mucho más rápido, con un margen de error relativamente bajo de alrededor del 2 %. La aproximación se justifica para consultas que devuelven una cantidad grande de valores distintos, millones o más por consulta, o por grupo, si es que hay una cláusula de grupo. Para conjuntos más pequeños de valores distintos, en miles, la aproximación puede ser más lenta que un conteo preciso. APPROXIMATE solo se puede usar con COUNT DISTINCT.
## Tipo de retorno
La función COUNT devuelve BIGINT.
## Ejemplos
Cuente todos los usuarios del estado de Florida:
```
select count(*) from users where state='FL';
count
-------
510
```
Cuenta todos los nombres de evento de la tabla EVENT:
```
select count(eventname) from event;
count
-------
8798
```
Cuenta todos los nombres de evento de la tabla EVENT:
```
select count(all eventname) from event;
count
-------
8798
```
Contar todos los ID únicos de lugares de la tabla EVENT:
```
select count(distinct venueid) as venues from event;
venues
--------
204
```
Contar la cantidad de veces que cada vendedor indicó lotes de más de cuatro tickets para venta. Agrupar los resultados según ID de vendedor:
```
select count(*), sellerid from listing
where numtickets > 4
group by sellerid
order by 1 desc, 2;
count | sellerid
------+----------
12 | 6386
11 | 17304
11 | 20123
11 | 25428
...
```
En los siguientes ejemplos, se comparan los valores de retorno y los tiempos de ejecución para COUNT y APPROXIMATE COUNT.
```
select count(distinct pricepaid) from sales;
count
-------
4528
Time: 48.048 ms
select approximate count(distinct pricepaid) from sales;
count
-------
4553
Time: 21.728 ms
```
# Función LISTAGG
Para cada grupo de una consulta, la función de agregación LISTAGG ordena las filas de ese grupo según la expresión ORDER BY y, luego, concatena los valores en una sola cadena.
## Sintaxis
```
LISTAGG( [DISTINCT] aggregate_expression [, 'delimiter' ] )
[ WITHIN GROUP (ORDER BY order_list) ]
```
## Argumentos
DISTINCT
Una cláusula que elimina los valores duplicados de la expresión especificada antes de la concatenación. Se omiten los espacios finales. Por ejemplo, las cadenas `'a'` y `'a '` se tratan como duplicados. LISTAGG usa el primer valor que se encuentra. Para obtener más información, consulte [Importancia de los espacios en blancos anteriores y posteriores](r_Character_types.md#r_Character_types-significance-of-trailing-blanks).
*expresión\$1de\$1agregación*
Toda expresión válida, como un nombre de columna, que proporcione los valores para la agregación. Se ignoran los valores NULL y las cadenas vacías.
*delimiter*
La constante de cadena que separa los valores concatenados. El valor predeterminado es NULL.
*WITHIN GROUP (ORDER BY order\$1list)*
Una cláusula que especifica el orden de los valores agregados.
## Devuelve
VARCHAR(MAX). Si el conjunto de resultados es mayor que el tamaño máximo VARCHAR, LISTAGG devuelve el siguiente error:
```
Invalid operation: Result size exceeds LISTAGG limit
```
## Notas de uso
+ Si una instrucción incluye varias funciones LISTAGG que usan cláusulas WITHIN GROUP, cada cláusula WITHIN GROUP debe usar los mismos valores ORDER BY.
Por ejemplo, la siguiente instrucción devuelve un error.
```
SELECT LISTAGG(sellerid)
WITHIN GROUP (ORDER BY dateid) AS sellers,
LISTAGG(dateid)
WITHIN GROUP (ORDER BY sellerid) AS dates
FROM sales;
```
Las siguientes instrucciones se ejecutan correctamente.
```
SELECT LISTAGG(sellerid)
WITHIN GROUP (ORDER BY dateid) AS sellers,
LISTAGG(dateid)
WITHIN GROUP (ORDER BY dateid) AS dates
FROM sales;
SELECT LISTAGG(sellerid)
WITHIN GROUP (ORDER BY dateid) AS sellers,
LISTAGG(dateid) AS dates
FROM sales;
```
+ No puede utilizar las funciones agregadas LISTAGG, PERCENTILE\$1CONT y MEDIAN con otras funciones agregadas distintas.
## Ejemplos
En el siguiente ejemplo, se agrega el ID de vendedores ordenados por ID de vendedor.
```
SELECT LISTAGG(sellerid, ', ')
WITHIN GROUP (ORDER BY sellerid)
FROM sales
WHERE eventid = 4337;
listagg
----------------------------------------------------------------------------------------------------------------------------------------
380, 380, 1178, 1178, 1178, 2731, 8117, 12905, 32043, 32043, 32043, 32432, 32432, 38669, 38750, 41498, 45676, 46324, 47188, 47188, 48294
```
En el siguiente ejemplo, se usa DISTINCT para devolver una lista de ID de vendedor distintos.
```
SELECT LISTAGG(DISTINCT sellerid, ', ')
WITHIN GROUP (ORDER BY sellerid)
FROM sales
WHERE eventid = 4337;
listagg
-------------------------------------------------------------------------------------------
380, 1178, 2731, 8117, 12905, 32043, 32432, 38669, 38750, 41498, 45676, 46324, 47188, 48294
```
En el siguiente ejemplo, se agrega el ID de vendedores ordenados por fecha.
```
SELECT LISTAGG(sellerid, ', ')
WITHIN GROUP (ORDER BY dateid)
FROM sales
WHERE eventid = 4337;
listagg
-----------------------------------------------------------------------------------------------------------------------------------------
41498, 47188, 47188, 1178, 1178, 1178, 380, 45676, 46324, 48294, 32043, 32043, 32432, 12905, 8117, 38750, 2731, 32432, 32043, 380, 38669
```
El siguiente ejemplo devuelve una lista separada con barras de fechas de ventas para el comprador con un ID de 660.
```
SELECT LISTAGG(
(SELECT caldate FROM date WHERE date.dateid=sales.dateid), ' | '
)
WITHIN GROUP (ORDER BY sellerid DESC, salesid ASC)
FROM sales
WHERE buyerid = 660;
listagg
-------------------------------------------------
2008-07-16 | 2008-07-09 | 2008-01-01 | 2008-10-26
```
El siguiente ejemplo devuelve una lista separada por comas de ID de ventas para los ID de comprador 660, 661 y 662.
```
SELECT buyerid,
LISTAGG(salesid,', ')
WITHIN GROUP (ORDER BY salesid) AS sales_id
FROM sales
WHERE buyerid BETWEEN 660 AND 662
GROUP BY buyerid
ORDER BY buyerid;
buyerid | sales_id
--------+-----------------------------------------------------
660 | 32872, 33095, 33514, 34548
661 | 19951, 20517, 21695, 21931
662 | 3318, 3823, 4215, 51980, 53202, 55908, 57832, 171603
```
# Función MAX
La función MAX devuelve el valor máximo en un conjunto de filas. Es posible utilizar DISTINCT o ALL pero no influye en el resultado.
## Sintaxis
```
MAX ( [ DISTINCT | ALL ] expression )
```
## Argumentos
*expresión *
La columna o expresión de destino sobre la que opera la función. La *expresión* corresponde a uno de los siguientes tipos de datos:
+ SMALLINT
+ INTEGER
+ BIGINT
+ DECIMAL
+ REAL
+ DOUBLE PRECISION
+ CHAR
+ VARCHAR
+ DATE
+ TIMESTAMP
+ TIMESTAMPTZ
+ TIME
+ TIMETZ
+ VARBYTE
+ SUPER
DISTINCT \$1 ALL
Con el argumento DISTINCT, la función elimina todos los valores duplicados de la expresión especificada antes de calcular el máximo. Con el argumento ALL, la función retiene todos los valores duplicados de la expresión especificada para calcular el máximo. El valor predeterminado es ALL.
## Tipos de datos
Devuelve el mismo tipo de datos que *expresión*. El equivalente en valor booleano de la función MIN es [Función BOOL\$1AND](r_BOOL_AND.md) y el equivalente en booleano de MAX es [Función BOOL\$1OR](r_BOOL_OR.md).
## Ejemplos
Encontrar el precio más alto pagado de todas las ventas:
```
select max(pricepaid) from sales;
max
----------
12624.00
(1 row)
```
Encontrar el precio más alto pagado por ticket de todas las ventas:
```
select max(pricepaid/qtysold) as max_ticket_price
from sales;
max_ticket_price
-----------------
2500.00000000
(1 row)
```
# Función MEDIAN
Calcula el valor medio del rango de valores. Los valores `NULL` del rango se ignoran.
MEDIAN es una función de distribución inversa que asume un modelo de distribución continua.
MEDIAN es un caso especial de [PERCENTILE\$1CONT](r_PERCENTILE_CONT.md).
## Sintaxis
```
MEDIAN(median_expression)
```
## Argumentos
*expresión\$1de\$1mediana*
La columna o expresión de destino sobre la que opera la función.
## Tipos de datos
El tipo de valor devuelto viene determinado por el tipo de datos de *expresión\$1de\$1mediana*. En la tabla siguiente, se muestra el tipo de valor devuelto para cada tipo de datos de *expresión\$1de\$1mediana*.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_MEDIAN.html)
## Notas de uso
Si el argumento *median\$1expression* es un tipo de dato `DECIMAL` definido con la precisión máxima de 38 dígitos, es posible que MEDIAN devuelva un resultado impreciso o un error. Si el valor de retorno de la función MEDIAN supera los 38 dígitos, el resultado se trunca para adaptarse, lo que genera pérdida de precisión. Si, durante la interpolación, un resultado intermedio supera la precisión máxima, se produce un desbordamiento numérico y la función devuelve un error. Para evitar estas condiciones, recomendamos usar un tipo de dato con menor precisión o emitir el argumento *median\$1expression* con una precisión menor.
Si una instrucción incluye varias llamadas a funciones de agregación basadas en ordenación (LISTAGG, PERCENTILE\$1CONT o MEDIAN), todas deben usar los mismos valores ORDER BY. Tenga en cuenta que MEDIAN aplica un comando ORDER BY implícito en el valor de expresión.
Por ejemplo, la siguiente instrucción devuelve un error.
```
SELECT TOP 10 salesid, SUM(pricepaid),
PERCENTILE_CONT(0.6) WITHIN GROUP(ORDER BY salesid),
MEDIAN(pricepaid)
FROM sales
GROUP BY salesid, pricepaid;
An error occurred when executing the SQL command:
SELECT TOP 10 salesid, SUM(pricepaid),
PERCENTILE_CONT(0.6) WITHIN GROUP(ORDER BY salesid),
MEDIAN(pricepaid)
FROM sales
GROUP BY salesid, pricepaid;
ERROR: within group ORDER BY clauses for aggregate functions must be the same
```
La siguiente instrucción se ejecuta correctamente.
```
SELECT TOP 10 salesid, SUM(pricepaid),
PERCENTILE_CONT(0.6) WITHIN GROUP(ORDER BY salesid),
MEDIAN(salesid)
FROM sales
GROUP BY salesid, pricepaid;
```
## Ejemplos
En los siguientes ejemplos se utiliza la base de datos de ejemplo TICKIT. Para obtener más información, consulte [Base de datos de muestra](c_sampledb.md).
En el siguiente ejemplo, se muestra que MEDIAN produce los mismos resultados que PERCENTILE\$1CONT(0.5).
```
SELECT TOP 10 DISTINCT sellerid, qtysold,
PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY qtysold),
MEDIAN(qtysold)
FROM sales
GROUP BY sellerid, qtysold;
+----------+---------+-----------------+--------+
| sellerid | qtysold | percentile_cont | median |
+----------+---------+-----------------+--------+
| 2 | 2 | 2 | 2 |
| 26 | 1 | 1 | 1 |
| 33 | 1 | 1 | 1 |
| 38 | 1 | 1 | 1 |
| 43 | 1 | 1 | 1 |
| 48 | 2 | 2 | 2 |
| 48 | 3 | 3 | 3 |
| 77 | 4 | 4 | 4 |
| 85 | 4 | 4 | 4 |
| 95 | 2 | 2 | 2 |
+----------+---------+-----------------+--------+
```
En el siguiente ejemplo se encuentra la cantidad media vendida para cada sellerid.
```
SELECT sellerid,
MEDIAN(qtysold)
FROM sales
GROUP BY sellerid
ORDER BY sellerid
LIMIT 10;
+----------+--------+
| sellerid | median |
+----------+--------+
| 1 | 1.5 |
| 2 | 2 |
| 3 | 2 |
| 4 | 2 |
| 5 | 1 |
| 6 | 1 |
| 7 | 1.5 |
| 8 | 1 |
| 9 | 4 |
| 12 | 2 |
+----------+--------+
```
Para comprobar los resultados de la consulta anterior del primer sellerid, use el siguiente ejemplo.
```
SELECT qtysold
FROM sales
WHERE sellerid=1;
+---------+
| qtysold |
+---------+
| 2 |
| 1 |
+---------+
```
# Función MIN
La función MIN devuelve el valor mínimo en un conjunto de filas. Es posible utilizar DISTINCT o ALL pero no influye en el resultado.
## Sintaxis
```
MIN ( [ DISTINCT | ALL ] expression )
```
## Argumentos
*expresión *
La columna o expresión de destino sobre la que opera la función. La *expresión* corresponde a uno de los siguientes tipos de datos:
+ SMALLINT
+ INTEGER
+ BIGINT
+ DECIMAL
+ REAL
+ DOUBLE PRECISION
+ CHAR
+ VARCHAR
+ DATE
+ TIMESTAMP
+ TIMESTAMPTZ
+ TIME
+ TIMETZ
+ VARBYTE
+ SUPER
DISTINCT \$1 ALL
Con el argumento DISTINCT, la función elimina todos los valores duplicados de la expresión especificada antes de calcular el mínimo. Con el argumento ALL, la función retiene todos los valores duplicados de la expresión especificada para calcular el mínimo. El valor predeterminado es ALL.
## Tipos de datos
Devuelve el mismo tipo de datos que *expresión*. El equivalente en valor booleano de la función MIN es [Función BOOL\$1AND](r_BOOL_AND.md) y el equivalente en booleano de MAX es [Función BOOL\$1OR](r_BOOL_OR.md).
## Ejemplos
Encontrar el precio más bajo pagado de todas las ventas:
```
select min(pricepaid) from sales;
min
-------
20.00
(1 row)
```
Encontrar el precio más bajo pagado por ticket de todas las ventas:
```
select min(pricepaid/qtysold)as min_ticket_price
from sales;
min_ticket_price
------------------
20.00000000
(1 row)
```
# Función PERCENTILE\$1CONT
PERCENTILE\$1CONT es una función de distribución inversa que asume un modelo de distribución continua. Toma un valor percentil y una especificación de ordenación, y devuelve un valor interpolado que se encuadraría dentro de ese valor percentil dado respecto de la especificación de ordenación.
PERCENTILE\$1CONT computa una interpolación linear entre valores después de ordenarlos. Utilizando el valor percentil `(P)` y la cantidad de filas no nulas `(N)` en el grupo de agregación, la función computa la cantidad de filas después de ordenar las filas según la especificación de ordenación. Esta cantidad de filas `(RN)` se computa según la fórmula `RN = (1+ (P*(N-1))`. El resultado final de la función de agregación se computa por interpolación lineal entre los valores de filas en números de filas `CRN = CEILING(RN)` y `FRN = FLOOR(RN)`.
El resultado final será el siguiente.
Si `(CRN = FRN = RN)`, entonces el resultado es `(value of expression from row at RN)`
De lo contrario, el resultado es el siguiente:
`(CRN - RN) * (value of expression for row at FRN) + (RN - FRN) * (value of expression for row at CRN)`.
## Sintaxis
```
PERCENTILE_CONT(percentile)
WITHIN GROUP(ORDER BY expr)
```
## Argumentos
*percentil*
Constante numérica entre 0 y 1. Los valores `NULL` se ignoran en el cálculo.
*expr*
Valores numéricos o de fecha/hora específicos para ordenar y calcular el percentil.
## Devuelve
El tipo de retorno se determina por el tipo de datos de la expresión ORDER BY en la cláusula WITHIN GROUP. En la tabla siguiente, se muestra el tipo de retorno para cada tipo de datos de la expresión ORDER BY.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_PERCENTILE_CONT.html)
## Notas de uso
Si la expresión ORDER BY es un tipo de dato DECIMAL definido con la precisión máxima de 38 dígitos, es posible que PERCENTILE\$1CONT devuelva un resultado impreciso o un error. Si el valor de retorno de la función PERCENTILE\$1CONT supera los 38 dígitos, el resultado se trunca para adaptarse, lo que genera pérdida de precisión. Si, durante la interpolación, un resultado intermedio supera la precisión máxima, se produce un desbordamiento numérico y la función devuelve un error. Para evitar estas condiciones, recomendamos usar un tipo de dato con menor precisión o emitir la expresión ORDER BY a una precisión menor.
Si una instrucción incluye varias llamadas a funciones de agregación basadas en ordenación (LISTAGG, PERCENTILE\$1CONT o MEDIAN), todas deben usar los mismos valores ORDER BY. Tenga en cuenta que MEDIAN aplica un comando ORDER BY implícito en el valor de expresión.
Por ejemplo, la siguiente instrucción devuelve un error.
```
SELECT TOP 10 salesid, SUM(pricepaid),
PERCENTILE_CONT(0.6) WITHIN GROUP(ORDER BY salesid),
MEDIAN(pricepaid)
FROM sales
GROUP BY salesid, pricepaid;
An error occurred when executing the SQL command:
SELECT TOP 10 salesid, SUM(pricepaid),
PERCENTILE_CONT(0.6) WITHIN GROUP(ORDER BY salesid),
MEDIAN(pricepaid)
FROM sales
GROUP BY salesid, pricepaid;
ERROR: within group ORDER BY clauses for aggregate functions must be the same
```
La siguiente instrucción se ejecuta correctamente.
```
SELECT TOP 10 salesid, SUM(pricepaid),
PERCENTILE_CONT(0.6) WITHIN GROUP(ORDER BY salesid),
MEDIAN(salesid)
FROM sales
GROUP BY salesid, pricepaid;
```
## Ejemplos
En los siguientes ejemplos se utiliza la base de datos de ejemplo TICKIT. Para obtener más información, consulte [Base de datos de muestra](c_sampledb.md).
En el siguiente ejemplo, se muestra que PERCENTILE\$1CONT(0.5) produce los mismos resultados que MEDIAN.
```
SELECT TOP 10 DISTINCT sellerid, qtysold,
PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY qtysold),
MEDIAN(qtysold)
FROM sales
GROUP BY sellerid, qtysold;
+----------+---------+-----------------+--------+
| sellerid | qtysold | percentile_cont | median |
+----------+---------+-----------------+--------+
| 2 | 2 | 2 | 2 |
| 26 | 1 | 1 | 1 |
| 33 | 1 | 1 | 1 |
| 38 | 1 | 1 | 1 |
| 43 | 1 | 1 | 1 |
| 48 | 2 | 2 | 2 |
| 48 | 3 | 3 | 3 |
| 77 | 4 | 4 | 4 |
| 85 | 4 | 4 | 4 |
| 95 | 2 | 2 | 2 |
+----------+---------+-----------------+--------+
```
En el siguiente ejemplo, se encuentra PERCENTILE\$1CONT(0.5) y PERCENTILE\$1CONT(0.75) para la cantidad vendida por cada sellerid en la tabla SALES.
```
SELECT sellerid,
PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY qtysold) as pct_50,
PERCENTILE_CONT(0.75) WITHIN GROUP(ORDER BY qtysold) as pct_75
FROM sales
GROUP BY sellerid
ORDER BY sellerid
LIMIT 10;
+----------+--------+---------+
| sellerid | pct_50 | pct_75 |
+----------+--------+---------+
| 1 | 1.5 | 1.75 |
| 2 | 2 | 2.25 |
| 3 | 2 | 3 |
| 4 | 2 | 2 |
| 5 | 1 | 1.5 |
| 6 | 1 | 1 |
| 7 | 1.5 | 1.75 |
| 8 | 1 | 1 |
| 9 | 4 | 4 |
| 12 | 2 | 3.25 |
+----------+--------+---------+
```
Para comprobar los resultados de la consulta anterior del primer sellerid, use el siguiente ejemplo.
```
SELECT qtysold
FROM sales
WHERE sellerid=1;
+---------+
| qtysold |
+---------+
| 2 |
| 1 |
+---------+
```
# Funciones STDDEV\$1SAMP y STDDEV\$1POP
Las funciones STDDEV\$1SAMP y STDDEV\$1POP devuelven la muestra y la desviación estándar de población de un conjunto de valores numéricos (entero, decimal o de punto flotante). El resultado de la función STDDEV\$1SAMP es equivalente a la raíz cuadrada de la varianza de muestra del mismo conjunto de valores.
STDDEV\$1SAMP y STDDEV son sinónimos para la misma función.
## Sintaxis
```
STDDEV_SAMP | STDDEV ( [ DISTINCT | ALL ] expression)
STDDEV_POP ( [ DISTINCT | ALL ] expression)
```
La expresión debe ser un tipo de datos entero, decimal o de punto flotante. Independientemente del tipo de datos de la expresión, el tipo de retorno de esta función es un número de doble precisión.
**nota**
La desviación estándar se calcula utilizando aritmética de punto flotante, que puede dar como resultado una leve imprecisión.
## Notas de uso
Cuando la desviación estándar de la muestra (STDDEV o STDDEV\$1SAMP) se calcula para una expresión que consta de un valor único, el resultado de la función es NULL no 0.
## Ejemplos
La siguiente consulta devuelve el promedio de valores en la columna VENUESEATS de la tabla VENUE, seguido de la desviación estándar de la muestra y la desviación estándar de la población del mismo conjunto de valores. VENUESEATS es una columna INTEGER. La escala del resultado se reduce a 2 dígitos.
```
select avg(venueseats),
cast(stddev_samp(venueseats) as dec(14,2)) stddevsamp,
cast(stddev_pop(venueseats) as dec(14,2)) stddevpop
from venue;
avg | stddevsamp | stddevpop
-------+------------+-----------
17503 | 27847.76 | 27773.20
(1 row)
```
La siguiente consulta devuelve la desviación estándar de muestra para la columna COMMISSION en la tabla SALES. COMMISSION es una columna DECIMAL. La escala del resultado se reduce a 10 dígitos.
```
select cast(stddev(commission) as dec(18,10))
from sales;
stddev
----------------
130.3912659086
(1 row)
```
La siguiente consulta convierte la desviación estándar de muestra para la columna COMMISSION en un número entero.
```
select cast(stddev(commission) as integer)
from sales;
stddev
--------
130
(1 row)
```
La siguiente consulta devuelve tanto la desviación estándar de muestra y la raíz cuadrada de la varianza de muestra para la columna COMMISSION. Los resultados de estos cálculos son semejantes.
```
select
cast(stddev_samp(commission) as dec(18,10)) stddevsamp,
cast(sqrt(var_samp(commission)) as dec(18,10)) sqrtvarsamp
from sales;
stddevsamp | sqrtvarsamp
----------------+----------------
130.3912659086 | 130.3912659086
(1 row)
```
# Función SUM
La función SUM devuelve la suma de la columna de entrada o valores de la expresión. La función SUM funciona con valores numéricos e ignora los valores NULL.
## Sintaxis
```
SUM ( [ DISTINCT | ALL ] expression )
```
## Argumentos
*expresión *
La columna o expresión de destino sobre la que opera la función. La *expresión* corresponde a uno de los siguientes tipos de datos:
+ SMALLINT
+ INTEGER
+ BIGINT
+ NUMERIC
+ DECIMAL
+ REAL
+ DOUBLE PRECISION
+ SUPER
DISTINCT \$1 ALL
Con el argumento DISTINCT, la función elimina todos los valores duplicados de la expresión especificada antes de calcular la suma. Con el argumento ALL, la función retiene todos los valores duplicados de la expresión especificada para calcular la suma. El valor predeterminado es ALL.
## Tipos de datos
Los tipos de argumento compatibles con la función SUM son SMALLINT, INTEGER, BIGINT, NUMERIC, DECIMAL, REAL, DOUBLE PRECISION y SUPER.
Los tipos de retorno compatibles con la función SUM son los siguientes:
+ BIGINT para los argumentos BIGINT, SMALLINT e INTEGER
+ NUMERIC para argumentos NUMERIC
+ DOUBLE PRECISION para argumentos de punto flotante
+ Devuelve el mismo tipo de datos como expresión para cualquier otro tipo de argumento.
La precisión predeterminada para un resultado de la función SUM con un argumento NUMERIC o DECIMAL es 38. La escala del resultado es la misma que la escala del argumento. Por ejemplo, un comando SUM de una columna DEC(5,2) devuelve un tipo de dato DEC(38,2).
## Ejemplos
Encontrar la suma de todas las comisiones pagadas de la tabla SALES:
```
select sum(commission) from sales;
sum
-------------
16614814.65
(1 row)
```
Encontrar la cantidad de asientos en todos los lugares en el estado de Florida:
```
select sum(venueseats) from venue
where venuestate = 'FL';
sum
--------
250411
(1 row)
```
Encontrar la cantidad de asientos vendidos en mayo:
```
select sum(qtysold) from sales, date
where sales.dateid = date.dateid and date.month = 'MAY';
sum
-------
32291
(1 row)
```
# Funciones VAR\$1SAMP y VAR\$1POP
Las funciones VAR\$1SAMP y VAR\$1POP devuelven la muestra y la varianza de población de un conjunto de valores numéricos (entero, decimal o de punto flotante). El resultado de la función VAR\$1SAMP es equivalente a la desviación cuadrada estándar de la muestra del mismo conjunto de valores.
VAR\$1SAMP y VARIANCE son sinónimos para la misma función.
## Sintaxis
```
VAR_SAMP | VARIANCE ( [ DISTINCT | ALL ] expression)
VAR_POP ( [ DISTINCT | ALL ] expression)
```
La expresión debe ser un tipo de datos entero, decimal o de punto flotante. Independientemente del tipo de datos de la expresión, el tipo de retorno de esta función es un número de doble precisión.
**nota**
Los resultados de estas funciones pueden variar entre clústeres de data warehouse, según la configuración del clúster en cada caso.
## Notas de uso
Cuando la varianza de la muestra (VARIANCE o VAR\$1SAMP) se calcula para una expresión que consta de un valor único, el resultado de la función es NULL no 0.
## Ejemplos
La siguiente consulta devuelve la varianza redondeada de muestra y población de la columna NUMTICKETS en la tabla LISTING.
```
select avg(numtickets),
round(var_samp(numtickets)) varsamp,
round(var_pop(numtickets)) varpop
from listing;
avg | varsamp | varpop
-----+---------+--------
10 | 54 | 54
(1 row)
```
La siguiente consulta ejecuta los mismos cálculos pero convierte los resultados a valores decimales.
```
select avg(numtickets),
cast(var_samp(numtickets) as dec(10,4)) varsamp,
cast(var_pop(numtickets) as dec(10,4)) varpop
from listing;
avg | varsamp | varpop
-----+---------+---------
10 | 53.6291 | 53.6288
(1 row)
```