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 de cálculos de tabela
Ao analisar dados em um visual específico, você pode aplicar cálculos de tabela para o conjunto atual de dados para descobrir como as dimensões influenciam as medidas ou umas as outras. Os *dados visualizados* são o conjunto de resultados com base no conjunto de dados atual, com todos os filtros, seleções de campos e personalizações aplicados. Para ver exatamente o que esse conjunto de resultados é, você pode exportar seu elemento visual para um arquivo. Uma *função de cálculos de tabela* realiza operações nos dados para revelar relações entre os campos.
Nesta seção, você pode encontrar uma lista das funções disponíveis em cálculos de tabela que você pode executar em dados visualizados no Amazon Quick.
Para ver uma lista de funções classificadas por categoria, com breves definições, consulte [Funções por categoria](https://docs.aws.amazon.com/quicksight/latest/user/functions-by-category.html).
**Topics**
+ [difference](difference-function.md)
+ [distinctCountOver](distinctCountOver-function.md)
+ [lag](lag-function.md)
+ [lead](lead-function.md)
+ [percentDifference](percentDifference-function.md)
+ [avgOver](avgOver-function.md)
+ [countOver](countOver-function.md)
+ [maxOver](maxOver-function.md)
+ [minOver](minOver-function.md)
+ [percentileOver](percentileOver-function.md)
+ [percentileContOver](percentileContOver-function.md)
+ [percentileDiscOver](percentileDiscOver-function.md)
+ [percentOfTotal](percentOfTotal-function.md)
+ [periodOverPeriodDifference](periodOverPeriodDifference-function.md)
+ [periodOverPeriodLastValue](periodOverPeriodLastValue-function.md)
+ [periodOverPeriodPercentDifference](periodOverPeriodPercentDifference-function.md)
+ [periodToDateAvgOverTime](periodToDateAvgOverTime-function.md)
+ [periodToDateCountOverTime](periodToDateCountOverTime-function.md)
+ [periodToDateMaxOverTime](periodToDateMaxOverTime-function.md)
+ [periodToDateMinOverTime](periodToDateMinOverTime-function.md)
+ [periodToDateSumOverTime](periodToDateSumOverTime-function.md)
+ [stdevOver](stdevOver-function.md)
+ [stdevpOver](stdevpOver-function.md)
+ [varOver](varOver-function.md)
+ [varpOver](varpOver-function.md)
+ [sumOver](sumOver-function.md)
+ [denseRank](denseRank-function.md)
+ [rank](rank-function.md)
+ [percentileRank](percentileRank-function.md)
+ [runningAvg](runningAvg-function.md)
+ [runningCount](runningCount-function.md)
+ [runningMax](runningMax-function.md)
+ [runningMin](runningMin-function.md)
+ [runningSum](runningSum-function.md)
+ [firstValue](firstValue-function.md)
+ [lastValue](lastValue-function.md)
+ [windowAvg](windowAvg-function.md)
+ [windowCount](windowCount-function.md)
+ [windowMax](windowMax-function.md)
+ [windowMin](windowMin-function.md)
+ [windowSum](windowSum-function.md)
# difference
A função `difference` calcula a diferença entre uma medida baseada em um conjunto de partições e classificações, bem como uma medida baseada em outra.
A função `difference` é compatível com o uso em análises baseadas em SPICE e conjuntos de dados de consulta direta.
## Sintaxe
São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.
```
difference
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,lookup_index,
,[ partition field, ... ]
)
```
## Argumentos
*medida*
Uma medida agregada para a qual deseja ver a diferença.
*campo da ordem de classificação*
Uma ou mais medidas e dimensões pelas quais deseja classificar os dados, separadas por vírgulas. Você pode especificar a ordem de classificação crescente (**ASC**) ou decrescente (**DESC**).
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*índice de consulta*
O índice de pesquisa pode ser positivo ou negativo, indicando a seguinte linha na classificação (positiva) ou uma linha na classificação anterior (negativa). O índice de pesquisa pode ser de 1 a 2,147,483,647. Para os mecanismos MySQL, MariaDB e Aurora com compatibilidade MySQL, o índice de pesquisa é limitado a apenas 1.
*campo de partição*
(Opcional) Uma ou mais dimensões pelas quais deseja particionar, separadas por vírgulas.
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
## Exemplo
O exemplo a seguir calcula a diferença entre `sum({Billed Amount})`, classificada por `Customer Region` em ordem crescente, comparada com a próxima linha e particionada por `Service Line`.
```
difference(
sum( {Billed Amount} ),
[{Customer Region} ASC],
1,
[{Service Line}]
)
```
O exemplo a seguir calcula a diferença entre `Billed Amount` comparada com a próxima linha e particionada por (`[{Customer Region}]`). Os campos dos cálculos de tabela estão nas fontes de campos do visual.
```
difference(
sum( {Billed Amount} ),
[{Customer Region} ASC],
1
)
```
Os destaques em vermelho mostram como cada quantidade é adicionada (a \$1 b = c) para mostrar a diferença entre as quantidades a e c.
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/differenceCalc.png)
# distinctCountOver
A função `distinctCountOver` calcula a contagem distinta do operando particionado pelos atributos especificados em um nível especificado. Os níveis compatíveis são `PRE_FILTER` e `PRE_AGG`. O operando deve ser não agregado.
## Sintaxe
São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.
```
distinctCountOver
(
measure or dimension field
,[ partition_field, ... ]
,calculation level
)
```
## Argumentos
*campo de medida ou de dimensão*
A medida ou a dimensão para a qual você deseja realizar o cálculo, por exemplo `{Sales Amt}`. Os valores válidos são `PRE_FILTER` e `PRE_AGG`.
*campo de partição*
(Opcional) Uma ou mais dimensões pelas quais deseja particionar, separadas por vírgulas.
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*nível de cálculo*
(Opcional) Especifica o nível de cálculo a ser usado:
+ **`PRE_FILTER`**: os cálculos de pré-filtro são computados antes dos filtros do conjunto de dados.
+ **`PRE_AGG`**: os cálculos pré-agregados são computados antes da aplicação de agregações e dos filtros *N* superiores e inferiores aos elementos visuais.
Esse valor é padronizado como `POST_AGG_FILTER` quando está em branco. `POST_AGG_FILTER` não é um nível válido para essa operação e resultará em uma mensagem de erro. Para obter mais informações, consulte [Uso de cálculos com reconhecimento de nível no Amazon Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Exemplo
O exemplo a seguir obtém a contagem distinta de `Sales` particionada em `City` e `State` no nível `PRE_AGG`.
```
distinctCountOver
(
Sales,
[City, State], PRE_AGG
)
```
# lag
A função `lag` calcula o valor de atraso (anterior) para uma medida com base em partições e classificações especificadas.
`lag` é compatível com o uso em análises baseadas em SPICE e conjuntos de dados de consulta direta.
## Sintaxe
São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.
```
lag
(
lag
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,lookup_index
,[ partition_field, ... ]
)]
)
```
## Argumentos
*medida*
A medida para a qual deseja a anterior. Isso pode incluir um agregado, por exemplo `sum({Sales Amt})`.
*campo da ordem de classificação*
Uma ou mais medidas e dimensões pelas quais deseja classificar os dados, separadas por vírgulas. Você pode especificar a ordem de classificação crescente (**ASC**) ou decrescente (**DESC**).
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*índice de consulta*
O índice de pesquisa pode ser positivo ou negativo, indicando a seguinte linha na classificação (positiva) ou uma linha na classificação anterior (negativa). O índice de pesquisa pode ser de 1 a 2,147,483,647. Para os mecanismos MySQL, MariaDB e Amazon Aurora com compatibilidade MySQL, o índice de pesquisa é limitado a apenas 1.
*campo de partição*
(Opcional) Uma ou mais dimensões pelas quais deseja particionar, separadas por vírgulas.
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
## Exemplo
O exemplo a seguir calcula a `sum(sales)` anterior, particionada pelo estado de origem, na ordem de classificação crescente em `cancellation_code`.
```
lag
(
sum(Sales),
[cancellation_code ASC],
1,
[origin_state_nm]
)
```
O exemplo a seguir usa um campo calculado com `lag` para exibir o valor das vendas da linha anterior ao lado da quantidade da linha atual, classificadas por `Order Date`. Os campos dos cálculos de tabela estão nas fontes de campos do visual.
```
lag(
sum({Sales}),
[{Order Date} ASC],
1
)
```
A captura de tela a seguir mostra os resultados do exemplo.
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/lagCalc.png)
O exemplo a seguir usa um campo calculado com `lag` para exibir o valor das vendas da linha anterior ao lado da quantidade da linha atual, classificadas por `Order Date` e particionadas por `Segment`.
```
lag
(
sum(Sales),
[Order Date ASC],
1, [Segment]
)
```
A captura de tela a seguir mostra os resultados do exemplo.
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/lagCalc2.png)
# lead
A função `lead` calcula o valor inicial (seguinte) para uma medida com base em partições e classificações especificadas.
## Sintaxe
São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.
```
lead
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,lookup_index,
,[ partition_field, ... ]
)
```
## Argumentos
*medida*
A medida para a qual deseja a seguinte. Isso pode incluir um agregado, por exemplo `sum({Sales Amt})`.
*campo da ordem de classificação*
Uma ou mais medidas e dimensões pelas quais deseja classificar os dados, separadas por vírgulas. Você pode especificar a ordem de classificação crescente (**ASC**) ou decrescente (**DESC**).
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*índice de consulta*
O índice de pesquisa pode ser positivo ou negativo, indicando a seguinte linha na classificação (positiva) ou uma linha na classificação anterior (negativa). O índice de pesquisa pode ser de 1 a 2,147,483,647. Para os mecanismos MySQL, MariaDB e Amazon Aurora com compatibilidade MySQL, o índice de pesquisa é limitado a apenas 1.
*campo de partição*
(Opcional) Uma ou mais dimensões pelas quais deseja particionar, separadas por vírgulas.
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
## Exemplo
O exemplo a seguir calcula a próxima `sum(sales)`, particionada pelo estado de origem, na ordem de classificação crescente em `cancellation_code`.
```
lead
(
sum(sales),
[cancellation_code ASC],
1,
[origin_state_nm]
)
```
O exemplo a seguir usa um campo calculado com lead para exibir a quantidade da próxima linha ao lado da quantidade da linha atual, classificadas por `Customer Segment`. Os campos dos cálculos de tabela estão nas fontes de campos do visual.
```
lead(
sum({Billed Amount}),
[{Customer Segment} ASC],
1
)
```
A captura de tela a seguir mostra os resultados do exemplo.
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/leadCalc.png)
# percentDifference
A função `percentDifference` calcula a diferença percentual entre o valor atual e um valor de comparação, com base em partições, classificações e índice de pesquisa.
## Sintaxe
São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.
```
percentDifference
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,lookup index
,[ partition_field, ... ]
)
```
## Argumentos
*medida*
Uma medida agregada para a qual deseja ver a porcentagem de diferença.
*campo da ordem de classificação*
Uma ou mais medidas e dimensões pelas quais deseja classificar os dados, separadas por vírgulas. Você pode especificar a ordem de classificação crescente (**ASC**) ou decrescente (**DESC**).
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*índice de consulta*
O índice de pesquisa pode ser positivo ou negativo, indicando a seguinte linha na classificação (positiva) ou uma linha na classificação anterior (negativa). O índice de pesquisa pode ser de 1 a 2,147,483,647. Para os mecanismos MySQL, MariaDB e Aurora com compatibilidade MySQL, o índice de pesquisa é limitado a apenas 1.
*campo de partição*
(Opcional) Uma ou mais dimensões pelas quais deseja particionar, separadas por vírgulas.
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
## Exemplo
O exemplo a seguir calcula a porcentagem de diferença entre a `sum(Sales)` do `State` atual e anterior, classificada por `Sales`.
```
percentDifference
(
sum(amount),
[sum(amount) ASC],
-1,
[State]
)
```
O exemplo a seguir calcula a porcentagem de determinada `Billed Amount` em comparação com outra `Billed Amount`, classificada por (`[{Customer Region} ASC]`). Os campos dos cálculos de tabela estão nas fontes de campos do visual.
```
percentDifference
(
sum( {Billed Amount} ),
[{Customer Region} ASC],
1
)
```
A captura de tela a seguir mostra os resultados do exemplo. As letras em vermelho mostram que a `Billed Amount` total para a `Customer Region` **APAC** é 24% menor que a quantidade para a região **EMEA**.
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/percentDifference.png)
# avgOver
A função `avgOver` calcula a média de uma medida particionada por uma lista de dimensões.
## Sintaxe
São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.
```
avgOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
O exemplo a seguir mostra a `Billed Amount` média por `Customer Region`. Os campos dos cálculos de tabela estão nas fontes de campos do visual.
```
avgOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
A captura de tela a seguir mostra os resultados do exemplo. Com a adição de `Service Line`, a quantidade total cobrada por cada é exibida e a média desses três valores é exibida no campo calculado.
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/avgOver.png)
## Argumentos
*medida*
A medida para a qual você quer fazer o cálculo, por exemplo `sum({Sales Amt})`. Use uma agregação se o nível de cálculo estiver definido como `NULL` ou `POST_AGG_FILTER`. Não use uma agregação se o nível de cálculo estiver definido como `PRE_FILTER` ou `PRE_AGG`.
*campo de partição*
(Opcional) Uma ou mais dimensões pelas quais deseja particionar, separadas por vírgulas.
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*nível de cálculo*
(Opcional) Especifica o nível de cálculo a ser usado:
+ **`PRE_FILTER`**: os cálculos de pré-filtro são computados antes dos filtros do conjunto de dados.
+ **`PRE_AGG`**: os cálculos pré-agregados são computados antes da aplicação de agregações e dos filtros *N* superiores e inferiores aos elementos visuais.
+ **`POST_AGG_FILTER`**: (Padrão) os cálculos de tabelas são computados quando os elementos visuais são exibidos.
Esse valor será padronizado como `POST_AGG_FILTER` quando for deixado em branco. Para obter mais informações, consulte [Usando cálculos com reconhecimento de nível no Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Exemplo
O exemplo a seguir obtém a `sum(Sales)` média particionada por `City` e `State`.
```
avgOver
(
sum(Sales),
[City, State]
)
```
# countOver
A função `countOver` calcula a contagem de uma dimensão ou medida particionada por uma lista de dimensões.
## Sintaxe
São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.
```
countOver
(
measure or dimension field
,[ partition_field, ... ]
,calculation level
)
```
## Argumentos
*campo de medida ou de dimensão*
A medida ou a dimensão para a qual você deseja realizar o cálculo, por exemplo `sum({Sales Amt})`. Use uma agregação se o nível de cálculo estiver definido como `NULL` ou `POST_AGG_FILTER`. Não use uma agregação se o nível de cálculo estiver definido como `PRE_FILTER` ou `PRE_AGG`.
*campo de partição*
(Opcional) Uma ou mais dimensões pelas quais deseja particionar, separadas por vírgulas.
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*nível de cálculo*
(Opcional) Especifica o nível de cálculo a ser usado:
+ **`PRE_FILTER`**: os cálculos de pré-filtro são computados antes dos filtros do conjunto de dados.
+ **`PRE_AGG`**: os cálculos pré-agregados são computados antes da aplicação de agregações e dos filtros *N* superiores e inferiores aos elementos visuais.
+ **`POST_AGG_FILTER`**: (Padrão) os cálculos de tabelas são computados quando os elementos visuais são exibidos.
Esse valor será padronizado como `POST_AGG_FILTER` quando for deixado em branco. Para obter mais informações, consulte [Usando cálculos com reconhecimento de nível no Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Exemplo
O exemplo a seguir obtém a contagem de `Sales` particionada sobre `City` e `State`.
```
countOver
(
Sales,
[City, State]
)
```
O exemplo a seguir obtém a contagem de `{County}` particionada sobre `City` e `State`.
```
countOver
(
{County},
[City, State]
)
```
O exemplo a seguir mostra a contagem de `Billed Amount` por `Customer Region`. Os campos dos cálculos de tabela estão nas fontes de campos do visual.
```
countOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
A captura de tela a seguir mostra os resultados do exemplo. Como não há outros campos envolvidos, a contagem é uma para cada região.
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/countOver1.png)
Se adicionar campos adicionais, a contagem muda. Na captura de tela a seguir, adicionamos `Customer Segment` e `Service Line`. Cada um desses campos contém três valores únicos. Com 3 segmentos, 3 linhas de serviço e 3 regiões, o campo calculado mostra 9.
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/countOver2.png)
Se adicionar os dois campos adicionais aos campos de particionamento no campo calculado, `countOver( sum({Billed Amount}), [{Customer Region}, {Customer Segment}, {Service Line}]`, a contagem volta a ser 1 para cada linha.
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/countOver.png)
# maxOver
A função `maxOver` calcula o máximo de uma medida ou data particionada por uma lista de dimensões.
## Sintaxe
São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.
```
maxOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
## Argumentos
*medida*
A medida para a qual você quer fazer o cálculo, por exemplo `sum({Sales Amt})`. Use uma agregação se o nível de cálculo estiver definido como `NULL` ou `POST_AGG_FILTER`. Não use uma agregação se o nível de cálculo estiver definido como `PRE_FILTER` ou `PRE_AGG`.
*campo de partição*
(Opcional) Uma ou mais dimensões pelas quais deseja particionar, separadas por vírgulas.
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*nível de cálculo*
(Opcional) Especifica o nível de cálculo a ser usado:
+ **`PRE_FILTER`**: os cálculos de pré-filtro são computados antes dos filtros do conjunto de dados.
+ **`PRE_AGG`**: os cálculos pré-agregados são computados antes da aplicação de agregações e dos filtros *N* superiores e inferiores aos elementos visuais.
+ **`POST_AGG_FILTER`**: (Padrão) os cálculos de tabelas são computados quando os elementos visuais são exibidos.
Esse valor será padronizado como `POST_AGG_FILTER` quando for deixado em branco. Para obter mais informações, consulte [Usando cálculos com reconhecimento de nível no Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Exemplo
O exemplo a seguir calcula a `sum(Sales)` máxima, particionada por `City` e `State`.
```
maxOver
(
sum(Sales),
[City, State]
)
```
O exemplo a seguir mostra a `Billed Amount` máxima por `Customer Region`. Os campos dos cálculos de tabela estão nas fontes de campos do visual.
```
maxOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
A captura de tela a seguir mostra os resultados do exemplo. Com a adição de `Service Line`, a quantidade total cobrada por cada é exibida e o máximo desses três valores é exibido no campo calculado.
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/maxOver.png)
# minOver
A função `minOver` calcula o mínimo de uma medida ou data particionada por uma lista de dimensões.
## Sintaxe
São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.
```
minOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
## Argumentos
*medida*
A medida para a qual você quer fazer o cálculo, por exemplo `sum({Sales Amt})`. Use uma agregação se o nível de cálculo estiver definido como `NULL` ou `POST_AGG_FILTER`. Não use uma agregação se o nível de cálculo estiver definido como `PRE_FILTER` ou `PRE_AGG`.
*campo de partição*
(Opcional) Uma ou mais dimensões pelas quais deseja particionar, separadas por vírgulas.
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*nível de cálculo*
(Opcional) Especifica o nível de cálculo a ser usado:
+ **`PRE_FILTER`**: os cálculos de pré-filtro são computados antes dos filtros do conjunto de dados.
+ **`PRE_AGG`**: os cálculos pré-agregados são computados antes da aplicação de agregações e dos filtros *N* superiores e inferiores aos elementos visuais.
+ **`POST_AGG_FILTER`**: (Padrão) os cálculos de tabelas são computados quando os elementos visuais são exibidos.
Esse valor será padronizado como `POST_AGG_FILTER` quando for deixado em branco. Para obter mais informações, consulte [Usando cálculos com reconhecimento de nível no Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Exemplo
O exemplo a seguir calcula a `sum(Sales)` mínima, particionada por `City` e `State`.
```
minOver
(
sum(Sales),
[City, State]
)
```
O exemplo a seguir mostra a `Billed Amount` mínima por `Customer Region`. Os campos dos cálculos de tabela estão nas fontes de campos do visual.
```
minOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
A captura de tela a seguir mostra os resultados do exemplo. Com a adição de `Service Line`, a quantidade total cobrada por cada é exibida e o mínimo desses três valores é exibido no campo calculado.
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/minOver.png)
# percentileOver
A função `percentileOver` calcula o *enésimo* percentil de uma medida particionada por uma lista de dimensões. Há duas variedades do `percentileOver` cálculo disponíveis no Quick:
+ [https://docs.aws.amazon.com/quicksight/latest/user/percentileContOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/percentileContOver-function.html) usa interpolação linear para determinar o resultado.
+ [https://docs.aws.amazon.com/quicksight/latest/user/percentileDiscOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/percentileDiscOver-function.html) usa valores reais para determinar o resultado.
A função `percentileOver` é um alias de `percentileDiscOver`.
# percentileContOver
A função `percentileContOver` calcula o percentil com base nos números reais em `measure`. Ela usa o agrupamento e a classificação aplicados nas fontes do campo. O resultado é particionado pela dimensão especificada no nível de cálculo especificado.
Use essa função para responder à seguinte pergunta: quais pontos de dados reais estão presentes nesse percentil? Para retornar o valor do percentil mais próximo que está presente no seu conjunto de dados, use `percentileDiscOver`. Para retornar um valor de percentil exato que talvez não esteja presente no seu conjunto de dados, use `percentileContOver`.
## Sintaxe
```
percentileContOver (
measure
, percentile-n
, [partition-by, …]
, calculation-level
)
```
## Argumentos
*medida*
Especifica um valor numérico a ser usado para computar o percentil. O argumento deve ser uma medida ou uma métrica. Nulls são ignorados no cálculo.
*percentil n*
O valor do percentil pode ser qualquer constante numérica de 0 a 100. Um valor de percentil 50 calcula o valor médio da medida.
*partition-by*
(Opcional) Uma ou mais dimensões pelas quais deseja particionar, separadas por vírgulas. Cada campo na lista está entre \$1 \$1 (chaves), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*calculation-level*
Especifica onde realizar o cálculo em relação à ordem de avaliação. Há três níveis de cálculo compatíveis:
+ PRE\$1FILTER
+ PRE\$1AGG
+ POST\$1AGG\$1FILTER (padrão): para usar esse nível de cálculo, especifique uma agregação em `measure`, por exemplo, `sum(measure)`.
PRE\$1FILTER e PRE\$1AGG são aplicados antes que a agregação ocorra em uma visualização. Para esses dois níveis de cálculo, você não pode especificar uma agregação em `measure` na expressão do campo calculado. Para saber mais sobre os níveis de cálculo e quando eles se aplicam, consulte [Ordem de avaliação no Amazon Quick](https://docs.aws.amazon.com/quicksight/latest/user/order-of-evaluation-quicksight.html) e [Uso de cálculos com reconhecimento de nível no](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html) Quick.
## Retornos
O resultado da função é um número.
## Exemplo de percentileContOver
O exemplo a seguir ajuda a explicar como percentileContOver funciona.
**Example Comparar os níveis de cálculo para a mediana**
O exemplo a seguir mostra a mediana de uma dimensão (categoria) usando diferentes níveis de cálculo com a função `percentileContOver`. O percentil é 50. O conjunto de dados é filtrado por um campo de região. O código para cada campo calculado é o seguinte:
+ `example = left( category, 1 )` (Um exemplo simplificado.)
+ `pre_agg = percentileContOver ( {Revenue} , 50 , [ example ] , PRE_AGG)`
+ `pre_filter = percentileContOver ( {Revenue} , 50 , [ example ] , PRE_FILTER) `
+ `post_agg_filter = percentileContOver ( sum ( {Revenue} ) , 50 , [ example ], POST_AGG_FILTER )`
```
example pre_filter pre_agg post_agg_filter
------------------------------------------------------
0 106,728 119,667 4,117,579
1 102,898 95,946 2,307,547
2 97,807 93,963 554,570
3 101,043 112,585 2,709,057
4 96,533 99,214 3,598,358
5 106,293 97,296 1,875,648
6 97,118 69,159 1,320,672
7 100,201 90,557 969,807
```
# percentileDiscOver
A função `percentileDiscOver` calcula o percentil com base nos números reais em `measure`. Ela usa o agrupamento e a classificação aplicados nas fontes do campo. O resultado é particionado pela dimensão especificada no nível de cálculo especificado. A função `percentileOver` é um alias de `percentileDiscOver`.
Use essa função para responder à seguinte pergunta: quais pontos de dados reais estão presentes nesse percentil? Para retornar o valor do percentil mais próximo que está presente no seu conjunto de dados, use `percentileDiscOver`. Para retornar um valor de percentil exato que talvez não esteja presente no seu conjunto de dados, use `percentileContOver`.
## Sintaxe
```
percentileDiscOver (
measure
, percentile-n
, [partition-by, …]
, calculation-level
)
```
## Argumentos
*medida*
Especifica um valor numérico a ser usado para computar o percentil. O argumento deve ser uma medida ou uma métrica. Nulls são ignorados no cálculo.
*percentil n*
O valor do percentil pode ser qualquer constante numérica de 0 a 100. Um valor de percentil 50 calcula o valor médio da medida.
*partition-by*
(Opcional) Uma ou mais dimensões pelas quais deseja particionar, separadas por vírgulas. Cada campo na lista está entre \$1 \$1 (chaves), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*calculation-level*
Especifica onde realizar o cálculo em relação à ordem de avaliação. Há três níveis de cálculo compatíveis:
+ PRE\$1FILTER
+ PRE\$1AGG
+ POST\$1AGG\$1FILTER (padrão): para usar esse nível de cálculo, você precisa especificar uma agregação em `measure`, por exemplo, `sum(measure)`.
PRE\$1FILTER e PRE\$1AGG são aplicados antes que a agregação ocorra em uma visualização. Para esses dois níveis de cálculo, você não pode especificar uma agregação em `measure` na expressão do campo calculado. Para saber mais sobre os níveis de cálculo e quando eles se aplicam, consulte [Ordem de avaliação no Amazon Quick](https://docs.aws.amazon.com/quicksight/latest/user/order-of-evaluation-quicksight.html) e [Uso de cálculos com reconhecimento de nível no](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html) Quick.
## Retornos
O resultado da função é um número.
## Exemplo de percentileDiscOver
O exemplo a seguir ajuda a explicar como percentileDiscOver funciona.
**Example Comparar os níveis de cálculo para a mediana**
O exemplo a seguir mostra a mediana de uma dimensão (categoria) usando diferentes níveis de cálculo com a função `percentileDiscOver`. O percentil é 50. O conjunto de dados é filtrado por um campo de região. O código para cada campo calculado é o seguinte:
+ `example = left( category, 1 )` (Um exemplo simplificado.)
+ `pre_agg = percentileDiscOver ( {Revenue} , 50 , [ example ] , PRE_AGG)`
+ `pre_filter = percentileDiscOver ( {Revenue} , 50 , [ example ] , PRE_FILTER) `
+ `post_agg_filter = percentileDiscOver ( sum ( {Revenue} ) , 50 , [ example ], POST_AGG_FILTER )`
```
example pre_filter pre_agg post_agg_filter
------------------------------------------------------
0 106,728 119,667 4,117,579
1 102,898 95,946 2,307,547
2 97,629 92,046 554,570
3 100,867 112,585 2,709,057
4 96,416 96,649 3,598,358
5 106,293 97,296 1,875,648
6 97,118 64,395 1,320,672
7 99,915 90,557 969,807
```
**Example A mediana**
O exemplo a seguir calcula a mediana (o 50º percentil) de `Sales`, particionada por `City` e `State`.
```
percentileDiscOver
(
Sales,
50,
[City, State]
)
```
O exemplo a seguir calcula o 98º percentil de `sum({Billed Amount})`, particionado por `Customer Region`. Os campos dos cálculos de tabela estão nas fontes de campos do visual.
```
percentileDiscOver
(
sum({Billed Amount}),
98,
[{Customer Region}]
)
```
A captura de tela a seguir mostra a aparência desses dois exemplos em um gráfico.
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/percentilOver-50-98.png)
# percentOfTotal
A função `percentOfTotal` calcula a porcentagem de contribuição de uma medida para o total, com base nas dimensões especificadas.
## Sintaxe
São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.
```
percentOfTotal
(
measure
,[ partition_field, ... ]
)
```
## Argumentos
*medida*
Uma medida agregada para a qual deseja ver a porcentagem do total. No momento, a agregação `distinct count` não é compatível com `percentOfTotal`.
*campo de partição*
(Opcional) Uma ou mais dimensões pelas quais deseja particionar, separadas por vírgulas.
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
## Exemplo
O exemplo a seguir cria um cálculo para a porcentagem do total de `Sales` contribuída por cada `State`.
```
percentOfTotal
(
sum(Sales),
[State]
)
```
O exemplo a seguir calcula a porcentagem que um determinado `Billed Amount` representa em comparação com o total `Billed Amount`, particionado pelo (`[{Service Line} ASC]`). Os campos dos cálculos de tabela estão nas fontes de campos do visual.
```
percentOfTotal
(
sum( {Billed Amount} ),
[{Service Line}]
)
```
A captura de tela a seguir mostra os resultados do exemplo. Os destaques em vermelho mostram que o campo de partição com o valor "`Billing`" tem três entradas, uma para cada região. A quantidade total cobrada para essa linha de serviço é dividida em três porcentagens, que totalizam 100%. As percentagens são arredondadas e podem, às vezes, não totalizar exatamente 100%.
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/percentOfTotal.png)
# periodOverPeriodDifference
A função `periodOverPeriodDifference` calcula a diferença de uma medida em dois períodos diferentes, conforme especificado pela granularidade e deslocamento do período. Ao contrário de um cálculo de diferença, essa função usa um deslocamento baseado em data em vez de um deslocamento de tamanho fixo. Isso garante que somente as datas corretas sejam comparadas, mesmo se faltarem pontos de dados no conjunto de dados.
## Sintaxe
```
periodOverPeriodDifference(
measure,
date,
period,
offset)
```
## Argumentos
*medida*
Uma medida agregada na qual você deseja realizar o periodOverPeriod cálculo.
*dateTime*
A dimensão de data sobre a qual estamos calculando Period-Over-Period os cálculos.
*período*
(Opcional) O período durante o qual você está computando a computação. A granularidade de `YEAR` significa computação de `YearToDate`, `Quarter` significa `QuarterToDate` e assim por diante. As granularidades válidas incluem `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` e `SECONDS`.
O valor padrão é a granularidade da dimensão visual da data.
*deslocamento*
(Opcional) O deslocamento pode ser um número inteiro positivo ou negativo representando o período anterior (especificado por período) com o qual você deseja comparar. Por exemplo, o período de um trimestre com deslocamento 1 significa comparação com o trimestre anterior.
O valor padrão é 1.
## Exemplo
O exemplo a seguir usa um campo calculado `PeriodOverPeriod` para exibir a diferença do valor das vendas de ontem.
```
periodOverPeriodDifference(sum(Sales), {Order Date})
```
![\[Esta é uma imagem do retorno do cálculo de exemplo.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/MonthOverMonthDifference.png)
O exemplo a seguir usa um campo calculado `PeriodOverPeriod` para exibir a diferença do valor das vendas dos dois meses anteriores. O exemplo abaixo está comparando as vendas de `Mar2020` com `Jan2020`.
```
periodOverPeriodDifference(sum(Sales),{Order Date}, MONTH, 1)
```
![\[Esta é uma imagem do retorno do cálculo de exemplo.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/MonthOverMonthDifference2.png)
# periodOverPeriodLastValue
A função `periodOverPeriodLastValue` calcula o último valor (anterior) de uma medida do período anterior, conforme especificado pela granularidade e pelo deslocamento do período. Essa função usa um deslocamento baseado em data em vez de um deslocamento de tamanho fixo. Isso garante que somente as datas corretas sejam comparadas, mesmo se faltarem pontos de dados no conjunto de dados.
## Sintaxe
```
periodOverPeriodLastValue(
measure,
date,
period,
offset)
```
## Argumentos
*medida*
Uma medida agregada para a qual deseja ver a diferença.
*data*
A dimensão da data na qual você está calculando periodOverPeriod os cálculos.
*período*
(Opcional) O período durante o qual você está computando a computação. A granularidade de `YEAR` significa computação de `YearToDate`, `Quarter` significa `QuarterToDate` e assim por diante. As granularidades válidas incluem `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` e `SECONDS`.
Esse argumento usa como padrão a granularidade da agregação visual.
*deslocamento*
(Opcional) O deslocamento pode ser um número inteiro positivo ou negativo representando o período anterior (especificado por período) com o qual você deseja comparar. Por exemplo, o período de um trimestre com deslocamento 1 significa comparação com o trimestre anterior.
O valor padrão desse argumento é 1.
## Exemplo
O exemplo a seguir calcula o valor mês a mês em vendas com a granularidade da dimensão visual e o deslocamento padrão de 1.
```
periodOverPeriodLastValue(sum(Sales), {Order Date})
```
O exemplo a seguir calcula o valor mês a mês em vendas com uma granularidade fixa de `MONTH` e um deslocamento fixo de 1.
```
periodOverPeriodLastValue(sum(Sales), {Order Date},MONTH, 1)
```
![\[Esta é uma imagem do retorno do cálculo de exemplo.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/MonthOverMonthLastValue.png)
# periodOverPeriodPercentDifference
A função `periodOverPeriodPercentDifference` calcula a diferença percentual de uma medida em dois períodos diferentes, conforme especificado pela granularidade e deslocamento do período. Ao contrário de percentDifference, essa função usa um deslocamento baseado em data em vez de um deslocamento de tamanho fixo. Isso garante que somente as datas corretas sejam comparadas, mesmo se faltarem pontos de dados no conjunto de dados.
## Sintaxe
```
periodOverPeriodPercentDifference(
measure,
date,
period,
offset)
```
## Argumentos
*medida*
Uma medida agregada para a qual deseja ver a diferença.
*data*
A dimensão da data na qual você está calculando periodOverPeriod os cálculos.
*período*
(Opcional) O período durante o qual você está computando a computação. A granularidade de `YEAR` significa computação de `YearToDate`, `Quarter` significa `QuarterToDate` e assim por diante. As granularidades válidas incluem `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` e `SECONDS`.
Esse argumento usa como padrão a granularidade da agregação visual.
*deslocamento*
(Opcional) O deslocamento pode ser um número inteiro positivo ou negativo representando o período anterior (especificado por período) com o qual você deseja comparar. Por exemplo, o período de um trimestre com deslocamento 1 significa comparação com o trimestre anterior.
O valor padrão desse argumento é 1.
## Exemplo
O exemplo a seguir calcula a diferença percentual mês a mês nas vendas com a granularidade da dimensão visual e o deslocamento padrão de 1.
```
periodOverPeriodPercentDifference(sum(Sales),{Order Date})
```
O exemplo a seguir calcula a diferença percentual mês a mês nas vendas com uma granularidade fixa de `MONTH` e um deslocamento fixo de 1.
```
periodOverPeriodPercentDifference(sum(Sales), {Order Date}, MONTH, 1)
```
![\[Esta é uma imagem do retorno do cálculo de exemplo.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/MonthOverMonthPercentDifference.png)
# periodToDateAvgOverTime
A função `periodToDateAvgOverTime` calcula a média de uma medida para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo.
## Sintaxe
```
periodToDateAvgOverTime(
measure,
dateTime,
period)
```
## Argumentos
*medida*
Uma medida agregada para a qual você deseja fazer o cálculo.
*dateTime*
A dimensão da data na qual você está calculando PeriodOverTime os cálculos.
*período*
(Opcional) O período durante o qual você está computando a computação. A granularidade de `YEAR` significa computação de `YearToDate`, `Quarter` significa `QuarterToDate` e assim por diante. As granularidades válidas incluem `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` e `SECONDS`.
O valor padrão é a granularidade da dimensão de data do elemento visual.
## Exemplo
A função a seguir calcula o valor médio da tarifa mês a mês.
```
periodToDateAvgOverTime(sum({fare_amount}), pickupDatetime, MONTH)
```
![\[Esta é uma imagem dos resultados do cálculo de exemplo com ilustrações.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/PTDAvgOverTimeResults.png)
# periodToDateCountOverTime
A função `periodToDateCountOverTime` calcula a contagem de uma dimensão ou medida para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo.
## Sintaxe
```
periodToDateCountOverTime(
measure,
dateTime,
period)
```
## Argumentos
*medida*
Uma medida agregada para a qual você deseja fazer o cálculo.
*dateTime*
A dimensão da data na qual você está calculando PeriodOverTime os cálculos.
*período*
(Opcional) O período durante o qual você está computando a computação. A granularidade de `YEAR` significa computação de `YearToDate`, `Quarter` significa `QuarterToDate` e assim por diante. As granularidades válidas incluem `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` e `SECONDS`.
O valor padrão é a granularidade da dimensão de data do elemento visual.
## Exemplo
O exemplo a seguir calcula a contagem de fornecedores mês a mês.
```
periodToDateCountOverTime(count(vendorid), pickupDatetime, MONTH)
```
![\[Esta é uma imagem dos resultados do cálculo de exemplo com ilustrações.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/PTDCountOverTimeResults.png)
# periodToDateMaxOverTime
A função `periodToDateMaxOverTime` calcula o máximo de uma medida para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo.
## Sintaxe
```
periodToDateMaxOverTime(
measure,
dateTime,
period)
```
## Argumentos
*medida*
Uma medida agregada para a qual você deseja fazer o cálculo.
*dateTime*
A dimensão da data na qual você está calculando PeriodOverTime os cálculos.
*período*
(Opcional) O período durante o qual você está computando a computação. A granularidade de `YEAR` significa computação de `YearToDate`, `Quarter` significa `QuarterToDate` e assim por diante. As granularidades válidas incluem `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` e `SECONDS`.
O valor padrão é a granularidade da dimensão de data do elemento visual.
## Exemplo
O exemplo a seguir calcula o valor máximo da tarifa mês a mês.
```
periodToDatemaxOverTime(max({fare_amount}), pickupDatetime, MONTH)
```
![\[Esta é uma imagem dos resultados do cálculo de exemplo com ilustrações.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/PTDMaxOverTimeResults.png)
# periodToDateMinOverTime
A função `periodToDateMinOverTime` calcula o mínimo de uma medida para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo.
## Sintaxe
```
periodToDateMinOverTime(
measure,
dateTime,
period)
```
## Argumentos
*medida*
Uma medida agregada para a qual você deseja fazer o cálculo.
*dateTime*
A dimensão da data na qual você está calculando PeriodOverTime os cálculos.
*período*
(Opcional) O período durante o qual você está computando a computação. A granularidade de `YEAR` significa computação de `YearToDate`, `Quarter` significa `QuarterToDate` e assim por diante. As granularidades válidas incluem `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` e `SECONDS`.
O valor padrão é a granularidade da dimensão de data do elemento visual.
## Exemplo
O exemplo a seguir calcula o valor mínimo da tarifa mês após mês.
```
periodToDateMinOverTime(min({fare_amount}), pickupDatetime, MONTH)
```
![\[Esta é uma imagem dos resultados do cálculo de exemplo com ilustrações.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/PTDMinOverTimeResults.png)
# periodToDateSumOverTime
A função `periodToDateSumOverTime` calcula a soma de uma medida para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo.
## Sintaxe
```
periodToDateSumOverTime(
measure,
dateTime,
period)
```
## Argumentos
*medida*
Uma medida agregada para a qual você deseja fazer o cálculo.
*dateTime*
A dimensão da data na qual você está calculando PeriodOverTime os cálculos.
*período*
(Opcional) O período durante o qual você está computando a computação. A granularidade de `YEAR` significa computação de `YearToDate`, `Quarter` significa `QuarterToDate` e assim por diante. As granularidades válidas incluem `YEAR`, `QUARTER`, `MONTH`, `WEEK`, `DAY`, `HOUR`, `MINUTE` e `SECONDS`.
O valor padrão é a granularidade da dimensão de data do elemento visual.
## Exemplo
A função a seguir retorna o valor total da tarifa mês a mês.
```
periodToDateSumOverTime(sum({fare_amount}), pickupDatetime, MONTH)
```
![\[Esta é uma imagem dos resultados do cálculo de exemplo com ilustrações.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/PTDSumOverTime-example-results.png)
# stdevOver
A função `stdevOver` calcula o desvio padrão da medida especificada, particionado pelo atributo ou atributos escolhidos, com base em uma amostra.
## Sintaxe
São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.
```
stdevOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
## Argumentos
*medida*
A medida para a qual você quer fazer o cálculo, por exemplo `sum({Sales Amt})`. Use uma agregação se o nível de cálculo estiver definido como `NULL` ou `POST_AGG_FILTER`. Não use uma agregação se o nível de cálculo estiver definido como `PRE_FILTER` ou `PRE_AGG`.
*campo de partição*
(Opcional) Uma ou mais dimensões pelas quais deseja particionar, separadas por vírgulas.
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*nível de cálculo*
(Opcional) Especifica o nível de cálculo a ser usado:
+ **`PRE_FILTER`**: os cálculos de pré-filtro são computados antes dos filtros do conjunto de dados.
+ **`PRE_AGG`**: os cálculos pré-agregados são computados antes da aplicação de agregações e dos filtros *N* superiores e inferiores aos elementos visuais.
+ **`POST_AGG_FILTER`**: (padrão) os cálculos de tabelas são computados quando os elementos visuais são exibidos.
Esse valor será padronizado como `POST_AGG_FILTER` quando for deixado em branco. Para obter mais informações, consulte [Usando cálculos com reconhecimento de nível no Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Exemplo
O exemplo a seguir calcula o desvio padrão de `sum(Sales)`, particionado por `City` e `State`, com base em uma amostra.
```
stdevOver
(
sum(Sales),
[City, State]
)
```
O exemplo a seguir calcula o desvio padrão de `Billed Amount` sobre `Customer Region`, com base em uma amostra. Os campos dos cálculos de tabela estão nas fontes de campos do visual.
```
stdevOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
# stdevpOver
A função `stdevpOver` calcula o desvio padrão da medida especificada, particionado pelo atributo ou atributos escolhidos, com base em uma população tendenciosa.
## Sintaxe
São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.
```
stdevpOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
## Argumentos
*medida*
A medida para a qual você quer fazer o cálculo, por exemplo `sum({Sales Amt})`. Use uma agregação se o nível de cálculo estiver definido como `NULL` ou `POST_AGG_FILTER`. Não use uma agregação se o nível de cálculo estiver definido como `PRE_FILTER` ou `PRE_AGG`.
*campo de partição*
(Opcional) Uma ou mais dimensões pelas quais deseja particionar, separadas por vírgulas.
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*nível de cálculo*
(Opcional) Especifica o nível de cálculo a ser usado:
+ **`PRE_FILTER`**: os cálculos de pré-filtro são computados antes dos filtros do conjunto de dados.
+ **`PRE_AGG`**: os cálculos pré-agregados são computados antes da aplicação de agregações e dos filtros *N* superiores e inferiores aos elementos visuais.
+ **`POST_AGG_FILTER`**: (padrão) os cálculos de tabelas são computados quando os elementos visuais são exibidos.
Esse valor será padronizado como `POST_AGG_FILTER` quando for deixado em branco. Para obter mais informações, consulte [Usando cálculos com reconhecimento de nível no Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Exemplo
O exemplo a seguir calcula o desvio padrão de `sum(Sales)`, particionado por `City` e `State`, com base em uma população tendenciosa.
```
stdevpOver
(
sum(Sales),
[City, State]
)
```
O exemplo a seguir calcula o desvio padrão de `Billed Amount` sobre `Customer Region`, com base em uma população tendenciosa. Os campos dos cálculos de tabela estão nas fontes de campos do visual.
```
stdevpOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
# varOver
A função `varOver` calcula a variação da medida especificada, particionada pelo atributo ou atributos escolhidos, com base em uma amostra.
## Sintaxe
São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.
```
varOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
## Argumentos
*medida*
A medida para a qual você quer fazer o cálculo, por exemplo `sum({Sales Amt})`. Use uma agregação se o nível de cálculo estiver definido como `NULL` ou `POST_AGG_FILTER`. Não use uma agregação se o nível de cálculo estiver definido como `PRE_FILTER` ou `PRE_AGG`.
*campo de partição*
(Opcional) Uma ou mais dimensões pelas quais deseja particionar, separadas por vírgulas.
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*nível de cálculo*
(Opcional) Especifica o nível de cálculo a ser usado:
+ **`PRE_FILTER`**: os cálculos de pré-filtro são computados antes dos filtros do conjunto de dados.
+ **`PRE_AGG`**: os cálculos pré-agregados são computados antes da aplicação de agregações e dos filtros *N* superiores e inferiores aos elementos visuais.
+ **`POST_AGG_FILTER`**: (Padrão) os cálculos de tabelas são computados quando os elementos visuais são exibidos.
Esse valor será padronizado como `POST_AGG_FILTER` quando for deixado em branco. Para obter mais informações, consulte [Usando cálculos com reconhecimento de nível no Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Exemplo
O exemplo a seguir calcula a variação de `sum(Sales)`, particionada por `City` e `State`, com base em uma amostra.
```
varOver
(
sum(Sales),
[City, State]
)
```
O exemplo a seguir calcula a variação de `Billed Amount` sobre `Customer Region`, com base em uma amostra. Os campos dos cálculos de tabela estão nas fontes de campos do visual.
```
varOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
# varpOver
A função `varpOver` calcula a variação da medida especificada, particionada pelo atributo ou atributos escolhidos, com base em uma população tendenciosa.
## Sintaxe
São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.
```
varpOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
## Argumentos
*medida*
A medida para a qual você quer fazer o cálculo, por exemplo `sum({Sales Amt})`. Use uma agregação se o nível de cálculo estiver definido como `NULL` ou `POST_AGG_FILTER`. Não use uma agregação se o nível de cálculo estiver definido como `PRE_FILTER` ou `PRE_AGG`.
*campo de partição*
(Opcional) Uma ou mais dimensões pelas quais deseja particionar, separadas por vírgulas.
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*nível de cálculo*
(Opcional) Especifica o nível de cálculo a ser usado:
+ **`PRE_FILTER`**: os cálculos de pré-filtro são computados antes dos filtros do conjunto de dados.
+ **`PRE_AGG`**: os cálculos pré-agregados são computados antes da aplicação de agregações e dos filtros *N* superiores e inferiores aos elementos visuais.
+ **`POST_AGG_FILTER`**: (Padrão) os cálculos de tabelas são computados quando os elementos visuais são exibidos.
Esse valor será padronizado como `POST_AGG_FILTER` quando for deixado em branco. Para obter mais informações, consulte [Usando cálculos com reconhecimento de nível no Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Exemplo
O exemplo a seguir calcula a variação de `sum(Sales)`, particionado pelo `City` e `State`, com base em uma população tendenciosa.
```
varpOver
(
sum(Sales),
[City, State]
)
```
O exemplo a seguir calcula a variação de `Billed Amount` sobre `Customer Region`, com base em uma população tendenciosa. Os campos dos cálculos de tabela estão nas fontes de campos do visual.
```
varpOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
# sumOver
A função `sumOver` calcula a soma de uma medida particionada por uma lista de dimensões.
## Sintaxe
São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.
```
sumOver
(
measure
,[ partition_field, ... ]
,calculation level
)
```
## Argumentos
*medida*
A medida para a qual você quer fazer o cálculo, por exemplo `sum({Sales Amt})`. Use uma agregação se o nível de cálculo estiver definido como `NULL` ou `POST_AGG_FILTER`. Não use uma agregação se o nível de cálculo estiver definido como `PRE_FILTER` ou `PRE_AGG`.
*campo de partição*
(Opcional) Uma ou mais dimensões pelas quais deseja particionar, separadas por vírgulas.
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*nível de cálculo*
(Opcional) Especifica o nível de cálculo a ser usado:
+ **`PRE_FILTER`**: os cálculos de pré-filtro são computados antes dos filtros do conjunto de dados.
+ **`PRE_AGG`**: os cálculos pré-agregados são computados antes da aplicação de agregações e dos filtros *N* superiores e inferiores aos elementos visuais.
+ **`POST_AGG_FILTER`**: (padrão) os cálculos de tabelas são computados quando os elementos visuais são exibidos.
Esse valor será padronizado como `POST_AGG_FILTER` quando for deixado em branco. Para obter mais informações, consulte [Usando cálculos com reconhecimento de nível no Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Exemplo
O exemplo a seguir calcula a soma de `sum(Sales)`, particionada por `City` e `State`.
```
sumOver
(
sum(Sales),
[City, State]
)
```
O exemplo a seguir soma `Billed Amount` por `Customer Region`. Os campos dos cálculos de tabela estão nas fontes de campos do visual.
```
sumOver
(
sum({Billed Amount}),
[{Customer Region}]
)
```
A captura de tela a seguir mostra os resultados do exemplo. Com a adição de `Customer Segment`, a quantidade total cobrada por cada é somada para a `Customer Region`, e é exibida no campo calculado.
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/sumOver.png)
# denseRank
A função `denseRank` calcula a classificação de uma medida ou uma dimensão em comparação com as partições especificadas. Conta cada item uma vez, ignorando duplicações, e atribui um nível "sem buracos" para que valores duplicados compartilhem o mesmo nível.
## Sintaxe
São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.
```
denseRank
(
[ sort_order_field ASC_or_DESC, ... ]
,[ partition_field, ... ]
)
```
## Argumentos
*campo da ordem de classificação*
Um ou mais campos agregados, medidas ou dimensões ou ambas, pelas quais deseja classificar os dados, separados por vírgulas. Você pode especificar ordem de classificação crescente (**ASC**) ou decrescente (**DESC**).
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*campo de partição*
(Opcional) Uma ou mais dimensões pelas quais deseja particionar, separadas por vírgulas.
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*nível de cálculo*
(Opcional) Especifica o nível de cálculo a ser usado:
+ **`PRE_FILTER`**: os cálculos de pré-filtro são computados antes dos filtros do conjunto de dados.
+ **`PRE_AGG`**: os cálculos pré-agregados são computados antes da aplicação de agregações e dos filtros *N* superiores e inferiores aos elementos visuais.
+ **`POST_AGG_FILTER`**: (Padrão) os cálculos de tabelas são computados quando os elementos visuais são exibidos.
Esse valor será padronizado como `POST_AGG_FILTER` quando for deixado em branco. Para obter mais informações, consulte [Usando cálculos com reconhecimento de nível no Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Exemplo
O exemplo a seguir classifica `max(Sales)` densamente, com base em uma ordem de classificação decrescente, por `State` e `City`. Quaisquer cidades com o mesmo `max(Sales)` recebem o mesmo nível e a próxima cidade é classificada consecutivamente depois delas. Por exemplo, se três cidades compartilham o mesmo nível, a quarta cidade é classificada como segunda.
```
denseRank
(
[max(Sales) DESC],
[State, City]
)
```
O exemplo a seguir classifica `max(Sales)` densamente, com base em uma ordem de classificação decrescente, por `State`. Quaisquer estados com o mesmo `max(Sales)` recebem o mesmo nível e o próximo estado é classificado consecutivamente depois deles. Por exemplo, se três estados compartilham o mesmo nível, o quarto estado é classificado como segundo.
```
denseRank
(
[max(Sales) DESC],
[State]
)
```
# rank
A função `rank` calcula a classificação de uma medida ou uma dimensão em comparação com as partições especificadas. Ele conta cada item, inclusive duplicações, uma vez e atribui um nível "com buracos" para compensar os valores duplicados.
## Sintaxe
São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.
```
rank
(
[ sort_order_field ASC_or_DESC, ... ]
,[ partition_field, ... ]
)
```
## Argumentos
*campo da ordem de classificação*
Uma ou mais medidas e dimensões agregadas pelas quais deseja classificar os dados, separadas por vírgulas. Você pode especificar a ordem de classificação crescente (**ASC**) ou decrescente (**DESC**).
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*campo de partição*
(Opcional) Uma ou mais dimensões pelas quais deseja particionar, separadas por vírgulas.
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*nível de cálculo*
(Opcional) Especifica o nível de cálculo a ser usado:
+ **`PRE_FILTER`**: os cálculos de pré-filtro são computados antes dos filtros do conjunto de dados.
+ **`PRE_AGG`**: os cálculos pré-agregados são computados antes da aplicação de agregações e dos filtros *N* superiores e inferiores aos elementos visuais.
+ **`POST_AGG_FILTER`**: (Padrão) os cálculos de tabelas são computados quando os elementos visuais são exibidos.
Esse valor será padronizado como `POST_AGG_FILTER` quando for deixado em branco. Para obter mais informações, consulte [Usando cálculos com reconhecimento de nível no Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Exemplo
O exemplo a seguir classifica `max(Sales)`, com base em uma ordem de classificação decrescente, por `State` e `City`, em `State` de **WA**. Quaisquer cidades com o mesmo `max(Sales)` recebem o mesmo nível, mas o próximo nível inclui a contagem de todos os níveis existentes anteriormente. Por exemplo, se três cidades compartilham o mesmo nível, a quarta cidade é classificada como quarta.
```
rank
(
[max(Sales) DESC],
[State, City]
)
```
O exemplo a seguir classifica `max(Sales)`, com base em uma ordem de classificação crescente, por `State`. Quaisquer estados com o mesmo `max(Sales)` recebem o mesmo nível, mas o próximo nível inclui a contagem de todos os níveis existentes anteriormente. Por exemplo, se três estados compartilham o mesmo nível, o quarto estado é classificado como quarto.
```
rank
(
[max(Sales) ASC],
[State]
)
```
O exemplo a seguir classifica `Customer Region` pela `Billed Amount` total. Os campos dos cálculos de tabela estão nas fontes de campos do visual.
```
rank(
[sum({Billed Amount}) DESC]
)
```
A captura de tela a seguir mostra os resultados do exemplo, junto com a `Billed Amount` total, para que você possa ver como cada região é classificada.
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/rankCalc.png)
# percentileRank
A função `percentileRank` calcula a classificação do percentil de uma medida ou dimensão em comparação com as partições especificadas. O valor da classificação percentual (*x*) indica que o item atual está acima de*x*% dos valores na partição especificada. O valor do nível de percentil varia de 0 (inclusivo) a 100 (exclusivo).
## Sintaxe
São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.
```
percentileRank
(
[ sort_order_field ASC_or_DESC, ... ]
,[ {partition_field}, ... ]
)
```
## Argumentos
*campo da ordem de classificação*
Uma ou mais medidas e dimensões agregadas pelas quais deseja classificar os dados, separadas por vírgulas. Você pode especificar a ordem de classificação crescente (**ASC**) ou decrescente (**DESC**).
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*campo de partição*
(Opcional) Uma ou mais dimensões pelas quais deseja particionar, separadas por vírgulas.
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*nível de cálculo*
(Opcional) Especifica o nível de cálculo a ser usado:
+ **`PRE_FILTER`**: os cálculos de pré-filtro são computados antes dos filtros do conjunto de dados.
+ **`PRE_AGG`**: os cálculos pré-agregados são computados antes da aplicação de agregações e dos filtros *N* superiores e inferiores aos elementos visuais.
+ **`POST_AGG_FILTER`**: (Padrão) os cálculos de tabelas são computados quando os elementos visuais são exibidos.
Esse valor será padronizado como `POST_AGG_FILTER` quando for deixado em branco. Para obter mais informações, consulte [Usando cálculos com reconhecimento de nível no Quick](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations.html).
## Exemplo
O exemplo a seguir faz uma classificação de percentil de `max(Sales)` em ordem decrescente, por `State`.
```
percentileRank
(
[max(Sales) DESC],
[State]
)
```
O exemplo a seguir faz uma classificação de percentil de `Customer Region` por `Billed Amount` total. Os campos dos cálculos de tabela estão nas fontes de campos do visual.
```
percentileRank(
[sum({Billed Amount}) DESC],
[{Customer Region}]
)
```
A captura de tela a seguir mostra os resultados do exemplo, junto com a `Billed Amount` total, para que você possa ver como cada região é classificada.
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/percentileRank.png)
# runningAvg
A função `runningAvg` calcula uma média em execução de uma medida com base nas dimensões e ordens de classificação especificadas.
## Sintaxe
São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.
```
runningAvg
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,[ partition_field, ... ]
)
```
## Argumentos
*medida*
Uma medida agregada para a qual você deseja ver a média em execução.
*campo da ordem de classificação*
Uma ou mais medidas e dimensões pelas quais deseja classificar os dados, separadas por vírgulas. Você pode especificar a ordem de classificação crescente (**ASC**) ou decrescente (**DESC**).
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*campo de partição*
(Opcional) Uma ou mais dimensões pelas quais deseja particionar, separadas por vírgulas.
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
## Exemplo
O exemplo a seguir calcula uma média em execução de `sum(Sales)`, classificada por `Sales`, particionada por `City` e `State`.
```
runningAvg
(
sum(Sales),
[Sales ASC],
[City, State]
)
```
O exemplo a seguir calcula uma média em execução de `Billed Amount`, classificada por mês (`[truncDate("MM",Date) ASC]`). Os campos dos cálculos de tabela estão nas fontes de campos do visual.
```
runningAvg
(
sum({Billed Amount}),
[truncDate("MM",Date) ASC]
)
```
# runningCount
A função `runningCount` calcula uma contagem em execução de uma medida ou dimensão, com base nas dimensões e ordens de classificação especificadas.
## Sintaxe
São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.
```
runningCount
(
measure_or_dimension
,[ sortorder_field ASC_or_DESC, ... ]
,[ partition_field, ... ]
)
```
## Argumentos
*medida ou dimensão*
Uma dimensão ou medida agregada para a qual você deseja ver a contagem em execução.
*campo da ordem de classificação*
Uma ou mais medidas e dimensões pelas quais deseja classificar os dados, separadas por vírgulas. Você pode especificar a ordem de classificação crescente (**ASC**) ou decrescente (**DESC**).
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*campo de partição*
(Opcional) Uma ou mais dimensões pelas quais deseja particionar, separadas por vírgulas.
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
## Exemplo
O exemplo a seguir calcula uma contagem em execução de `sum(Sales)`, classificada por `Sales`, particionada por `City` e `State`.
```
runningCount
(
sum(Sales),
[Sales ASC],
[City, State]
)
```
O exemplo a seguir calcula uma contagem em execução de `Billed Amount`, classificada por mês (`[truncDate("MM",Date) ASC]`). Os campos dos cálculos de tabela estão nas fontes de campos do visual.
```
runningCount
(
sum({Billed Amount}),
[truncDate("MM",Date) ASC]
)
```
# runningMax
A função `runningMax` calcula um máximo em execução de uma medida com base nas dimensões e ordens de classificação especificadas.
## Sintaxe
São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.
```
runningMax
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,[ partition_field, ... ]
)
```
## Argumentos
*medida*
Uma medida agregada para a qual você deseja ver o máximo em execução.
*campo da ordem de classificação*
Uma ou mais medidas e dimensões pelas quais deseja classificar os dados, separadas por vírgulas. Você pode especificar a ordem de classificação crescente (**ASC**) ou decrescente (**DESC**).
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*campo de partição*
(Opcional) Uma ou mais dimensões pelas quais deseja particionar, separadas por vírgulas.
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
## Exemplo
O exemplo a seguir calcula um máximo em execução de `sum(Sales)`, classificado por `Sales`, particionado por `City` e `State`.
```
runningMax
(
sum(Sales),
[Sales ASC],
[City, State]
)
```
O exemplo a seguir calcula um máximo em execução de `Billed Amount`, classificado por mês (`[truncDate("MM",Date) ASC]`). Os campos dos cálculos de tabela estão nas fontes de campos do visual.
```
runningMax
(
sum({Billed Amount}),
[truncDate("MM",Date) ASC]
)
```
# runningMin
A função `runningMin` calcula um mínimo em execução de uma medida com base nas dimensões e ordens de classificação especificadas.
## Sintaxe
São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.
```
runningMin
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,[ partition_field, ... ]
)
```
## Argumentos
*medida*
Uma medida agregada para a qual você deseja ver o mínimo em execução.
*campo da ordem de classificação*
Uma ou mais medidas e dimensões pelas quais deseja classificar os dados, separadas por vírgulas. Você pode especificar a ordem de classificação crescente (**ASC**) ou decrescente (**DESC**).
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*campo de partição*
(Opcional) Uma ou mais dimensões pelas quais deseja particionar, separadas por vírgulas.
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
## Exemplo
O exemplo a seguir calcula um mínimo em execução de `sum(Sales)`, classificado por `Sales`, particionado por `City` e `State`.
```
runningMin
(
sum(Sales),
[Sales ASC],
[City, State]
)
```
O exemplo a seguir calcula um mínimo em execução de `Billed Amount`, classificado por mês (`[truncDate("MM",Date) ASC]`). Os campos dos cálculos de tabela estão nas fontes de campos do visual.
```
runningMin
(
sum({Billed Amount}),
[truncDate("MM",Date) ASC]
)
```
# runningSum
A função `runningSum` calcula uma soma em execução de uma medida com base nas dimensões e ordens de classificação especificadas.
## Sintaxe
São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.
```
runningSum
(
measure
,[ sortorder_field ASC_or_DESC, ... ]
,[ partition_field, ... ]
)
```
## Argumentos
*medida*
Uma medida agregada para a qual deseja ver a soma em execução.
*campo da ordem de classificação*
Uma ou mais medidas e dimensões pelas quais deseja classificar os dados, separadas por vírgulas. Você pode especificar a ordem de classificação crescente (**ASC**) ou decrescente (**DESC**).
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*campo de partição*
(Opcional) Uma ou mais dimensões pelas quais deseja particionar, separadas por vírgulas.
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
## Exemplo
O exemplo a seguir calcula uma soma em execução de `sum(Sales)`, classificada por `Sales`, particionada por `City` e `State`.
```
runningSum
(
sum(Sales),
[Sales ASC],
[City, State]
)
```
O exemplo a seguir calcula uma soma em execução de `Billed Amount`, classificada por mês (`[truncDate("MM",Date) ASC]`). Os campos dos cálculos de tabela estão nas fontes de campos do visual.
```
runningSum
(
sum({Billed Amount}),
[truncDate("MM",Date) ASC]
)
```
A captura de tela a seguir mostra os resultados do exemplo. Os rótulos em vermelho mostram como cada quantidade é adicionada (`a + b = c`) à próxima quantidade, resultando em um novo total.
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/runningSum.png)
# firstValue
A função `firstValue` calcula o primeiro valor da medida ou dimensão agregada particionada e classificada por atributos especificados.
## Sintaxe
São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.
```
firstValue
(
aggregated measure or dimension,
[ sort_attribute ASC_or_DESC, ... ],
[ partition_by_attribute, ... ]
)
```
## Argumentos
*medida ou dimensão agregada*
Uma dimensão ou medida agregada para a qual você deseja ver o primeiro valor.
*atributo de classificação*
Um ou mais campos agregados, medidas ou dimensões ou ambas, pelas quais deseja classificar os dados, separados por vírgulas. Você pode especificar ordem de classificação crescente (**ASC**) ou decrescente (**DESC**).
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*partição por atributo*
(Opcional) Uma ou mais dimensões ou medidas pelas quais você deseja particionar, separadas por vírgulas.
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
## Exemplo
O exemplo a seguir calcula o primeiro `Destination Airport`, classificado por `Flight Date`, particionado por `Flight Date` crescente e `Origin Airport`.
```
firstValue(
{Destination Airport}
[{Flight Date} ASC],
[
{Origin Airport},
{Flight Date}
]
)
```
# lastValue
A função `lastValue` calcula o último valor da dimensão ou medida agregada particionada e classificada por atributos especificados.
## Sintaxe
São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.
```
lastValue
(
aggregated measure or dimension,
[ sort_attribute ASC_or_DESC, ... ],
[ partition_by_attribute, ... ]
)
```
## Argumentos
*medida ou dimensão agregada*
Uma dimensão ou medida agregada para a qual você deseja ver o último valor.
*atributo de classificação*
Um ou mais campos agregados, medidas ou dimensões ou ambas, pelas quais deseja classificar os dados, separados por vírgulas. Você pode especificar ordem de classificação crescente (`ASC`) ou decrescente (`DESC`).
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*partição por atributo*
(Opcional) Uma ou mais dimensões ou medidas pelas quais você deseja particionar, separadas por vírgulas.
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
## Exemplo
O exemplo a seguir calcula o último valor de `Destination Airport`. Esse cálculo é classificado pelo valor `Flight Date` e particionado pelo valor `Flight Date` classificado em ordem crescente e pelo valor `Origin Airport`.
```
lastValue(
[{Destination Airport}],
[{Flight Date} ASC],
[
{Origin Airport},
truncDate('DAY', {Flight Date})
]
)
```
# windowAvg
A função `windowAvg` calcula a média da medida agregada em uma janela personalizada que está particionada e classificada por atributos especificados. Normalmente, as funções de janela personalizada são usadas em uma série temporal, na qual o visual exibe uma métrica e um campo de data. Por exemplo, você pode usar `windowAvg` para calcular uma média móvel, que normalmente é usada para suavizar o ruído em um gráfico de linha.
As funções de janela não são compatíveis com versões do MySQL anteriores à 8 e versões do MariaDB anteriores à 10.2.
## Sintaxe
São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.
```
windowAvg
(
measure
, [sort_order_field ASC/DESC, ...]
, start_index
, end_index
,[ partition_field, ... ]
)
```
## Argumentos
*medida*
A métrica agregada para a qual você deseja obter a média, por exemplo, `sum({Revenue})`.
*atributo de classificação*
Um ou mais campos agregados, medidas ou dimensões ou ambas, pelas quais deseja classificar os dados, separados por vírgulas. Você pode especificar ordem de classificação crescente (**ASC**) ou decrescente (**DESC**).
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*índice de início*
O índice de início é um inteiro positivo, indicando *n* linhas acima da linha atual. O índice de início conta os pontos de dados disponíveis acima da linha atual, em vez de contar os períodos em si. Se os dados estiverem dispersos (meses ou anos ausentes, por exemplo), ajuste os índices de acordo.
*índice de término*
O índice de término é um inteiro positivo, indicando *n* linhas abaixo da linha atual. O índice de término conta os pontos de dados disponíveis abaixo da linha atual, em vez de contar os períodos em si. Se os dados estiverem dispersos (meses ou anos ausentes, por exemplo), ajuste os índices de acordo.
*campo de partição*
(Opcional) Uma ou mais dimensões pelas quais deseja particionar, separadas por vírgulas.
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
## Exemplo
O exemplo a seguir calcula a média móvel de `sum(Revenue)`, particionada por `SaleDate`. O cálculo inclui três linhas acima e duas linhas abaixo da linha atual.
```
windowAvg
(
sum(Revenue),
[SaleDate ASC],
3,
2
)
```
A captura de tela a seguir mostra os resultados desse exemplo de média móvel. O campo sum(Revenue) é adicionado ao gráfico para mostrar a diferença entre a receita e a média móvel da receita.
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/windowAvg.png)
# windowCount
A função `windowCount` calcula a contagem da dimensão ou medida agregada em uma janela personalizada que está particionada e classificada por atributos especificados. Normalmente, as funções de janela personalizada são usadas em uma série temporal, na qual o visual exibe uma métrica e um campo de data.
As funções de janela não são compatíveis com versões do MySQL anteriores à 8 e versões do MariaDB anteriores à 10.2.
## Sintaxe
São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.
```
windowCount
(
measure_or_dimension
, [sort_order_field ASC/DESC, ...]
, start_index
, end_index
,[ partition_field, ... ]
)
```
## Argumentos
*medida ou dimensão*
A métrica agregada para a qual você deseja obter a média, por exemplo, `sum({Revenue})`.
*atributo de classificação*
Um ou mais campos agregados, medidas ou dimensões ou ambas, pelas quais deseja classificar os dados, separados por vírgulas. Você pode especificar ordem de classificação crescente (**ASC**) ou decrescente (**DESC**).
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*índice de início*
O índice de início é um inteiro positivo, indicando *n* linhas acima da linha atual. O índice de início conta os pontos de dados disponíveis acima da linha atual, em vez de contar os períodos em si. Se os dados estiverem dispersos (meses ou anos ausentes, por exemplo), ajuste os índices de acordo.
*índice de término*
O índice de término é um inteiro positivo, indicando *n* linhas abaixo da linha atual. O índice de término conta os pontos de dados disponíveis abaixo da linha atual, em vez de contar os períodos em si. Se os dados estiverem dispersos (meses ou anos ausentes, por exemplo), ajuste os índices de acordo.
*campo de partição*
(Opcional) Uma ou mais dimensões pelas quais deseja particionar, separadas por vírgulas.
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
## Exemplo
O exemplo a seguir calcula a contagem móvel de `sum(Revenue)`, particionada por `SaleDate`. O cálculo inclui três linhas acima e duas linhas abaixo da linha atual.
```
windowCount
(
sum(Revenue),
[SaleDate ASC],
3,
2
)
```
# windowMax
A função `windowMax` calcula o máximo da medida agregada em uma janela personalizada que está particionada e classificada por atributos especificados. Normalmente, as funções de janela personalizada são usadas em uma série temporal, na qual o visual exibe uma métrica e um campo de data. Use `windowMax` para ajudar você a identificar o máximo da métrica durante um período.
As funções de janela não são compatíveis com versões do MySQL anteriores à 8 e versões do MariaDB anteriores à 10.2.
## Sintaxe
São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.
```
windowMax
(
measure
, [sort_order_field ASC/DESC, ...]
, start_index
, end_index
,[ partition_field, ... ]
)
```
## Argumentos
*medida*
A métrica agregada para a qual você deseja obter a média, por exemplo, `sum({Revenue})`.
*atributo de classificação*
Um ou mais campos agregados, medidas ou dimensões ou ambas, pelas quais deseja classificar os dados, separados por vírgulas. Você pode especificar ordem de classificação crescente (**ASC**) ou decrescente (**DESC**).
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*índice de início*
O índice de início é um inteiro positivo, indicando *n* linhas acima da linha atual. O índice de início conta os pontos de dados disponíveis acima da linha atual, em vez de contar os períodos em si. Se os dados estiverem dispersos (meses ou anos ausentes, por exemplo), ajuste os índices de acordo.
*índice de término*
O índice de término é um inteiro positivo, indicando *n* linhas abaixo da linha atual. O índice de término conta os pontos de dados disponíveis abaixo da linha atual, em vez de contar os períodos em si. Se os dados estiverem dispersos (meses ou anos ausentes, por exemplo), ajuste os índices de acordo.
*campo de partição*
(Opcional) Uma ou mais dimensões pelas quais deseja particionar, separadas por vírgulas.
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
## Exemplo
O exemplo a seguir calcula o máximo nos últimos 12 meses de `sum(Revenue)`, particionado por `SaleDate`. O cálculo inclui 12 linhas acima e nenhuma linha abaixo da linha atual.
```
windowMax
(
sum(Revenue),
[SaleDate ASC],
12,
0
)
```
A captura de tela a seguir mostra os resultados desse exemplo dos últimos 12 meses. O campo sum(Revenue) é adicionado ao gráfico para mostrar a diferença entre a receita e a receita máxima dos últimos 12 meses.
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/windowMax.png)
# windowMin
A função `windowMin` calcula o mínimo da medida agregada em uma janela personalizada que está particionada e classificada por atributos especificados. Normalmente, as funções de janela personalizada são usadas em uma série temporal, na qual o visual exibe uma métrica e um campo de data. Use `windowMin` para ajudar você a identificar o mínimo da métrica durante um período.
As funções de janela não são compatíveis com versões do MySQL anteriores à 8 e versões do MariaDB anteriores à 10.2.
## Sintaxe
São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.
```
windowMin
(
measure
, [sort_order_field ASC/DESC, ...]
, start_index
, end_index
,[ partition_field, ... ]
)
```
## Argumentos
*medida*
A métrica agregada para a qual você deseja obter a média, por exemplo, `sum({Revenue})`.
*atributo de classificação*
Um ou mais campos agregados, medidas ou dimensões ou ambas, pelas quais deseja classificar os dados, separados por vírgulas. Você pode especificar ordem de classificação crescente (**ASC**) ou decrescente (**DESC**).
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*índice de início*
O índice de início é um inteiro positivo, indicando *n* linhas acima da linha atual. O índice de início conta os pontos de dados disponíveis acima da linha atual, em vez de contar os períodos em si. Se os dados estiverem dispersos (meses ou anos ausentes, por exemplo), ajuste os índices de acordo.
*índice de término*
O índice de término é um inteiro positivo, indicando *n* linhas abaixo da linha atual. O índice de término conta os pontos de dados disponíveis abaixo da linha atual, em vez de contar os períodos em si. Se os dados estiverem dispersos (meses ou anos ausentes, por exemplo), ajuste os índices de acordo.
*campo de partição*
(Opcional) Uma ou mais dimensões pelas quais deseja particionar, separadas por vírgulas.
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
## Exemplo
O exemplo a seguir calcula o mínimo dos últimos 12 meses de `sum(Revenue)`, particionado por `SaleDate`. O cálculo inclui 12 linhas acima e nenhuma linha abaixo da linha atual.
```
windowMin
(
sum(Revenue),
[SaleDate ASC],
12,
0
)
```
A captura de tela a seguir mostra os resultados desse exemplo dos últimos 12 meses. O campo sum(Revenue) é adicionado ao gráfico para mostrar a diferença entre a receita e a receita mínima dos últimos 12 meses.
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/windowMin.png)
# windowSum
A função `windowSum` calcula a soma da medida agregada em uma janela personalizada que está particionada e classificada por atributos especificados. Normalmente, as funções de janela personalizada são usadas em uma série temporal, na qual o visual exibe uma métrica e um campo de data.
As funções de janela não são compatíveis com versões do MySQL anteriores à 8 e versões do MariaDB anteriores à 10.2.
## Sintaxe
São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.
```
windowSum
(
measure
, [sort_order_field ASC/DESC, ...]
, start_index
, end_index
,[ partition_field, ... ]
)
```
## Argumentos
*medida*
A métrica agregada para a qual você deseja obter a soma, por exemplo, `sum({Revenue})`.
Para os mecanismos MySQL, MariaDB e Amazon Aurora com compatibilidade MySQL, o índice de pesquisa é limitado a apenas 1. As funções de janela não são compatíveis com versões do MySQL anteriores à 8 e versões do MariaDB anteriores à 10.2.
*atributo de classificação*
Um ou mais campos agregados, medidas ou dimensões ou ambas, pelas quais deseja classificar os dados, separados por vírgulas. Você pode especificar ordem de classificação crescente (**ASC**) ou decrescente (**DESC**).
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
*índice de início*
O índice de início é um inteiro positivo, indicando *n* linhas acima da linha atual. O índice de início conta os pontos de dados disponíveis acima da linha atual, em vez de contar os períodos em si. Se os dados estiverem dispersos (meses ou anos ausentes, por exemplo), ajuste os índices de acordo.
*índice de término*
O índice de término é um inteiro positivo, indicando *n* linhas abaixo da linha atual. O índice de término conta os pontos de dados disponíveis abaixo da linha atual, em vez de contar os períodos em si. Se os dados estiverem dispersos (meses ou anos ausentes, por exemplo), ajuste os índices de acordo.
*campo de partição*
(Opcional) Uma ou mais dimensões pelas quais deseja particionar, separadas por vírgulas.
Cada campo na lista está entre chaves (\$1\$1), caso seja mais de uma palavra. A lista completa está entre colchetes ([ ]).
## Exemplo
O exemplo a seguir calcula a soma móvel de `sum(Revenue)`, classificada por `SaleDate`. O cálculo inclui duas linhas acima e uma linha abaixo da linha atual.
```
windowSum
(
sum(Revenue),
[SaleDate ASC],
2,
1
)
```
O exemplo a seguir mostra uma soma dos últimos 12 meses.
```
windowSum(sum(Revenue),[SaleDate ASC],12,0)
```
A captura de tela a seguir mostra os resultados desse exemplo de soma dos últimos 12 meses. O campo `sum(Revenue)` é adicionado ao gráfico para mostrar a diferença entre a receita e a some dos últimos 12 meses da receita.
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/windowSum.png)