As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Funções agregadas
As funções agregadas no AWS Clean Rooms Spark SQL são usadas para realizar cálculos ou operações em um grupo de linhas e retornar um único valor. Eles são essenciais para tarefas de análise e resumo de dados.
AWS Clean Rooms O Spark SQL é compatível com as seguintes funções agregadas:
**Topics**
+ [Função ANY\$1VALUE](ANY_VALUE.md)
+ [Função APPROX COUNT\$1DISTINCT](approx-count-distinct.md)
+ [Função PERCENTILE APROXIMADA](approx-percentile.md)
+ [Função AVG](avg-function.md)
+ [Função BOOL\$1AND](BOOL_AND.md)
+ [Função BOOL\$1OR](BOOL_OR.md)
+ [Função CARDINALITY](CARDINALITY.md)
+ [função COLLECT\$1LIST](COLLECT_LIST.md)
+ [função COLLECT\$1SET](COLLECT_SET.md)
+ [Funções COUNT e COUNT DISTINCT](count-function.md)
+ [Função COUNT](COUNT.md)
+ [Função MAX](MAX.md)
+ [Função MEDIAN](MEDIAN.md)
+ [Função MIN](MIN.md)
+ [Função PERCENTILE](percentile.md)
+ [Função SKEWNESS](SKEWNESS.md)
+ [Funções STDDEV\$1SAMP e STDDEV\$1POP](STDDEV_functions.md)
+ [Funções SUM e SUM DISTINCT](sum-function.md)
+ [Funções VAR\$1SAMP e VAR\$1POP](VARIANCE_functions.md)
# Função ANY\$1VALUE
A função ANY\$1VALUE retorna qualquer valor dos valores de expressão de entrada não deterministicamente. Esta função pode retornar NULL se a expressão de entrada não resultar no retorno de nenhuma linha.
## Sintaxe
```
ANY_VALUE (expression[, isIgnoreNull] )
```
## Argumentos
*expressão*
A coluna ou expressão de destino na qual a função opera. A *expressão* é um destes tipos de dados:
*isIgnoreNull*
Um booleano que determina se a função deve retornar somente valores não nulos.
## 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
O exemplo a seguir exibe uma instância de qualquer `dateid` em que o `eventname` seja `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 exibe uma instância de qualquer `dateid` em que o `eventname` seja `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 APPROX COUNT\$1DISTINCT
APPROX COUNT\$1DISTINCT fornece uma maneira eficiente de estimar o número de valores exclusivos em uma coluna ou conjunto de dados.
## Sintaxe
```
approx_count_distinct(expr[, relativeSD])
```
## Argumentos
*expr*
A expressão ou coluna para a qual você deseja estimar o número de valores exclusivos.
Pode ser uma única coluna, uma expressão complexa ou uma combinação de colunas.
*SD relativo*
Um parâmetro opcional que especifica o desvio padrão relativo desejado da estimativa.
É um valor entre 0 e 1, representando o erro relativo máximo aceitável da estimativa. Um valor menor de RelativeSD resultará em uma estimativa mais precisa, porém mais lenta.
Se esse parâmetro não for fornecido, um valor padrão (geralmente em torno de 0,05 ou 5%) será usado.
## Retornos
Retorna a cardinalidade estimada em HyperLogLog \$1\$1. RelativeSD define o desvio padrão relativo máximo permitido.
## Exemplo
A consulta a seguir estima o número de valores exclusivos na `col1` coluna, com um desvio padrão relativo de 1% (0,01).
```
SELECT approx_count_distinct(col1, 0.01)
```
A consulta a seguir estima que há 3 valores exclusivos na `col1` coluna (os valores 1, 2 e 3).
```
SELECT approx_count_distinct(col1) FROM VALUES (1), (1), (2), (2), (3) tab(col1)
```
# Função PERCENTILE APROXIMADA
O PERCENTILE APROXIMADO é usado para estimar o valor percentual de uma determinada expressão ou coluna sem precisar classificar todo o conjunto de dados. Essa função é útil em cenários em que você precisa entender rapidamente a distribuição de um grande conjunto de dados ou rastrear métricas baseadas em percentis, sem a sobrecarga computacional de realizar um cálculo de percentil exato. No entanto, é importante entender as vantagens e desvantagens entre velocidade e precisão e escolher a tolerância de erro apropriada com base nos requisitos específicos do seu caso de uso.
## Sintaxe
```
APPROX_PERCENTILE(expr, percentile [, accuracy])
```
## Argumentos
*expr*
A expressão ou coluna para a qual você deseja estimar o valor do percentil.
Pode ser uma única coluna, uma expressão complexa ou uma combinação de colunas.
*percentil*
O valor do percentil que você deseja estimar, expresso como um valor entre 0 e 1.
Por exemplo, 0,5 corresponderia ao 50º percentil (mediana).
*precisão*
Um parâmetro opcional que especifica a precisão desejada da estimativa do percentil. É um valor entre 0 e 1, representando o erro relativo máximo aceitável da estimativa. Um `accuracy` valor menor resultará em uma estimativa mais precisa, porém mais lenta. Se esse parâmetro não for fornecido, um valor padrão (geralmente em torno de 0,05 ou 5%) será usado.
## Retornos
Retorna o percentil aproximado da coluna de intervalo numérico ou ANSI col, que é o menor valor nos valores de col ordenados (classificados do menor para o maior), de forma que não mais do que a porcentagem dos valores de col seja menor que o valor ou igual a esse valor.
O valor da porcentagem deve estar entre 0,0 e 1,0. O parâmetro de precisão (padrão: 10000) é um literal numérico positivo que controla a precisão da aproximação ao custo da memória.
Um valor mais alto de precisão gera melhor precisão, `1.0/accuracy` é o erro relativo da aproximação.
Quando a porcentagem é uma matriz, cada valor da matriz de porcentagem deve estar entre 0,0 e 1,0. Nesse caso, retorna a matriz de percentis aproximada da coluna col na matriz de porcentagem fornecida.
## Exemplos
A consulta a seguir estima o 95º percentil da `response_time` coluna, com um erro relativo máximo de 1% (0,01).
```
SELECT APPROX_PERCENTILE(response_time, 0.95, 0.01) AS p95_response_time
FROM my_table;
```
A consulta a seguir estima os valores dos percentis 50, 40 e 10 da coluna na `col` tabela. `tab`
```
SELECT approx_percentile(col, array(0.5, 0.4, 0.1), 100) FROM VALUES (0), (1), (2), (10) AS tab(col)
```
A consulta a seguir estima o 50º percentil (mediana) dos valores na coluna col.
```
SELECT approx_percentile(col, 0.5, 100) FROM VALUES (0), (6), (7), (9), (10) AS tab(col)
```
# Função AVG
A função AVG retorna a média (média aritmética) dos valores da expressão de entrada. A função AVG trabalha com valores numéricos e ignora valores NULL.
## Sintaxe
```
AVG (column)
```
## Argumentos
*column*
A coluna de destino na qual a função opera. A coluna é um dos seguintes tipos de dados:
+ SMALLINT
+ INTEGER
+ BIGINT
+ DECIMAL
+ DOUBLE
+ FLOAT
## Tipos de dados
Os tipos de argumentos suportados pela função AVG são SMALLINT, INTEGER, BIGINT, DECIMAL e DOUBLE.
Os tipos de retorno suportados pela função AVG são:
+ BIGINT para qualquer argumento de tipo inteiro
+ DOUBLE para um argumento de ponto flutuante
+ Retorna o mesmo tipo de dados que a expressão para qualquer outro tipo de argumento
A precisão padrão para um resultado de função AVG com um argumento DECIMAL é 38. A escala do resultado é a mesma que a escala do argumento. Por exemplo, um AVG de uma coluna DEC(5,2) de a retorna um tipo de dados DEC(38,2).
## Exemplo
Encontre a quantidade média vendida por transação na tabela SALES.
```
select avg(qtysold) from sales;
```
# Função BOOL\$1AND
A função BOOL\$1AND opera em uma única coluna ou expressão de boolianos ou inteiros. Essa função aplica lógica semelhante às funções BIT\$1AND e BIT\$1OR. Para essa função, o tipo de retorno é um valor booliano (`true` ou `false`).
Se todos os valores em um conjunto forem verdadeiros, a função BOOL\$1AND retorna `true` (`t`). Se qualquer valor for falso, a função retorna `false` (`f`).
## Sintaxe
```
BOOL_AND ( [DISTINCT | ALL] expression )
```
## Argumentos
*expressão*
A coluna ou expressão de destino na qual a função opera. Essa expressão deve ter um tipo de dados BOOLEAN ou de inteiros. O tipo de retorno da função é BOOLEAN.
DISTINCT \$1 ALL
Com o argumento DISTINCT, a função elimina todos os valores duplicados para a expressão especificada antes de calcular o resultado. Com o argumento ALL, a função retém todos os valores duplicados. ALL é o padrão.
## Exemplos
Você pode usar as funções booleanas com expressões booleanas ou expressões de inteiro.
Por exemplo, o seguinte retorno de consulta resultada da tabela USERS padrão no banco de dados TICKIT, que tem várias colunas booleanas.
A função BOOL\$1AND retorna `false` para todas as cinco linhas. Nem todos os usuários em cada um dos estados gostam de esportes.
```
select state, bool_and(likesports) from users
group by state order by state limit 5;
state | bool_and
------+---------
AB | f
AK | f
AL | f
AZ | f
BC | f
(5 rows)
```
# Função BOOL\$1OR
A função BOOL\$1OR opera em uma única coluna ou expressão de boolianos ou inteiros. Essa função aplica lógica semelhante às funções BIT\$1AND e BIT\$1OR. Para essa função, o tipo de retorno é um valor booliano (`true`, `false` ou `NULL`).
Se um valor de um conjunto for `true`, a função BOOL\$1OR retornará `true` (`t`). Se um valor de um conjunto for `false`, a função retornará `false` (`f`). NULL poderá ser retornado se o valor for desconhecido.
## Sintaxe
```
BOOL_OR ( [DISTINCT | ALL] expression )
```
## Argumentos
*expressão*
A coluna ou expressão de destino na qual a função opera. Essa expressão deve ter um tipo de dados BOOLEAN ou de inteiros. O tipo de retorno da função é BOOLEAN.
DISTINCT \$1 ALL
Com o argumento DISTINCT, a função elimina todos os valores duplicados para a expressão especificada antes de calcular o resultado. Com o argumento ALL, a função retém todos os valores duplicados. ALL é o padrão.
## Exemplos
Você pode usar as funções booleanas com expressões booleanas ou expressões de inteiro. Por exemplo, o seguinte retorno de consulta resultada da tabela USERS padrão no banco de dados TICKIT, que tem várias colunas booleanas.
A função BOOL\$1OR retorna `true` para todas as cinco linhas. Pelo menos um usuário em cada um dos estados gosta de esportes.
```
select state, bool_or(likesports) from users
group by state order by state limit 5;
state | bool_or
------+--------
AB | t
AK | t
AL | t
AZ | t
BC | t
(5 rows)
```
O exemplo a seguir retorna NULL.
```
SELECT BOOL_OR(NULL = '123')
bool_or
------
NULL
```
# Função CARDINALITY
A função CARDINALITY retorna o tamanho de uma expressão ARRAY ou MAP (*expr*).
Essa função é útil para encontrar o tamanho ou o comprimento de uma matriz.
## Sintaxe
```
cardinality(expr)
```
## Argumentos
*expr*
Uma expressão ARRAY ou MAP.
## Retornos
Retorna o tamanho de uma matriz ou mapa (INTEGER).
A função retorna `NULL` para entrada nula se `sizeOfNull` estiver definida como `false` ou `enabled` definida como. `true`
Caso contrário, a função retornará `-1` para entrada nula. Com as configurações padrão, a função retorna `-1` para entrada nula.
## Exemplo
A consulta a seguir calcula a cardinalidade, ou o número de elementos, na matriz fornecida. O array (`'b', 'd', 'c', 'a'`) tem 4 elementos, então a saída dessa consulta seria`4`.
```
SELECT cardinality(array('b', 'd', 'c', 'a'));
4
```
# função COLLECT\$1LIST
A função COLLECT\$1LIST coleta e retorna uma lista de elementos não exclusivos.
Esse tipo de função é útil quando você deseja coletar vários valores de um conjunto de linhas em uma única matriz ou estrutura de dados de lista.
**nota**
A função não é determinística porque a ordem dos resultados coletados depende da ordem das linhas, que pode não ser determinística após a execução de uma operação aleatória.
## Sintaxe
```
collect_list(expr)
```
## Argumentos
*expr*
Uma expressão de qualquer tipo.
## Retornos
Retorna um ARRAY do tipo de argumento. A ordem dos elementos na matriz não é determinística.
Valores NULL são excluídos.
Se DISTINCT for especificado, a função coletará somente valores exclusivos e será sinônimo de função `collect_set ` agregada.
## Exemplo
A consulta a seguir coleta todos os valores da coluna col em uma lista. A `VALUES` cláusula é usada para criar uma tabela embutida com três linhas, em que cada linha tem uma única coluna com os valores 1, 2 e 1, respectivamente. A `collect_list() ` função é então usada para agregar todos os valores da coluna col em uma única matriz. A saída dessa instrução SQL seria a matriz`[1,2,1]`, que contém todos os valores da coluna col na ordem em que eles aparecem nos dados de entrada.
```
SELECT collect_list(col) FROM VALUES (1), (2), (1) AS tab(col);
[1,2,1]
```
# função COLLECT\$1SET
A função COLLECT\$1SET coleta e retorna um conjunto de elementos exclusivos.
Essa função é útil quando você deseja coletar todos os valores distintos de um conjunto de linhas em uma única estrutura de dados, sem incluir duplicatas.
**nota**
A função não é determinística porque a ordem dos resultados coletados depende da ordem das linhas, que pode não ser determinística após a execução de uma operação aleatória.
## Sintaxe
```
collect_set(expr)
```
## Argumentos
*expr*
Uma expressão de qualquer tipo, exceto MAP.
## Retornos
Retorna um ARRAY do tipo de argumento. A ordem dos elementos na matriz não é determinística.
Valores NULL são excluídos.
## Exemplo
A consulta a seguir coleta todos os valores exclusivos da coluna col em um conjunto. A `VALUES` cláusula é usada para criar uma tabela embutida com três linhas, em que cada linha tem uma única coluna com os valores 1, 2 e 1, respectivamente. A `collect_set()` função é então usada para agregar todos os valores exclusivos da coluna col em um único conjunto. A saída dessa instrução SQL seria o conjunto`[1,2]`, que contém os valores exclusivos da coluna col. O valor duplicado de 1 só é incluído uma vez no resultado.
```
SELECT collect_set(col) FROM VALUES (1), (2), (1) AS tab(col);
[1,2]
```
# Funções COUNT e COUNT DISTINCT
A função COUNT conta as linhas definidas pela expressão. A função COUNT DISTINCT calcula o número de valores distintos não NULL em uma coluna ou uma expressão. Ela elimina todos os valores duplicados da expressão especificada antes de realizar a contagem.
## Sintaxe
```
COUNT (DISTINCT column)
```
## Argumentos
*column*
A coluna de destino na qual a função opera.
## Tipos de dados
As funções COUNT e COUNT DISTINCT comportam todos os tipos de dados de argumento.
A função COUNT DISTINCT exibe BIGINT.
## Exemplos
Conte todos os usuários do Estado da Flórida.
```
select count (identifier) from users where state='FL';
```
Conte todo o local exclusivo IDs da EVENT mesa.
```
select count (distinct venueid) as venues from event;
```
# 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.
## Sintaxe
```
COUNT( * | expression )
```
```
COUNT ( [ DISTINCT | ALL ] 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.
## 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 locais exclusivos IDs da tabela do EVENTO:
```
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
...
```
# 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* é qualquer tipo de dado numérico.
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*.
## 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
## Sintaxe
```
MEDIAN ( median_expression )
```
## Argumentos
*median\$1expression*
A coluna ou expressão de destino na qual a função opera.
# 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* é qualquer tipo de dado numérico.
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*.
## 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
A função PERCENTILE é usada para calcular o valor exato do percentil, primeiro classificando os valores na `col` coluna e, em seguida, localizando o valor no especificado. `percentage`
A função PERCENTILE é útil quando você precisa calcular o valor exato do percentil e o custo computacional é aceitável para seu caso de uso. Ela fornece resultados mais precisos do que a função APPROX\$1PERCENTILE, mas pode ser mais lenta, especialmente para grandes conjuntos de dados.
Por outro lado, a função APPROX\$1PERCENTILE é uma alternativa mais eficiente que pode fornecer uma estimativa do valor do percentil com uma tolerância de erro especificada, tornando-a mais adequada para cenários em que a velocidade é uma prioridade maior do que a precisão absoluta.
## Sintaxe
```
percentile(col, percentage [, frequency])
```
## Argumentos
*resfriado*
A expressão ou coluna para a qual você deseja calcular o valor do percentil.
*porcentagem*
O valor do percentil que você deseja calcular, expresso como um valor entre 0 e 1.
Por exemplo, 0,5 corresponderia ao 50º percentil (mediana).
*frequência*
Um parâmetro opcional que especifica a frequência ou o peso de cada valor na `col` coluna. Se fornecida, a função calculará o percentil com base na frequência de cada valor.
## Retornos
Retorna o valor percentual exato da coluna numérica ou de intervalo ANSI col na porcentagem fornecida.
O valor da porcentagem deve estar entre 0,0 e 1,0.
O valor da frequência deve ser integral positiva
## Exemplo
A consulta a seguir encontra o valor maior ou igual a 30% dos valores na `col` coluna. Como os valores são 0 e 10, o 30º percentil é 3,0, porque é o valor maior ou igual a 30% dos dados.
```
SELECT percentile(col, 0.3) FROM VALUES (0), (10) AS tab(col);
3.0
```
# Função SKEWNESS
A função SKEWNESS retorna o valor de assimetria calculado a partir dos valores de um grupo.
A assimetria é uma medida estatística que descreve a assimetria ou a falta de simetria em um conjunto de dados. Ele fornece informações sobre a forma da distribuição de dados.
Essa função pode ser útil para entender as propriedades estatísticas de um conjunto de dados e informar análises adicionais ou tomadas de decisão.
## Sintaxe
```
skewness(expr)
```
## Argumentos
*expr*
Uma expressão que é avaliada como numérica.
## Retornos
Retorna em DOBRO.
Se DISTINCT for especificado, a função operará somente em um conjunto exclusivo de valores *expr.*
## Exemplos
A consulta a seguir calcula a assimetria dos valores na coluna. `col` Neste exemplo, a `VALUES` cláusula é usada para criar uma tabela embutida com quatro linhas, em que cada linha tem uma única coluna `col` com os valores -10, -20, 100 e 1000. A `skewness()` função é então usada para calcular a assimetria dos valores na `col` coluna. O resultado, 1.1135657469022011, representa o grau e a direção da distorção nos dados. Um valor de assimetria positivo indica que os dados estão inclinados para a direita, com a maior parte dos valores concentrados no lado esquerdo da distribuição. Um valor de distorção negativo indica que os dados estão inclinados para a esquerda, com a maior parte dos valores concentrados no lado direito da distribuição.
```
SELECT skewness(col) FROM VALUES (-10), (-20), (100), (1000) AS tab(col);
1.1135657469022011
```
A consulta a seguir calcula a assimetria dos valores na coluna col. Semelhante ao exemplo anterior, a `VALUES` cláusula é usada para criar uma tabela embutida com quatro linhas, em que cada linha tem uma única coluna `col` com os valores -1000, -100, 10 e 20. A `skewness()` função é então usada para calcular a assimetria dos valores na `col` coluna. O resultado, -1.1135657469022011, representa o grau e a direção da distorção nos dados. Nesse caso, o valor de assimetria negativa indica que os dados estão inclinados para a esquerda, com a maior parte dos valores concentrados no lado direito da distribuição.
```
SELECT skewness(col) FROM VALUES (-1000), (-100), (10), (20) AS tab(col);
-1.1135657469022011
```
# 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 numérico. 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ções SUM e SUM DISTINCT
A função SUM retorna a soma da coluna de entrada ou dos valores da expressão. A função SUM trabalha com valores numéricos e ignora valores NULL.
A função SUM DISTINCT elimina todos os valores duplicados da expressão especificada antes de calcular a soma.
## Sintaxe
```
SUM (DISTINCT column )
```
## Argumentos
*column*
A coluna de destino na qual a função opera. A coluna é qualquer tipo de dado numérico.
## Exemplos
Encontre a soma de todas as comissões pagas na tabela SALES.
```
select sum(commission) from sales
```
Encontre a soma de todas as comissões distintas pagas na tabela SALES.
```
select sum (distinct (commission)) from sales
```
# 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)
```