O Amazon Redshift não permitirá mais a criação de UDFs do Python a partir do Patch 198. As UDFs do Python existentes continuarão a funcionar normalmente até 30 de junho de 2026. Para ter mais informações, consulte a [publicação de blog ](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
# Funções agregadas
**Topics**
+ [Função ANY\$1VALUE](r_ANY_VALUE.md)
+ [Função APPROXIMATE PERCENTILE\$1DISC](r_APPROXIMATE_PERCENTILE_DISC.md)
+ [Função AVG](r_AVG.md)
+ [Função COUNT](r_COUNT.md)
+ [Função LISTAGG](r_LISTAGG.md)
+ [Função MAX](r_MAX.md)
+ [Função MEDIAN](r_MEDIAN.md)
+ [Função MIN](r_MIN.md)
+ [Função PERCENTILE\$1CONT](r_PERCENTILE_CONT.md)
+ [Funções STDDEV\$1SAMP e STDDEV\$1POP](r_STDDEV_functions.md)
+ [Função SUM](r_SUM.md)
+ [Funções VAR\$1SAMP e VAR\$1POP](r_VARIANCE_functions.md)
Funções agregadas computam um único valor de resultado a partir de um conjunto de valores de entrada.
Instruções SELECT usando funções agregadas podem incluir duas cláusulas opcionais: GROUP BY e HAVING. A sintaxe para essas cláusulas é seguinte (usando a função COUNT como um exemplo):
```
SELECT count (*) expression FROM table_reference
WHERE condition [GROUP BY expression ] [ HAVING condition]
```
A cláusula GROUP BY agrega e agrupa os resultados pelos valores exclusivos em uma coluna ou colunas especificada(s). A cláusula HAVING restringe os resultados obtidos para linhas onde determinada condição de agregação é verdadeira, tal como uma contagem (\$1) > 1. A cláusula HAVING é usada na mesma forma que WHERE para restringir as linhas com base no valor de uma coluna. Para obter um exemplo dessas cláusulas adicionais, consulte [COUNT](r_COUNT.md).
Funções agregadas não aceitam funções agregadas aninhadas ou funções da janela como argumentos.
# Função ANY\$1VALUE
A função ANY\$1VALUE retorna qualquer valor dos valores de expressão de entrada não deterministicamente. Essa função retornará `NULL` se a expressão de entrada não resultar no retorno de nenhuma linha. A função também poderá retornar `NULL` se houver valores `NULL` na expressão de entrada. Se a entrada contiver valores `NULL` misturados com valores não `NULL`, `NULL` poderá ser retornado. Se todos os valores forem `NULL`, `NULL` será retornado. Se nenhuma linha corresponder à condição, `NULL` será retornado.
## Sintaxe
```
ANY_VALUE( [ DISTINCT | ALL ] expression )
```
## Argumentos
DISTINCT \$1 ALL
Especifique DISTINCT ou ALL para retornar qualquer valor dos valores de expressão de entrada. O argumento DISTINCT não tem efeito e é ignorado.
*expressão *
A coluna ou expressão de destino na qual a função opera. A *expressão* é um destes tipos de dados:
+ SMALLINT
+ INTEGER
+ BIGINT
+ DECIMAL
+ REAL
+ DOUBLE PRECISION
+ BOOLEAN
+ CHAR
+ VARCHAR
+ DATE
+ TIMESTAMP
+ TIMESTAMPTZ
+ TIME
+ TIMETZ
+ INTERVALO ENTRE UM ANO E UM MÊS
+ INTERVALO ENTRE UM DIA E UM SEGUNDO
+ VARBYTE
+ SUPER
+ HLLSKETCH
+ GEOMETRY
+ GEOGRAPHY
## Retornos
Retorna o mesmo tipo de dados da *expressão*.
## Observações de uso
Se uma instrução que especifica a função ANY\$1VALUE para uma coluna também incluir uma segunda referência de coluna, a segunda coluna deve aparecer em uma cláusula GROUP BY ou ser incluída em uma função agregada.
## Exemplos
Os exemplos usam a tabela de eventos que é criada na [Etapa 4: Carregar dados do Amazon S3 para o Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/gsg/rs-gsg-create-sample-db.html) no *Guia de conceitos básicos do Amazon Redshift*. O exemplo a seguir retorna uma instância de qualquer dateid onde o eventname é Eagles.
```
select any_value(dateid) as dateid, eventname from event where eventname ='Eagles' group by eventname;
```
A seguir estão os resultados.
```
dateid | eventname
-------+---------------
1878 | Eagles
```
O exemplo a seguir retorna uma instância de qualquer dateid em que o eventname é Eagles ou Cold War Kids.
```
select any_value(dateid) as dateid, eventname from event where eventname in('Eagles', 'Cold War Kids') group by eventname;
```
A seguir estão os resultados.
```
dateid | eventname
-------+---------------
1922 | Cold War Kids
1878 | Eagles
```
# Função APPROXIMATE PERCENTILE\$1DISC
APPROXIMATE PERCENTILE\$1DISC é uma função de distribuição inversa que assume um modelo de distribuição discreta. Ela pega um valor percentil e uma especificação de classificação e retorna um elemento do conjunto fornecido. A aproximação permite que a função seja executada muito mais rápido, com um baixo erro relativo de cerca de 0,5%.
Para dado valor *percentil* APPROXIMATE PERCENTILE\$1DISC usa um algoritmo de resumo quantílico para aproximação do percentil discreto da expressão na cláusula ORDER BY. APPROXIMATE PERCENTILE\$1DISC retorna o valor com o menor valor de distribuição cumulativa (em relação à mesma especificação de classificação) que é maior ou igual ao *percentil*.
## Sintaxe
```
APPROXIMATE PERCENTILE_DISC ( percentile )
WITHIN GROUP (ORDER BY expr)
```
## Argumentos
*percentil*
Constante numérica entre 0 e 1. Nulls são ignorados no cálculo.
WITHIN GROUP ( ORDER BY *expr*)
Cláusula que especifica valores numéricos ou de data/hora para classificação e computação do percentil.
## Retornos
O mesmo tipo de dados que a expressão ORDER BY na cláusula WITHIN GROUP.
## Observações de uso
Se a instrução APPROXIMATE PERCENTILE\$1DISC incluir uma cláusula GROUP BY, o conjunto de resultados é limitado. O limite varia com base no tipo de nó e no número de nós. Se o limite for excedido, a função falha e retorna o seguintes erro.
```
GROUP BY limit for approximate percentile_disc exceeded.
```
Se você precisar avaliar mais grupos do que o limite permite, considere usar [Função PERCENTILE\$1CONT](r_PERCENTILE_CONT.md).
## Exemplos
O seguinte exemplo retorna o número de vendas, vendas globais e o quinquagésimo valor percentil para as primeiras 10 datas.
```
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
```
# Função AVG
A função AVG retorna a média (meio aritmético) dos valores de expressão de entrada. A função AVG funciona com valores numéricos e ignora valores NULL.
## Sintaxe
```
AVG ( [ DISTINCT | ALL ] expression )
```
## Argumentos
*expressão *
A coluna ou expressão de destino na qual a função opera. A *expressão* é um destes tipos de dados:
+ SMALLINT
+ INTEGER
+ BIGINT
+ NUMERIC
+ DECIMAL
+ REAL
+ DOUBLE PRECISION
+ SUPER
DISTINCT \$1 ALL
Com o argumento DISTINCT, a função elimina todos os valores duplicados da expressão especificada antes de calcular a média. Com o argumento ALL, a função retém todos os valores duplicados da expressão especificada para calcular a média. ALL é o padrão.
## Tipos de dados
Os tipos de argumento compatíveis com a função AVG são SMALLINT, INTEGER, BIGINT, NUMERIC, DECIMAL, REAL, DOUBLE PRECISION e SUPER.
Os tipos de retorno compatíveis com a função AVG são:
+ BIGINT para qualquer tipo argumento de inteiro
+ DOUBLE PRECISION para um argumento de ponto flutuante
+ Retorna o mesmo tipo de dados da expressão para qualquer outro tipo de argumento.
A precisão padrão para o resultado de uma função AVG com um argumento NUMERIC ou DECIMAL é 38. A escala do resultado é a mesma que a escala do argumento. Por exemplo, uma AVG de uma coluna DEC(5,2) retorna um tipo de dado DEC(38,2).
## Exemplos
Encontre a quantidade média vendida por transação na tabela SALES:
```
select avg(qtysold)from sales;
avg
-----
2
(1 row)
```
Encontre o preço total médio listado para todas as ofertas:
```
select avg(numtickets*priceperticket) as avg_total_price from listing;
avg_total_price
-----------------
3034.41
(1 row)
```
Encontre o preço médio pago, agrupado por mês em ordem descendente:
```
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)
```
# Função COUNT
A função COUNT conta as linhas definidas pela expressão.
A função COUNT tem as variações a seguir.
+ COUNT ( \$1 ) conta todas as linhas na tabela de destino independente se elas contêm nulls ou não.
+ COUNT ( *expressão* ) computa o número de linhas com valores não NULL em uma coluna ou expressão específica.
+ COUNT ( *expressão* DISTINCT ) computa o número de valores distintos não NULL em uma coluna ou expressão.
+ APPROXIMATE COUNT DISTINCT aproxima o número de valores distintos não NULL em uma coluna ou expressão.
## Sintaxe
```
COUNT( * | expression )
```
```
COUNT ( [ DISTINCT | ALL ] expression )
```
```
APPROXIMATE COUNT ( DISTINCT expression )
```
## Argumentos
*expressão *
A coluna ou expressão de destino na qual a função opera. A função COUNT é compatível com todos os tipos de dados de argumento.
DISTINCT \$1 ALL
Com o argumento DISTINCT, a função elimina todos os valores duplicados da expressão especificada antes realizar a contagem. Com o argumento ALL, a função retém todos os valores duplicados da expressão para contagem. ALL é o padrão.
APPROXIMATE
Quando usada com APPROXIMATE, uma função COUNT DISTINCT usa um algoritmo de HyperLogLog para aproximar o número de valores distintos não NULL em uma coluna ou expressão. A consultas que usam a palavra-chave APPROXIMATE são executadas muito mais rápido, com um baixo erro relativo de cerca de 2%. A aproximação é justificada para consultas que retornam um grande número de valores distintos, com milhões ou mais por consulta ou grupo, se houver uma cláusula group by. Para conjuntos menores de valores distintos, na casa dos milhares, a aproximação pode ser mais lenta do que uma contagem precisa. APPROXIMATE pode ser usada somente com COUNT DISTINCT.
## Tipo de retorno
A função COUNT retorna BIGINT.
## Exemplos
Conte todos os usuários do estado da Flórida:
```
select count(*) from users where state='FL';
count
-------
510
```
Conte todos os nomes de eventos da tabela EVENT:
```
select count(eventname) from event;
count
-------
8798
```
Conte todos os nomes de eventos da tabela EVENT:
```
select count(all eventname) from event;
count
-------
8798
```
Conte todos os IDs exclusivos dos locais de evento da tabela EVENT:
```
select count(distinct venueid) as venues from event;
venues
--------
204
```
Conte o número de vezes que cada vendedor listou lotes de um ou mais ingressos para venda. Agrupe os resultados por 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
...
```
Os seguintes exemplos comparam os valores de retorno e os tempos de execução para COUNT e 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
```
# Função LISTAGG
Para cada grupo em uma consulta, a função de agregação LISTAGG ordena as linhas desse grupo de acordo com a expressão ORDER BY e, depois, concatena os valores em uma única string.
## Sintaxe
```
LISTAGG( [DISTINCT] aggregate_expression [, 'delimiter' ] )
[ WITHIN GROUP (ORDER BY order_list) ]
```
## Argumentos
DISTINCT
Uma cláusula que elimina valores duplicados da expressão especificada antes de concatenar. Os espaços à direita são ignorados. Por exemplo, as strings `'a'` e `'a '` são tratadas como duplicatas. LISTAGG usa o primeiro valor encontrado. Para obter mais informações, consulte [Significância de espaços em branco](r_Character_types.md#r_Character_types-significance-of-trailing-blanks).
*aggregate\$1expression*
Qualquer expressão válida, como um nome de coluna, que forneça os valores para agregar. Valores NULL e strings vazias são ignoradas.
*delimitador*
A constante de string que separará os valores concatenados. O padrão é NULL.
*WITHIN GROUP (ORDER BY order\$1list)*
Uma cláusula que especifica a ordem de classificação dos valores agregados.
## Retornos
VARCHAR(MAX). Se o resultado for maior que o tamanho máximo de VARCHAR, LISTAGG retornará o seguinte erro:
```
Invalid operation: Result size exceeds LISTAGG limit
```
## Observações de uso
+ Se uma instrução inclui várias funções LISTAGG que usam cláusulas WITHIN GROUP, todas as cláusulas WITHIN GROUP devem usar os mesmos valores ORDER BY.
Por exemplo, a seguinte instrução retorna um erro.
```
SELECT LISTAGG(sellerid)
WITHIN GROUP (ORDER BY dateid) AS sellers,
LISTAGG(dateid)
WITHIN GROUP (ORDER BY sellerid) AS dates
FROM sales;
```
As instruções a seguir são executadas com êxito.
```
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;
```
+ Não é possível usar as funções agregadas LISTAGG, PERCENTILE\$1CONT e MEDIAN com outras funções agregadas distintas.
## Exemplos
O seguinte exemplo agrega os IDs de vendedor, 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
```
O exemplo a seguir usa DISTINCT para retornar uma lista de IDs de vendedor exclusivos.
```
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
```
O seguinte exemplo agrega os IDs de vendedor por ordem de data.
```
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
```
O exemplo a seguir retorna uma lista separada por pipes das datas de vendas do comprador com ID 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
```
O exemplo a seguir retorna uma lista separada por vírgulas dos IDs de venda dos compradores com ID 660, 661 e 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
```
# Função MAX
A função MAX retorna o valor máximo em um conjunto de linhas. DISTINCT ou ALL podem ser usadas, mas não afetam os resultados.
## Sintaxe
```
MAX ( [ DISTINCT | ALL ] expression )
```
## Argumentos
*expressão *
A coluna ou expressão de destino na qual a função opera. A *expressão* é um destes tipos de dados:
+ SMALLINT
+ INTEGER
+ BIGINT
+ DECIMAL
+ REAL
+ DOUBLE PRECISION
+ CHAR
+ VARCHAR
+ DATE
+ TIMESTAMP
+ TIMESTAMPTZ
+ TIME
+ TIMETZ
+ VARBYTE
+ SUPER
DISTINCT \$1 ALL
Com o argumento DISTINCT, a função elimina todos os valores duplicados da expressão especificada antes de calcular o máximo. Com o argumento ALL, a função retém todos os valores duplicados da expressão para calcular o máximo. ALL é o padrão.
## Tipos de dados
Retorna o mesmo tipo de dados da *expressão*. O equivalente booleano da função MIN é [Função BOOL\$1AND](r_BOOL_AND.md) e o equivalente booleano de MAX é [Função BOOL\$1OR](r_BOOL_OR.md).
## Exemplos
Encontre o preço mais alto pago de todas as vendas:
```
select max(pricepaid) from sales;
max
----------
12624.00
(1 row)
```
Encontre o preço mais alto pago por ingresso em todas as vendas:
```
select max(pricepaid/qtysold) as max_ticket_price
from sales;
max_ticket_price
-----------------
2500.00000000
(1 row)
```
# Função MEDIAN
Calcula o valor médio para o intervalo de valores. Os valores `NULL` no intervalo são ignorados.
MEDIAN é uma função de distribuição inversa que assume um modelo de distribuição contínua.
MEDIAN é um caso especial de [PERCENTILE\$1CONT](r_PERCENTILE_CONT.md).
## Sintaxe
```
MEDIAN(median_expression)
```
## Argumentos
*median\$1expression*
A coluna ou expressão de destino na qual a função opera.
## Tipos de dados
O tipo de retorno é determinado pelo tipo de dados de *median\$1expression*. A tabela a seguir mostra o tipo de retorno para cada tipo de dados de *median\$1expression*.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_MEDIAN.html)
## Observações de uso
Se o argumento de *median\$1expression* é um tipo de dados `DECIMAL` com a precisão máxima de 38 dígitos, é possível que MEDIAN retorne um resultado impreciso ou um erro. Se o valor de retorno da função MEDIAN excede 38 dígitos, o resultado é truncado, o que causa a perda de precisão. Se, durante a interpolação, um resultado intermediário excede a precisão máxima, um excedente numérico ocorre e função retorna um erro. Para evitar essas condições, recomendamos o uso de um tipo de dados com menor precisão ou a conversão do argumento *median\$1expression* para uma precisão mais baixa.
Se uma instrução inclui várias chamadas para funções agregadas baseadas em classificação (LISTAGG, PERCENTILE\$1CONT ou MEDIAN), todas devem usar os mesmos valores ORDER BY. Observe que MEDIAN aplica um order by implícito no valor da expressão.
Por exemplo, a seguinte instrução retorna um erro.
```
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
```
A instrução a seguir é executada com êxito.
```
SELECT TOP 10 salesid, SUM(pricepaid),
PERCENTILE_CONT(0.6) WITHIN GROUP(ORDER BY salesid),
MEDIAN(salesid)
FROM sales
GROUP BY salesid, pricepaid;
```
## Exemplos
Os exemplos a seguir usam o banco de dados de exemplo de TICKIT. Para obter mais informações, consulte [Banco de dados de exemplo](c_sampledb.md).
O seguinte exemplo mostra que MEDIAN produz os mesmos 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 |
+----------+---------+-----------------+--------+
```
O exemplo a seguir encontra a quantidade média 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 verificar os resultados da consulta anterior para o primeiro sellerid, use o exemplo a seguir.
```
SELECT qtysold
FROM sales
WHERE sellerid=1;
+---------+
| qtysold |
+---------+
| 2 |
| 1 |
+---------+
```
# Função MIN
A função MIN retorna o valor mínimo em um conjunto de linhas. DISTINCT ou ALL podem ser usadas, mas não afetam os resultados.
## Sintaxe
```
MIN ( [ DISTINCT | ALL ] expression )
```
## Argumentos
*expressão *
A coluna ou expressão de destino na qual a função opera. A *expressão* é um destes tipos de dados:
+ SMALLINT
+ INTEGER
+ BIGINT
+ DECIMAL
+ REAL
+ DOUBLE PRECISION
+ CHAR
+ VARCHAR
+ DATE
+ TIMESTAMP
+ TIMESTAMPTZ
+ TIME
+ TIMETZ
+ VARBYTE
+ SUPER
DISTINCT \$1 ALL
Com o argumento DISTINCT, a função elimina todos os valores duplicados da expressão especificada antes de calcular o mínimo. Com o argumento ALL, a função retém todos os valores duplicados da expressão para calcular o mínimo. ALL é o padrão.
## Tipos de dados
Retorna o mesmo tipo de dados da *expressão*. O equivalente booleano de função MIN é o [Função BOOL\$1AND](r_BOOL_AND.md) e o equivalente booleano de MAX é o [Função BOOL\$1OR](r_BOOL_OR.md).
## Exemplos
Encontre o preço mais baixo pago de todas as vendas:
```
select min(pricepaid) from sales;
min
-------
20.00
(1 row)
```
Encontre o preço mais baixo pago por ingresso em todas as vendas:
```
select min(pricepaid/qtysold)as min_ticket_price
from sales;
min_ticket_price
------------------
20.00000000
(1 row)
```
# Função PERCENTILE\$1CONT
PERCENTILE\$1CONT é uma função de distribuição inversa que assume um modelo de distribuição contínua. Ela pega um valor percentil e uma especificação de classificação e retorna um valor intercalar que cairia dentro do valor percentil fornecido em relação à especificação de classificação.
PERCENTILE\$1CONT computa uma interpolação linear entre valores após ordená-los. Usando o valor percentil `(P)` e o número de linhas não nulas `(N)` no grupo de agregação, a função computa o número da linha após ordenar as linhas de acordo com a especificação de classificação. Esse número de linha `(RN)` é computado de acordo com a fórmula `RN = (1+ (P*(N-1))`. O resultado final da função agregada é computado por interpolação linear entre os valores das linhas nos números de linha `CRN = CEILING(RN)` e `FRN = FLOOR(RN)`.
O resultado final será o seguinte.
Se `(CRN = FRN = RN)`, o resultado é `(value of expression from row at RN)`
Caso contrário, o resultado é o seguinte:
`(CRN - RN) * (value of expression for row at FRN) + (RN - FRN) * (value of expression for row at CRN)`.
## Sintaxe
```
PERCENTILE_CONT(percentile)
WITHIN GROUP(ORDER BY expr)
```
## Argumentos
*percentil*
Constante numérica entre 0 e 1. Os valores `NULL` são ignorados no cálculo.
*expr*
Especifica valores numéricos ou de data/hora para classificação e computação do percentil.
## Retornos
O tipo de retorno é determinado pelo tipo de dados da expressão ORDER BY na cláusula WITHIN GROUP. A tabela a seguir mostra o tipo de retorno para cada tipo de dados da expressão ORDER BY.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_PERCENTILE_CONT.html)
## Observações de uso
Se a expressão ORDER BY é um tipo de dados DECIMAL com a precisão máxima de 38 dígitos, é possível que PERCENTILE\$1CONT retorne um resultado impreciso ou um erro. Se o valor de retorno da função PERCENTILE\$1CONT excede 38 dígitos, o resultado é truncado, o que causa a perda de precisão. Se, durante a interpolação, um resultado intermediário excede a precisão máxima, um excedente numérico ocorre e função retorna um erro. Para evitar essas condições, recomendamos o uso de um tipo de dados com menor precisão ou a conversão da expressão ORDER BY para uma precisão mais baixa.
Se uma instrução inclui várias chamadas para funções agregadas baseadas em classificação (LISTAGG, PERCENTILE\$1CONT ou MEDIAN), todas devem usar os mesmos valores ORDER BY. Observe que MEDIAN aplica um order by implícito no valor da expressão.
Por exemplo, a seguinte instrução retorna um erro.
```
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
```
A instrução a seguir é executada com êxito.
```
SELECT TOP 10 salesid, SUM(pricepaid),
PERCENTILE_CONT(0.6) WITHIN GROUP(ORDER BY salesid),
MEDIAN(salesid)
FROM sales
GROUP BY salesid, pricepaid;
```
## Exemplos
Os exemplos a seguir usam o banco de dados de exemplo de TICKIT. Para obter mais informações, consulte [Banco de dados de exemplo](c_sampledb.md).
O seguinte exemplo mostra que PERCENTILE\$1CONT(0.5) produz os mesmos 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 |
+----------+---------+-----------------+--------+
```
O exemplo a seguir encontra PERCENTILE\$1CONT(0.5) e PERCENTILE\$1CONT(0.75) da quantidade vendida para cada sellerid na tabela 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 verificar os resultados da consulta anterior para o primeiro sellerid, use o exemplo a seguir.
```
SELECT qtysold
FROM sales
WHERE sellerid=1;
+---------+
| qtysold |
+---------+
| 2 |
| 1 |
+---------+
```
# Funções STDDEV\$1SAMP e STDDEV\$1POP
As funções STDDEV\$1SAMP e STDDEV\$1POP retornam o desvio padrão da amostra e da população de um conjunto de valores numéricos (número inteiro, decimal ou ponto flutuante). O resultado da função STDDEV\$1SAMP é equivalente à raiz quadrada da variação de amostra do mesmo conjunto de valores.
STDDEV\$1SAMP e STDDEV são sinônimos para a mesma função.
## Sintaxe
```
STDDEV_SAMP | STDDEV ( [ DISTINCT | ALL ] expression)
STDDEV_POP ( [ DISTINCT | ALL ] expression)
```
A expressão deve ter um tipo de dados de número inteiro, decimal ou ponto flutuante. Independente do tipo de dados da expressão, o tipo de retorno desta função é um número de precisão dupla.
**nota**
O desvio padrão é calculado utilizando a aritmética de ponto flutuante, que pode resultar em uma ligeira imprecisão.
## Observações de uso
Quando o desvio padrão de amostra (STDDEV ou STDDEV\$1SAMP) é calculado para uma expressão que consiste em um único valor, o resultado da função é NULL ou 0.
## Exemplos
A seguinte consulta retorna a média dos valores na coluna VENUESEATS da tabela VENUE, seguida pelo desvio padrão de amostra e desvio padrão de população do mesmo conjunto de valores. VENUESEATS é uma coluna INTEGER. A escala do resultado é reduzida 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)
```
A seguinte consulta retorna o desvio padrão de amostra para a coluna COMMISSION na tabela SALES. COMMISSION é uma coluna DECIMAL. A escala do resultado é reduzida a 10 dígitos.
```
select cast(stddev(commission) as dec(18,10))
from sales;
stddev
----------------
130.3912659086
(1 row)
```
A seguinte consulta converte o desvio padrão de amostra para a coluna COMMISSION para um inteiro.
```
select cast(stddev(commission) as integer)
from sales;
stddev
--------
130
(1 row)
```
A seguinte consulta retorna o desvio padrão da amostra e a raiz quadrada da variação da amostra para a coluna COMMISSION. Os resultados desses cálculos são os mesmos.
```
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)
```
# Função SUM
A função SUM retorna a soma dos valores de entrada da coluna ou expressão. A função SUM funciona com valores numéricos e ignora valores NULL.
## Sintaxe
```
SUM ( [ DISTINCT | ALL ] expression )
```
## Argumentos
*expressão *
A coluna ou expressão de destino na qual a função opera. A *expressão* é um destes tipos de dados:
+ SMALLINT
+ INTEGER
+ BIGINT
+ NUMERIC
+ DECIMAL
+ REAL
+ DOUBLE PRECISION
+ SUPER
DISTINCT \$1 ALL
Com o argumento DISTINCT, a função elimina todos os valores duplicados da expressão especificada antes de calcular a soma. Com o argumento ALL, a função retém todos os valores duplicados da expressão para calcular a soma. ALL é o padrão.
## Tipos de dados
Os tipos de argumento compatíveis com a função SUM são SMALLINT, INTEGER, BIGINT, NUMERIC, DECIMAL, REAL, DOUBLE PRECISION e SUPER.
Os tipos de retorno compatíveis com a função SUM são
+ BIGINT para argumentos BIGINT, SMALLINT e INTEGER
+ NUMERIC para argumentos NUMERIC
+ DOUBLE PRECISION para argumentos de ponto flutuante
+ Retorna o mesmo tipo de dados da expressão para qualquer outro tipo de argumento.
A precisão padrão para o resultado de uma função SUM com um argumento NUMERIC ou DECIMAL é 38. A escala do resultado é a mesma que a escala do argumento. Por exemplo, uma SUM de uma coluna DEC(5,2) retorna um tipo de dado DEC(38,2).
## Exemplos
Encontre a soma de todas as comissões pagas da tabela SALES:
```
select sum(commission) from sales;
sum
-------------
16614814.65
(1 row)
```
Encontre o número de assentos em todos os locais de evento no estado da Flórida:
```
select sum(venueseats) from venue
where venuestate = 'FL';
sum
--------
250411
(1 row)
```
Encontre o número de assentos vendidos em maio:
```
select sum(qtysold) from sales, date
where sales.dateid = date.dateid and date.month = 'MAY';
sum
-------
32291
(1 row)
```
# Funções VAR\$1SAMP e VAR\$1POP
As funções VAR\$1SAMP e VAR\$1POP retornam a variação da amostra e da população de um conjunto de valores numéricos (número inteiro, decimal ou ponto flutuante). O resultado da função VAR\$1SAMP é equivalente à raiz quadrada do desvio padrão da amostra do mesmo conjunto de valores.
VAR\$1SAMP e VARIANCE são sinônimos para a mesma função.
## Sintaxe
```
VAR_SAMP | VARIANCE ( [ DISTINCT | ALL ] expression)
VAR_POP ( [ DISTINCT | ALL ] expression)
```
A expressão deve ter um tipo de dados de número inteiro, decimal ou ponto flutuante. Independente do tipo de dados da expressão, o tipo de retorno desta função é um número de precisão dupla.
**nota**
Os resultados dessas funções podem variar entre os clusters de data warehouse dependendo da configuração do cluster em cada caso.
## Observações de uso
Quando a variação da amostra (VARIANCE ou VAR\$1SAMP) é calculada para uma expressão que consiste em um único valor, o resultado da função é NULL ou 0.
## Exemplos
A seguinte consulta retorna a variação arredondada da amostra e da população para a coluna NUMTICKETS da tabela LISTING.
```
select avg(numtickets),
round(var_samp(numtickets)) varsamp,
round(var_pop(numtickets)) varpop
from listing;
avg | varsamp | varpop
-----+---------+--------
10 | 54 | 54
(1 row)
```
A seguinte consulta executa os mesmos cálculos, mas converte os resultados para valores decimais.
```
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)
```