

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á.

# Como adicionar cálculos
<a name="working-with-calculated-fields"></a>

Crie campos calculados para transformar seus dados usando uma ou mais das seguintes opções: 
+ [Operadores](arithmetic-and-comparison-operators.md)
+ [Funções](functions.md)
+ Campos contendo dados
+ Outros campos calculados

Você pode adicionar campos calculados a um conjunto de dados durante a preparação de dados ou na página de análise. Quando adicionar um campo calculado a um conjunto de dados durante a preparação dos dados, ele estará disponível para todas as análises que usarem esse conjunto de dados. Ao adicionar um campo calculado a um conjunto de dados em uma análise, ele só estará disponível nessa análise. Para obter mais informações sobre como adicionar campos calculados, consulte os tópicos a seguir.

**Topics**
+ [Como adicionar campos calculados](adding-a-calculated-field-analysis.md)
+ [Ordem de avaliação no Amazon Quick Sight](order-of-evaluation-quicksight.md)
+ [Usando cálculos com reconhecimento de nível no Quick Sight](level-aware-calculations.md)
+ [Função de campo calculada e referência do operador para o Amazon Quick](calculated-field-reference.md)

# Como adicionar campos calculados
<a name="adding-a-calculated-field-analysis"></a>

Crie campos calculados para transformar seus dados usando uma ou mais das seguintes opções: 
+ [Operadores](arithmetic-and-comparison-operators.md)
+ [Funções](functions.md)
+ Funções agregadas (você só pode adicioná-las a uma análise)
+ Campos contendo dados
+ Outros campos calculados

Você pode adicionar campos calculados a um conjunto de dados durante a preparação de dados ou na página de análise. Quando adicionar um campo calculado a um conjunto de dados durante a preparação dos dados, ele estará disponível para todas as análises que usarem esse conjunto de dados. Ao adicionar um campo calculado a um conjunto de dados em uma análise, ele só estará disponível nessa análise. 

As análises oferecem suporte a operações de linha única e a operações de agregação. Operações de linha única são aquelas que fornecem um resultado (possivelmente) diferente para cada linha. Operações de agregação fornecem resultados que são sempre os mesmos para conjuntos inteiros de linhas. Por exemplo, se você usar uma função de sequência de caracteres simples sem nenhuma condição, ela alterará cada linha. Se você usar uma função de agregação, ela se aplicará a todas as linhas em um grupo. Se você solicitar o valor total de vendas para os EUA, o mesmo número se aplicará ao conjunto inteiro. Se você solicitar dados sobre um estado específico, o total de vendas será alterado para refletir o novo agrupamento. Ele ainda fornece um resultado para o conjunto inteiro.

Ao criar o campo calculado agregado dentro da análise, você pode fazer busca detalhada nos dados. O valor desse campo agregado é recalculado apropriadamente para cada nível. Esse tipo de agregação não é possível durante a preparação do conjunto de dados.

Por exemplo, digamos que você deseja descobrir a porcentagem de lucro de cada país, região e estado. Você pode adicionar um campo calculado à sua análise, `(sum(salesAmount - cost)) / sum(salesAmount)`. Esse campo será calculado para cada país, região e estado, no momento em que seu analista fizer uma busca detalhada na área geográfica.

**Topics**
+ [Como adicionar campos calculados a uma análise](#using-the-calculated-field-editor-analysis)
+ [Como adicionar campos calculados a um conjunto de dados](#using-the-calculated-field-editor)
+ [Tratamento de valores decimais em campos calculados](#handling-decimal-fields)

## Como adicionar campos calculados a uma análise
<a name="using-the-calculated-field-editor-analysis"></a>

Quando você adiciona um conjunto de dados a uma análise, cada campo calculado que existe no conjunto de dados é adicionado à análise. Você pode adicionar mais campos calculados no nível da análise para criar campos calculados que estejam disponíveis somente nessa análise.

**Para adicionar um campo calculado a uma análise**

1. Abra o [console Quick](https://quicksight.aws.amazon.com/).

1. Abra a análise que você deseja alterar.

1. No painel **Dados**, acesse **Adicionar** no canto superior esquerdo e, em seguida, selecione **\$1 CAMPO CALCULADO**.

   1. No editor de cálculos que é aberto, faça o seguinte:

   1. Insira um nome para o campo calculado.

   1. Insira uma fórmula usando campos do seu conjunto de dados, funções e operadores.

1. Quando terminar, escolha **Save (Salvar)**.

Para obter mais informações sobre como criar fórmulas usando as funções disponíveis no Quick Sight, consulte[Função de campo calculada e referência do operador para o Amazon QuickFunções e operadores](calculated-field-reference.md).

## Como adicionar campos calculados a um conjunto de dados
<a name="using-the-calculated-field-editor"></a>

Os autores do Amazon Quick Sight podem gerar campos calculados durante a fase de preparação de dados da criação de um conjunto de dados. Quando você cria um campo calculado para um conjunto de dados, o campo se torna uma nova coluna no conjunto de dados. Todas as análises que usam o conjunto de dados herdam os campos calculados do conjunto de dados.

Se o campo calculado operar no nível da linha e o conjunto de dados estiver armazenadoSPICE, o Quick Sight calculará e materializará o resultado em. SPICE Se o campo calculado depender de uma função de agregação, o Quick Sight retém a fórmula e executa o cálculo quando a análise é gerada. Esse tipo de campo calculado é chamado de campo calculado não materializado.

**Para adicionar ou editar um campo calculado de um conjunto de dados**

1. Abra o conjunto de dados com o qual deseja trabalhar. Para obter mais informações, consulte [Como editar conjuntos de dados](edit-a-data-set.md).

1. Na página de preparação dos dados, faça um dos seguintes procedimentos:
   + Para criar um campo, escolha **Adicionar campo calculado** à esquerda.
   + Para editar um campo calculado existente, escolha-o em **Campos calculados** à esquerda e selecione **Editar** no menu de contexto (clique com o botão direito do mouse).

1. No editor de cálculo, insira um nome descritivo para **Adicionar título**, dando um nome ao novo campo calculado. Esse nome aparece na lista de campos no conjunto de dados, portanto, deve ser semelhante aos outros campos. Para esse exemplo, definimos o nome do campo como `Total Sales This Year`.

1. (Opcional) Adicione um comentário, por exemplo, para explicar o que a expressão faz, colocando o texto em barras e asteriscos.

   ```
   /* Calculates sales per year for this year*/
   ```

1. Identifique métricas, funções e outros itens a serem usados. Neste exemplo, precisamos identificar o seguinte:
   + A métrica a ser usada
   + Funções: `ifelse` e `datediff`

   Queremos criar uma declaração como: “Se a venda aconteceu durante este ano, mostre o total de vendas, caso contrário, mostre 0”.

   Para adicionar a função `ifelse`, abra a lista de **Funções**. Escolha **Tudo** para fechar a lista de todas as funções. Agora você deve ver os grupos de funções: **Agregado**, **Condicional**, **Data** e assim por diante. 

   Escolha **Condicional** e clique duas vezes em `ifelse` para adicioná-lo ao espaço de trabalho. 

   ```
   ifelse()
   ```

1. Coloque o cursor dentro dos parênteses no espaço de trabalho e adicione três linhas em branco.

   ```
   ifelse(
                                               
                                               
                                               
   )
   ```

1. Com o cursor na primeira linha em branco, encontre a função `dateDiff`. Está listada em **Funções** em **Datas**. Você também pode encontrá-la inserindo **date** em **Funções de pesquisa**. A função `dateDiff` retorna todas as funções que têm *`date`* como parte do nome. Ela não retorna todas as funções listadas em **Datas**; por exemplo, a função `now` está faltando nos resultados da pesquisa.

   Clique duas vezes em `dateDiff` para adicioná-lo à primeira linha em branco da declaração `ifelse`. 

   ```
   ifelse(
   dateDiff()                                            
                                               
                                               
   )
   ```

   Adicione os parâmetros que `dateDiff` usa. Coloque o cursor dentro dos parênteses `dateDiff` para começar a adicionar `date1`, `date2` e `period`:

   1. Para `date1`: o primeiro parâmetro é o campo que contém a data. Encontre-o em **Campos** e adicione-o ao espaço de trabalho clicando duas vezes nele ou inserindo o nome. 

   1. Para `date2`, adicione uma vírgula e escolha `truncDate()` em **Funções**. Entre parênteses, adicione o período e a data, assim: **truncDate( "YYYY", now() )**

   1. Para `period`: adicione uma vírgula depois de `date2` e insira **YYYY**. Esse é o período do ano. Para ver uma lista de todos os períodos compatíveis, encontre `dateDiff` na lista **Funções** e abra a documentação selecionando **Saiba mais**. Se você já estiver visualizando a documentação, como agora, consulte [dateDiff](dateDiff-function.md).

   Adicione alguns espaços para facilitar a leitura, se quiser. A expressão deve ser algo semelhante a:

   ```
   ifelse(
      dateDiff( {Date}, truncDate( "YYYY", now() ) ,"YYYY" )                                       
                                               
                                               
   )
   ```

1. Especifique o valor de retorno. Para o nosso exemplo, o primeiro parâmetro em `ifelse` precisa retornar um valor de `TRUE` ou `FALSE`. Como queremos o ano atual e o estamos comparando com este ano, especificamos que a declaração `dateDiff` deve retornar `0`. A parte `if` de `ifelse` é avaliada como verdadeira para linhas em que não há diferença entre o ano da venda e o ano atual.

   ```
      dateDiff( {Date}, truncDate( "YYYY", now() ) ,"YYYY" ) = 0 
   ```

   Para criar um campo de `TotalSales` para o ano passado, você pode mudar `0` para `1`.

   Outra maneira de fazer a mesma coisa é usar `addDateTime` em vez de `truncDate`. Então, para cada ano anterior, você altera o primeiro parâmetro para `addDateTime` a fim de representar cada ano. Para isso, use `-1` para o ano passado, `-2` para o ano anterior a ele e assim por diante. Se você usar `addDateTime`, deixe a função `dateDiff` em `= 0` para cada ano.

   ```
      dateDiff( {Discharge Date}, addDateTime(-1, "YYYY", now() ) ,"YYYY" ) = 0 /* Last year */
   ```

1. Mova o cursor para a primeira linha em branco, logo abaixo de `dateDiff`. Adicione uma vírgula. 

   Para a parte `then` da declaração `ifelse`, precisamos escolher a medida (métrica) que contém o valor das vendas, `TotalSales`.

   Para escolher um campo, abra a lista **Campos** e clique duas vezes em um campo para adicioná-lo à tela. Também é possível inserir o nome. Adicione chaves `{ }` ao redor dos nomes que contenham espaços. É provável que sua métrica tenha um nome diferente. Você consegue saber qual campo é uma métrica pelo sinal numérico na frente dele (**\$1**).

   Agora, a expressão deve ser semelhante à que é mostrada a seguir.

   ```
   ifelse(
      dateDiff( {Date}, truncDate( "YYYY", now() ) ,"YYYY" ) = 0
      ,{TotalSales}                            
                                              
   )
   ```

1. Adicione uma cláusula `else`. A função `ifelse` não exige uma, mas queremos adicioná-la. Para fins de geração de relatórios, normalmente não é desejado ter valores nulos, porque às vezes as linhas com nulos são omitidas. 

   Definimos a parte else de ifelse como `0`. O resultado é que esse campo é `0` para linhas que contêm vendas de anos anteriores.

   Para isso, na linha em branco, adicione uma vírgula e depois um `0`. Se tiver adicionado o comentário no início, sua expressão `ifelse` final deve ter a aparência a seguir.

   ```
   /* Calculates sales per year for this year*/
   ifelse(
      dateDiff( {Date}, truncDate( "YYYY", now() ) ,"YYYY" ) = 0
      ,{TotalSales}                            
      ,0                                         
   )
   ```

1. Salve seu trabalho escolhendo **Salvar** no canto superior direito. 

   Se houver erros na sua expressão, o editor exibirá uma mensagem de erro na parte inferior. Verifique se há uma linha ondulada vermelha na expressão. Em seguida, passe o cursor sobre essa linha para ver qual é a mensagem de erro. Os erros comuns incluem pontuação ausente, parâmetros ausentes, erros ortográficos e tipos de dados inválidos.

   Para evitar fazer alterações, escolha **Cancelar**.

**Para adicionar um valor de parâmetro a um campo calculado**

1. Você pode fazer referência a parâmetros em campos calculados. Ao adicionar o parâmetro à sua expressão, você adiciona o valor atual desse parâmetro.

1. Para adicionar um parâmetro, abra a lista **Parâmetros** e selecione o parâmetro cujo valor você deseja incluir. 

1. (Opcional) Para adicionar manualmente um parâmetro à expressão, digite o nome dele. Em seguida, coloque-o entre chaves `{}` e prefixe-o com um `$`, por exemplo, `${parameterName}`.

Você pode alterar o tipo de dados de qualquer campo no seu conjunto de dados, incluindo os tipos de campos calculados. Você só pode escolher tipos de dados que correspondam aos dados que estão no campo.

**Para alterar o tipo de dados de um campo calculado**
+ Em **Campos calculados** (à esquerda), escolha o campo que deseja alterar e selecione **Alterar tipo de dados** no menu de contexto (clique com o botão direito do mouse).

Ao contrário dos outros campos no conjunto de dados, os campos calculados não podem ser desabilitados. Em vez disso, exclua-os. 

**Para excluir um campo calculado**
+ Em **Campos calculados** (à esquerda), escolha o campo que deseja alterar e selecione **Excluir** no menu de contexto (clique com o botão direito do mouse).

## Tratamento de valores decimais em campos calculados
<a name="handling-decimal-fields"></a>

Quando seu conjunto de dados usa o modo de Direct Query, o cálculo do tipo de dados decimal é determinado pelo comportamento do mecanismo de origem do qual o conjunto de dados se origina. Em alguns casos específicos, o Quick Sight aplica manipulações especiais para determinar o tipo de dados do cálculo de saída.

Quando seu conjunto de dados usa o modo de consulta do SPICE e um campo calculado é materializado, o tipo de dados do resultado depende dos operadores de função específicos e do tipo de dados da entrada. As tabelas abaixo mostram o comportamento esperado para alguns campos numéricos calculados.

**Operadores unários**

A tabela a seguir mostra qual tipo de dados é gerado com base no operador que você usa e no tipo de dados do valor inserido. Por exemplo, se você inserir um número inteiro em um cálculo `abs`, o tipo de dados do valor de saída será inteiro.


****  
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/adding-a-calculated-field-analysis.html)

**Operadores binários**

As tabelas a seguir mostram qual tipo de dados é gerado com base nos tipos de dados dos dois valores que você insere. Por exemplo, para um operador aritmético, se você fornecer dois tipos de dados inteiros, o resultado da saída do cálculo será um número inteiro.

Para operadores básicos (\$1, -, \$1):


|  | **Inteiro** | **Fixado em decimal** | **Flutuação decimal** | 
| --- | --- | --- | --- | 
|  **Inteiro**  |  Inteiro  |  Fixado em decimal  |  Flutuação decimal  | 
|  **Fixado em decimal**  |  Fixado em decimal  |  Fixado em decimal  |  Flutuação decimal  | 
|  **Flutuação decimal**  |  Flutuação decimal  |  Flutuação decimal  |  Flutuação decimal  | 

Para operadores de divisão (/):


|  | **Inteiro** | **Fixado em decimal** | **Flutuação decimal** | 
| --- | --- | --- | --- | 
|  **Inteiro**  |  Flutuação decimal  |  Flutuação decimal  |  Flutuação decimal  | 
|  **Fixado em decimal**  |  Flutuação decimal  |  Fixado em decimal  |  Flutuação decimal  | 
|  **Flutuação decimal**  |  Flutuação decimal  |  Flutuação decimal  |  Flutuação decimal  | 

Para operadores exponenciais e de modificação (^, %):


|  | **Inteiro** | **Fixado em decimal** | **Flutuação decimal** | 
| --- | --- | --- | --- | 
|  **Inteiro**  |  Flutuação decimal  |  Flutuação decimal  |  Flutuação decimal  | 
|  **Fixado em decimal**  |  Flutuação decimal  |  Flutuação decimal  |  Flutuação decimal  | 
|  **Flutuação decimal**  |  Flutuação decimal  |  Flutuação decimal  |  Flutuação decimal  | 

# Ordem de avaliação no Amazon Quick Sight
<a name="order-of-evaluation-quicksight"></a>

Quando você abre ou atualiza uma análise, antes de exibi-la, o Amazon Quick Sight avalia tudo o que está configurado na análise em uma sequência específica. O Amazon Quick Sight traduz a configuração em uma consulta que um mecanismo de banco de dados pode executar. A consulta retorna os dados de forma semelhante, independentemente de você se conectar a um banco de dados, a uma fonte de software como serviço (SaaS) ou ao mecanismo de análise Amazon Quick Sight ([SPICE](spice.md)). 

Se você compreender a ordem em que a configuração é avaliada, saberá a sequência que determina quando um filtro ou cálculo específico é aplicado aos seus dados.

A ilustração a seguir mostra a ordem de avaliação. A coluna à esquerda mostra a ordem de avaliação quando nenhuma função de janela de cálculo (LAC-W) nem agregada (LAC-A) com reconhecimento de nível está envolvida. A segunda coluna mostra a ordem de avaliação das análises que contêm campos calculados para computar expressões LAC-W no nível de pré-filtro (`PRE_FILTER`). A terceira coluna mostra a ordem de avaliação das análises que contêm campos calculados para computar expressões LAC-W no nível de pré-agregação (`PRE_AGG`). A última coluna mostra a ordem de avaliação das análises que contêm campos calculados para computar expressões LAC-A. Após a ilustração, há uma explicação mais detalhada da ordem de avaliação. Para obter mais informações sobre cálculos com reconhecimento de nível, consulte [Usando cálculos com reconhecimento de nível no Quick Sight](level-aware-calculations.md).

![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/order-of-evaluation2.png)


A lista a seguir mostra a sequência na qual o Amazon Quick Sight aplica a configuração em sua análise. Tudo o que está configurado no conjunto de dados acontece fora da análise, por exemplo, cálculos no nível do conjunto de dados, filtros e configurações de segurança. Todos eles se aplicam aos dados subjacentes. A lista a seguir abrange apenas o que acontece dentro da análise. 

1. **Nível de pré-filtro LAC-W**: avalia os dados na cardinalidade da tabela original antes dos filtros de análise

   1. **Cálculos simples**: cálculos no nível escalar sem agregações ou cálculos de janela. Por exemplo, .`date_metric/60, parseDate(date, 'yyyy/MM/dd'), ifelse(metric > 0, metric, 0), split(string_column, '|' 0)`

   1. **Função LAC-W PRE\$1FILTER**: Se alguma expressão LAC-W PRE\$1FILTER estiver envolvida no visual, o Amazon Quick Sight primeiro calculará a função de janela no nível da tabela original, antes de qualquer filtro. Se a expressão LAC-W PRE\$1FILTER for usada em filtros, ela será aplicada neste momento. Por exemplo, .`maxOver(Population, [State, County], PRE_FILTER) > 1000`

1. **LAC-W PRE\$1AGG**: avalia os dados na cardinalidade da tabela original antes das agregações

   1. **Filtros adicionados durante a análise**: os filtros criados para campos não agregados nos elementos visuais são aplicados nesse momento, que são semelhantes às cláusulas WHERE. Por exemplo, .`year > 2020`

   1. **Função LAC-W PRE\$1AGG**: Se alguma expressão LAC-W PRE\$1AGG estiver envolvida no visual, o Amazon Quick Sight computará a função de janela antes de qualquer agregação ser aplicada. Se a expressão LAC-W PRE\$1AGG for usada em filtros, ela será aplicada neste momento. Por exemplo, .`maxOver(Population, [State, County], PRE_AGG) > 1000`

   1. **Filtros N superior/inferior**: filtros configurados em dimensões para exibir top/bottom N itens.

1. **Nível LAC-A**: avalia as agregações em nível personalizado, antes das agregações visuais

   1. **Agregações de nível personalizado**: se alguma expressão LAC-A estiver envolvida no elemento visual, ela será calculada neste momento. Com base na tabela após os filtros mencionados acima, a Amazon QuickSight calcula a agregação, agrupada pelas dimensões especificadas nos campos calculados. Por exemplo, .`max(Sales, [Region])`

1. **Nível no elemento visual**: avalia agregações no nível de elemento visual e cálculos de tabela pós-agregação, com as configurações restantes aplicadas nos elementos visuais

   1. **Agregações no nível do elemento visual**: as agregações de elementos visuais sempre devem ser aplicadas, exceto em tabelas tabulares (nas quais a dimensão está vazia). Com essa configuração, são calculadas as agregações baseadas nos campos nas fontes de campo, agrupadas pelas dimensões inseridas nos elementos visuais. Se algum filtro for criado com base nas agregações, ele será aplicado neste momento, semelhante às cláusulas HAVING. Por exemplo, .`min(distance) > 100`

   1. **Cálculos de tabela**: se houver algum cálculo de tabela pós-agregação (a expressão agregada deve ser usada como operando) referenciado no elemento visual, ele será calculado neste momento. O Amazon Quick Sight realiza cálculos de janela após agregações visuais. Da mesma forma, são aplicados os filtros criados com base nesses cálculos.

   1. **Outros cálculos de categoria**: esse tipo de cálculo só existe em line/bar/pie/donut gráficos. Para obter mais informações, consulte [Limites de exibição](working-with-visual-types.md#display-limits).

   1. **Totais e subtotais**: os totais e subtotais são calculados em gráficos de rosca (somente totais), tabelas (somente totais) e tabelas dinâmicas, se solicitado.

# Usando cálculos com reconhecimento de nível no Quick Sight
<a name="level-aware-calculations"></a>


|  | 
| --- |
|    Aplica-se a: Enterprise Edition e Standard Edition  | 

Com os *cálculos com reconhecimento de nível (LAC)*, você pode especificar o nível de granularidade que deseja para computar funções de janela ou funções agregadas. Há dois tipos de funções LAC: cálculo com reconhecimento de nível para funções agregadas (LAC-A) e cálculo com reconhecimento de nível para funções de janela (LAC-W).

**Topics**
+ [Funções LAC-A](#level-aware-calculations-aggregate)
+ [Funções LAC-W](#level-aware-calculations-window)

## Cálculo com reconhecimento de nível para funções agregadas (LAC-A)
<a name="level-aware-calculations-aggregate"></a>

Com as funções LAC-A, você pode especificar em qual nível agrupar a computação. Ao adicionar um argumento a uma função agregada existente, como `sum() , max() , count()`, você pode definir qualquer nível de agrupamento que desejar para a agregação. O nível adicionado pode ser qualquer dimensão, independente das dimensões adicionadas ao elemento visual. Por exemplo:

```
sum(measure,[group_field_A])
```

Para usar as funções LAC-A, digite-as diretamente no editor de cálculo adicionando os níveis de agregação pretendidos como o segundo argumento entre colchetes. A seguir está um exemplo de uma função agregada e uma função LAC-A, para comparação.
+ Função agregada: `sum({sales})`
+ Função LAC-A: `sum({sales}, [{Country},{Product}])`

Os resultados do LAC-A são computados com o nível especificado entre colchetes `[ ]` e podem ser usados como operando de uma função agregada. O nível de agrupamento da função agregada é o nível visual, com campos **Agrupar por** adicionados à fonte de campo do elemento visual. 

Além de criar uma chave de grupo LAC estática no colchete `[ ]`, você pode adaptá-la dinamicamente aos campos visuais de agrupamento, colocando um parâmetro `$visualDimensions` no colchete. Esse é um parâmetro fornecido pelo sistema, em contraste com o parâmetro definido pelo usuário. O parâmetro `[$visualDimensions]` representa os campos adicionados à fonte de campo **Agrupar por** no elemento visual atual. Os exemplos a seguir mostram como adicionar dinamicamente chaves de grupo às dimensões visuais ou remover chaves de grupo das dimensões visuais.
+ LAC-A com chave de grupo dinamicamente adicionada: `sum({sales}, [${visualDimensions},{Country},{Products}])`

  Ele calcula, antes que a agregação de nível visual seja calculada, a soma das vendas, agrupando por `country`, `products` e quaisquer outros campos na fonte de campo **Agrupar por**. 
+ LAC-A com chave de grupo dinamicamente removida: `sum({sales}, [${visualDimensions},!{Country},!{Products}])` 

  Ele calcula, antes que a agregação de nível visual seja calculada, a soma das vendas, agrupando pelos campos na fonte de campo **Agrupar por** do elemento visual, exceto `country` e `product`. 

Você pode especificar a chave de grupo adicionada ou a chave de grupo removida na expressão LAC, mas não ambas.

As funções LAC-A são compatíveis com as seguintes funções agregadas:
+ [avg](avg-function.md)
+ [count](count-function.md)
+ [distinct\$1count](distinct_count-function.md)
+ [max](max-function.md)
+ [median](median-function.md)
+ [min](min-function.md)
+ [percentile](percentile-function.md)
+ [percentileCont](percentileCont-function.md)
+ [percentileDisc (percentil)](percentileDisc-function.md)
+ [stdev](stdev-function.md)
+ [stdevp](stdevp-function.md)
+ [sum](sum-function.md)
+ [var](var-function.md)
+ [varp](varp-function.md)

### Exemplos de LAC-A
<a name="level-aware-calculations-aggregate-examples"></a>

Você pode fazer o seguinte com as funções LAC-A:
+ Executar cálculos que sejam independentes dos níveis no elemento visual. Por exemplo, se você tiver o cálculo a seguir, os números de vendas serão agregados somente no nível do país, mas não em outras dimensões (região ou produto) no elemento visual.

  ```
  sum({Sales},[{Country}])
  ```
+ Executar cálculos para as dimensões que não estão no elemento visual. Por exemplo, se você tiver a função a seguir, será possível calcular a média das vendas totais do país por região.

  ```
  sum({Sales},[{Country}])
  ```

  Embora o país não esteja incluído no elemento visual, a função LAC-A primeiro agrega as vendas no nível do país e, em seguida, o cálculo de nível visual gera o número médio para cada região. Se a função LAC-A não for usada para especificar o nível, a média das vendas será calculada no nível granular mais baixo (o nível básico do conjunto de dados) de cada região (exibido na coluna de vendas).
+ Usar LAC-A em combinação com outras funções agregadas e funções LAC-W. Há duas formas de aninhar funções LAC-A com outras.
  + Você pode escrever uma sintaxe aninhada ao criar um cálculo. Por exemplo, a função LAC-A pode ser aninhada com uma função LAC-W para calcular o total de vendas por país usando o preço médio de cada produto:

    ```
    sum(avgOver({Sales},[{Product}],PRE_AGG),[{Country}])
    ```
  + Ao adicionar uma função LAC-A a um elemento visual, o cálculo pode ser ainda mais aninhado com as funções agregadas de nível visual que você selecionou na fonte de campos. Para obter mais informações sobre como alterar a agregação de campos no elemento visual, consulte [Como alterar ou adicionar uma agregação a um campo ao usar uma fonte de campo](changing-field-aggregation.md#change-field-aggregation-field-wells).

### Limitações do LAC-A
<a name="level-aware-calculations-aggregate-limitations"></a>

As seguintes limitações se aplicam às funções LAC-A:
+ As funções LAC-A são compatíveis com todas as funções agregadas aditivas e não aditivas, como, `sum()`, `count()` e `percentile()`. As funções LAC-A não são suportadas para funções agregadas condicionais que terminam com “if”, como `sumif()` e`countif()`, nem para funções agregadas de período que começam com "periodToDate“, como e. `periodToDateSum()` `periodToDateMax()`
+ Atualmente, não há suporte para totais em nível de linha e de coluna para funções LAC-A em tabelas e tabelas dinâmicas. Quando você adiciona totais em nível de linha ou de coluna ao gráfico, o número total é exibido em branco. Outras dimensões que não sejam do LAC não são afetadas.
+ Atualmente, não há suporte para as funções LAC-A aninhadas. Há suporte para uma capacidade limitada de funções LAC-A aninhadas com funções agregadas regulares e funções LAC-W.

  Por exemplo, as seguintes funções são válidas:
  + `Aggregation(LAC-A())`. Por exemplo: `max(sum({sales}, [{country}]))`
  + `LAC-A(LAC-W())`. Por exemplo: `sum(sumOver({Sales},[{Product}],PRE_AGG), [{Country}])`

  As seguintes funções não são válidas:
  + `LAC-A(Aggregation())`. Por exemplo: `sum(max({sales}), [{country}])`
  + `LAC-A(LAC-A())`. Por exemplo: `sum(max({sales}, [{country}]),[category])`
  + `LAC-W(LAC-A())`. Por exemplo: `sumOver(sum({Sales},[{Product}]),[{Country}],PRE_AGG)`

## Cálculo com reconhecimento de nível para funções de janela (LAC-W)
<a name="level-aware-calculations-window"></a>

Com as funções LAC-W, você pode especificar a janela ou a partição para computar o cálculo. As funções LAC-W são um grupo de funções de janela, como `sumover()`, `(maxover)`, `denseRank`, que você pode executar no nível de pré-filtro ou pré-agregado. Por exemplo: `sumOver(measure,[partition_field_A],pre_agg)`.

As funções LAC-W eram chamadas de agregações com reconhecimento de nível (LAA).

As funções LAC-W ajudam você a responder aos seguintes tipos de perguntas:
+ Quantos dos meus clientes fizeram apenas um pedido de compra? Ou 10? Ou 50? Queremos que o visual use a contagem como uma dimensão e não como uma métrica no visual.
+ Quais são as vendas totais por segmento de mercado para clientes cujos gastos em tempo de vida sejam superiores a 100.000 USD? O visual deve mostrar apenas o segmento de mercado e o total de vendas para cada um deles.
+ Qual é a contribuição de cada setor para todo o lucro da empresa (porcentagem do total)? Queremos poder filtrar o visual para mostrar alguns dos setores e como eles contribuem para o total de vendas dos setores exibidos. Porém, também queremos ver a porcentagem do total de vendas de cada setor para toda a empresa (incluindo os setores filtrados). 
+ Qual é o total de vendas de cada categoria em comparação com a média do setor? A média do setor deve incluir todas as categorias, mesmo após a filtragem.
+ Como meus clientes são agrupados em intervalos de gastos cumulativos? Queremos usar o agrupamento como uma dimensão e não como uma métrica. 

Para perguntas mais complexas, você pode injetar um cálculo ou filtro antes que o Quick Sight chegue a um ponto específico na avaliação de suas configurações. Para influenciar diretamente os resultados, adicione uma palavra-chave em nível de cálculo a um cálculo de tabela. Para obter mais informações sobre como o Quick Sight avalia as consultas, consulte. [Ordem de avaliação no Amazon Quick Sight](order-of-evaluation-quicksight.md)

Há suporte para os seguintes níveis de cálculo nas funções LAC-W:
+ **`PRE_FILTER`**— Antes de aplicar os filtros da análise, o Quick Sight avalia os cálculos do pré-filtro. Depois, aplica todos os filtros configurados nesses cálculos de pré-filtro.
+ **`PRE_AGG`**— Antes de calcular as agregações em nível de exibição, o Quick Sight realiza cálculos pré-agregados. Depois, aplica todos os filtros configurados nesses cálculos de pré-agregação. Esse trabalho acontece antes da aplicação de *N* filtros superiores e inferiores.

Você pode usar a palavra-chave `PRE_AGG` ou `PRE_FILTER` como um parâmetro nas funções de cálculo de tabela a seguir. Ao especificar um nível de cálculo, você usa uma medida não agregada na função. Por exemplo, você poderá usar o `countOver({ORDER ID}, [{Customer ID}], PRE_AGG)`. Ao usar `PRE_AGG`, você especifica que o `countOver` é executado no nível de pré-agregação. 
+ [avgOver](avgOver-function.md)
+ [countOver](countOver-function.md)
+ [denseRank](denseRank-function.md)
+ [distinctCountOver](distinctCountOver-function.md)
+ [minOver](minOver-function.md)
+ [maxOver](maxOver-function.md)
+ [percentileRank](percentileRank-function.md)
+ [rank](rank-function.md)
+ [stdevOver](stdevOver-function.md)
+ [stdevpOver](stdevpOver-function.md)
+ [sumOver](sumOver-function.md)
+ [varOver](varOver-function.md)
+ [varpOver](varpOver-function.md)

Por padrão, o primeiro parâmetro de cada função deve ser uma medida agregada. Se usar `PRE_FILTER` ou `PRE_AGG`, você usará uma medida não agregada para o primeiro parâmetro. 

Para funções LAC-W, a agregação visual é padronizada como `MIN` para eliminar duplicatas. Para alterar a agregação, abra o menu de contexto do campo (clique com o botão direito do mouse) e escolha uma agregação diferente.

Para exemplos de quando e como usar as funções do LAC-W em cenários da vida real, consulte a seguinte postagem no blog de AWS Big Data: [Crie insights avançados usando agregações com reconhecimento de nível na Amazon](https://aws.amazon.com/jp/blogs/big-data/create-advanced-insights-using-level-aware-aggregations-in-amazon-quicksight/). QuickSight 

# Função de campo calculada e referência do operador para o Amazon Quick
<a name="calculated-field-reference"></a>

Você pode adicionar campos calculados a um conjunto de dados durante a preparação de dados ou na página de análise. Quando adicionar um campo calculado a um conjunto de dados durante a preparação dos dados, ele estará disponível para todas as análises que usarem esse conjunto de dados. Ao adicionar um campo calculado a um conjunto de dados em uma análise, ele só estará disponível nessa análise. 

É possível criar campos calculados para transformar os dados ao usar as funções e os operadores apresentados a seguir.

**Topics**
+ [Operadores](arithmetic-and-comparison-operators.md)
+ [Funções por categoria](functions-by-category.md)
+ [Funções](functions.md)
+ [Funções agregadas](calculated-field-aggregations.md)
+ [Funções de cálculos de tabela](table-calculation-functions.md)

# Operadores
<a name="arithmetic-and-comparison-operators"></a>

Você pode usar os operadores a seguir nos campos calculados. O Quick usa a ordem padrão das operações: parênteses, expoentes, multiplicação, divisão, adição, subtração (PEMDAS). As comparações de igual a (=) e diferente de (<>) diferenciam maiúsculas de minúsculas. 
+ Adição (\$1)
+ Subtração (−)
+ Multiplicação (\$1)
+ Divisão (/)
+ Módulo (%): veja também `mod()` na lista a seguir.
+ Potência (^): veja também `exp()` na lista a seguir.
+ Igual (=)
+ Diferente (<>)
+ Maior que (>)
+ Maior ou igual a (>=)
+ Menor que (<)
+ Menor ou igual a (<=)
+ E
+ OU
+ NOT

O Amazon Quick suporta a aplicação das seguintes funções matemáticas a uma expressão.
+ `[https://docs.aws.amazon.com/quicksight/latest/user/mod-function.html](https://docs.aws.amazon.com/quicksight/latest/user/mod-function.html)(number, divisor)`: localiza o restante depois de dividir um número por um divisor.
+ `[https://docs.aws.amazon.com/quicksight/latest/user/log-function.html](https://docs.aws.amazon.com/quicksight/latest/user/log-function.html)(expression) `: retorna o logaritmo decimal de uma determinada expressão. 
+ `[https://docs.aws.amazon.com/quicksight/latest/user/ln-function.html](https://docs.aws.amazon.com/quicksight/latest/user/ln-function.html)(expression) `: retorna o logaritmo natural de uma determinada expressão. 
+ `[https://docs.aws.amazon.com/quicksight/latest/user/abs-function.html](https://docs.aws.amazon.com/quicksight/latest/user/abs-function.html)(expression) `: retorna o valor absoluto de uma determinada expressão. 
+ `[https://docs.aws.amazon.com/quicksight/latest/user/sqrt-function.html](https://docs.aws.amazon.com/quicksight/latest/user/sqrt-function.html)(expression) `: retorna a raiz quadrada de uma determinada expressão. 
+ `[https://docs.aws.amazon.com/quicksight/latest/user/exp-function.html](https://docs.aws.amazon.com/quicksight/latest/user/exp-function.html)(expression) `: retorna a base do logaritmo natural *e* elevada à potência de uma determinada expressão. 

Para facilitar a leitura de cálculos compridos, você pode usar parênteses para esclarecer agrupamentos e a precedência nos cálculos. Na instrução a seguir, você não precisa parênteses. A declaração de multiplicação é processada primeiro e, em seguida, o resultado é somando a cinco, retornando um valor de 26. No entanto, parênteses facilitam a leitura da instrução e, portanto, devem ser mantidos.

```
5 + (7 * 3)
```

Como os parêntese são os primeiros na ordem das operações, você pode alterar a ordem em que os operadores são aplicados. Por exemplo, na declaração a seguir, a adição é processada primeiro e, em seguida, o resultado é multiplicado por 3, retornando o valor 36.

```
(5 + 7) * 3
```

## Exemplo: operadores aritméticos
<a name="operator-example-multiple-operators"></a>

O exemplo a seguir usa vários operadores aritméticos para determinar o total de vendas após desconto.

```
(Quantity * Amount) - Discount
```

## Exemplo: (/) divisão
<a name="operator-example-division-operators"></a>

O exemplo apresentado a seguir usa a operação de divisão para dividir 3 por 2. Um valor de 1,5 é retornado. O Amazon Quick usa divisões de ponto flutuante.

```
3/2
```

## Exemplo: (=) igual a
<a name="operator-example-equal"></a>

Usar = realiza uma comparação de valores com diferenciação entre maiúsculas e minúsculas. As linhas em que a comparação é VERDADEIRA são incluídas no conjunto de resultados. 

No exemplo a seguir, as linhas em que o campo `Region` é **South** são incluídas nos resultados. Se a `Region` for **south**, essas linhas serão excluídas.

```
Region = 'South'
```

No exemplo a seguir, a comparação é avaliada como FALSA. 

```
Region = 'south'
```

O exemplo a seguir mostra uma comparação que converte `Region` em letras maiúsculas (**SOUTH**) e a compara com **SOUTH**. Isso retorna as linhas cuja região é **south**, **South** ou **SOUTH**.

```
toUpper(Region) = 'SOUTH'
```

## Exemplo: (<>)
<a name="operator-example-not-equal"></a>

O símbolo de diferente de <> significa *menor ou maior que*. 

Portanto, se dissermos **x<>1**, estamos afirmando *se x for menor que 1 OU se x for maior que 1*. Ambos os símbolos < e > são avaliados em conjunto. Em outras palavras, *se x é qualquer valor exceto 1*. Ou *x é diferente de 1*. 

**nota**  
Use <>, não \$1=.

O exemplo a seguir compara `Status Code` a um valor numérico. Isso retorna as linhas onde `Status Code` é diferente de **1**.

```
statusCode <> 1
```

O exemplo a seguir compara vários valores de `statusCode`. Neste caso, os registros ativos têm `activeFlag = 1`. Este exemplo retorna linhas em que uma das seguintes situações se aplica:
+ Para registros ativos, mostra linhas onde o status não é 1 ou 2
+ Para registros inativos, mostra linhas onde o status é 99 ou -1

```
( activeFlag = 1 AND (statusCode <> 1 AND statusCode <> 2) )
OR
( activeFlag = 0 AND (statusCode= 99 OR statusCode= -1) )
```

## Exemplo: (^)
<a name="operator-example-power"></a>

O símbolo de potência `^` significa *elevado a*. Você pode usar o operador de potência com qualquer campo numérico e com qualquer expoente válido. 

O exemplo a seguir é uma expressão simples de 2 elevado a 4 ou (2 \$1 2 \$1 2 \$1 2). Isso retorna um valor de 16.

```
2^4
```

O exemplo a seguir calcula a raiz quadrada do campo de receita.

```
revenue^0.5
```

## Exemplo: E, OU, e NÃO
<a name="operator-example-and-or-not"></a>

O exemplo a seguir usa AND, OR e NOT para comparar várias expressões. Isso é feito usando operadores condicionais para marcar os principais clientes com uma promoção especial que NÃO estão em Washington ou Oregon, que fizeram mais de dez pedidos. Se nenhum valor for retornado, o valor "n/d" será usado.

```
ifelse(( (NOT (State = 'WA' OR State = 'OR')) AND Orders > 10), 'Special Promotion XYZ', 'n/a')
```

## Exemplo: como criar listas de comparação, como "em" ou "não está em"
<a name="operator-example-in-or-not-in"></a>

Este exemplo usa operadores para criar uma comparação para encontrar valores que existem ou não em uma lista especificada de valores.

O exemplo a seguir compara o `promoCode` como uma lista especificada de valores. Este exemplo retorna as linhas onde o `promoCode` está na lista **(1, 2, 3)**.

```
promoCode    = 1
OR promoCode = 2
OR promoCode = 3
```

O exemplo a seguir compara o `promoCode` como uma lista especificada de valores. Este exemplo retorna as linhas onde o `promoCode` NÃO está na lista **(1, 2, 3)**.

```
NOT(promoCode = 1
OR promoCode  = 2
OR promoCode  = 3
)
```

Outra forma de expressar isso é fornecer uma lista onde o `promoCode` não é igual aos itens na lista.

```
promoCode     <> 1
AND promoCode <> 2
AND promoCode <> 3
```

## Exemplo: como criar uma comparação "entre"
<a name="operator-example-between"></a>

Este exemplo usa operadores de comparação para criar uma comparação mostrando valores que existem entre um valor e outro.

O exemplo a seguir examina o `OrderDate` e retorna linhas onde o `OrderDate` está entre o primeiro dia e o último dia de 2016. Nesse caso, queremos o primeiro e o último dia incluídos, portanto, usa-se "ou igual a" nos operadores de comparação. 

```
OrderDate >= "1/1/2016" AND OrderDate <= "12/31/2016"
```

# Funções por categoria
<a name="functions-by-category"></a>

Nesta seção, você pode encontrar uma lista das funções disponíveis no Amazon Quick, classificadas por categoria.

**Topics**
+ [Funções agregadas](#aggregate-functions)
+ [Funções condicionais](#conditional-functions)
+ [Funções de data](#date-functions)
+ [Funções numéricas](#numeric-functions)
+ [Funções matemáticas](#mathematical-functions)
+ [Funções de string](#string-functions)
+ [Cálculos de tabela](#table-calculations)

## Funções agregadas
<a name="aggregate-functions"></a>

As funções agregadas para campos calculados no Amazon Quick incluem o seguinte. Elas só estão disponíveis durante a análise e a visualização. Cada uma dessas funções retorna valores agrupados pela dimensão ou dimensões escolhidas. Para cada agregação, há também uma agregação condicional. Elas executam o mesmo tipo de agregação, com base em uma condição. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/avg-function.html](https://docs.aws.amazon.com/quicksight/latest/user/avg-function.html) calcula a média do conjunto de números na medida especificada, agrupados pela dimensão ou dimensões escolhidas.
+ [https://docs.aws.amazon.com/quicksight/latest/user/avgIf-function.html](https://docs.aws.amazon.com/quicksight/latest/user/avgIf-function.html) calcula a média com base em uma declaração condicional.
+ [https://docs.aws.amazon.com/quicksight/latest/user/count-function.html](https://docs.aws.amazon.com/quicksight/latest/user/count-function.html) calcula o número de valores em uma dimensão ou medida, agrupados pela dimensão ou dimensões escolhidas. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/countIf-function.html](https://docs.aws.amazon.com/quicksight/latest/user/countIf-function.html) calcula a contagem com base em uma declaração condicional.
+ [https://docs.aws.amazon.com/quicksight/latest/user/distinct_count-function.html](https://docs.aws.amazon.com/quicksight/latest/user/distinct_count-function.html) calcula o número de valores distintos em uma dimensão ou medida, agrupados pela dimensão ou dimensões escolhidas. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/distinct_countIf-function.html](https://docs.aws.amazon.com/quicksight/latest/user/distinct_countIf-function.html) calcula a contagem distinta com base em uma declaração condicional.
+ [https://docs.aws.amazon.com/quicksight/latest/user/max-function.html](https://docs.aws.amazon.com/quicksight/latest/user/max-function.html) retorna o valor máximo da medida especificada, agrupado pela dimensão ou dimensões escolhidas.
+ [https://docs.aws.amazon.com/quicksight/latest/user/maxIf-function.html](https://docs.aws.amazon.com/quicksight/latest/user/maxIf-function.html) calcula o máximo com base em uma declaração condicional.
+ [https://docs.aws.amazon.com/quicksight/latest/user/median-function.html](https://docs.aws.amazon.com/quicksight/latest/user/median-function.html) retorna o valor mediano da medida especificada, agrupado pela dimensão ou dimensões escolhidas.
+ [https://docs.aws.amazon.com/quicksight/latest/user/medianIf-function.html](https://docs.aws.amazon.com/quicksight/latest/user/medianIf-function.html) calcula a mediana com base em uma declaração condicional.
+ O [https://docs.aws.amazon.com/quicksight/latest/user/min-function.html](https://docs.aws.amazon.com/quicksight/latest/user/min-function.html) retorna o valor mínimo da medida especificada, agrupado pela dimensão ou dimensões escolhidas.
+ [https://docs.aws.amazon.com/quicksight/latest/user/minIf-function.html](https://docs.aws.amazon.com/quicksight/latest/user/minIf-function.html) calcula o mínimo com base em uma declaração condicional.
+ [https://docs.aws.amazon.com/quicksight/latest/user/percentile-function.html](https://docs.aws.amazon.com/quicksight/latest/user/percentile-function.html) (alias de `percentileDisc`) computa o *enésimo* percentil da medida especificada, agrupado pela dimensão ou dimensões escolhidas.
+ [https://docs.aws.amazon.com/quicksight/latest/user/percentileCont-function.html](https://docs.aws.amazon.com/quicksight/latest/user/percentileCont-function.html) calcula o *enésimo* percentil com base em uma distribuição contínua dos números da medida especificada, agrupados pela dimensão ou dimensões escolhidas. 
+ [percentileDisc(percentil)](https://docs.aws.amazon.com/quicksight/latest/user/percentileDisc-function.html) *calcula o enésimo percentil com base nos números reais da medida especificada, agrupados pela dimensão ou dimensões escolhidas.* 
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDateAvg-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDateAvg-function.html) calcula a média do conjunto de números na medida especificada para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDateCount-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDateCount-function.html) calcula o número de valores em uma dimensão ou medida para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo, incluindo duplicatas.
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDateMax-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDateMax-function.html) retorna o valor máximo da medida especificada para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo.
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDateMedian-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDateMedian-function.html) retorna o valor médio da medida especificada para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo.
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDateMin-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDateMin-function.html) retorna o valor mínimo da medida ou data especificadas para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo.
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDatePercentile-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDatePercentile-function.html) calcula o percentil com base nos números reais medidos para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo.
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDatePercentileCont-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDatePercentileCont-function.html) calcula o percentil com base em uma distribuição contínua dos números na medida para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo.
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDateStDev-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDateStDev-function.html) calcula o desvio padrão do conjunto de números na medida especificada para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo com base em uma amostra.
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDateStDevP-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDateStDevP-function.html) calcula o desvio padrão da população do conjunto de números na medida especificada para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo com base em uma amostra.
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDateSum-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDateSum-function.html) adiciona o conjunto de números na medida especificada para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo.
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDateVar-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDateVar-function.html) calcula a variação amostral do conjunto de números na medida especificada para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo.
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDateVarP-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDateVarP-function.html) calcula a variação populacional do conjunto de números na medida especificada para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo.
+ [https://docs.aws.amazon.com/quicksight/latest/user/stdev-function.html](https://docs.aws.amazon.com/quicksight/latest/user/stdev-function.html)) calcula o desvio padrão do conjunto de números na medida especificada, agrupados pela dimensão ou pelas dimensões escolhidas, com base em uma amostra.
+ [https://docs.aws.amazon.com/quicksight/latest/user/stdevIf-function.html](https://docs.aws.amazon.com/quicksight/latest/user/stdevIf-function.html) calcula o desvio padrão da amostra com base em uma declaração condicional.
+ [https://docs.aws.amazon.com/quicksight/latest/user/stdevp-function.html](https://docs.aws.amazon.com/quicksight/latest/user/stdevp-function.html) calcula o desvio padrão do conjunto de números na medida especificada, agrupados pela dimensão ou dimensões escolhidas, com base em uma população tendenciosa.
+ [https://docs.aws.amazon.com/quicksight/latest/user/stdevpIf-function.html](https://docs.aws.amazon.com/quicksight/latest/user/stdevpIf-function.html) calcula o desvio populacional com base em uma declaração condicional.
+ [https://docs.aws.amazon.com/quicksight/latest/user/var-function.html](https://docs.aws.amazon.com/quicksight/latest/user/var-function.html)) calcula a variação do conjunto de números na medida especificada, agrupados pela dimensão ou dimensões escolhidas, com base em uma amostra.
+ [https://docs.aws.amazon.com/quicksight/latest/user/varIf-function.html](https://docs.aws.amazon.com/quicksight/latest/user/varIf-function.html) calcula a variação amostral com base em uma declaração condicional.
+ [https://docs.aws.amazon.com/quicksight/latest/user/varp-function.html](https://docs.aws.amazon.com/quicksight/latest/user/varp-function.html)) calcula a variação do conjunto de números na medida especificada, agrupados pela dimensão ou dimensões escolhidas, com base em uma população tendenciosa.
+ [https://docs.aws.amazon.com/quicksight/latest/user/varpIf-function.html](https://docs.aws.amazon.com/quicksight/latest/user/varpIf-function.html) calcula a variação populacional com base em uma declaração condicional.
+ [https://docs.aws.amazon.com/quicksight/latest/user/sum-function.html](https://docs.aws.amazon.com/quicksight/latest/user/sum-function.html)) adiciona o conjunto de números na medida especificada, agrupados pela dimensão ou dimensões escolhidas.
+ [https://docs.aws.amazon.com/quicksight/latest/user/sumIf-function.html](https://docs.aws.amazon.com/quicksight/latest/user/sumIf-function.html)) calcula a soma com base em uma declaração condicional.

## Funções condicionais
<a name="conditional-functions"></a>

As funções condicionais para campos calculados no Amazon Quick incluem o seguinte:
+ [https://docs.aws.amazon.com/quicksight/latest/user/coalesce-function.html](https://docs.aws.amazon.com/quicksight/latest/user/coalesce-function.html) retorna o valor do primeiro argumento que não for nulo.
+ [https://docs.aws.amazon.com/quicksight/latest/user/ifelse-function.html](https://docs.aws.amazon.com/quicksight/latest/user/ifelse-function.html) avalia um conjunto de pares de expressão *if*, *then* e retorna o valor do argumento *then* para o primeiro argumento *if* que for verdadeiro.
+ [https://docs.aws.amazon.com/quicksight/latest/user/in-function.html](https://docs.aws.amazon.com/quicksight/latest/user/in-function.html) avalia uma expressão para ver se está em uma determinada lista de valores.
+ [https://docs.aws.amazon.com/quicksight/latest/user/isNotNull-function.html](https://docs.aws.amazon.com/quicksight/latest/user/isNotNull-function.html) avalia uma expressão para ver se não é nula.
+ [https://docs.aws.amazon.com/quicksight/latest/user/isNull-function.html](https://docs.aws.amazon.com/quicksight/latest/user/isNull-function.html) avalia uma expressão para ver se é nula. Se a expressão for nula, `isNull` retornará verdadeiro; do contrário, retornará falso.
+ [https://docs.aws.amazon.com/quicksight/latest/user/notIn-function.html](https://docs.aws.amazon.com/quicksight/latest/user/notIn-function.html) avalia uma expressão para ver se não está em uma determinada lista de valores.
+ [https://docs.aws.amazon.com/quicksight/latest/user/nullIf-function.html](https://docs.aws.amazon.com/quicksight/latest/user/nullIf-function.html) compara duas expressões. Se elas forem iguais, a função retornará nula. Se eles não forem iguais, a função retornará a primeira expressão.
+ [https://docs.aws.amazon.com/quicksight/latest/user/switch-function.html](https://docs.aws.amazon.com/quicksight/latest/user/switch-function.html) retorna uma expressão que corresponde ao primeiro rótulo igual à expressão da condição.

## Funções de data
<a name="date-functions"></a>

As funções de data para campos calculados no Amazon Quick incluem o seguinte:
+ [https://docs.aws.amazon.com/quicksight/latest/user/addDateTime-function.html](https://docs.aws.amazon.com/quicksight/latest/user/addDateTime-function.html) adiciona ou subtrai uma unidade de tempo à data ou hora fornecida.
+ [https://docs.aws.amazon.com/quicksight/latest/user/addWorkDays-function.html](https://docs.aws.amazon.com/quicksight/latest/user/addWorkDays-function.html) adiciona ou subtrai o determinado número de dias úteis à data ou hora fornecida.
+ [https://docs.aws.amazon.com/quicksight/latest/user/dateDiff-function.html](https://docs.aws.amazon.com/quicksight/latest/user/dateDiff-function.html) retorna a diferença de dias entre dois campos de data. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/epochDate-function.html](https://docs.aws.amazon.com/quicksight/latest/user/epochDate-function.html) converte uma data de epoch em uma data padrão. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/extract-function.html](https://docs.aws.amazon.com/quicksight/latest/user/extract-function.html) retorna uma parte especificada de um valor de data. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/formatDate-function.html](https://docs.aws.amazon.com/quicksight/latest/user/formatDate-function.html) formata uma data usando um padrão que você especificar. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/isWorkDay-function.html](https://docs.aws.amazon.com/quicksight/latest/user/isWorkDay-function.html) retorna VERDADEIRO se um determinado valor de data e hora for um dia útil.
+ [https://docs.aws.amazon.com/quicksight/latest/user/netWorkDays-function.html](https://docs.aws.amazon.com/quicksight/latest/user/netWorkDays-function.html) retorna o número de dias úteis entre os dois valores de data fornecidos.
+ [https://docs.aws.amazon.com/quicksight/latest/user/now-function.html](https://docs.aws.amazon.com/quicksight/latest/user/now-function.html) retorna a data e a hora atuais usando as configurações de um banco de dados, ou UTC para arquivo e Salesforce. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/truncDate-function.html](https://docs.aws.amazon.com/quicksight/latest/user/truncDate-function.html) retorna um valor de data que representa uma parte especificada de uma data. 

## Funções numéricas
<a name="numeric-functions"></a>

As funções numéricas para campos calculados no Amazon Quick incluem o seguinte:
+ [https://docs.aws.amazon.com/quicksight/latest/user/ceil-function.html](https://docs.aws.amazon.com/quicksight/latest/user/ceil-function.html) arredonda uma casa decimal para o próximo inteiro. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/decimalToInt-function.html](https://docs.aws.amazon.com/quicksight/latest/user/decimalToInt-function.html) converte um valor decimal em um valor inteiro. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/floor-function.html](https://docs.aws.amazon.com/quicksight/latest/user/floor-function.html) diminui um valor decimal até o próximo inteiro mais baixo. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/intToDecimal-function.html](https://docs.aws.amazon.com/quicksight/latest/user/intToDecimal-function.html) converte um valor inteiro em um valor decimal. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/round-function.html](https://docs.aws.amazon.com/quicksight/latest/user/round-function.html) arredonda um valor decimal para o inteiro mais próximo ou, se a escala for especificada, para o decimal mais próximo. 

## Funções matemáticas
<a name="mathematical-functions"></a>

As funções matemáticas para campos calculados no Amazon Quick incluem o seguinte: 
+ `[https://docs.aws.amazon.com/quicksight/latest/user/mod-function.html](https://docs.aws.amazon.com/quicksight/latest/user/mod-function.html)(number, divisor)`: localiza o restante depois de dividir um número por um divisor.
+ `[https://docs.aws.amazon.com/quicksight/latest/user/log-function.html](https://docs.aws.amazon.com/quicksight/latest/user/log-function.html)(expression) `: retorna o logaritmo decimal de uma determinada expressão. 
+ `[https://docs.aws.amazon.com/quicksight/latest/user/ln-function.html](https://docs.aws.amazon.com/quicksight/latest/user/ln-function.html)(expression) `: retorna o logaritmo natural de uma determinada expressão. 
+ `[https://docs.aws.amazon.com/quicksight/latest/user/abs-function.html](https://docs.aws.amazon.com/quicksight/latest/user/abs-function.html)(expression) `: retorna o valor absoluto de uma determinada expressão. 
+ `[https://docs.aws.amazon.com/quicksight/latest/user/sqrt-function.html](https://docs.aws.amazon.com/quicksight/latest/user/sqrt-function.html)(expression) `: retorna a raiz quadrada de uma determinada expressão. 
+ `[https://docs.aws.amazon.com/quicksight/latest/user/exp-function.html](https://docs.aws.amazon.com/quicksight/latest/user/exp-function.html)(expression) `: retorna a base do logaritmo natural *e* elevada à potência de uma determinada expressão. 

## Funções de string
<a name="string-functions"></a>

As funções de string (texto) para campos calculados no Amazon Quick incluem o seguinte:
+ [https://docs.aws.amazon.com/quicksight/latest/user/concat-function.html](https://docs.aws.amazon.com/quicksight/latest/user/concat-function.html) concatena duas ou mais strings. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/contains-function.html](https://docs.aws.amazon.com/quicksight/latest/user/contains-function.html) verifica se uma expressão contém uma substring. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/endsWith-function.html](https://docs.aws.amazon.com/quicksight/latest/user/endsWith-function.html) verifica se a expressão termina com a substring especificada.
+ [https://docs.aws.amazon.com/quicksight/latest/user/left-function.html](https://docs.aws.amazon.com/quicksight/latest/user/left-function.html) retorna o número especificado de caracteres mais à esquerda de uma sequência de caracteres. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/locate-function.html](https://docs.aws.amazon.com/quicksight/latest/user/locate-function.html) localiza uma sub-sequência de caracteres dentro de outra sequência de caracteres e retorna o número de caracteres antes da sub-sequência de caracteres. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/ltrim-function.html](https://docs.aws.amazon.com/quicksight/latest/user/ltrim-function.html) remove o espaço em branco anterior de uma string. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/parseDate-function.html](https://docs.aws.amazon.com/quicksight/latest/user/parseDate-function.html) analisa uma sequência de caracteres para determinar se ela contém um valor de data e retorna a data, se encontrada. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/parseDecimal-function.html](https://docs.aws.amazon.com/quicksight/latest/user/parseDecimal-function.html) analisa uma string para determinar se ela contém um valor decimal. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/parseInt-function.html](https://docs.aws.amazon.com/quicksight/latest/user/parseInt-function.html) analisa uma string para determinar se ela contém um valor inteiro.
+ [https://docs.aws.amazon.com/quicksight/latest/user/parseJson-function.html](https://docs.aws.amazon.com/quicksight/latest/user/parseJson-function.html) analisa os valores de um JSON nativo ou de um objeto JSON em um campo de texto.
+ [https://docs.aws.amazon.com/quicksight/latest/user/replace-function.html](https://docs.aws.amazon.com/quicksight/latest/user/replace-function.html) substitui parte de uma sequência de caracteres por uma nova sequência de caracteres. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/right-function.html](https://docs.aws.amazon.com/quicksight/latest/user/right-function.html) retorna o número especificado de caracteres mais à direita de uma sequência de caracteres.
+ [https://docs.aws.amazon.com/quicksight/latest/user/rtrim-function.html](https://docs.aws.amazon.com/quicksight/latest/user/rtrim-function.html) remove o espaço em branco posterior de uma string.
+ [https://docs.aws.amazon.com/quicksight/latest/user/split-function.html](https://docs.aws.amazon.com/quicksight/latest/user/split-function.html) divide uma string em uma matriz de substrings, com base em um delimitador que você seleciona, e retorna o item especificado pela posição. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/startsWith-function.html](https://docs.aws.amazon.com/quicksight/latest/user/startsWith-function.html) verifica se a expressão começa com a substring especificada.
+ [https://docs.aws.amazon.com/quicksight/latest/user/strlen-function.html](https://docs.aws.amazon.com/quicksight/latest/user/strlen-function.html) retorna o número de caracteres na sequência de caracteres.
+ [https://docs.aws.amazon.com/quicksight/latest/user/substring-function.html](https://docs.aws.amazon.com/quicksight/latest/user/substring-function.html) retorna o número especificado de caracteres de uma sequência de caracteres, começando pelo local especificado. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/toLower-function.html](https://docs.aws.amazon.com/quicksight/latest/user/toLower-function.html) formata uma string toda em minúsculas.
+ [https://docs.aws.amazon.com/quicksight/latest/user/toString-function.html](https://docs.aws.amazon.com/quicksight/latest/user/toString-function.html) formata a expressão de entrada como string.
+ [https://docs.aws.amazon.com/quicksight/latest/user/toUpper-function.html](https://docs.aws.amazon.com/quicksight/latest/user/toUpper-function.html) formata uma string toda em maiúsculas.
+ [https://docs.aws.amazon.com/quicksight/latest/user/trim-function.html](https://docs.aws.amazon.com/quicksight/latest/user/trim-function.html) remove o espaço em branco anterior e posterior de uma string.

## Cálculos de tabela
<a name="table-calculations"></a>

Os cálculos de tabela formam um grupo de funções que fornecem contexto em uma análise. Eles fornecem suporte para análise agregada enriquecida. Ao usar esses cálculos, é possível abordar cenários empresariais comuns, como calcular a porcentagem do total, executar soma, diferença, base comum e classificação. 

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. 

**Funções baseadas em pesquisa**
+ [https://docs.aws.amazon.com/quicksight/latest/user/difference-function.html](https://docs.aws.amazon.com/quicksight/latest/user/difference-function.html) calcula a diferença entre uma medida baseada em um conjunto de partições e classificações, e uma medida baseada em outra. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/lag-function.html](https://docs.aws.amazon.com/quicksight/latest/user/lag-function.html) calcula o valor anterior para uma medida. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/lead-function.html](https://docs.aws.amazon.com/quicksight/latest/user/lead-function.html) calcula o valor seguinte para uma medida. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/percentDifference-function.html](https://docs.aws.amazon.com/quicksight/latest/user/percentDifference-function.html) calcula a diferença percentual entre o valor atual e um valor de comparação.

**Funções OVER**
+ [https://docs.aws.amazon.com/quicksight/latest/user/avgOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/avgOver-function.html) calcula a média de uma medida sobre uma ou mais dimensões.
+ [https://docs.aws.amazon.com/quicksight/latest/user/countOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/countOver-function.html) calcula a contagem de um campo sobre uma ou mais dimensões.
+ [https://docs.aws.amazon.com/quicksight/latest/user/distinctCountOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/distinctCountOver-function.html) calcula a contagem distinta do operando particionado pelos atributos especificados em um nível especificado. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/maxOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/maxOver-function.html) calcula o máximo de uma medida sobre uma ou mais dimensões. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/minOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/minOver-function.html) calcula o mínimo de uma medida sobre uma ou mais dimensões. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/percentileOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/percentileOver-function.html) (alias de `percentileDiscOver`) calcula o *enésimo* percentil de uma medida particionada por uma lista de dimensões. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/percentileContOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/percentileContOver-function.html) calcula o *enésimo* percentil com base em uma distribuição contínua dos números de uma medida particionada por uma lista de dimensões.
+ [https://docs.aws.amazon.com/quicksight/latest/user/percentileDiscOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/percentileDiscOver-function.html) calcula o *enésimo* percentil com base nos números reais de uma medida particionada por uma lista de dimensões. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/percentOfTotal-function.html](https://docs.aws.amazon.com/quicksight/latest/user/percentOfTotal-function.html) calcula a porcentagem de contribuição de uma medida para o total. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodOverPeriodDifference-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodOverPeriodDifference-function.html) calcula a diferença de uma medida em dois períodos diferentes, conforme especificado pela granularidade e deslocamento do período.
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodOverPeriodLastValue-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodOverPeriodLastValue-function.html) calcula o último valor (anterior) de uma medida de um período anterior, conforme especificado pela granularidade e deslocamento do período.
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodOverPeriodPercentDifference-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodOverPeriodPercentDifference-function.html) calcula a diferença percentual de uma medida em dois períodos diferentes, conforme especificado pela granularidade e deslocamento do período.
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDateAvgOverTime-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDateAvgOverTime-function.html) calcula a média de uma medida para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDateCountOverTime-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDateCountOverTime-function.html) calcula a contagem de uma dimensão ou medida para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDateMaxOverTime-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDateMaxOverTime-function.html) calcula o máximo de uma medida ou data para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDateMinOverTime-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDateMinOverTime-function.html) calcula o mínimo de uma medida ou data para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/periodToDateSumOverTime-function.html](https://docs.aws.amazon.com/quicksight/latest/user/periodToDateSumOverTime-function.html) calcula a soma de uma medida para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/sumOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/sumOver-function.html) calcula a soma de uma medida sobre uma ou mais dimensões. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/stdevOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/stdevOver-function.html) calcula o desvio padrão da medida especificada, particionado pelo atributo ou atributos escolhidos, com base em uma amostra.
+ [https://docs.aws.amazon.com/quicksight/latest/user/stdevpOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/stdevpOver-function.html) calcula o desvio padrão da medida especificada, particionado pelo atributo ou atributos escolhidos, com base em uma população tendenciosa.
+ [https://docs.aws.amazon.com/quicksight/latest/user/varOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/varOver-function.html) calcula a variação da medida especificada, particionado pelo atributo ou atributos escolhidos, com base em uma amostra. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/varpOver-function.html](https://docs.aws.amazon.com/quicksight/latest/user/varpOver-function.html) calcula a variação da medida especificada, particionada pelo atributo ou atributos escolhidos, com base em uma população tendenciosa. 

**Funções de classificação**
+ [https://docs.aws.amazon.com/quicksight/latest/user/rank-function.html](https://docs.aws.amazon.com/quicksight/latest/user/rank-function.html) calcula o nível de uma medida ou de uma dimensão.
+ [https://docs.aws.amazon.com/quicksight/latest/user/denseRank-function.html](https://docs.aws.amazon.com/quicksight/latest/user/denseRank-function.html) calcula o nível de uma medida ou de uma dimensão, ignorando duplicações.
+ [https://docs.aws.amazon.com/quicksight/latest/user/percentileRank-function.html](https://docs.aws.amazon.com/quicksight/latest/user/percentileRank-function.html) calcula o nível de uma medida ou de uma dimensão, com base no percentil.

**Funções de execução**
+ [https://docs.aws.amazon.com/quicksight/latest/user/runningAvg-function.html](https://docs.aws.amazon.com/quicksight/latest/user/runningAvg-function.html) calcula uma média em execução para uma medida.
+ [https://docs.aws.amazon.com/quicksight/latest/user/runningCount-function.html](https://docs.aws.amazon.com/quicksight/latest/user/runningCount-function.html) calcula uma contagem em execução para uma medida.
+ [https://docs.aws.amazon.com/quicksight/latest/user/runningMax-function.html](https://docs.aws.amazon.com/quicksight/latest/user/runningMax-function.html) calcula um máximo em execução para uma medida.
+ [https://docs.aws.amazon.com/quicksight/latest/user/runningMin-function.html](https://docs.aws.amazon.com/quicksight/latest/user/runningMin-function.html) calcula um mínimo em execução para uma medida.
+ [https://docs.aws.amazon.com/quicksight/latest/user/runningSum-function.html](https://docs.aws.amazon.com/quicksight/latest/user/runningSum-function.html) calcula uma soma em execução para uma medida. 

**Funções de janela**
+ [https://docs.aws.amazon.com/quicksight/latest/user/firstValue-function.html](https://docs.aws.amazon.com/quicksight/latest/user/firstValue-function.html) calcula o primeiro valor da dimensão ou da medida agregada particionada e classificada por atributos especificados. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/lastValue-function.html](https://docs.aws.amazon.com/quicksight/latest/user/lastValue-function.html) calcula o último valor da dimensão ou da medida agregada particionada e classificada por atributos especificados. 
+ [https://docs.aws.amazon.com/quicksight/latest/user/windowAvg-function.html](https://docs.aws.amazon.com/quicksight/latest/user/windowAvg-function.html) calcula a média da medida agregada em uma janela personalizada que está particionada e organizada por atributos especificados.
+ [https://docs.aws.amazon.com/quicksight/latest/user/windowCount-function.html](https://docs.aws.amazon.com/quicksight/latest/user/windowCount-function.html) calcula a contagem da medida agregada em uma janela personalizada que está particionada e organizada por atributos especificados.
+ [https://docs.aws.amazon.com/quicksight/latest/user/windowMax-function.html](https://docs.aws.amazon.com/quicksight/latest/user/windowMax-function.html) calcula o máximo da medida agregada em uma janela personalizada que está particionada e organizada por atributos especificados.
+ [https://docs.aws.amazon.com/quicksight/latest/user/windowMin-function.html](https://docs.aws.amazon.com/quicksight/latest/user/windowMin-function.html) calcula o mínimo da medida agregada em uma janela personalizada que está particionada e organizada por atributos especificados.
+ [https://docs.aws.amazon.com/quicksight/latest/user/windowSum-function.html](https://docs.aws.amazon.com/quicksight/latest/user/windowSum-function.html) calcula a soma da medida agregada em uma janela personalizada que está particionada e organizada por atributos especificados.

# Funções
<a name="functions"></a>

Nesta seção, você pode encontrar uma lista de funções disponíveis 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**
+ [addDateTime](addDateTime-function.md)
+ [addWorkDays](addWorkDays-function.md)
+ [Abs](abs-function.md)
+ [Ceil](ceil-function.md)
+ [Coalesce](coalesce-function.md)
+ [Concat](concat-function.md)
+ [contains](contains-function.md)
+ [decimalToInt](decimalToInt-function.md)
+ [dateDiff](dateDiff-function.md)
+ [endsWith](endsWith-function.md)
+ [epochDate](epochDate-function.md)
+ [Exp](exp-function.md)
+ [Extract](extract-function.md)
+ [Floor](floor-function.md)
+ [formatDate](formatDate-function.md)
+ [Ifelse](ifelse-function.md)
+ [in](in-function.md)
+ [intToDecimal](intToDecimal-function.md)
+ [isNotNull](isNotNull-function.md)
+ [isNull](isNull-function.md)
+ [isWorkDay](isWorkDay-function.md)
+ [Left](left-function.md)
+ [Locate](locate-function.md)
+ [Log](log-function.md)
+ [Ln](ln-function.md)
+ [Ltrim](ltrim-function.md)
+ [Mod](mod-function.md)
+ [netWorkDays](netWorkDays-function.md)
+ [Now](now-function.md)
+ [notIn](notIn-function.md)
+ [nullIf](nullIf-function.md)
+ [parseDate](parseDate-function.md)
+ [parseDecimal](parseDecimal-function.md)
+ [parseInt](parseInt-function.md)
+ [parseJson](parseJson-function.md)
+ [Replace](replace-function.md)
+ [Right](right-function.md)
+ [Round](round-function.md)
+ [Rtrim](rtrim-function.md)
+ [Split](split-function.md)
+ [Sqrt](sqrt-function.md)
+ [startsWith](startsWith-function.md)
+ [Strlen](strlen-function.md)
+ [Substring](substring-function.md)
+ [switch](switch-function.md)
+ [toLower](toLower-function.md)
+ [toString](toString-function.md)
+ [toUpper](toUpper-function.md)
+ [trim](trim-function.md)
+ [truncDate](truncDate-function.md)

# addDateTime
<a name="addDateTime-function"></a>

`addDateTime` adiciona ou subtrai uma unidade de tempo de um valor de data e hora. Por exemplo, `addDateTime(2,'YYYY',parseDate('02-JUL-2018', 'dd-MMM-yyyy') )` exibe `02-JUL-2020`. Use essa função para realizar cálculos de data nos dados de data e hora. 

## Sintaxe
<a name="addDateTime-function-syntax"></a>

```
addDateTime(amount, period, datetime)
```

## Argumentos
<a name="addDateTime-function-arguments"></a>

 *amount*   
Um valor inteiro positivo ou negativo que representa a quantidade de tempo que você deseja adicionar ou subtrair do campo datetime fornecido. 

 *período*   
Um valor positivo ou negativo que representa a quantidade de tempo que deseja adicionar ou subtrair do campo datetime fornecido. Os períodos válidos são:   
+ AAAA: retorna a parte do ano da data. 
+ Q: isso retorna o trimestre ao qual a data pertence (de 1 a 4). 
+ MM: Isto retorna a parte do mês da data. 
+ DD: retorna a parte do dia da data. 
+ WK: retorna a parte da semana da data. A semana começa no domingo no Amazon Quick. 
+ HH: retorna a parte da hora da data. 
+ MI: Isto retorna a parte do minuto da data. 
+ SS: Isto retorna a parte do segundo da data.
+ MS: isso retorna a parte do milissegundo da data.

 *datetime*   
A data ou hora em que deseja executar o cálculo de data. 

## Tipo de retorno
<a name="addDateTime-function-return-type"></a>

Datetime

## Exemplo
<a name="addDateTime-function-example"></a>

Vamos supor que você tenha um campo chamado `purchase_date` com os valores a seguir.

```
2018 May 13 13:24
2017 Jan 31 23:06
2016 Dec 28 06:45
```

Usando os seguintes cálculos, `addDateTime` altera os valores conforme mostrado a seguir.

```
addDateTime(-2, 'YYYY', purchaseDate)

2016 May 13 13:24
2015 Jan 31 23:06
2014 Dec 28 06:45


addDateTime(4, 'DD', purchaseDate)

2018 May 17 13:24
2017 Feb 4 23:06
2017 Jan 1 06:45


addDateTime(20, 'MI', purchaseDate)

2018 May 13 13:44
2017 Jan 31 23:26
2016 Dec 28 07:05
```

# addWorkDays
<a name="addWorkDays-function"></a>

`addWorkDays` adiciona ou subtrai um número designado de dias úteis a um determinado valor de data. A função retorna a data de um dia útil, que corresponde aos dias úteis designados após ou antes de um determinado valor de data de entrada. 

## Sintaxe
<a name="addWorkDays-function-syntax"></a>

```
addWorkDays(initDate, numWorkDays)
```

## Argumentos
<a name="addWorkDays-function-arguments"></a>

*initDate*  
Uma data válida não nula que atua como a data de início do cálculo.   
+ **Campo do conjunto de dados**: qualquer campo de `date` do conjunto de dados ao qual você está adicionando essa função.
+ **Função de data**: qualquer saída de data de outra função de `date`, por exemplo `parseDate`, `epochDate`, `addDateTime` e assim por diante.  
**Example**  

  ```
  addWorkDays(epochDate(1659484800), numWorkDays)
  ```
+ **Campos calculados** — Qualquer campo calculado rapidamente que retorna um `date` valor.  
**Example**  

  ```
  calcFieldStartDate = addDateTime(10, “DD”, startDate)
  addWorkDays(calcFieldStartDate, numWorkDays)
  ```
+ **Parâmetros** — Qualquer `datetime` parâmetro rápido.  
**Example**  

  ```
  addWorkDays($paramStartDate, numWorkDays)
  ```
+ Qualquer combinação dos valores dos argumentos acima indicados.

 *numWorkDays*   
Um número inteiro não NULO que atua como a data final do cálculo.   
+ **Literal**: um número inteiro literal digitado diretamente no editor de expressões.  
**Example**  

  ```
  ```
+ **Campo do conjunto de dados**: qualquer campo de data do conjunto de dados   
**Example**  

  ```
  ```
+ **Função ou cálculo escalar** — Qualquer função escalar rápida que retorna uma saída inteira de outra, por exemplo `decimalToInt``abs`, e assim por diante.  
**Example**  

  ```
  addWorkDays(initDate, decimalToInt(sqrt (abs(numWorkDays)) ) )
  ```
+ **Campo calculado** — Qualquer campo calculado rapidamente que retorna um `date` valor.  
**Example**  

  ```
  someOtherIntegerCalcField = (num_days * 2) + 12
  addWorkDays(initDate, someOtherIntegerCalcField)
  ```
+ **Parâmetro** — Qualquer `datetime` parâmetro rápido.  
**Example**  

  ```
  addWorkDays(initDate, $param_numWorkDays)
  ```
+ Qualquer combinação dos valores dos argumentos acima indicados.

## Tipo de retorno
<a name="addWorkDays-function-return-type"></a>

Inteiro 

## Valores de saída
<a name="addWorkDays-function-output-type"></a>

Os valores de saída esperados incluem os seguintes:
+ número inteiro positivo (quando start\$1date < end\$1date);
+ número inteiro negativo (quando start\$1date > end\$1date);
+ NULL, quando um ou ambos os argumentos obtêm um valor nulo do `dataset field`.

## Erro de entrada
<a name="addWorkDays-function-errors"></a>

Valores de argumentos não permitidos causam erros, conforme mostrado nos exemplos a seguir.
+ Não é permitido usar um NULL literal como argumento na expressão.  
**Example**  

  ```
  addWorkDays(NULL, numWorkDays) 
  ```  
**Example**  

  ```
  Error
  At least one of the arguments in this function does not have correct type. 
  Correct the expression and choose Create again.
  ```
+ Não é permitido usar um literal de string como argumento, ou qualquer outro tipo de dados que não seja uma data, na expressão. No exemplo a seguir, a string **"2022-08-10"** parece uma data, mas na verdade é uma string. Para usá-la, você precisaria usar uma função que converta em um tipo de dados de data.  
**Example**  

  ```
  addWorkDays("2022-08-10", 10)
  ```  
**Example**  

  ```
  Error
  Expression addWorkDays("2022-08-10", numWorkDays) for function addWorkDays has 
  incorrect argument type addWorkDays(String, Number). 
  Function syntax expects Date, Integer.
  ```

## Exemplo
<a name="addWorkDays-function-example"></a>

Um número inteiro positivo como argumento `numWorkDays` produzirá uma data futura da data de entrada. Um número inteiro negativo como argumento `numWorkDays` produzirá uma data resultante no passado da data de entrada. Um valor zero para o argumento `numWorkDays` produz o mesmo valor da data de entrada, independentemente de ela cair em um dia útil ou em um fim de semana.

A função `addWorkDays` opera na granularidade: `DAY`. A precisão não pode ser preservada em nenhuma granularidade inferior ou superior ao nível `DAY`.

```
addWorkDays(startDate, endDate)
```

Vamos supor que haja um campo chamado `employmentStartDate` com os seguintes valores: 

```
2022-08-10 2022-08-06 2022-08-07 
```

Usando o campo acima e os cálculos a seguir, `addWorkDays` retorna os valores modificados, conforme mostrado abaixo:

```
addWorkDays(employmentStartDate, 7)

2022-08-19 
2022-08-16 
2022-08-16 

addWorkDays(employmentStartDate, -5)

2022-08-02 
2022-08-01 
2022-08-03 

addWorkDays(employmentStartDate, 0)

2022-08-10 
2022-08-06 
2022-08-07
```

O exemplo a seguir calcula o bônus total proporcional a ser pago a cada funcionário por dois anos, com base em quantos dias cada funcionário realmente trabalhou.

```
last_day_of_work = addWorkDays(employment_start_date, 730)
total_days_worked = netWorkDays(employment_start_date, last_day_of_work)
total_bonus = total_days_worked * bonus_per_day
```

![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/addWorkDays-function-example.png)


# Abs
<a name="abs-function"></a>

O `abs` retorna o valor absoluto de uma determinada expressão. 

## Sintaxe
<a name="abs-function-syntax"></a>

```
abs(expression)
```

## Argumentos
<a name="abs-function-arguments"></a>

 *expressão*   
A expressão deve ser numérica. Pode ser um nome de campo, um valor literal ou outra função. 

# Ceil
<a name="ceil-function"></a>

`ceil` arredonda uma casa decimal para o próximo inteiro. Por exemplo, `ceil(29.02)` exibe `30`.

## Sintaxe
<a name="ceil-function-syntax"></a>

```
ceil(decimal)
```

## Argumentos
<a name="ceil-function-arguments"></a>

 *decimal*   
Um campo que usa o tipo de dados decimal, um valor literal, como **17.62**, ou uma chamada para outra função que gera um decimal.

## Tipo de retorno
<a name="ceil-function-return-type"></a>

Inteiro

## Exemplo
<a name="ceil-function-example"></a>

O exemplo a seguir arredonda um campo decimal para o próximo inteiro mais alto.

```
ceil(salesAmount)
```

A seguir estão os valores de campo especificados.

```
20.13
892.03
57.54
```

Para esses valores de campo, os seguintes valores são retornados.

```
21
893
58
```

# Coalesce
<a name="coalesce-function"></a>

`coalesce` retorna o valor do primeiro argumento que não for nulo. Quando um valor não nulo for localizado, os argumentos restantes na lista não serão avaliados. Se todos os argumentos forem nulos, o resultado é nulo. As strings de comprimento 0 são valores válidos e não são considerados equivalentes a nulo.

## Sintaxe
<a name="coalesce-function-syntax"></a>

```
coalesce(expression1, expression2 [, expression3, ...])
```

## Argumentos
<a name="coalesce-function-arguments"></a>

`coalesce` pega duas ou mais expressões como argumentos. Todas as expressões devem ter o mesmo tipo de dados ou poderem ser implicitamente convertidas para o mesmo tipo de dados.

 *expressão*   
A expressão pode ser numérica, data e hora ou string. Pode ser um nome de campo, um valor literal ou outra função. 

## Tipo de retorno
<a name="coalesce-function-return-type"></a>

`coalesce` retorna um valor do mesmo tipo de dados como argumentos de entrada.

## Exemplo
<a name="coalesce-function-example"></a>

O exemplo a seguir recupera o endereço de pagamento de um cliente, se existir, seu endereço de correspondência se não houver endereço de pagamento, ou retorna "Nenhum endereço listado" se nenhum endereço estiver disponível.

```
coalesce(billingAddress, streetAddress, 'No address listed')
```

# Concat
<a name="concat-function"></a>

`concat` concatena duas ou mais strings.

## Sintaxe
<a name="concat-function-syntax"></a>

```
concat(expression1, expression2 [, expression3 ...])
```

## Argumentos
<a name="concat-function-arguments"></a>

`concat` leva duas ou mais expressões de string como argumentos. 

 *expressão*   
A expressão deve ser uma string. Isso pode ser o nome de um campo que usa o tipo de dados de string, um valor literal, como **'12 Main Street'**, ou uma chamada para outra função que gere uma string.

## Tipo de retorno
<a name="concat-function-return-type"></a>

String

## Exemplos
<a name="concat-function-example"></a>

O exemplo a seguir concatena três campos de strings e adiciona espaçamento apropriado.

```
concat(salutation, ' ', firstName, ' ', lastName)
```

A seguir estão os valores de campo especificados.

```
salutation     firstName          lastName
-------------------------------------------------------
Ms.            Li                  Juan
Dr.            Ana Carolina        Silva
Mr.            Nikhil              Jayashankar
```

Para esses valores de campo, os seguintes valores são retornados.

```
Ms. Li Juan
Dr. Ana Carolina Silva
Mr. Nikhil Jayashankar
```

O exemplo a seguir concatena dois literais de strings.

```
concat('Hello', 'world')
```

O valor a seguir é retornado.

```
Helloworld
```

# contains
<a name="contains-function"></a>

`contains` avalia se a substring especificada existe em uma expressão. Se a expressão contiver a substring, a função contains retornará true, caso contrário, retornará false.

## Sintaxe
<a name="contains-function-syntax"></a>

```
contains(expression, substring, string-comparison-mode)
```

## Argumentos
<a name="contains-function-arguments"></a>

 *expressão*   
A expressão deve ser uma string. Isso pode ser o nome de um campo que usa o tipo de dados de string, um valor literal, como **'12 Main Street'**, ou uma chamada para outra função que gere uma string.

 *substring*   
O conjunto de caracteres a serem comparados com a *expressão*. A substring pode ocorrer uma ou mais vezes na *expressão*.

 *string-comparison-mode*   
(Opcional) Especifica o modo de comparação de strings a ser usado:  
+ `CASE_SENSITIVE`: as comparações de strings diferenciam maiúsculas de minúsculas. 
+ `CASE_INSENSITIVE`: as comparações de strings não diferenciam maiúsculas de minúsculas.
Esse valor será padronizado como `CASE_SENSITIVE` quando for deixado em branco.

## Tipo de retorno
<a name="contains-function-return-type"></a>

Booleano

## Exemplos
<a name="contains-function-example"></a>

### Exemplo padrão de diferenciação entre maiúsculas e minúsculas
<a name="contains-function-example-default-case-sensitive"></a>

O exemplo a seguir, com distinção entre maiúsculas e minúsculas, avalia se `state_nm` contém **New**.

```
contains(state_nm, "New")
```

A seguir estão os valores de campo especificados.

```
New York
new york
```

Para esses valores de campo, os seguintes valores são retornados.

```
true
false
```

### Exemplo sem distinção entre maiúsculas e minúsculas
<a name="contains-function-example-case-insensitive"></a>

O exemplo a seguir, sem distinção entre maiúsculas e minúsculas, avalia se `state_nm` contém **new**.

```
contains(state_nm, "new", CASE_INSENSITIVE)
```

A seguir estão os valores de campo especificados.

```
New York
new york
```

Para esses valores de campo, os seguintes valores são retornados.

```
true
true
```

### Exemplo com declarações condicionais
<a name="contains-function-example-conditional-statements"></a>

A função contains pode ser usada como a declaração condicional nas seguintes funções if: [avgIf](https://docs.aws.amazon.com/quicksight/latest/user/avgIf-function.html), [minIf](https://docs.aws.amazon.com/quicksight/latest/user/minIf-function.html), [distinct\$1countIf](https://docs.aws.amazon.com/quicksight/latest/user/distinct_countIf-function.html), [countIf](https://docs.aws.amazon.com/quicksight/latest/user/countIf-function.html), [maxIf](https://docs.aws.amazon.com/quicksight/latest/user/maxIf-function.html), [medianIf](https://docs.aws.amazon.com/quicksight/latest/user/medianIf-function.html), [stdevIf](https://docs.aws.amazon.com/quicksight/latest/user/stdevIf-function.html), [stdevpIf](https://docs.aws.amazon.com/quicksight/latest/user/stdevpIf-function.html), [sumIf](https://docs.aws.amazon.com/quicksight/latest/user/sumIf-function.html), [varIf](https://docs.aws.amazon.com/quicksight/latest/user/varIf-function.html) e [varpIf](https://docs.aws.amazon.com/quicksight/latest/user/varpIf-function.html). 

O exemplo a seguir soma `Sales` somente se `state_nm` contiver **New**.

```
sumIf(Sales,contains(state_nm, "New"))
```

### Exemplo does NOT contain
<a name="contains-function-example-does-not-contain"></a>

O operador condicional `NOT` pode ser usado para avaliar se a expressão não contém a substring especificada. 

```
NOT(contains(state_nm, "New"))
```

### Exemplo de uso com valores numéricos
<a name="contains-function-example-numeric-values"></a>

Valores numéricos podem ser usados nos argumentos da expressão ou da substring aplicando a função `toString`.

```
contains(state_nm, toString(5) )
```

# decimalToInt
<a name="decimalToInt-function"></a>

`decimalToInt` converte um valor decimal ao tipo de dados integer retirando o ponto decimal e todos os números depois dele. `decimalToInt` não arredonda. Por exemplo, `decimalToInt(29.99)` exibe `29`.

## Sintaxe
<a name="decimalToInt-function-syntax"></a>

```
decimalToInt(decimal)
```

## Argumentos
<a name="decimalToInt-function-arguments"></a>

 *decimal*   
Um campo que usa o tipo de dados decimal, um valor literal, como **17.62**, ou uma chamada para outra função que gera um decimal.

## Tipo de retorno
<a name="decimalToInt-function-return-type"></a>

Inteiro

## Exemplo
<a name="decimalToInt-function-example"></a>

O exemplo a seguir converte um campo decimal em um inteiro.

```
decimalToInt(salesAmount)
```

A seguir estão os valores de campo especificados.

```
 20.13
892.03
 57.54
```

Para esses valores de campo, os seguintes valores são retornados.

```
 20
892
 57
```

# dateDiff
<a name="dateDiff-function"></a>

`dateDiff` retorna a diferença de dias entre dois campos de data. Se você incluir um valor para o período, `dateDiff` retorna a diferença no intervalo do período, em vez de em dias.

## Sintaxe
<a name="dateDiff-function-syntax"></a>

```
dateDiff(date1, date2,[period])
```

## Argumentos
<a name="dateDiff-function-arguments"></a>

`dateDiff` leva duas datas como argumentos. Especificar um período é opcional.

 *data 1*   
A primeira data na comparação. Um campo de data ou uma chamada para outra função que gera uma data. 

 *data 2*   
A segunda data na comparação. Um campo de data ou uma chamada para outra função que gera uma data. 

 *período*   
O período de diferença que você quer que retorne, entre aspas. Os períodos válidos são:  
+ AAAA: retorna a parte do ano da data.
+ P: Isso retorna a data do primeiro dia do trimestre ao qual a data pertence. 
+ MM: Isto retorna a parte do mês da data.
+ DD: retorna a parte do dia da data.
+ WK: retorna a parte da semana da data. A semana começa no domingo no Amazon Quick.
+ HH: retorna a parte da hora da data.
+ MI: Isto retorna a parte do minuto da data.
+ SS: Isto retorna a parte do segundo da data.
+ MS: isso retorna a parte do milissegundo da data.

## Tipo de retorno
<a name="dateDiff-function-return-type"></a>

Inteiro

## Exemplo
<a name="dateDiff-function-example"></a>

O exemplo a seguir retorna a diferença entre duas datas.

```
dateDiff(orderDate, shipDate, "MM")
```

A seguir estão os valores de campo especificados.

```
orderDate          shipdate
=============================
01/01/18            03/05/18
09/13/17            10/20/17
```

Para esses valores de campo, os seguintes valores são retornados.

```
2
1
```

# endsWith
<a name="endsWith-function"></a>

`endsWith` avalia se a expressão termina com uma substring especificada por você. Se a expressão terminar com a substring, `endsWith` retornará true, caso contrário, retornará false.

## Sintaxe
<a name="endsWith-function-syntax"></a>

```
endsWith(expression, substring, string-comparison-mode)
```

## Argumentos
<a name="endsWith-function-arguments"></a>

 *expressão*   
A expressão deve ser uma string. Isso pode ser o nome de um campo que usa o tipo de dados de string, um valor literal, como **'12 Main Street'**, ou uma chamada para outra função que gere uma string.

 *substring*   
O conjunto de caracteres a serem comparados com a *expressão*. A substring pode ocorrer uma ou mais vezes na *expressão*.

 *string-comparison-mode*   
(Opcional) Especifica o modo de comparação de strings a ser usado:  
+ `CASE_SENSITIVE`: as comparações de strings diferenciam maiúsculas de minúsculas. 
+ `CASE_INSENSITIVE`: as comparações de strings não diferenciam maiúsculas de minúsculas.
Esse valor será padronizado como `CASE_SENSITIVE` quando for deixado em branco.

## Tipo de retorno
<a name="endsWith-function-return-type"></a>

Booleano

## Exemplos
<a name="endsWith-function-example"></a>

### Exemplo padrão de diferenciação entre maiúsculas e minúsculas
<a name="endsWith-function-example-default-case-sensitive"></a>

O exemplo a seguir, com distinção entre maiúsculas e minúsculas, avalia se `state_nm` endsWith **"York"**.

```
endsWith(state_nm, "York")
```

A seguir estão os valores de campo especificados.

```
New York
new york
```

Para esses valores de campo, os seguintes valores são retornados.

```
true
false
```

### Exemplo sem distinção entre maiúsculas e minúsculas
<a name="endsWith-function-example-case-insensitive"></a>

O exemplo a seguir, sem distinção entre maiúsculas e minúsculas, avalia se `state_nm` endsWith **"york"**.

```
endsWith(state_nm, "york", CASE_INSENSITIVE)
```

A seguir estão os valores de campo especificados.

```
New York
new york
```

Para esses valores de campo, os seguintes valores são retornados.

```
true
true
```

### Exemplo com declarações condicionais
<a name="endsWith-function-example-conditional-statements"></a>

A função `endsWith` pode ser usada como a declaração condicional nas seguintes funções IF: [avgIf](https://docs.aws.amazon.com/quicksight/latest/user/avgIf-function.html), [minIf](https://docs.aws.amazon.com/quicksight/latest/user/minIf-function.html), [distinct\$1countIf](https://docs.aws.amazon.com/quicksight/latest/user/distinct_countIf-function.html), [countIf](https://docs.aws.amazon.com/quicksight/latest/user/countIf-function.html), [maxIf](https://docs.aws.amazon.com/quicksight/latest/user/maxIf-function.html), [medianIf](https://docs.aws.amazon.com/quicksight/latest/user/medianIf-function.html), [stdevIf](https://docs.aws.amazon.com/quicksight/latest/user/stdevIf-function.html), [stdevpIf](https://docs.aws.amazon.com/quicksight/latest/user/stdevpIf-function.html), [sumIf](https://docs.aws.amazon.com/quicksight/latest/user/sumIf-function.html), [varIf](https://docs.aws.amazon.com/quicksight/latest/user/varIf-function.html) e [varpIf](https://docs.aws.amazon.com/quicksight/latest/user/varpIf-function.html). 

O exemplo a seguir soma `Sales` somente se `state_nm` terminar com **"York"**.

```
sumIf(Sales,endsWith(state_nm, "York"))
```

### Exemplo does NOT contain
<a name="endsWith-function-example-does-not-start-with"></a>

O operador condicional `NOT` pode ser usado para avaliar se a expressão não começa com a substring especificada. 

```
NOT(endsWith(state_nm, "York"))
```

### Exemplo de uso com valores numéricos
<a name="endsWith-function-example-numeric-values"></a>

Valores numéricos podem ser usados nos argumentos da expressão ou da substring aplicando a função `toString`.

```
endsWith(state_nm, toString(5) )
```

# epochDate
<a name="epochDate-function"></a>

`epochDate`[converte uma data de época em uma data padrão no formato aaaa-MM-dd **T** kk:mm:ss.sss **Z**, usando a sintaxe do padrão de formato especificada em Class na documentação do projeto Joda. DateTimeFormat](http://www.joda.org/joda-time/apidocs/org/joda/time/format/DateTimeFormat.html) Um exemplo é `2015-10-15T19:11:51.003Z`. 

`epochDate`é suportado para uso com análises baseadas em conjuntos de dados armazenados em Quick (SPICE).

## Sintaxe
<a name="epochDate-function-syntax"></a>

```
epochDate(epochdate)
```

## Argumentos
<a name="epochDate-function-arguments"></a>

 *epochdate*   
Uma data de referência (epoch), que é uma representação de número inteiro de uma data como o número de segundos desde 00:00:00 UTC em 1º de janeiro de 1970.   
*epochdate* deve ser um número inteiro. Isso pode ser o nome de um campo que usa o tipo de dados inteiro, um valor inteiro literal ou uma chamada para outra função que gere um número inteiro. Se o valor inteiro for maior que dez dígitos, os dígitos após a décima casa serão descartados.

## Tipo de retorno
<a name="epochDate-function-return-type"></a>

Data

## Exemplo
<a name="epochDate-function-example"></a>

O exemplo a seguir converte uma data de referência (epoch) em uma data padrão.

```
epochDate(3100768000)
```

O valor a seguir é retornado.

```
2068-04-04T12:26:40.000Z
```

# Exp
<a name="exp-function"></a>

O `exp` retorna a base de logaritmo natural e elevada à potência de uma determinada expressão. 

## Sintaxe
<a name="exp-function-syntax"></a>

```
exp(expression)
```

## Argumentos
<a name="exp-function-arguments"></a>

 *expressão*   
A expressão deve ser numérica. Pode ser um nome de campo, um valor literal ou outra função. 

# Extract
<a name="extract-function"></a>

`extract` retorna uma parte especificada de um valor de data. Solicitar uma parte de uma data relacionada a tempo que não contém informações de tempo retorna 0.

## Sintaxe
<a name="extract-function-syntax"></a>

```
extract(period, date)
```

## Argumentos
<a name="extract-function-arguments"></a>

 *período*   
O período que você deseja extrair do valor de data. Os períodos válidos são:  
+ AAAA: retorna a parte do ano da data.
+ Q: isso retorna o trimestre ao qual a data pertence (de 1 a 4). 
+ MM: Isto retorna a parte do mês da data.
+ DD: retorna a parte do dia da data.
+ WD: retorna o dia da semana como número inteiro, com domingo sendo 1.
+ HH: retorna a parte da hora da data.
+ MI: Isto retorna a parte do minuto da data.
+ SS: Isto retorna a parte do segundo da data.
+ MS: isso retorna a parte do milissegundo da data.
**nota**  
A extração de milissegundos não tem suporte dos bancos de dados do Presto anteriores à versão 0.216.

 *data*   
Um campo de data ou uma chamada para outra função que gera uma data.

## Tipo de retorno
<a name="extract-function-return-type"></a>

Inteiro

## Exemplo
<a name="extract-function-example"></a>

O exemplo a seguir extrai o dia de um valor de data.

```
extract('DD', orderDate)
```

A seguir estão os valores de campo especificados.

```
orderDate
=========
01/01/14  
09/13/16
```

Para esses valores de campo, os seguintes valores são retornados.

```
01
13
```

# Floor
<a name="floor-function"></a>

`floor` diminui um valor decimal até o próximo inteiro mais baixo. Por exemplo, `floor(29.08)` exibe `29`.

## Sintaxe
<a name="floor-function-syntax"></a>

```
floor(decimal)
```

## Argumentos
<a name="floor-function-arguments"></a>

 *decimal*   
Um campo que usa o tipo de dados decimal, um valor literal, como **17.62**, ou uma chamada para outra função que gera um decimal.

## Tipo de retorno
<a name="floor-function-return-type"></a>

Inteiro

## Exemplo
<a name="floor-function-example"></a>

O exemplo a seguir diminui um campo decimal para o próximo inteiro mais baixo.

```
floor(salesAmount)
```

A seguir estão os valores de campo especificados.

```
20.13
892.03
57.54
```

Para esses valores de campo, os seguintes valores são retornados.

```
20
892
57
```

# formatDate
<a name="formatDate-function"></a>

`formatDate` formata uma data usando um padrão que você especificar. Ao preparar dados, você pode usar `formatDate` para reformatar a data. Para reformatar uma data em uma análise, escolha a opção de formato no menu de contexto no campo de data.

## Sintaxe
<a name="formatDate-function-syntax"></a>

```
formatDate(date, ['format'])
```

## Argumentos
<a name="formatDate-function-arguments"></a>

 *data*   
Um campo de data ou uma chamada para outra função que gera uma data.

 *format*   
(Opcional) Uma string contendo o padrão de formato a ser aplicado. Esse argumento aceita os padrões de formato especificados em Formatos de [data suportados](https://docs.aws.amazon.com/quicksight/latest/user/supported-date-formats.html).  
Se você não especificar um formato, a sequência de caracteres usa o padrão aaaa-MM-dd**T**kk:mm:ss:SSS.

## Tipo de retorno
<a name="formatDate-function-return-type"></a>

String

## Exemplo
<a name="formatDate-function-example"></a>

O exemplo a seguir formata uma data UTC.

```
formatDate(orderDate, 'dd-MMM-yyyy')
```

A seguir estão os valores de campo especificados.

```
order date      
=========
2012-12-14T00:00:00.000Z  
2013-12-29T00:00:00.000Z
2012-11-15T00:00:00.000Z
```

Para esses valores de campo, os seguintes valores são retornados.

```
13 Dec 2012
28 Dec 2013
14 Nov 2012
```

## Exemplo
<a name="formatDate-function-example2"></a>

Se a data contiver aspas simples ou apóstrofos, por exemplo `yyyyMMdd'T'HHmmss`, você poderá manipular esse formato de data usando um dos métodos a seguir.
+ Coloque a data inteira entre aspas duplas, como mostrado no seguinte exemplo:

  ```
  formatDate({myDateField}, "yyyyMMdd'T'HHmmss")
  ```
+ Evite as aspas simples ou apóstrofos adicionando uma barra invertida ( `\` ) à esquerda, conforme mostrado no seguinte exemplo: 

  ```
  formatDate({myDateField}, 'yyyyMMdd\'T\'HHmmss')
  ```

# Ifelse
<a name="ifelse-function"></a>

`ifelse` avalia um conjunto de pares de expressão *if*, *then* e retorna o valor do argumento *then* para o primeiro argumento *if* que for verdadeiro. Se nenhum dos argumentos *if* for verdadeiro, será retornado o valor do argumento *else*.

## Sintaxe
<a name="ifelse-function-syntax"></a>

```
ifelse(if-expression-1, then-expression-1 [, if-expression-n, then-expression-n ...], else-expression)
```

## Argumentos
<a name="ifelse-function-arguments"></a>

`ifelse` requer um ou mais pares de expressão *if*, *then* e exige exatamente uma expressão para o argumento *else*. 

 *if-expression*   
A expressão a ser avaliada como verdadeira ou não. Pode ser um nome de campo, como **address1**, um valor literal, como **'Unknown'**, ou outra função, como `toString(salesAmount)`. Um exemplo é `isNotNull(FieldName)`.   
Se você usar vários operadores AND e OR no argumento `if`, coloque parênteses nas instruções para identificar a ordem de processamento. Por exemplo, o argumento `if` a seguir retorna registros com um mês de 1, 2 ou 5 e um ano de 2000.  

```
ifelse((month = 5 OR month < 3) AND year = 2000, 'yes', 'no')
```
O próximo argumento `if` usa os mesmos operadores, mas retorna registros com um mês de 5 e qualquer ano, ou com um mês de 1 ou 2 e um ano de 2000.  

```
ifelse(month = 5 OR (month < 3 AND year = 2000), 'yes', 'no')
```

 *then-expression*   
A expressão a ser retornada se o respectivo argumento *if* for avaliado como verdadeiro. Pode ser um nome de campo, como **address1**, um valor literal, como **'Unknown'**, ou uma chamada para outra função. A expressão deve ter o mesmo tipo de dados que os outros argumentos `then` e o argumento `else`. 

 *else-expression*   
A expressão a ser retornada se nenhum dos argumentos *if* for avaliado como verdadeiro. Pode ser um nome de campo, como **address1**, um valor literal, como **'Unknown'**, ou outra função, como `toString(salesAmount)`. A expressão deve ter o mesmo tipo de dados que todos os argumentos `then`. 

## Tipo de retorno
<a name="ifelse-function-return-type"></a>

`ifelse` retorna um valor do mesmo tipo de dados que os valores em *then-expression*. Todos os dados que retornam as expressões *then* e *else* devem ser do mesmo tipo de dados ou ser convertidos no mesmo tipo de dados. 

## Exemplos
<a name="ifelse-function-example"></a>

O exemplo a seguir gera uma coluna de aliases para o campo `country`.

```
ifelse(country = "United States", "US", country = "China", "CN", country = "India", "IN", "Others") 
```

Para esses casos de uso, avaliar cada valor em um campo em relação a uma lista de literais e retornar o resultado correspondente ao primeiro valor compatível, a troca de função é recomendada para simplificar seu trabalho. O exemplo anterior pode ser reescrito para a seguinte declaração usando [https://docs.aws.amazon.com/quicksight/latest/user/switch-function.html](https://docs.aws.amazon.com/quicksight/latest/user/switch-function.html):

```
switch(country,"United States","US","China","CN","India","IN","Others")
```

O exemplo a seguir categoriza as vendas por cliente em níveis legíveis para humanos.

```
ifelse(salesPerCustomer < 1000, “VERY_LOW”, salesPerCustomer < 10000, “LOW”, salesPerCustomer < 100000, “MEDIUM”, “HIGH”)
```

O exemplo a seguir usa E, OU e NÃO para comparar várias expressões usando operadores condicionais para marcar os principais clientes que NÃO são de Washington ou Oregon com uma promoção especial, e que fizeram mais de 10 pedidos. Se nenhum valor for retornado, o valor `'n/a'` será usado.

```
ifelse(( (NOT (State = 'WA' OR State =  'OR')) AND Orders > 10),  'Special Promotion XYZ',  'n/a')
```

Os exemplos a seguir usam somente OR para gerar uma nova coluna que contém o nome do continente que corresponde a cada `country`.

```
ifelse(country = "United States" OR country = "Canada", "North America", country = "China" OR country = "India" OR country = "Japan", "Asia", "Others")
```

O exemplo anterior pode ser simplificado conforme mostrado no próximo exemplo. O exemplo a seguir usa `ifelse` e [https://docs.aws.amazon.com/quicksight/latest/user/in-function.html](https://docs.aws.amazon.com/quicksight/latest/user/in-function.html) para criar um valor em uma nova coluna para qualquer linha em que o valor testado esteja em uma lista literal. Você também pode usar `ifelse` com [https://docs.aws.amazon.com/quicksight/latest/user/notIn-function.html](https://docs.aws.amazon.com/quicksight/latest/user/notIn-function.html).

```
ifelse(in(country,["United States", "Canada"]), "North America", in(country,["China","Japan","India"]),"Asia","Others")
```

Os autores podem salvar uma lista literal em um parâmetro de vários valores e usá-la nas funções [https://docs.aws.amazon.com/quicksight/latest/user/in-function.html](https://docs.aws.amazon.com/quicksight/latest/user/in-function.html) ou [https://docs.aws.amazon.com/quicksight/latest/user/notIn-function.html](https://docs.aws.amazon.com/quicksight/latest/user/notIn-function.html). O exemplo a seguir é equivalente ao exemplo anterior, exceto que as listas literais são armazenadas em dois parâmetros de vários valores. 

```
ifelse(in(country,${NorthAmericaCountryParam}), "North America", in(country,${AsiaCountryParam}),"Asia", "Others") 
```

O exemplo a seguir atribui um grupo a um registro de vendas com base no total de vendas. A estrutura de cada frase `if-then` imita o comportamento de *between*, uma palavra-chave que atualmente não funciona em expressões de campo calculado. Por exemplo, o resultado da comparação `salesTotal >= 0 AND salesTotal < 500` retorna os mesmos valores da comparação `salesTotal between 0 and 499` do SQL.

```
ifelse(salesTotal >= 0 AND salesTotal < 500, 'Group 1', salesTotal >= 500 AND salesTotal < 1000, 'Group 2', 'Group 3')
```

O exemplo a seguir testa um valor NULL usando `coalesce` para retornar o primeiro valor que não é NULL. Em vez de precisar lembrar o significado de um NULL em um campo de data, você pode usar uma descrição legível. Se a data de desconexão for NULL, o exemplo retornará a data de suspensão, a menos que ambas sejam NULL. Em seguida, `coalesce(DiscoDate, SuspendDate, '12/31/2491')` retorna `'12/31/2491'`. O valor de retorno deve corresponder aos outros tipos de dados. Essa data pode parecer um valor incomum, mas uma data no século XXV simula razoavelmente o “fim dos tempos”, definido como a data mais alta em um data mart. 

```
ifelse (  (coalesce(DiscoDate, SuspendDate, '12/31/2491') = '12/31/2491'),  'Active subscriber', 'Inactive subscriber')
```

A seguir, você verá um exemplo mais complexo em um formato mais legível, apenas para mostrar que você não precisa compactar todo o código em uma linha longa. Este exemplo fornece várias comparações do valor resultante de uma pesquisa. Ele lida com possíveis valores NULL para esse campo e categoriza dois intervalos aceitáveis. Além disso, rotula um intervalo que precisa de mais testes e outro que não é válido (fora do intervalo). Para todos os valores restantes, ele aplica a condição `else` e rotula a linha como precisando de um novo teste três anos após a data dessa linha. 

```
ifelse
( 
    isNull({SurveyResult}), 'Untested',  
    {SurveyResult}=1, 'Range 1', 
    {SurveyResult}=2, 'Range 2', 
    {SurveyResult}=3, 'Need more testing',
    {SurveyResult}=99, 'Out of Range',
    concat  
    (
        'Retest by ', 
        toString    
        (
           addDateTime(3, "YYYY", {Date}) 
        )
    )
)
```

O exemplo a seguir atribui um nome de região criado “manualmente” a um grupo de estados. Ele também usa espaçamento e comentários, agrupados em `/* */`, para facilitar a manutenção do código. 

```
ifelse 
(    /* NE REGION*/
     locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) > 0,
    'Northeast',

     /* SE REGION*/
     locate('Georgia, Alabama, South Carolina, Louisiana',{State}) > 0,
    'Southeast',

    'Other Region'
)
```

A lógica da marcação de regiões é dividida da seguinte forma:

1. Listamos os estados que queremos para cada região, colocando cada lista entre aspas para transformar cada lista em uma string, da seguinte forma: 
   + `'New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire'`
   + `'Georgia, Alabama, South Carolina, Louisiana'`
   + Você pode adicionar mais conjuntos ou usar países, cidades, províncias ou What3Words, se quiser. 

1. Perguntamos se o valor de `State` (para cada linha) é encontrado na lista, usando a função `locate` para retornar um valor diferente de zero se o estado for encontrado na lista, como mostrado a seguir.

   ```
   locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) 
   
   and
   
   locate('Georgia, Alabama, South Carolina, Louisiana',{State})
   ```

1. A função `locate` retorna um número em vez de um `TRUE` ou `FALSE`, mas `ifelse` requer o valor booleano `TRUE` e `FALSE`. Para contornar isso, podemos comparar o resultado de `locate` com um número. Se o estado estiver na lista, o valor de retorno será maior que zero.

   1. Pergunte se o estado está presente.

      ```
      locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) > 0
      ```

   1. Se a região estiver presente, rotule-a como a região específica, neste caso, uma região Nordeste.

      ```
      /*The if expression:*/     locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) > 0,
      /*The then expression:*/   'Northeast',
      ```

1. Como temos estados que não estão em uma lista e porque `ifelse` exige uma única expressão `else`, fornecemos `'Other Region'` como o rótulo para os estados restantes. 

   ```
   /*The if expression:*/     locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) > 0,
   /*The then expression:*/   'Northeast',
   /*The else expression:*/   'Other Region'
   ```

1. Agrupamos tudo isso na função `ifelse( )` para obter a versão final. O exemplo a seguir omite os estados da região Sudeste que estavam no original. Você pode adicioná-los novamente no lugar da tag *`<insert more regions here>`*. 

   Se quiser adicionar mais regiões, você pode criar mais cópias dessas duas linhas e alterar a lista de estados de acordo com sua finalidade. Você pode alterar o nome da região para algo que lhe agrade e mudar o nome do campo de `State` para qualquer coisa que precisar. 

   ```
   ifelse 
   (
   /*The if expression:*/     locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) > 0,
   /*The then expression:*/   'Northeast',
   
   /*<insert more regions here>*/
   
   /*The else expression:*/   'Other Region'
   )
   ```
**nota**  
Há outras maneiras de fazer a comparação inicial para a expressão IF. Por exemplo, suponha que você faça a pergunta “Quais estados não estão faltando nessa lista?” em vez de “Quais estados estão na lista?” Se você fizer isso, talvez expresse de forma diferente. Você pode comparar a instrução LOCATE com zero para encontrar valores que estão ausentes na lista e, em seguida, usar o operador NOT para classificá-los como “não ausentes”, como mostrado a seguir.  

   ```
   /*The if expression:*/      NOT (locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) = 0),
   ```
Ambas as versões estão corretas. A versão escolhida deve fazer mais sentido para você e sua equipe, para que consiga mantê-la facilmente. Se todas as opções parecerem iguais, escolha a mais simples.

# in
<a name="in-function"></a>

`in` avalia se existe uma expressão em uma lista literal. Se a lista contiver a expressão, in retornará true, caso contrário, retornará false. `in` diferencia maiúsculas de minúsculas em entradas do tipo string.

`in` aceita dois tipos de lista literal, uma é a lista inserida manualmente e a outra é um [parâmetro de vários valores](https://docs.aws.amazon.com/quicksight/latest/user/parameters-in-quicksight.html).

## Sintaxe
<a name="in-function-syntax"></a>

Usando uma lista inserida manualmente:

```
in(expression, [literal-1, ...])  
```

Usando um parâmetro de vários valores:

```
in(expression, $multivalue_parameter)
```

## Argumentos
<a name="in-function-arguments"></a>

 *expressão*   
A expressão a ser comparada com os elementos na lista literal. Pode ser um nome de campo, como `address`, um valor literal, como '**Unknown**', um parâmetro de valor único ou uma chamada para outra função escalar, desde que essa função não seja uma função agregada ou um cálculo de tabela.

 *lista literal*   
(obrigatório) Isso pode ser uma lista inserida manualmente ou um parâmetro de vários valores. Esse argumento aceita até cinco mil elementos. No entanto, em uma consulta direta a uma fonte de dados de terceiros, por exemplo, Oracle ou Teradata, a restrição pode ser menor.  
+ ***Lista inserida manualmente***: um ou mais valores literais em uma lista a serem comparados com a expressão. A lista deve estar entre colchetes. Todos os literais a serem comparados devem ter o mesmo tipo de dados da expressão. 
+ ***Parâmetro de vários valores***: um parâmetro de vários valores predefinido transmitido como uma lista literal. O parâmetro de vários valores deve ter o mesmo tipo de dados da expressão. 


## Tipo de retorno
<a name="in-function-return-type"></a>

Booleano: TRUE ou FALSE

## Exemplo com uma lista estática
<a name="in-function-example-static-list"></a>

O exemplo a seguir avalia o campo `origin_state_name` para valores em uma lista de string. Ao comparar a entrada do tipo de string, `in` aceita apenas a comparação com distinção entre maiúsculas e minúsculas.

```
in(origin_state_name,["Georgia", "Ohio", "Texas"])
```

A seguir estão os valores de campo especificados.

```
"Washington"
        "ohio"
        "Texas"
```

Para esses valores de campo, os valores a seguir são retornados.

```
false
        false
        true
```

O terceiro valor de retorno é verdadeiro porque somente “Texas” é um dos valores incluídos.

O exemplo a seguir avalia o campo `fl_date` para valores em uma lista de string. Para corresponder ao tipo, `toString` é usado para converter o tipo de data ao tipo de string.

```
in(toString(fl_date),["2015-05-14","2015-05-15","2015-05-16"])
```

![\[Uma imagem dos resultados do exemplo de função, mostrada em forma de tabela.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/in-function-example-manual-list.png)


Os valores literais e NULL são compatíveis com o argumento da expressão para serem comparados com os literais na lista. Os dois exemplos a seguir gerarão uma nova coluna de valores true. 

```
in("Washington",["Washington","Ohio"])
```

```
in(NULL,[NULL,"Ohio"])
```

## Exemplo com parâmetro de vários valores
<a name="in-function-example-mutivalue-parameter"></a>

Digamos que um autor crie um [parâmetro de vários valores](https://docs.aws.amazon.com/quicksight/latest/user/parameters-in-quicksight.html) que contenha uma lista de todos os nomes dos estados. Em seguida, o autor adiciona um controle para permitir que o leitor selecione valores da lista.

Depois, o leitor seleciona três valores, “Georgia”, “Ohio” e “Texas”, no controle da lista suspensa do parâmetro. Nesse caso, a expressão a seguir é equivalente ao primeiro exemplo, em que esses três nomes de estado são passados como a lista literal a ser comparada com o campo `original_state_name`. 

```
in (origin_state_name, ${stateName MultivalueParameter})
```

## Exemplo com `ifelse`
<a name="in-function-example-with-ifelse"></a>

`in` pode ser aninhado em outras funções como um valor booleano. Um exemplo é que os autores podem avaliar qualquer expressão em uma lista e retornar o valor desejado usando `in` e `ifelse`. O exemplo a seguir avalia se o `dest_state_name` de um voo está em uma lista específica de estados dos EUA e retorna diferentes categorias dos estados com base na comparação.

```
ifelse(in(dest_state_name,["Washington", "Oregon","California"]), "WestCoastUSState", "Other US State")
```

![\[Uma imagem dos resultados do exemplo de função, mostrada em forma de tabela.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/in-function-with-ifelse.png)


# intToDecimal
<a name="intToDecimal-function"></a>

`intToDecimal` converte um valor inteiro no tipo de dados decimal.

## Sintaxe
<a name="intToDecimal-function-syntax"></a>

```
intToDecimal(integer)
```

## Argumentos
<a name="intToDecimal-function-arguments"></a>

 *int*   
Um campo que usa o tipo de dados integer, um valor literal, como **14**, ou uma chamada para outra função que gera um inteiro.

## Tipo de retorno
<a name="intToDecimal-function-return-type"></a>

Decimal (fixo) na experiência antiga de preparação de dados.

Decimal (Float) na nova experiência de preparação de dados.

## Exemplo
<a name="intToDecimal-function-example"></a>

O exemplo a seguir converte um campo inteiro em um decimal.

```
intToDecimal(price)
```

A seguir estão os valores de campo especificados.

```
20
892
57
```

Para esses valores de campo, os seguintes valores são retornados.

```
20.0
892.0
58.0
```

Você pode aplicar a formatação dentro de uma análise, por exemplo, para formatar `price` como moeda. 

# isNotNull
<a name="isNotNull-function"></a>

`isNotNull` avalia uma expressão para ver se não é nula. Se a expressão não for nula, `isNotNull` retornará verdadeiro; do contrário, retornará falso.

## Sintaxe
<a name="isNotNull-function-syntax"></a>

```
isNotNull(expression)
```

## Argumentos
<a name="isNotNull-function-arguments"></a>

 *expressão*   
A expressão a ser avaliada como nula ou não. Pode ser um nome de campo, como **address1**, ou uma chamada para outra função que gera uma string. 

## Tipo de retorno
<a name="isNotNull-function-return-type"></a>

Booleano

## Exemplo
<a name="isNotNull-function-example"></a>

O exemplo a seguir avalia o campo sales\$1amount quanto a valores nulos.

```
isNotNull(salesAmount)
```

A seguir estão os valores de campo especificados.

```
20.13
(null)
57.54
```

Para esses valores de campo, os seguintes valores são retornados.

```
true
false
true
```

# isNull
<a name="isNull-function"></a>

`isNull` avalia uma expressão para ver se é nula. Se a expressão for nula, `isNull` retornará verdadeiro; do contrário, retornará falso.

## Sintaxe
<a name="isNull-function-syntax"></a>

```
isNull(expression)
```

## Argumentos
<a name="isNull-function-arguments"></a>

 *expressão*   
A expressão a ser avaliada como nula ou não. Pode ser um nome de campo, como **address1**, ou uma chamada para outra função que gera uma string. 

## Tipo de retorno
<a name="isNull-function-return-type"></a>

Booleano

## Exemplo
<a name="isNull-function-example"></a>

O exemplo a seguir avalia o campo sales\$1amount quanto a valores nulos.

```
isNull(salesAmount)
```

A seguir estão os valores de campo especificados.

```
20.13
(null)
57.54
```

Para esses valores de campo, os seguintes valores são retornados.

```
false
true
false
```

O exemplo a seguir testa um valor NULL em uma instrução `ifelse` e, em vez disso, retorna um valor legível para humanos.

```
ifelse( isNull({ActiveFlag}) , 'Inactive',  'Active') 
```

# isWorkDay
<a name="isWorkDay-function"></a>

`isWorkDay` avalia um determinado valor de data e hora para determinar se é um dia útil ou não.

`isWorkDay` pressupõe uma semana de trabalho padrão de cinco dias, começando na segunda-feira e terminando na sexta-feira. Presume-se que sábado e domingo sejam fins de semana. A função sempre calcula seu resultado na granularidade de `DAY` e exclui a data de entrada fornecida.

## Sintaxe
<a name="isWorkDay-function-syntax"></a>

```
isWorkDay(inputDate)
```

## Argumentos
<a name="isWorkDay-function-arguments"></a>

 *inputDate*   
O valor de data e hora que você deseja avaliar. Os valores válidos são os seguintes:  
+ Campos do conjunto de dados: qualquer campo de `date` do conjunto de dados ao qual você está adicionando essa função.
+ Funções de data: qualquer saída de data de outra função `date`, por exemplo, `parseDate`.
+ Campos calculados: qualquer campo calculado rapidamente que retorne um `date` valor.
+ Parâmetros: Qualquer `DateTime` parâmetro rápido.

## Tipo de retorno
<a name="isWorkDay-function-return-type"></a>

Número inteiro (`0` ou `1`)

## Exemplo
<a name="isWorkDay-function-example"></a>

O exemplo a seguir determina se o campo `application_date` é ou não um dia útil.

Vamos supor que haja um campo chamado `application_date` com os seguintes valores:

```
2022-08-10 
2022-08-06 
2022-08-07
```

Quando você usa esses campos e adiciona os seguintes cálculos, `isWorkDay` retorna os valores abaixo:

```
isWorkDay({application_date})     
                                                     
1
0
0
```

O exemplo abaixo filtra funcionários cujo trabalho termina em um dia útil e determina se o trabalho começou no dia útil ou no fim de semana, usando formatação condicional:

```
is_start_date_work_day = isWorkDay(employment_start_date)
is_end_date_work_day = isWorkDay(employment_end_date)
```

![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/isWorkDay-example.png)


# Left
<a name="left-function"></a>

`left` retorna os caracteres mais à esquerda de uma sequência de caracteres, incluindo espaços. Você especifica o número de caracteres a ser retornado. 

## Sintaxe
<a name="left-function-syntax"></a>

```
left(expression, limit)
```

## Argumentos
<a name="left-function-arguments"></a>

 *expressão*   
A expressão deve ser uma string. Isso pode ser o nome de um campo que usa o tipo de dados de string, um valor literal, como **'12 Main Street'**, ou uma chamada para outra função que gere uma string.

 *limit*   
O número de caracteres a ser retornado da *expressão*, a partir do primeiro caractere na string.

## Tipo de retorno
<a name="left-function-return-type"></a>

String

## Exemplo
<a name="left-function-example"></a>

O exemplo a seguir retorna os três primeiros caracteres de uma string.

```
left('Seattle Store #14', 3)
```

O valor a seguir é retornado.

```
Sea
```

# Locate
<a name="locate-function"></a>

`locate` localiza uma substring que você especifica dentro de outra string e retorna o número de caracteres até o primeiro caractere na substring. A função retorna 0 se não encontrar a substring. A função é baseada em 1.

## Sintaxe
<a name="locate-function-syntax"></a>

```
locate(expression, substring, start)
```

## Argumentos
<a name="locate-function-arguments"></a>

 *expressão*   
A expressão deve ser uma string. Isso pode ser o nome de um campo que usa o tipo de dados de string, um valor literal, como **'12 Main Street'**, ou uma chamada para outra função que gere uma string.

 *substring*   
O conjunto de caracteres na *expressão* que você deseja localizar. A substring pode ocorrer uma ou mais vezes na *expressão*.

 *start*   
(Opcional) Se a *substring* ocorrer mais de uma vez, use *start* para identificar onde na string a função deve começar a procurar pela substring. Por exemplo, suponha que você deseja encontrar o segundo exemplo de uma sub-sequência de caracteres e acha que ele ocorre normalmente após os primeiros 10 caracteres. Especifique um valor *inicial* de 10. Deve começar a partir de 1.

## Tipo de retorno
<a name="locate-function-return-type"></a>

Inteiro

## Exemplos
<a name="locate-function-example"></a>

O exemplo a seguir retorna informações sobre onde a primeira ocorrência da substring 'and' aparece na string.

```
locate('1 and 2 and 3 and 4', 'and')
```

O valor a seguir é retornado.

```
3
```

O exemplo a seguir retorna informações sobre onde a primeira ocorrência da substring 'and' aparece na string após o quarto caractere.

```
locate('1 and 2 and 3 and 4', 'and', 4)
```

O valor a seguir é retornado.

```
9
```

# Log
<a name="log-function"></a>

O `log` retorna o logaritmo de base 10 de uma determinada expressão.

## Sintaxe
<a name="log-function-syntax"></a>

```
log(expression)
```

## Argumentos
<a name="log-function-arguments"></a>

 *expressão*   
A expressão deve ser numérica. Pode ser um nome de campo, um valor literal ou outra função. 

# Ln
<a name="ln-function"></a>

O `ln` retorna o logaritmo natural de uma determinada expressão. 

## Sintaxe
<a name="ln-function-syntax"></a>

```
ln(expression)
```

## Argumentos
<a name="ln-function-arguments"></a>

 *expressão*   
A expressão deve ser numérica. Pode ser um nome de campo, um valor literal ou outra função. 

# Ltrim
<a name="ltrim-function"></a>

`ltrim` remove o espaço em branco anterior de uma string.

## Sintaxe
<a name="ltrim-function-syntax"></a>

```
ltrim(expression)
```

## Argumentos
<a name="ltrim-function-arguments"></a>

 *expressão*   
A expressão deve ser uma string. Isso pode ser o nome de um campo que usa o tipo de dados de string, um valor literal, como **'12 Main Street'**, ou uma chamada para outra função que gere uma string.

## Tipo de retorno
<a name="ltrim-function-return-type"></a>

String

## Exemplo
<a name="ltrim-function-example"></a>

O exemplo a seguir remove os espaços precedentes de uma string.

```
ltrim('   Seattle Store #14')
```

O valor a seguir é retornado.

```
Seattle Store #14
```

# Mod
<a name="mod-function"></a>

Use a função `mod` para encontrar o restante depois de dividir o número pelo divisor. Você pode usar a função `mod` ou o operador módulo (%) de forma intercambiável.

## Sintaxe
<a name="mod-function-syntax"></a>

```
mod(number, divisor)
```

```
number%divisor
```

## Argumentos
<a name="mod-function-arguments"></a>

 *número*   
O número é o inteiro positivo que você deseja dividir e para o qual quer encontrar o restante. 

 *divisor*   
O divisor é o inteiro positivo pelo qual você está dividindo. Se o divisor for zero, a função retornará um erro ao dividir por 0.

## Exemplo
<a name="mod-function-example"></a>

Os exemplos a seguir retornam o módulo de 17 ao dividir por 6. O primeiro exemplo usa o operador %, e o segundo exemplo, a função mod.

```
17%6
```

```
mod( 17, 6 )
```

O valor a seguir é retornado.

```
5
```

# netWorkDays
<a name="netWorkDays-function"></a>

`netWorkDays`retorna o número de dias úteis entre os dois campos de data fornecidos ou até mesmo valores de data personalizados gerados usando outras funções de data rápida, como `parseDate` ou `epochDate` como um número inteiro. 

`netWorkDays` pressupõe uma semana de trabalho padrão de cinco dias, começando na segunda-feira e terminando na sexta-feira. Presume-se que sábado e domingo sejam fins de semana. O cálculo inclui tanto `startDate` quanto `endDate`. A função utiliza e mostra os resultados da granularidade DAY. 

## Sintaxe
<a name="netWorkDays-function-syntax"></a>

```
netWorkDays(startDate, endDate)
```

## Argumentos
<a name="netWorkDays-function-arguments"></a>

 *startDate*   
Uma data válida não nula que atua como a data de início do cálculo.   
+ Campos do conjunto de dados: qualquer campo de `date` do conjunto de dados ao qual você está adicionando essa função.
+ Funções de data: qualquer saída de data de outra função `date`, por exemplo, `parseDate`.
+ Campos calculados: qualquer campo calculado rapidamente que retorne um `date` valor.
+ Parâmetros: Qualquer `DateTime` parâmetro rápido.
+ Qualquer combinação dos valores dos argumentos acima indicados.

 *endDate*   
Uma data válida não NULL que atua como a data final do cálculo.   
+ Campos do conjunto de dados: qualquer campo de `date` do conjunto de dados ao qual você está adicionando essa função.
+ Funções de data: qualquer saída de data de outra função `date`, por exemplo, `parseDate`.
+ Campos calculados: qualquer campo calculado rapidamente que retorne um `date` valor.
+ Parâmetros: Qualquer `DateTime` parâmetro rápido.
+ Qualquer combinação dos valores dos argumentos acima indicados.

## Tipo de retorno
<a name="netWorkDays-function-return-type"></a>

Inteiro 

## Valores de saída
<a name="netWorkDays-function-output-type"></a>

Os valores de saída esperados incluem os seguintes:
+ número inteiro positivo (quando start\$1date < end\$1date);
+ número inteiro negativo (quando start\$1date > end\$1date);
+ NULL, quando um ou ambos os argumentos obtêm um valor nulo do `dataset field`.

## Exemplo
<a name="netWorkDays-function-example"></a>

O exemplo a seguir retorna o número de dias úteis entre duas datas.

Vamos supor que haja um campo chamado `application_date` com os seguintes valores:

```
netWorkDays({startDate}, {endDate})
```

A seguir estão os valores de campo especificados.

```
startDate	endDate	netWorkDays
        9/4/2022	9/11/2022	5
        9/9/2022	9/2/2022	-6
        9/10/2022	9/11/2022	0
        9/12/2022	9/12/2022	1
```

O exemplo abaixo calcula o número de dias trabalhados por cada funcionário e o salário gasto por dia para cada um:

```
days_worked = netWorkDays({employment_start_date}, {employment_end_date})
        salary_per_day = {salary}/{days_worked}
```

O exemplo abaixo filtra funcionários cujo trabalho termina em um dia útil e determina se o trabalho começou no dia útil ou no fim de semana, usando formatação condicional:

```
is_start_date_work_day = netWorkDays(employment_start_date)
        is_end_date_work_day = netWorkDays(employment_end_date)
```

![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/netWorkDays-function-example.png)


# Now
<a name="now-function"></a>

Para conjuntos de dados de banco de dados que consultam diretamente o banco de dados, `now` retorna a data e hora atuais usando as configurações e o formato especificados pelo servidor do banco de dados. Para conjuntos de dados do SPICE e do Salesforce, `now` retorna a data e a hora em UTC no formato `yyyy-MM-ddTkk:mm:ss:SSSZ` (por exemplo, 2015-10-15T19:11:51:003Z). 

## Sintaxe
<a name="now-function-syntax"></a>

```
now()
```

## Tipo de retorno
<a name="now-function-return-type"></a>

Data

# notIn
<a name="notIn-function"></a>

`notIn` avalia se existe uma expressão em uma lista literal. Se a lista não contiver a expressão, `notIn` retornará true, caso contrário, retornará false. `notIn` diferencia maiúsculas de minúsculas para entradas do tipo string.

`notIn` aceita dois tipos de lista literal, uma é a lista inserida manualmente e a outra é um [parâmetro de vários valores](https://docs.aws.amazon.com/quicksight/latest/user/parameters-in-quicksight.html).

## Sintaxe
<a name="notIn-function-syntax"></a>

Usando uma lista inserida manualmente:

```
notIn(expression, [literal-1, ...])  
```

Usando um parâmetro de vários valores:

```
notIn(expression, $multivalue_parameter)
```

## Argumentos
<a name="notIn-function-arguments"></a>

 *expressão*   
A expressão a ser comparada com os elementos na lista literal. Pode ser um nome de campo, como `address`, um valor literal, como '**Unknown**', um parâmetro de valor único ou uma chamada para outra função escalar, desde que essa função não seja uma função agregada ou um cálculo de tabela.

 *lista literal*   
(obrigatório) Isso pode ser uma lista inserida manualmente ou um parâmetro de vários valores. Esse argumento aceita até cinco mil elementos. No entanto, em uma consulta direta a uma fonte de dados de terceiros, por exemplo, Oracle ou Teradata, a restrição pode ser menor.  
+ ***Lista inserida manualmente***: um ou mais valores literais em uma lista a serem comparados com a expressão. A lista deve estar entre colchetes. Todos os literais a serem comparados devem ter o mesmo tipo de dados da expressão. 
+ ***Parâmetro de vários valores***: um parâmetro de vários valores predefinido transmitido como uma lista literal. O parâmetro de vários valores deve ter o mesmo tipo de dados da expressão. 


## Tipo de retorno
<a name="notIn-function-return-type"></a>

Booleano: TRUE ou FALSE

## Exemplo com uma lista inserida manualmente
<a name="notIn-function-example-manual-list"></a>

O exemplo a seguir avalia o campo `origin_state_name` para valores em uma lista de string. Ao comparar a entrada do tipo de string, `notIn` aceita apenas a comparação com distinção entre maiúsculas e minúsculas.

```
notIn(origin_state_name,["Georgia", "Ohio", "Texas"])
```

A seguir estão os valores de campo especificados.

```
"Washington"
        "ohio"
        "Texas"
```

Para esses valores de campo, os valores a seguir são retornados.

```
true
        true
        false
```

O terceiro valor de retorno é falso porque somente “Texas” é um dos valores excluídos.

O exemplo a seguir avalia o campo `fl_date` para valores em uma lista de string. Para corresponder ao tipo, `toString` é usado para converter o tipo de data ao tipo de string.

```
notIn(toString(fl_date),["2015-05-14","2015-05-15","2015-05-16"])
```

![\[Uma imagem dos resultados do exemplo de função, mostrada em forma de tabela.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/notin-function-example-manual-list.png)


Os valores literais e NULL são compatíveis com o argumento da expressão para serem comparados com os literais na lista. Os dois exemplos a seguir gerarão uma nova coluna de valores FALSE. 

```
notIn("Washington",["Washington","Ohio"])
```

```
notIn(NULL,[NULL,"Ohio"])
```

## Exemplo com parâmetro de vários valores
<a name="notIn-function-example-mutivalue-parameter"></a>

Digamos que um autor crie um [parâmetro de vários valores](https://docs.aws.amazon.com/quicksight/latest/user/parameters-in-quicksight.html) que contenha uma lista de todos os nomes dos estados. Em seguida, o autor adiciona um controle para permitir que o leitor selecione valores da lista.

Depois, o leitor seleciona três valores, “Georgia”, “Ohio” e “Texas”, no controle da lista suspensa do parâmetro. Nesse caso, a expressão a seguir é equivalente ao primeiro exemplo, em que esses três nomes de estado são passados como a lista literal a ser comparada com o campo `original_state_name`. 

```
notIn (origin_state_name, ${stateName MultivalueParameter})
```

## Exemplo com `ifelse`
<a name="notIn-function-example-with-ifelse"></a>

`notIn` pode ser aninhado em outras funções como um valor booleano. Um exemplo é que os autores podem avaliar qualquer expressão em uma lista e retornar o valor desejado usando `notIn` e `ifelse`. O exemplo a seguir avalia se o `dest_state_name` de um voo está em uma lista específica de estados dos EUA e retorna diferentes categorias dos estados com base na comparação.

```
ifelse(notIn(dest_state_name,["Washington", "Oregon","California"]), "notWestCoastUSState", "WestCoastUSState")
```

![\[Uma imagem dos resultados do exemplo de função, mostrada em forma de tabela.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/notin-function-with-ifelse.png)


# nullIf
<a name="nullIf-function"></a>

`nullIf` compara duas expressões. Se elas forem iguais, a função retornará nula. Se eles não forem iguais, a função retornará a primeira expressão.

## Sintaxe
<a name="nullIf-function-syntax"></a>

```
nullIf(expression1, expression2)
```

## Argumentos
<a name="nullIf-function-arguments"></a>

`nullIf` leva duas expressões como argumentos. 

 *expressão*   
A expressão pode ser numérica, data e hora ou string. Pode ser um nome de campo, um valor literal ou outra função. 

## Tipo de retorno
<a name="nullIf-function-return-type"></a>

String

## Exemplo
<a name="nullIf-function-example"></a>

O exemplo a seguir retornará nulo se o motivo para o atraso na entrega for desconhecido.

```
nullIf(delayReason, 'unknown')
```

A seguir estão os valores de campo especificados.

```
delayReason
============
unknown         
back ordered 
weather delay
```

Para esses valores de campo, os seguintes valores são retornados.

```
(null)
back ordered 
weather delay
```

# parseDate
<a name="parseDate-function"></a>

`parseDate`analisa uma string para determinar se ela contém um valor de data e retorna uma data padrão no formato `yyyy-MM-ddTkk:mm:ss.SSSZ` (usando a sintaxe do padrão de formato especificada em [Class DateTimeFormat](http://www.joda.org/joda-time/apidocs/org/joda/time/format/DateTimeFormat.html) na documentação do projeto Joda), por exemplo, 2015-10-15T 19:11:51.003 Z. Essa função retorna todas as linhas que contêm uma data em um formato válido e ignora as linhas que não contêm, inclusive linhas que contêm valores nulos.

O Quick oferece suporte a datas no intervalo de 1º de janeiro de 1900 às 00:00:00 UTC a 31 de dezembro de 2037 às 23:59:59 UTC. Para obter mais informações, consulte [Formatos de data compatíveis](https://docs.aws.amazon.com/quicksight/latest/user/supported-date-formats.html).

## Sintaxe
<a name="parseDate-function-syntax"></a>

```
parseDate(expression, ['format'])
```

## Argumentos
<a name="parseDate-function-arguments"></a>

 *expressão*   
A expressão deve ser uma string. Isso pode ser o nome de um campo que usa o tipo de dados de string, um valor literal, como **'1/1/2016'**, ou uma chamada para outra função que gere uma string.

 *format*   
(Opcional) Uma string contendo o formato padrão com o qual *date\$1string* deve corresponder. Por exemplo, se você estiver usando um campo com dados como**01/03/2016**, você especifica o formato 'MM/dd/yyyy'. Se você não especificar um formato, o padrão será `yyyy-MM-dd`. Linhas cujos dados não estejam de acordo com o *formato* serão ignoradas.   
Diferentes formatos de data são compatíveis com base no tipo de conjunto de dados usado. Use a tabela a seguir para ver os detalhes dos formatos de data suportados.    
****    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/parseDate-function.html)

## Tipo de retorno
<a name="parseDate-function-return-type"></a>

Data

## Exemplo
<a name="parseDate-function-example"></a>

O exemplo a seguir avalia `prodDate` para determinar se ele contém valores de data.

```
parseDate(prodDate, 'MM/dd/yyyy')
```

A seguir estão os valores de campo especificados.

```
prodDate
--------
01-01-1999
12/31/2006
1/18/1982 
7/4/2010
```

Para esses valores de campo, as seguintes linhas são retornadas.

```
12-31-2006T00:00:00.000Z
01-18-1982T00:00:00.000Z
07-04-2010T00:00:00.000Z
```

# parseDecimal
<a name="parseDecimal-function"></a>

`parseDecimal` analisa uma string para determinar se ela contém um valor decimal. Essa função retorna todas as linhas que contêm um valor decimal, inteiro ou nulo e ignora as linhas que não têm. Se a linha contiver um valor inteiro, ela será retornada como decimal com até quatro espaços decimais. Por exemplo, um valor de '2' é retornado como '2.0'.

## Sintaxe
<a name="parseDecimal-function-syntax"></a>

```
parseDecimal(expression)
```

## Argumentos
<a name="parseDecimal-function-arguments"></a>

 *expressão*   
A expressão deve ser uma string. Isso pode ser o nome de um campo que usa o tipo de dados de string, um valor literal, como **'9.62'**, ou uma chamada para outra função que gere uma string.

## Tipo de retorno
<a name="parseDecimal-function-return-type"></a>

Decimal (fixo) na experiência antiga de preparação de dados.

Decimal (Float) na nova experiência de preparação de dados.

## Exemplo
<a name="parseDecimal-function-example"></a>

O exemplo a seguir avalia `fee` para determinar se ele contém valores decimais.

```
parseDecimal(fee)
```

A seguir estão os valores de campo especificados.

```
fee
--------
2
2a
12.13
3b
3.9
(null)
198.353398
```

Para esses valores de campo, as seguintes linhas são retornadas.

```
2.0
12.13
3.9
(null)
198.3533
```

# parseInt
<a name="parseInt-function"></a>

`parseInt` analisa uma string para determinar se ela contém um valor inteiro. Essa função retorna todas as linhas que contêm um valor decimal, inteiro ou nulo e ignora as linhas que não têm. Se a linha contiver um valor decimal, ele será retornado como o inteiro mais próximo, arredondado para baixo. Por exemplo, um valor de '2.99' é retornado como '2'.

## Sintaxe
<a name="parseInt-function-syntax"></a>

```
parseInt(expression)
```

## Argumentos
<a name="parseInt-function-arguments"></a>

 *expressão*   
A expressão deve ser uma string. Isso pode ser o nome de um campo que usa o tipo de dados de string, um valor literal, como **'3'**, ou uma chamada para outra função que gere uma string.

## Tipo de retorno
<a name="parseInt-function-return-type"></a>

Inteiro

## Exemplo
<a name="parseInt-function-example"></a>

O exemplo a seguir avalia `feeType` para determinar se ele contém valores inteiros.

```
parseInt(feeType)
```

A seguir estão os valores de campo especificados.

```
feeType
--------
2
2.1
2a
3
3b
(null)
5
```

Para esses valores de campo, as seguintes linhas são retornadas.

```
2
2
3
(null)
5
```

# parseJson
<a name="parseJson-function"></a>

Use `parseJson` para extrair valores de um objeto JSON. 

Se seu conjunto de dados estiver armazenado no QuickSPICE, você poderá usá-lo `parseJson` ao preparar um conjunto de dados, mas não em campos calculados durante a análise.

Para consultas diretas, você pode usar `parseJson` durante a preparação de dados e a análise. A função `parseJson` aplica-se aos tipos de dados JSON nativos ou a strings, dependendo do dialeto, conforme mostrado na tabela a seguir.


| Dialeto | Tipo | 
| --- | --- | 
| PostgreSQL | JSON | 
| banco de dados de origem | String | 
| Microsoft SQL Server | String | 
| MySQL | JSON | 
| Teradata | JSON | 
| Oracle | String | 
| Presto | String | 
| Snowflake | Objeto de tipo de dados semiestruturado e matriz | 
| Hive | String | 

## Sintaxe
<a name="parseJson-function-syntax"></a>

```
parseJson(fieldName, path)
```

## Argumentos
<a name="parseJson-function-arguments"></a>

 *fieldName*   
O campo que contém o objeto JSON que você deseja analisar.

 *path*   
O caminho para o elemento de dados que você deseja analisar a partir do objeto JSON. Somente letras, números e espaços em branco são compatíveis com o argumento de caminho. A sintaxe do caminho válido inclui:  
+ *\$1*: objeto raiz
+ *.*: operador secundário.
+ *[ ]*: operador de subscrito para matriz

## Tipo de retorno
<a name="parseJson-function-return-type"></a>

String

## Exemplo
<a name="parseJson-function-example-query"></a>

O exemplo a seguir avalia um JSON de entrada para recuperar um valor de quantidade do item. Ao usar isso durante a preparação de dados, você pode criar uma tabela a partir do JSON.

```
parseJson({jsonField}, “$.items.qty”)
```

Veja o JSON a seguir.

```
{
    "customer": "John Doe",
    "items": {
        "product": "Beer",
        "qty": 6
    },
    "list1": [
        "val1",
        "val2"
    ],
    "list2": [
        {
            "list21key1": "list1value1"
        }
    ]
}
```

Neste exemplo, o seguinte valor é retornado.

```
6
```

## Exemplo
<a name="parseJson-function-example"></a>

O exemplo a seguir avalia o `JSONObject1` para extrair o primeiro par de chave-valor (KVP), rotulado `"State"`, e atribuir o valor ao campo calculado que você está criando.

```
parseJson(JSONObject1, “$.state”)
```

A seguir estão os valores de campo especificados.

```
JSONObject1
-----------
{"State":"New York","Product":"Produce","Date Sold":"1/16/2018","Sales Amount":"$3423.39"}
{"State":"North Carolina","Product":"Bakery Products","Date Sold":"2/1/2018","Sales Amount":"$3226.42"}
{"State":"Utah","Product":"Water","Date Sold":"4/24/2018","Sales Amount":"$7001.52"}
```

Para esses valores de campo, as seguintes linhas são retornadas.

```
New York
North Carolina
Utah
```

# Replace
<a name="replace-function"></a>

`replace` substitui parte de uma string por outra string que você especificar. 

## Sintaxe
<a name="replace-function-syntax"></a>

```
replace(expression, substring, replacement)
```

## Argumentos
<a name="replace-function-arguments"></a>

 *expressão*   
A expressão deve ser uma string. Isso pode ser o nome de um campo que usa o tipo de dados de string, um valor literal, como **'12 Main Street'**, ou uma chamada para outra função que gere uma string.

 *substring*   
O conjunto de caracteres na *expressão* que você deseja substituir. A substring pode ocorrer uma ou mais vezes na *expressão*.

 *replacement*   
A string que você deseja ter substituída pela *substring*.

## Tipo de retorno
<a name="replace-function-return-type"></a>

String

## Exemplo
<a name="replace-function-example"></a>

O exemplo a seguir substitui a substring 'e' por 'ou'.

```
replace('1 and 2 and 3', 'and', 'or')
```

A string a seguir é retornada.

```
1 or 2 or 3
```

# Right
<a name="right-function"></a>

`right` retorna os caracteres mais à direita de uma string, incluindo espaços. Você especifica o número de caracteres a ser retornado.

## Sintaxe
<a name="right-function-syntax"></a>

```
right(expression, limit)
```

## Argumentos
<a name="right-function-arguments"></a>

 *expressão*   
A expressão deve ser uma string. Isso pode ser o nome de um campo que usa o tipo de dados de string, um valor literal, como **'12 Main Street'**, ou uma chamada para outra função que gere uma string.

 *limit*   
O número de caracteres a ser retornado da *expressão*, a partir do último caractere na string.

## Tipo de retorno
<a name="right-function-return-type"></a>

String

## Exemplo
<a name="right-function-example"></a>

O exemplo a seguir retorna os cinco últimos caracteres de uma string.

```
right('Seattle Store#14', 12)
```

O valor a seguir é retornado.

```
tle Store#14
```

# Round
<a name="round-function"></a>

`round` arredonda um valor decimal para o inteiro mais próximo se nenhuma escala for especificada, ou para o decimal mais próximo se a escala for especificada.

## Sintaxe
<a name="round-function-syntax"></a>

```
round(decimal, scale)
```

## Argumentos
<a name="round-function-arguments"></a>

 *decimal*   
Um campo que usa o tipo de dados decimal, um valor literal, como **17.62**, ou uma chamada para outra função que gera um decimal.

 *escala*   
O número de casas decimais para usar para valores de retorno.

## Tipo de retorno
<a name="round-function-return-type"></a>


| Operando | Tipo de retorno na experiência antiga de preparação de dados | Tipo de retorno na nova experiência de preparação de dados | 
| --- | --- | --- | 
|  INT  |  DECIMAL (FIXO)  |  DECIMAL (FIXO)  | 
|  DECIMAL (FIXO)  |  DECIMAL (FIXO)  |  DECIMAL (FIXO)  | 
|  DECIMAL (FLUTUAR)  |  DECIMAL (FIXO)  |  DECIMAL (FLUTUAR)  | 

## Exemplo
<a name="round-function-example"></a>

O exemplo a seguir arredonda um campo decimal para a segunda casa decimal mais próxima.

```
round(salesAmount, 2)
```

A seguir estão os valores de campo especificados.

```
20.1307
892.0388
57.5447
```

Para esses valores de campo, os seguintes valores são retornados.

```
20.13
892.04
58.54
```

# Rtrim
<a name="rtrim-function"></a>

`rtrim` remove o espaço em branco posterior de uma string. 

## Sintaxe
<a name="rtrim-function-syntax"></a>

```
rtrim(expression)
```

## Argumentos
<a name="rtrim-function-arguments"></a>

 *expressão*   
A expressão deve ser uma string. Isso pode ser o nome de um campo que usa o tipo de dados de string, um valor literal, como **'12 Main Street'**, ou uma chamada para outra função que gere uma string.

## Tipo de retorno
<a name="rtrim-function-return-type"></a>

String

## Exemplo
<a name="rtrim-function-example"></a>

O exemplo a seguir remove os espaços seguintes de uma string.

```
rtrim('Seattle Store #14   ')
```

Para esses valores de campo, os seguintes valores são retornados.

```
Seattle Store #14
```

# Split
<a name="split-function"></a>

`split` divide uma string em uma matriz de substrings, com base em um delimitador que você seleciona, e retorna o item especificado pela posição.

Só é possível adicionar `split` a um campo calculado durante a preparação de dados, e não a uma análise. Essa função não é compatível com consultas diretas para o Microsoft SQL Server.

## Sintaxe
<a name="split-function-syntax"></a>

```
split(expression, delimiter , position)
```

## Argumentos
<a name="split-function-arguments"></a>

 *expressão*   
A expressão deve ser uma string. Isso pode ser o nome de um campo que usa o tipo de dados de string, um valor literal, como **'12 Main Street;1402 35th Ave;1818 Elm Ct;11 Janes Lane'**, ou uma chamada para outra função que gere uma string.

 *delimitador*   
O caractere que delimita onde a string é dividida em substrings. Por exemplo, `split('one|two|three', '|', 2)` transforma-se no que vem a seguir.  

```
one
two
three
```
Se escolher `position = 2`, `split` retornará `'two'`.

 *position*   
(Obrigatório) A posição do item a ser retornado do array. A posição do primeiro item na matriz é 1.

## Tipo de retorno
<a name="split-function-return-type"></a>

Matriz de strings

## Exemplo
<a name="split-function-example"></a>

O exemplo a seguir divide uma string em uma matriz, usando o caractere ponto-e-vírgula (;) como delimitador, e retorna o terceiro elemento da matriz.

```
split('123 Test St;1402 35th Ave;1818 Elm Ct;11 Janes Lane', ';', 3)
```

O item a seguir é retornado.

```
1818 Elm Ct
```

Esta função ignora itens que contêm valores nulos ou strings vazias. 

# Sqrt
<a name="sqrt-function"></a>

O `sqrt` retorna a raiz quadrada de uma determinada expressão. 

## Sintaxe
<a name="sqrt-function-syntax"></a>

```
sqrt(expression)
```

## Argumentos
<a name="sqrt-function-arguments"></a>

 *expressão*   
A expressão deve ser numérica. Pode ser um nome de campo, um valor literal ou outra função. 

# startsWith
<a name="startsWith-function"></a>

`startsWith` avalia se a expressão começa com uma substring especificada por você. Se a expressão começar com a substring, `startsWith` retornará true, caso contrário, retornará false.

## Sintaxe
<a name="startsWith-function-syntax"></a>

```
startsWith(expression, substring, string-comparison-mode)
```

## Argumentos
<a name="startsWith-function-arguments"></a>

 *expressão*   
A expressão deve ser uma string. Isso pode ser o nome de um campo que usa o tipo de dados de string, um valor literal, como **'12 Main Street'**, ou uma chamada para outra função que gere uma string.

 *substring*   
O conjunto de caracteres a serem comparados com a *expressão*. A substring pode ocorrer uma ou mais vezes na *expressão*.

 *string-comparison-mode*   
(Opcional) Especifica o modo de comparação de strings a ser usado:  
+ `CASE_SENSITIVE`: as comparações de strings diferenciam maiúsculas de minúsculas. 
+ `CASE_INSENSITIVE`: as comparações de strings não diferenciam maiúsculas de minúsculas.
Esse valor será padronizado como `CASE_SENSITIVE` quando for deixado em branco.

## Tipo de retorno
<a name="startsWith-function-return-type"></a>

Booleano

## Exemplos
<a name="startsWith-function-example"></a>

### Exemplo padrão de diferenciação entre maiúsculas e minúsculas
<a name="startsWith-function-example-default-case-sensitive"></a>

O exemplo a seguir, com distinção entre maiúsculas e minúsculas, avalia se `state_nm` startsWith **New**.

```
startsWith(state_nm, "New")
```

A seguir estão os valores de campo especificados.

```
New York
new york
```

Para esses valores de campo, os seguintes valores são retornados.

```
true
false
```

### Exemplo sem distinção entre maiúsculas e minúsculas
<a name="startsWith-function-example-case-insensitive"></a>

O exemplo a seguir, sem distinção entre maiúsculas e minúsculas, avalia se `state_nm` startsWith **new**.

```
startsWith(state_nm, "new", CASE_INSENSITIVE)
```

A seguir estão os valores de campo especificados.

```
New York
new york
```

Para esses valores de campo, os seguintes valores são retornados.

```
true
true
```

### Exemplo com declarações condicionais
<a name="startsWith-function-example-conditional-statements"></a>

A função `startsWith` pode ser usada como a declaração condicional nas seguintes funções IF: [avgIf](https://docs.aws.amazon.com/quicksight/latest/user/avgIf-function.html), [minIf](https://docs.aws.amazon.com/quicksight/latest/user/minIf-function.html), [distinct\$1countIf](https://docs.aws.amazon.com/quicksight/latest/user/distinct_countIf-function.html), [countIf](https://docs.aws.amazon.com/quicksight/latest/user/countIf-function.html), [maxIf](https://docs.aws.amazon.com/quicksight/latest/user/maxIf-function.html), [medianIf](https://docs.aws.amazon.com/quicksight/latest/user/medianIf-function.html), [stdevIf](https://docs.aws.amazon.com/quicksight/latest/user/stdevIf-function.html), [stdevpIf](https://docs.aws.amazon.com/quicksight/latest/user/stdevpIf-function.html), [sumIf](https://docs.aws.amazon.com/quicksight/latest/user/sumIf-function.html), [varIf](https://docs.aws.amazon.com/quicksight/latest/user/varIf-function.html) e [varpIf](https://docs.aws.amazon.com/quicksight/latest/user/varpIf-function.html). 

O exemplo a seguir soma `Sales` somente se state\$1nm começar com **New**.

```
sumIf(Sales,startsWith(state_nm, "New"))
```

### Exemplo does NOT contain
<a name="startsWith-function-example-does-not-start-with"></a>

O operador condicional `NOT` pode ser usado para avaliar se a expressão não começa com a substring especificada. 

```
NOT(startsWith(state_nm, "New"))
```

### Exemplo de uso com valores numéricos
<a name="startsWith-function-example-numeric-values"></a>

Valores numéricos podem ser usados nos argumentos da expressão ou da substring aplicando a função `toString`.

```
startsWith(state_nm, toString(5) )
```

# Strlen
<a name="strlen-function"></a>

`strlen` retorna os caracteres em uma string, incluindo espaços.

## Sintaxe
<a name="strlen-function-syntax"></a>

```
strlen(expression)
```

## Argumentos
<a name="strlen-function-arguments"></a>

 *expressão*   
Uma expressão pode ser o nome de um campo que usa o tipo de dados string, como **address1**, um valor literal, como **'Unknown'**, ou outra função, como `substring(field_name,0,5)`.

## Tipo de retorno
<a name="strlen-function-return-type"></a>

Inteiro

## Exemplo
<a name="strlen-function-example"></a>

O exemplo a seguir retorna o comprimento da string especificada.

```
strlen('1421 Main Street')
```

O valor a seguir é retornado.

```
16
```

# Substring
<a name="substring-function"></a>

`substring` retorna os caracteres de uma string, começando pelo local especificado pelo argumento *start* e prosseguindo para o número de caracteres especificado pelos argumentos *length*. 

## Sintaxe
<a name="substring-function-syntax"></a>

```
substring(expression, start, length)
```

## Argumentos
<a name="substring-function-arguments"></a>

 *expressão*   
Uma expressão pode ser o nome de um campo que usa o tipo de dados string, como **address1**, um valor literal, como **'Unknown'**, ou outra função, como `substring(field_name,1,5)`.

 *start*   
A localização de caractere a partir da qual começar. *start* é inclusivo, de forma que o caractere na posição inicial é o primeiro caractere no valor retornado. O valor mínimo de *start* é 1. 

 *length*   
O número de caracteres adicionais a serem incluídos após *start*. *length* inclui *start*, por isso o último caractere retornado será (*length* - 1) após o caractere inicial.

## Tipo de retorno
<a name="substring-function-return-type"></a>

String

## Exemplo
<a name="substring-function-example"></a>

O exemplo a seguir retorna do 13º ao 19º caracteres de uma string. O início da string é o índice 1, então você começa a contar no primeiro caractere.

```
substring('Fantasy and Science Fiction',13,7)
```

O valor a seguir é retornado.

```
Science
```

# switch
<a name="switch-function"></a>

`switch` compara uma *condition-expression* com os rótulos literais, dentro de um conjunto de pares de rótulos literais e *return-expression*. Em seguida, retorna a *return-expression* correspondente ao primeiro rótulo literal igual à *condition-expression*. Se nenhum rótulo for igual à *condition-expression*, `switch` retornará a *default-expression*. Cada *return-expression* e *default-expression* devem ter o mesmo tipo de dados.

## Sintaxe
<a name="switch-function-syntax"></a>

```
switch(condition-expression, label-1, return-expression-1 [, label-n, return-expression-n ...], 
        default-expression)
```

## Argumentos
<a name="switch-function-arguments"></a>

`switch` requer um ou mais pares de expressão *if*, *then* e exige exatamente uma expressão para o argumento *else*. 

 *condition-expression*   
A expressão a ser comparada com os literais do rótulo. Pode ser um nome de campo, como `address`, um valor literal, como '`Unknown`', ou outra função escalar, como `toString(salesAmount)`. 

 *rótulo*   
O literal a ser comparado com o argumento da *condition-expression*, todos os literais devem ter o mesmo tipo de dados do argumento da *condition-expression*. `switch` aceita até cinco mil rótulos. 

 *return-expression*   
A expressão a ser retornada se o valor de seu rótulo for igual ao valor da *condition-expression*. Pode ser um nome de campo, como `address`, um valor literal, como '`Unknown`', ou outra função escalar, como `toString(salesAmount)`. Todos os argumentos da *return-expression* devem ter o mesmo tipo de dados que a *default-expression*.

 *default-expression*   
A expressão a ser retornada se nenhum valor de nenhum argumento de rótulo for igual ao valor da *condition-expression*. Pode ser um nome de campo, como `address`, um valor literal, como '`Unknown`', ou outra função escalar, como `toString(salesAmount)`. A *default-expression* deve ter o mesmo tipo de dados que todos os argumentos da *return-expression*.

## Tipo de retorno
<a name="switch-function-return-type"></a>

`switch` retorna um valor do mesmo tipo de dados que os valores na *return-expression*. Todos os dados que retornam *return-expression* e *default-expression* devem ser do mesmo tipo de dados ou ser convertidos no mesmo tipo de dados. 

## Exemplos gerais
<a name="switch-function-example"></a>

O exemplo a seguir retorna o Região da AWS código do nome da região de entrada. 

```
switch(region_name, 
               "US East (N. Virginia)", "us-east-1", 
               "Europe (Ireland)", "eu-west-1", 
               "US West (N. California)", "us-west-1", 
               "other regions")
```

A seguir estão os valores de campo especificados.

```
"US East (N. Virginia)"
        "US West (N. California)"
        "Asia Pacific (Tokyo)"
```

Para esses valores de campo, os valores a seguir são retornados.

```
"us-east-1"
        "us-west-1"
        "other regions"
```

## Use switch para substituir `ifelse`
<a name="switch-instead-of-ifelse"></a>

O caso de uso de `ifelse` a seguir é equivalente ao exemplo anterior, para `ifelse` avaliar se os valores de um campo são iguais a valores literais diferentes. Em vez disso, usar `switch` é uma opção melhor.

```
ifelse(region_name = "US East (N. Virginia)", "us-east-1", 
               region_name = "Europe (Ireland)", "eu-west-1", 
               region_name = "US West (N. California)", "us-west-1", 
               "other regions")
```

## Expressão como valor de retorno
<a name="switch-expression-as-return-value"></a>

O exemplo abaixo usa expressões em *return-expressions*:

```
switch({origin_city_name}, 
               "Albany, NY", {arr_delay} + 20, 
               "Alexandria, LA", {arr_delay} - 10,
               "New York, NY", {arr_delay} * 2, 
               {arr_delay})
```

O exemplo anterior altera o tempo de atraso esperado para cada voo de uma cidade específica.

![\[Uma imagem dos resultados do exemplo de função, mostrada em forma de tabela.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/switch-function-example.png)


# toLower
<a name="toLower-function"></a>

`toLower` formata uma string toda em minúsculas. `toLower` ignora linhas que contêm valores nulos.

## Sintaxe
<a name="toLower-function-syntax"></a>

```
toLower(expression)
```

## Argumentos
<a name="toLower-function-arguments"></a>

 *expressão*   
A expressão deve ser uma string. Isso pode ser o nome de um campo que usa o tipo de dados de string, um valor literal, como **'12 Main Street'**, ou uma chamada para outra função que gere uma string.

## Tipo de retorno
<a name="toLower-function-return-type"></a>

String

## Exemplo
<a name="toLower-function-example"></a>

O exemplo a seguir converte um valor de string em letras minúsculas.

```
toLower('Seattle Store #14')
```

O valor a seguir é retornado.

```
seattle store #14
```

# toString
<a name="toString-function"></a>

`toString` formata a expressão de entrada como uma string. `toString` ignora linhas que contêm valores nulos.

## Sintaxe
<a name="toString-function-syntax"></a>

```
toString(expression)
```

## Argumentos
<a name="toString-function-arguments"></a>

 *expressão*   
 Uma expressão pode ser um campo de qualquer tipo de dados, um valor literal, como **14.62**, ou uma chamada para outra função que retorna qualquer tipo de dados.

## Tipo de retorno
<a name="toString-function-return-type"></a>

String

## Exemplo
<a name="toString-function-example"></a>

O exemplo a seguir retorna os valores de `payDate` (que usa o tipo de dados de `date`) como strings.

```
toString(payDate)
```

A seguir estão os valores de campo especificados.

```
payDate
--------
1992-11-14T00:00:00.000Z
2012-10-12T00:00:00.000Z
1973-04-08T00:00:00.000Z
```

Para esses valores de campo, as seguintes linhas são retornadas.

```
1992-11-14T00:00:00.000Z
2012-10-12T00:00:00.000Z
1973-04-08T00:00:00.000Z
```

# toUpper
<a name="toUpper-function"></a>

`toUpper` formata uma string toda em maiúsculas. `toUpper` ignora linhas que contêm valores nulos.

## Sintaxe
<a name="toUpper-function-syntax"></a>

```
toUpper(expression)
```

## Argumentos
<a name="toUpper-function-arguments"></a>

 *expressão*   
A expressão deve ser uma string. Isso pode ser o nome de um campo que usa o tipo de dados de string, um valor literal, como **'12 Main Street'**, ou uma chamada para outra função que gere uma string.

## Tipo de retorno
<a name="toUpper-function-return-type"></a>

String

## Exemplo
<a name="toUpper-function-example"></a>

O exemplo a seguir converte um valor de string em letras maiúsculas.

```
toUpper('Seattle Store #14')
```

O valor a seguir é retornado.

```
SEATTLE STORE #14
```

# trim
<a name="trim-function"></a>

`trim` remove o espaço em branco anterior e posterior de uma string. 

## Sintaxe
<a name="trim-function-syntax"></a>

```
trim(expression)
```

## Argumentos
<a name="trim-function-arguments"></a>

 *expressão*   
A expressão deve ser uma string. Isso pode ser o nome de um campo que usa o tipo de dados de string, um valor literal, como **'12 Main Street'**, ou uma chamada para outra função que gere uma string.

## Tipo de retorno
<a name="trim-function-return-type"></a>

String

## Exemplo
<a name="trim-function-example"></a>

O exemplo a seguir remove os espaços seguintes de uma string.

```
trim('   Seattle Store #14   ')
```

Para esses valores de campo, os seguintes valores são retornados.

```
Seattle Store #14
```

# truncDate
<a name="truncDate-function"></a>

`truncDate` retorna um valor de data que representa uma parte especificada de uma data. Por exemplo, solicitar a parte do ano do valor 2012-09-02T00:00:00.000Z retorna 2012-01-01T00:00:00.000Z. Especificar um período de horas para uma data que não contenha informações de hora retorna o valor de data inicial inalterado.

## Sintaxe
<a name="truncDate-function-syntax"></a>

```
truncDate('period', date)
```

## Argumentos
<a name="truncDate-function-arguments"></a>

 *período*   
O período da data em que você deseja retornar. Os períodos válidos são:  
+ AAAA: retorna a parte do ano da data.
+ P: Isso retorna a data do primeiro dia do trimestre ao qual a data pertence. 
+ MM: Isto retorna a parte do mês da data.
+ DD: retorna a parte do dia da data.
+ WK: retorna a parte da semana da data. A semana começa no domingo no Amazon Quick.
+ HH: retorna a parte da hora da data.
+ MI: Isto retorna a parte do minuto da data.
+ SS: Isto retorna a parte do segundo da data.
+ MS: isso retorna a parte do milissegundo da data.

 *data*   
Um campo de data ou uma chamada para outra função que gera uma data.

## Tipo de retorno
<a name="truncDate-function-return-type"></a>

Data

## Exemplo
<a name="truncDate-function-example"></a>

O exemplo a seguir retorna uma data que representa o mês da data do pedido.

```
truncDate('MM', orderDate)
```

A seguir estão os valores de campo especificados.

```
orderDate      
=========
2012-12-14T00:00:00.000Z  
2013-12-29T00:00:00.000Z
2012-11-15T00:00:00.000Z
```

Para esses valores de campo, os seguintes valores são retornados.

```
2012-12-01T00:00:00.000Z
2013-12-01T00:00:00.000Z
2012-11-01T00:00:00.000Z
```

# Funções agregadas
<a name="calculated-field-aggregations"></a>

As funções agregadas só estão disponíveis durante a análise e a visualização. Cada uma dessas funções retorna valores agrupados pela dimensão ou dimensões escolhidas. Para cada agregação, há também uma agregação condicional. Elas executam o mesmo tipo de agregação, com base em uma condição.

Quando uma fórmula de campo calculado contém uma agregação, ela se torna uma agregação personalizada. Para garantir que seus dados sejam exibidos com precisão, o Amazon Quick aplica as seguintes regras:
+ As agregações personalizadas não podem conter funções de agregação aninhadas. Por exemplo, esta fórmula não funciona: `sum(avg(x)/avg(y))`. No entanto, aninhar as funções não agregadas dentro ou fora das funções agregadas funciona. Por exemplo, `ceil(avg(x))` funciona. Assim como `avg(ceil(x))`.
+ As agregações personalizadas não podem conter campos agregados e não agregados em qualquer combinação. Por exemplo, esta fórmula não funciona: `Sum(sales)+quantity`.
+ Grupos de filtros não podem conter campos agregados e não agregados.
+ As agregações personalizadas não podem ser convertidas em uma dimensão. Elas também não podem ser soltas na fonte de campos como uma dimensão.
+ Em uma tabela dinâmica, as agregações personalizadas não podem ser adicionadas a cálculos de tabela.
+ Os gráficos de dispersão com agregações personalizadas precisam de pelo menos uma dimensão em **Group/Color** na fonte de campos.

Para obter mais informações sobre funções e operadores compatíveis, consulte [Função de campo calculada e referência do operador para o Amazon Quick](https://docs.aws.amazon.com/quicksight/latest/user/calculated-field-reference.html). 

As funções agregadas para campos calculados no Quick incluem o seguinte.

**Topics**
+ [avg](avg-function.md)
+ [avgIf](avgIf-function.md)
+ [count](count-function.md)
+ [countIf](countIf-function.md)
+ [distinct\$1count](distinct_count-function.md)
+ [distinct\$1countIf](distinct_countIf-function.md)
+ [max](max-function.md)
+ [maxIf](maxIf-function.md)
+ [median](median-function.md)
+ [medianIf](medianIf-function.md)
+ [min](min-function.md)
+ [minIf](minIf-function.md)
+ [percentile](percentile-function.md)
+ [percentileCont](percentileCont-function.md)
+ [percentileDisc (percentil)](percentileDisc-function.md)
+ [periodToDateAvg](periodToDateAvg-function.md)
+ [periodToDateCount](periodToDateCount-function.md)
+ [periodToDateMax](periodToDateMax-function.md)
+ [periodToDateMedian](periodToDateMedian-function.md)
+ [periodToDateMin](periodToDateMin-function.md)
+ [periodToDatePercentile](periodToDatePercentile-function.md)
+ [periodToDatePercentileCont](periodToDatePercentileCont-function.md)
+ [periodToDateStDev](periodToDateStDev-function.md)
+ [periodToDateStDevP](periodToDateStDevP-function.md)
+ [periodToDateSum](periodToDateSum-function.md)
+ [periodToDateVar](periodToDateVar-function.md)
+ [periodToDateVarP](periodToDateVarP-function.md)
+ [stdev](stdev-function.md)
+ [stdevp](stdevp-function.md)
+ [stdevIf](stdevIf-function.md)
+ [stdevpIf](stdevpIf-function.md)
+ [sum](sum-function.md)
+ [sumIf](sumIf-function.md)
+ [var](var-function.md)
+ [varIf](varIf-function.md)
+ [varp](varp-function.md)
+ [varpIf](varpIf-function.md)

# avg
<a name="avg-function"></a>

A função `avg` calcula a média do conjunto de números na medida especificada, agrupados pela dimensão ou dimensões escolhidas. Por exemplo, `avg(salesAmount)` retorna a média dessa medida agrupada pela dimensão escolhida (opcional).

## Sintaxe
<a name="avg-function-syntax"></a>

```
avg(decimal, [group-by level])
```

## Argumentos
<a name="avg-function-arguments"></a>

 *decimal*   
O argumento deve ser uma medida. Valores nulos são omitidos nos resultados. Valores literais não funcionam. O argumento deve ser um campo.

 *nível por grupo*   
(Opcional) Especifica o nível pelo qual agrupar a agregação. O nível adicionado pode ser qualquer dimensão ou dimensões, independentemente das dimensões adicionadas ao elemento visual.  
O argumento deve ser um campo de dimensão. O nível por grupo deve estar entre colchetes `[ ]`. Para obter mais informações, consulte [Cálculo sensível ao nível - funções agregadas (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)).

## Exemplos
<a name="avg-function-example"></a>

O exemplo a seguir calcula a média de vendas.

```
avg({Sales})
```

Você também pode especificar em que nível agrupar a computação usando uma ou mais dimensões na visualização ou no seu conjunto de dados. Isso é chamado de função LAC-A. Para obter mais informações sobre as funções LAC-A, consulte [Cálculo sensível ao nível - funções agregadas (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)). O exemplo a seguir calcula a média de vendas no nível do país, mas não em outras dimensões (região ou produto) no elemento visual.

```
avg({Sales}, [{Country}])
```

![\[Os números médios de vendas são agregados somente no nível do país.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/avg-function-example.png)


# avgIf
<a name="avgIf-function"></a>

Com base em uma declaração condicional, a função `avgIf` calcula a média do conjunto de números na medida especificada, agrupados pela dimensão ou dimensões escolhidas. Por exemplo, `avgIf(ProdRev,CalendarDay >= ${BasePeriodStartDate} AND CalendarDay <= ${BasePeriodEndDate} AND SourcingType <> 'Indirect')` retorna a média dessa medida, agrupada pela dimensão escolhida (opcional), desde que a condição seja verdadeira.

## Sintaxe
<a name="avgIf-function-syntax"></a>

```
avgIf(dimension or measure, condition) 
```

## Argumentos
<a name="avgIf-function-arguments"></a>

 *decimal*   
O argumento deve ser uma medida. Valores nulos são omitidos nos resultados. Valores literais não funcionam. O argumento deve ser um campo.

 *condição*   
Uma ou mais condições em uma única declaração.

# count
<a name="count-function"></a>

A função `count` calcula o número de valores em uma dimensão ou medida, agrupados pela dimensão ou dimensões escolhidas. Por exemplo, `count(product type)` retorna o número total de tipos de produtos agrupados pela dimensão (opcional) escolhida, incluindo todas as duplicatas. A função `count(sales)` retorna o número total de tipos de vendas concluídos agrupados pela dimensão (opcional) escolhida, por exemplo, vendedor.

## Sintaxe
<a name="count-function-syntax"></a>

```
count(dimension or measure, [group-by level])
```

## Argumentos
<a name="count-function-arguments"></a>

 *dimensão ou medida*   
O argumento deve ser uma medida ou uma dimensão. Valores nulos são omitidos nos resultados. Valores literais não funcionam. O argumento deve ser um campo.

 *nível por grupo*   
(Opcional) Especifica o nível pelo qual agrupar a agregação. O nível adicionado pode ser qualquer dimensão ou dimensões, independentemente das dimensões adicionadas ao elemento visual.  
O argumento deve ser um campo de dimensão. O nível por grupo deve estar entre colchetes `[ ]`. Para obter mais informações, consulte [Cálculo sensível ao nível - funções agregadas (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)).

## Exemplos
<a name="count-function-example"></a>

O exemplo a seguir calcula a contagem de vendas por uma dimensão especificada no elemento visual. Nesse exemplo, a contagem de vendas por mês é mostrada.

```
count({Sales})
```

![\[A contagem das vendas por mês.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/count-function-example.png)


Você também pode especificar em que nível agrupar a computação usando uma ou mais dimensões na visualização ou no seu conjunto de dados. Isso é chamado de função LAC-A. Para obter mais informações sobre as funções LAC-A, consulte [Cálculo sensível ao nível - funções agregadas (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)). O exemplo a seguir calcula a contagem de vendas no nível do país, mas não em outras dimensões (região ou produto) no elemento visual.

```
count({Sales}, [{Country}])
```

![\[A contagem de vendas é agregada somente no nível do país.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/count-function-example2.png)


# countIf
<a name="countIf-function"></a>

Com base em uma declaração, a função `countIf` calcula o número de valores distintos em uma dimensão ou medida, agrupados pela dimensão ou dimensões escolhidas.

## Sintaxe
<a name="countIf-function-syntax"></a>

```
countIf(dimension or measure, condition)
```

## Argumentos
<a name="countIf-function-arguments"></a>

 *dimensão ou medida*   
O argumento deve ser uma medida ou uma dimensão. Valores nulos são omitidos nos resultados. Valores literais não funcionam. O argumento deve ser um campo.

 *condição*   
Uma ou mais condições em uma única declaração.

## Tipo de retorno
<a name="countIf-function-return-type"></a>

Inteiro

## Exemplo
<a name="countIf-function-example"></a>

A função a seguir retorna uma contagem das transações de vendas (`Revenue`) que atendem às condições, incluindo quaisquer duplicatas. 

```
countIf (
    Revenue,
    # Conditions
        CalendarDay >= ${BasePeriodStartDate} AND 
        CalendarDay <= ${BasePeriodEndDate} AND 
        SourcingType <> 'Indirect'
)
```

# distinct\$1count
<a name="distinct_count-function"></a>

A função `distinct_count` calcula o número de valores distintos em uma dimensão ou medida, agrupados pela dimensão ou dimensões escolhidas. Por exemplo, `distinct_count(product type)` retorna o número total de tipos de produtos exclusivos agrupados pela dimensão (opcional) escolhida, sem nenhuma duplicata. A função `distinct_count(ship date)` retorna o número total de datas em que os produtos foram enviados, agrupadas pela dimensão (opcional) escolhida, por exemplo, região.

## Sintaxe
<a name="distinct_count-function-syntax"></a>

```
distinct_count(dimension or measure, [group-by level])
```

## Argumentos
<a name="distinct_count-function-arguments"></a>

 *dimensão ou medida*   
O argumento deve ser uma medida ou uma dimensão. Valores nulos são omitidos nos resultados. Valores literais não funcionam. O argumento deve ser um campo.

 *nível por grupo*   
(Opcional) Especifica o nível pelo qual agrupar a agregação. O nível adicionado pode ser qualquer dimensão ou dimensões, independentemente das dimensões adicionadas ao elemento visual.  
O argumento deve ser um campo de dimensão. O nível por grupo deve estar entre colchetes `[ ]`. Para obter mais informações, consulte [Cálculo sensível ao nível - funções agregadas (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)).

## Exemplo
<a name="distinct_count-function-examples"></a>

O exemplo a seguir calcula o número total de datas em que os produtos foram pedidos, agrupados pela dimensão escolhida (opcional) no elemento visual, por exemplo, região.

```
distinct_count({Order Date})
```

![\[O número total de datas em que os produtos foram pedidos em cada região.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/distinct_count-function-example.png)


Você também pode especificar em que nível agrupar a computação usando uma ou mais dimensões na visualização ou no seu conjunto de dados. Isso é chamado de função LAC-A. Para obter mais informações sobre as funções LAC-A, consulte [Cálculo sensível ao nível - funções agregadas (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)). O exemplo a seguir calcula a média de vendas no nível do país, mas não em outras dimensões (região) no elemento visual.

```
distinct_count({Order Date}, [Country])
```

![\[O número total de datas em que os produtos foram pedidos em cada país.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/distinct_count-function-example2.png)


# distinct\$1countIf
<a name="distinct_countIf-function"></a>

Com base em uma declaração, a função `distinct_countIf` calcula o número de valores distintos em uma dimensão ou medida, agrupados pela dimensão ou dimensões escolhidas. Por exemplo, `distinct_countIf(product type)` retorna o número total de tipos de produtos exclusivos agrupados pela dimensão (opcional) escolhida, sem nenhuma duplicata. A função `distinct_countIf(ProdRev,CalendarDay >= ${BasePeriodStartDate} AND CalendarDay <= ${BasePeriodEndDate} AND SourcingType <> 'Indirect')` retorna o número total de datas em que os produtos foram enviados, agrupados pela dimensão escolhida (opcional), por exemplo, região, desde que a condição seja verdadeira.

## Sintaxe
<a name="distinct_countIf-function-syntax"></a>

```
distinct_countIf(dimension or measure, condition)
```

## Argumentos
<a name="distinct_countIf-function-arguments"></a>

 *dimensão ou medida*   
O argumento deve ser uma medida ou uma dimensão. Valores nulos são omitidos nos resultados. Valores literais não funcionam. O argumento deve ser um campo.

 *condição*   
Uma ou mais condições em uma única declaração.

# max
<a name="max-function"></a>

A função `max` retorna o valor máximo da medida ou data especificada, agrupado pela dimensão ou dimensões escolhidas. Por exemplo, `max(sales goal)` retorna as metas de vendas máximas agrupadas pela dimensão escolhida (opcional).

## Sintaxe
<a name="max-function-syntax"></a>

```
max(measure, [group-by level])
```

## Argumentos
<a name="max-function-arguments"></a>

 *medida*   
O argumento deve ser uma medida ou uma data. Valores nulos são omitidos nos resultados. Valores literais não funcionam. O argumento deve ser um campo.  
As datas máximas funcionam somente na fonte de campo **Value (Valor)** das tabelas e tabelas dinâmicas. 

 *nível por grupo*   
(Opcional) Especifica o nível pelo qual agrupar a agregação. O nível adicionado pode ser qualquer dimensão ou dimensões, independentemente das dimensões adicionadas ao elemento visual.  
O argumento deve ser um campo de dimensão. O nível por grupo deve estar entre colchetes `[ ]`. Para obter mais informações, consulte [Cálculo sensível ao nível - funções agregadas (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)).

## Exemplos
<a name="max-function-example"></a>

O exemplo a seguir retorna o valor máximo de vendas para cada região. É comparado aos valores de vendas totais, mínimos e medianos.

```
max({Sales})
```

![\[O valor máximo de vendas para cada região.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/min-max-median-function-example.png)


Você também pode especificar em que nível agrupar a computação usando uma ou mais dimensões na visualização ou no seu conjunto de dados. Isso é chamado de função LAC-A. Para obter mais informações sobre as funções LAC-A, consulte [Cálculo sensível ao nível - funções agregadas (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)). O exemplo a seguir calcula o máximo de vendas no nível do país, mas não em outras dimensões (região) no elemento visual.

```
max({Sales}, [Country])
```

![\[O valor máximo de vendas em cada país.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/max-function-example2.png)


# maxIf
<a name="maxIf-function"></a>

Com base em uma declaração condicional, a função `maxIf` retorna o valor máximo da medida especificada, agrupados pela dimensão ou dimensões escolhidas. Por exemplo, `maxIf(ProdRev,CalendarDay >= ${BasePeriodStartDate} AND CalendarDay <= ${BasePeriodEndDate} AND SourcingType <> 'Indirect')` retorna a meta máxima de vendas agrupada pela dimensão escolhida (opcional), desde que a condição seja verdadeira.

## Sintaxe
<a name="maxIf-function-syntax"></a>

```
maxIf(measure, condition)
```

## Argumentos
<a name="maxIf-function-arguments"></a>

 *medida*   
O argumento deve ser uma medida. Valores nulos são omitidos nos resultados. Valores literais não funcionam. O argumento deve ser um campo.

 *condição*   
Uma ou mais condições em uma única declaração.

# median
<a name="median-function"></a>

A agregação `median` retorna o valor mediano da medida especificada, agrupado pela dimensão ou dimensões escolhidas. Por exemplo, `median(revenue)` retorna a receita média agrupada pela dimensão escolhida (opcional). 

## Sintaxe
<a name="median-function-syntax"></a>

```
median(measure, [group-by level])
```

## Argumentos
<a name="median-function-arguments"></a>

 *medida*   
O argumento deve ser uma medida. Valores nulos são omitidos nos resultados. Valores literais não funcionam. O argumento deve ser um campo.

 *nível por grupo*   
(Opcional) Especifica o nível pelo qual agrupar a agregação. O nível adicionado pode ser qualquer dimensão ou dimensões, independentemente das dimensões adicionadas ao elemento visual.  
O argumento deve ser um campo de dimensão. O nível por grupo deve estar entre colchetes `[ ]`. Para obter mais informações, consulte [Cálculo sensível ao nível - funções agregadas (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)).

## Exemplos
<a name="median-function-example"></a>

O exemplo a seguir retorna o valor médio de vendas para cada região. É comparado às vendas totais, máximas e mínimas.

```
median({Sales})
```

![\[O valor médio das vendas para cada região.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/min-max-median-function-example.png)


Você também pode especificar em que nível agrupar a computação usando uma ou mais dimensões na visualização ou no seu conjunto de dados. Isso é chamado de função LAC-A. Para obter mais informações sobre as funções LAC-A, consulte [Cálculo sensível ao nível - funções agregadas (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)). O exemplo a seguir calcula a média de vendas no nível do país, mas não em outras dimensões (região) no elemento visual.

```
median({Sales}, [Country])
```

![\[O valor médio das vendas em cada país.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/median-function-example2.png)


# medianIf
<a name="medianIf-function"></a>

Com base em uma instrução condicional, a agregação `medianIf` retorna o valor mediano da medida especificada, agrupado pela dimensão ou dimensões escolhidas. Por exemplo, `medianIf(Revenue,SaleDate >= ${BasePeriodStartDate} AND SaleDate <= ${BasePeriodEndDate})` retorna a receita média agrupada pela dimensão escolhida (opcional), desde que a condição seja verdadeira. 

## Sintaxe
<a name="medianIf-function-syntax"></a>

```
medianIf(measure, condition)
```

## Argumentos
<a name="medianIf-function-arguments"></a>

 *medida*   
O argumento deve ser uma medida. Valores nulos são omitidos nos resultados. Valores literais não funcionam. O argumento deve ser um campo.

 *condição*   
Uma ou mais condições em uma única declaração.

# min
<a name="min-function"></a>

A função `min` retorna o valor mínimo da medida ou data especificada, agrupado pela dimensão ou dimensões escolhidas. Por exemplo, `min(return rate)` retorna a taxa mínima de devoluções agrupadas pela dimensão escolhida (opcional).

## Sintaxe
<a name="min-function-syntax"></a>

```
min(measure, [group-by level])
```

## Argumentos
<a name="min-function-arguments"></a>

 *medida*   
O argumento deve ser uma medida ou uma data. Valores nulos são omitidos nos resultados. Valores literais não funcionam. O argumento deve ser um campo.  
As datas mínimas funcionam somente na fonte de campo **Value (Valor)** das tabelas e tabelas dinâmicas. 

 *nível por grupo*   
(Opcional) Especifica o nível pelo qual agrupar a agregação. O nível adicionado pode ser qualquer dimensão ou dimensões, independentemente das dimensões adicionadas ao elemento visual.  
O argumento deve ser um campo de dimensão. O nível por grupo deve estar entre colchetes `[ ]`. Para obter mais informações, consulte [Cálculo sensível ao nível - funções agregadas (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)).

## Exemplos
<a name="min-function-example"></a>

O exemplo a seguir retorna o valor mínimo de vendas para cada região. É comparado às vendas totais, máximas e médias.

```
min({Sales})
```

![\[O valor mínimo de vendas para cada região.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/min-max-median-function-example.png)


Você também pode especificar em que nível agrupar a computação usando uma ou mais dimensões na visualização ou no seu conjunto de dados. Isso é chamado de função LAC-A. Para obter mais informações sobre as funções LAC-A, consulte [Cálculo sensível ao nível - funções agregadas (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)). O exemplo a seguir calcula as vendas mínimas no nível do país, mas não em outras dimensões (região) no elemento visual.

```
min({Sales}, [Country])
```

![\[O valor mínimo de vendas em cada país.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/min-function-example2.png)


# minIf
<a name="minIf-function"></a>

Com base em uma declaração condicional, a função `minIf` retorna o valor mínimo da medida especificada, agrupados pela dimensão ou dimensões escolhidas. Por exemplo, `minIf(ProdRev,CalendarDay >= ${BasePeriodStartDate} AND CalendarDay <= ${BasePeriodEndDate} AND SourcingType <> 'Indirect')` retorna a taxa mínima de devoluções agrupada pela dimensão escolhida (opcional), desde que a condição seja verdadeira.

## Sintaxe
<a name="minIf-function-syntax"></a>

```
minIf(measure, condition)
```

## Argumentos
<a name="minIf-function-arguments"></a>

 *medida*   
O argumento deve ser uma medida. Valores nulos são omitidos nos resultados. Valores literais não funcionam. O argumento deve ser um campo.

 *condição*   
Uma ou mais condições em uma única declaração.

# percentile
<a name="percentile-function"></a>

A função `percentile` calcula o percentil dos valores medidos, agrupados pela dimensão que está na fonte do campo. Há duas variedades de cálculo de percentil disponíveis no Quick:
+ [https://docs.aws.amazon.com/quicksight/latest/user/percentileCont-function.html](https://docs.aws.amazon.com/quicksight/latest/user/percentileCont-function.html) usa interpolação linear para determinar o resultado.
+ [percentileDisc(percentil)](https://docs.aws.amazon.com/quicksight/latest/user/percentileDisc-function.html) usa valores reais para determinar o resultado. 

A função `percentile` é um alias de `percentileDisc`.

# percentileCont
<a name="percentileCont-function"></a>

A função `percentileCont` calcula o percentil com base em uma distribuição contínua dos números na medida. Ela usa o agrupamento e a classificação aplicados nas fontes do campo. Ela responde a perguntas como: quais valores são representativos desse percentil? Para retornar um valor percentual exato que talvez não esteja presente no seu conjunto de dados, use `percentileCont`. Para retornar o valor percentual mais próximo que está presente no seu conjunto de dados, use `percentileDisc`.

## Sintaxe
<a name="percentileCont-function-syntax"></a>

```
percentileCont(expression, percentile, [group-by level])
```

## Argumentos
<a name="percentileCont-function-arguments"></a>

 *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*   
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. 

 *nível por grupo*   
(Opcional) Especifica o nível pelo qual agrupar a agregação. O nível adicionado pode ser qualquer dimensão ou dimensões, independentemente das dimensões adicionadas ao elemento visual.  
O argumento deve ser um campo de dimensão. O nível por grupo deve estar entre colchetes `[ ]`. Para obter mais informações, consulte [Cálculo sensível ao nível - funções agregadas (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)).

## Retornos
<a name="percentileCont-function-return-type"></a>

O resultado da função é um número. 

## Observações de uso
<a name="percentileCont-usage-notes"></a>

A função `percentileCont` calcula um resultado com base em uma distribuição contínua dos valores de uma medida especificada. O resultado é computado por interpolação linear entre os valores após ordená-los com base nas configurações do elemento visual. É diferente de `percentileDisc`, que simplesmente retorna um valor do conjunto de valores agregados. O resultado de `percentileCont` pode ou não existir nos valores da medida especificada.

## Exemplos de percentileCont
<a name="percentileCont-examples"></a>

Os exemplos a seguir ajudam a explicar como o percentileCont funciona.

**Example Comparar a mediana, `percentileCont` e `percentileDisc`**  
O exemplo a seguir mostra a mediana de uma dimensão (categoria) usando as funções `median`, `percentileCont` e `percentileDisc`. O valor médio é o mesmo que o valor de percentileCont. `percentileCont` interpola um valor, que pode ou não estar no conjunto de dados. No entanto, como `percentileDisc` sempre exibe um valor que existe no conjunto de dados, os dois resultados podem não corresponder. A última coluna neste exemplo mostra a diferença entre os dois valores. O código para cada campo calculado é o seguinte:  
+ `50%Cont = percentileCont( example , 50 )`
+ `median = median( example )`
+ `50%Disc = percentileDisc( example , 50 )`
+ `Cont-Disc = percentileCont( example , 50 ) − percentileDisc( example , 50 )`
+ `example = left( category, 1 )` (Para fazer um exemplo mais simples, usamos essa expressão para encurtar os nomes das categorias até a primeira letra.)

```
  example     median       50%Cont      50%Disc      Cont-Disc
 -------- ----------- ------------ -------------- ------------ 
 A          22.48          22.48          22.24          0.24
 B          20.96          20.96          20.95          0.01
 C          24.92          24.92          24.92          0
 D          24.935         24.935         24.92          0.015
 E          14.48          14.48          13.99          0.49
```

**Example 100º percentil como máximo**  
O exemplo a seguir mostra uma variedade de valores de `percentileCont` para o campo `example`. Os campos calculados `n%Cont` são definidos como `percentileCont( {example} ,n)`. Os valores interpolados em cada coluna representam os números que se enquadram nesse bucket de percentis. Em alguns casos, os valores reais dos dados correspondem aos valores interpolados. Por exemplo, a coluna `100%Cont` mostra o mesmo valor para cada linha porque 6783,02 é o número mais alto.  

```
 example      50%Cont     75%Cont      99%Cont    100%Cont  
 --------- ----------- ----------- ------------ ----------- 

 A             20.97       84.307      699.99      6783.02  
 B             20.99       88.84       880.98      6783.02  
 C             20.99       90.48       842.925     6783.02  
 D             21.38       85.99       808.49      6783.02
```

Você também pode especificar em que nível agrupar a computação usando uma ou mais dimensões na visualização ou no seu conjunto de dados. Isso é chamado de função LAC-A. Para obter mais informações sobre as funções LAC-A, consulte [Cálculo sensível ao nível - funções agregadas (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)). O exemplo a seguir calcula o 30º percentil com base em uma distribuição contínua dos números no nível do país, mas não em outras dimensões (região) no elemento visual.

```
percentileCont({Sales}, 30, [Country])
```

![\[O percentil de vendas em cada país.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/percentileCont-function-example-lac.png)


# percentileDisc (percentil)
<a name="percentileDisc-function"></a>

A função `percentileDisc` calcula o percentil com base nos números reais em `measure`. Ela usa o agrupamento e a classificação aplicados nas fontes do campo. A função `percentile` é um alias de `percentileDisc`.

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 `percentileDisc`. Para retornar um valor de percentil exato que talvez não esteja presente no seu conjunto de dados, use `percentileCont`. 

## Sintaxe
<a name="percentileDisc-function-syntax"></a>

```
percentileDisc(expression, percentile, [group-by level])
```

## Argumentos
<a name="percentileDisc-function-arguments"></a>

 *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*   
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. 

 *nível por grupo*   
(Opcional) Especifica o nível pelo qual agrupar a agregação. O nível adicionado pode ser qualquer dimensão ou dimensões, independentemente das dimensões adicionadas ao elemento visual.  
O argumento deve ser um campo de dimensão. O nível por grupo deve estar entre colchetes `[ ]`. Para obter mais informações, consulte [Cálculo sensível ao nível - funções agregadas (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)).

## Retornos
<a name="percentileDisc-function-return-type"></a>

O resultado da função é um número. 

## Observações de uso
<a name="percentileDisc-usage-notes"></a>

`percentileDisc` é uma função de distribuição inversa que pressupõe um modelo de distribuição discreta. Ela pega um valor percentil e uma especificação de classificação e retorna um elemento do conjunto fornecido. 

Para um determinado valor de percentil `P`, `percentileDisc` usa os valores classificados no elemento visual e retorna o valor com o menor valor de distribuição cumulativa maior ou igual a `P`. 

## Exemplos de percentileDisc
<a name="percentileDisc-examples"></a>

Os exemplos a seguir ajudam a explicar como o percentileDisc funciona.

**Example Comparar a mediana, `percentileDisc` e `percentileCont`**  
O exemplo a seguir mostra a mediana de uma dimensão (categoria) usando as funções `percentileCont`, `percentileDisc` e `median`. O valor médio é o mesmo que o valor de percentileCont. `percentileCont` interpola um valor, que pode ou não estar no conjunto de dados. No entanto, como `percentileDisc` sempre exibe o valor mais próximo que existe no conjunto de dados, os dois resultados podem não corresponder. A última coluna neste exemplo mostra a diferença entre os dois valores. O código para cada campo calculado é o seguinte:  
+ `50%Cont = percentileCont( example , 50 )`
+ `median = median( example )`
+ `50%Disc = percentileDisc( example , 50 )`
+ `Cont-Disc = percentileCont( example , 50 ) − percentileDisc( example , 50 )`
+ `example = left( category, 1 )` (Para fazer um exemplo mais simples, usamos essa expressão para encurtar os nomes das categorias até a primeira letra.)

```
 example     median       50%Cont      50%Disc      Cont-Disc
 -------- ----------- ------------ -------------- ------------ 
 A          22.48          22.48          22.24          0.24
 B          20.96          20.96          20.95          0.01
 C          24.92          24.92          24.92          0
 D          24.935         24.935         24.92          0.015
 E          14.48          14.48          13.99          0.49
```

**Example 100º percentil como máximo**  
O exemplo a seguir mostra uma variedade de valores de `percentileDisc` para o campo `example`. Os campos calculados `n%Disc` são definidos como `percentileDisc( {example} ,n)`. Os valores em cada coluna são números reais provenientes do conjunto de dados.   

```
 example     50%Disc      75%Disc        99%Disc      100%Disc
 -------- ----------- ------------ -------------- ------------ 
 A            20.97        73.98         699.99       6783.02
 B            42.19        88.84         820.08       6783.02
 C            30.52        90.48         733.44       6783.02
 D            41.38        85.99         901.29       6783.0
```

Você também pode especificar em que nível agrupar a computação usando uma ou mais dimensões na visualização ou no seu conjunto de dados. Isso é chamado de função LAC-A. Para obter mais informações sobre as funções LAC-A, consulte [Cálculo sensível ao nível - funções agregadas (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)). O exemplo a seguir calcula o 30º percentil com base em uma distribuição contínua dos números no nível do país, mas não em outras dimensões (região) no elemento visual.

```
percentile({Sales}, 30, [Country])
```

![\[O percentil de vendas em cada país.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/percentile-function-example-lac.png)


# periodToDateAvg
<a name="periodToDateAvg-function"></a>

A função `periodToDateAvg` calcula a média do conjunto de números na medida especificada para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo, em relação a esse período.

## Sintaxe
<a name="periodToDateAvg-function-syntax"></a>

```
periodToDateAvg(
	measure, 
	dateTime, 
	period, 
	endDate (optional))
```

## Argumentos
<a name="periodToDateAvg-function-arguments"></a>

 *medida*   
O argumento deve ser um campo. Valores nulos são omitidos nos resultados. Valores literais não funcionam.

 *dateTime*   
A dimensão Data na qual você está computando PeriodToDate agregações.

 *período*   
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`.

 *endDate*   
(Opcional) A dimensão da data em que você está encerrando periodToDate as agregações computacionais. Se omitida, assumirá `now()` como padrão.

## Exemplo
<a name="periodToDateAvg-function-example"></a>

O exemplo a seguir calcula o valor week-to-date mínimo da tarifa por tipo de pagamento, para a semana de 30/06/21. Para simplificar o exemplo, filtramos um único pagamento. A data 30/6/21 é quarta-feira. O Quick começa a semana aos domingos. No nosso exemplo, essa data é 27/6/21.

```
periodToDateAvg(fare_amount, pickUpDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy"))
```

![\[Esta é uma imagem dos resultados do cálculo de exemplo.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/PTDAvgResults.png)


# periodToDateCount
<a name="periodToDateCount-function"></a>

A função `periodToDateCount` calcula o número de valores em uma dimensão ou medida, incluindo duplicatas, para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo, em relação a esse período.

## Sintaxe
<a name="periodToDateCount-function-syntax"></a>

```
periodToDateCount(
	measure, 
	dateTime, 
	period, 
	endDate (optional))
```

## Argumentos
<a name="periodToDateCount-function-arguments"></a>

 *medida*   
O argumento deve ser um campo. Valores nulos são omitidos nos resultados. Valores literais não funcionam.

 *dateTime*   
A dimensão Data na qual você está computando PeriodToDate agregações.

 *período*   
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`.

 *endDate*   
(Opcional) A dimensão da data em que você está encerrando periodToDate as agregações computacionais. Se omitida, assumirá `now()` como padrão.

## Exemplo
<a name="periodToDateCount-function-example"></a>

O exemplo a seguir calcula o valor week-to-date mínimo da tarifa por tipo de pagamento, para a semana de 30/06/21. Para simplificar o exemplo, filtramos um único pagamento. A data 30/6/21 é quarta-feira. O Quick começa a semana aos domingos. No nosso exemplo, essa data é 27/6/21.

```
periodToDateCount(fare_amount, pickUpDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy"))
```

![\[Esta é uma imagem dos resultados do cálculo de exemplo.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/PTDCountResults.png)


# periodToDateMax
<a name="periodToDateMax-function"></a>

A função `periodToDateMax` retorna o valor máximo da medida especificada para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo, em relação a esse ponto.

## Sintaxe
<a name="periodToDateMax-function-syntax"></a>

```
periodToDateMax(
	measure, 
	dateTime, 
	period, 
	endDate (optional))
```

## Argumentos
<a name="periodToDateMax-function-arguments"></a>

 *medida*   
O argumento deve ser um campo. Valores nulos são omitidos nos resultados. Valores literais não funcionam.

 *dateTime*   
A dimensão Data na qual você está computando PeriodToDate agregações.

 *período*   
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`.

 *endDate*   
(Opcional) A dimensão da data em que você está encerrando periodToDate as agregações computacionais. Se omitida, assumirá `now()` como padrão.

## Exemplo
<a name="periodToDateMax-function-example"></a>

O exemplo a seguir calcula o valor week-to-date mínimo da tarifa por tipo de pagamento, para a semana de 30/06/21. Para simplificar o exemplo, filtramos um único pagamento. A data 30/6/21 é quarta-feira. O Quick começa a semana aos domingos. No nosso exemplo, essa data é 27/6/21.

```
periodToDateMax(fare_amount, pickUpDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy"))
```

![\[Esta é uma imagem dos resultados do cálculo de exemplo.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/PTDMaxResults.png)


# periodToDateMedian
<a name="periodToDateMedian-function"></a>

A função `periodToDateMedian` retorna o valor médio da medida especificada para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo, em relação a esse período.

## Sintaxe
<a name="periodToDateMedian-function-syntax"></a>

```
periodToDateMedian(
	measure, 
	dateTime, 
	period, 
	endDate (optional))
```

## Argumentos
<a name="periodToDateMedian-function-arguments"></a>

 *medida*   
O argumento deve ser um campo. Valores nulos são omitidos nos resultados. Valores literais não funcionam.

 *dateTime*   
A dimensão Data na qual você está computando PeriodToDate agregações.

 *período*   
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`.

 *endDate*   
(Opcional) A dimensão da data em que você está encerrando periodToDate as agregações computacionais. Se omitida, assumirá `now()` como padrão.

## Exemplo
<a name="periodToDateMedian-function-example"></a>

O exemplo a seguir calcula o valor week-to-date mínimo da tarifa por tipo de pagamento, para a semana de 30/06/21. Para simplificar o exemplo, filtramos um único pagamento. A data 30/6/21 é quarta-feira. O Quick começa a semana aos domingos. No nosso exemplo, essa data é 27/6/21.

```
periodToDateMedian(fare_amount, pickUpDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy"))
```

![\[Esta é uma imagem dos resultados do cálculo de exemplo.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/PTDMedianResults.png)


# periodToDateMin
<a name="periodToDateMin-function"></a>

A função `periodToDateMin` retorna o valor mínimo da medida ou data especificada, ou uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo, em relação a esse período.

## Sintaxe
<a name="periodToDateMin-function-syntax"></a>

```
periodToDateMin(
	measure, 
	dateTime, 
	period, 
	endDate (optional))
```

## Argumentos
<a name="periodToDateMin-function-arguments"></a>

 *medida*   
O argumento deve ser um campo. Valores nulos são omitidos nos resultados. Valores literais não funcionam.

 *dateTime*   
A dimensão Data na qual você está computando PeriodToDate agregações.

 *período*   
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`.

 *endDate*   
(Opcional) A dimensão da data em que você está encerrando periodToDate as agregações computacionais. Se omitida, assumirá `now()` como padrão.

## Exemplo
<a name="periodToDateMin-function-example"></a>

O exemplo a seguir calcula o valor week-to-date mínimo da tarifa por tipo de pagamento, para a semana de 30/06/21. Para simplificar o exemplo, filtramos um único pagamento. A data 30/6/21 é quarta-feira. O Quick começa a semana aos domingos. No nosso exemplo, essa data é 27/6/21.

```
periodToDateMin(fare_amount, pickUpDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy"))
```

![\[Esta é uma imagem dos resultados do cálculo de exemplo.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/PTDMinResults.png)


# periodToDatePercentile
<a name="periodToDatePercentile-function"></a>

A função `periodToDatePercentile` calcula o percentil com base nos números reais medidos para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo, em relação a esse período. Ela usa o agrupamento e a classificação aplicados nas fontes do campo.

Para retornar o valor do percentil mais próximo que está presente no seu conjunto de dados, use `periodToDatePercentile`. Para retornar um valor de percentil exato que talvez não esteja presente no seu conjunto de dados, use `periodToDatePercentileCont`.

## Sintaxe
<a name="periodToDatePercentile-function-syntax"></a>

```
periodToDatePercentile(
	measure, 
	percentile, 
	dateTime, 
	period, 
	endDate (optional))
```

## Argumentos
<a name="periodToDatePercentile-function-arguments"></a>

 *medida*   
O argumento deve ser um campo. Valores nulos são omitidos nos resultados. Valores literais não funcionam.

 *percentil*   
O valor do percentil pode ser qualquer constante numérica de 0 a 100. Um percentil de 50 computa o valor médio da medida.

 *dateTime*   
A dimensão Data na qual você está computando PeriodToDate agregações.

 *período*   
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`.

 *endDate*   
(Opcional) A dimensão da data em que você está encerrando periodToDate as agregações computacionais. Se omitida, assumirá `now()` como padrão.

## Exemplo
<a name="periodToDatePercentile-function-example"></a>

O exemplo a seguir calcula o week-to-date 90º percentil do valor da tarifa por tipo de pagamento para a semana de 30/06/21. Para simplificar o exemplo, filtramos um único pagamento. A data 30/6/21 é quarta-feira. O Quick começa a semana aos domingos. No nosso exemplo, essa data é 27/6/21.

```
periodToDatePercentile(fare_amount, 90, pickupDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy"))
```

![\[Esta é uma imagem do retorno do cálculo de exemplo.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/PTDPercentileResults.png)


# periodToDatePercentileCont
<a name="periodToDatePercentileCont-function"></a>

A função `periodToDatePercentileCont` calcula o percentil com base em uma distribuição contínua dos números na medida para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo nesse período. Ela usa o agrupamento e a classificação aplicados nas fontes do campo.

Para retornar um valor percentual exato que talvez não esteja presente no seu conjunto de dados, use `periodToDatePercentileCont`. Para retornar o valor percentual mais próximo que está presente no seu conjunto de dados, use `periodToDatePercentile`.

## Sintaxe
<a name="periodToDatePercentileCont-function-syntax"></a>

```
periodToDatePercentileCont(
	measure, 
	percentile, 
	dateTime, 
	period, 
	endDate (optional))
```

## Argumentos
<a name="periodToDatePercentileCont-function-arguments"></a>

 *medida*   
O argumento deve ser um campo. Valores nulos são omitidos nos resultados. Valores literais não funcionam.

 *percentil*   
O valor do percentil pode ser qualquer constante numérica de 0 a 100. Um percentil de 50 computa o valor médio da medida.

 *dateTime*   
A dimensão Data na qual você está computando PeriodToDate agregações.

 *período*   
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`.

 *endDate*   
(Opcional) A dimensão da data em que você está encerrando periodToDate as agregações computacionais. Se omitida, assumirá `now()` como padrão.

## Exemplo
<a name="periodToDatePercentileCont-function-example"></a>

O exemplo a seguir calcula o week-to-date 90º percentil do valor da tarifa por tipo de pagamento para a semana de 30/06/21. Para simplificar o exemplo, filtramos um único pagamento. A data 30/6/21 é quarta-feira. O Quick começa a semana aos domingos. No nosso exemplo, essa data é 27/6/21.

```
periodToDatePercentileCont(fare_amount, 90, pickupDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy"))
```

![\[Esta é uma imagem do retorno do cálculo de exemplo.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/PTDContPercentileResults.png)


# periodToDateStDev
<a name="periodToDateStDev-function"></a>

A função `periodToDateStDev` calcula o desvio padrão do conjunto de números na medida especificada para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo, com base em uma amostra e em relação a esse período.

## Sintaxe
<a name="periodToDateStDev-function-syntax"></a>

```
periodToDateStDev(
	measure, 
	dateTime, 
	period, 
	endDate (optional))
```

## Argumentos
<a name="periodToDateStDev-function-arguments"></a>

 *medida*   
O argumento deve ser um campo. Valores nulos são omitidos nos resultados. Valores literais não funcionam.

 *dateTime*   
A dimensão Data na qual você está computando PeriodToDate agregações.

 *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`.

 *endDate*   
(Opcional) A dimensão da data em que você está encerrando periodToDate as agregações computacionais. Se omitida, assumirá `now()` como padrão.

## Exemplo
<a name="periodToDateStDev-function-example"></a>

O exemplo a seguir calcula o valor week-to-date mínimo da tarifa por tipo de pagamento, para a semana de 30/06/21. Para simplificar o exemplo, filtramos um único pagamento. A data 30/6/21 é quarta-feira. O Quick começa a semana aos domingos. No nosso exemplo, essa data é 27/6/21.

```
periodToDateStDev(fare_amount, pickUpDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy"))
```

![\[Esta é uma imagem dos resultados do cálculo de exemplo.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/PTDStDevResults.png)


# periodToDateStDevP
<a name="periodToDateStDevP-function"></a>

A função `periodToDateStDevP` calcula o desvio padrão da população do conjunto de números na medida especificada, para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo, com base em uma amostra desse período.

## Sintaxe
<a name="periodToDateStDevP-function-syntax"></a>

```
periodToDateStDevP(
	measure, 
	dateTime, 
	period, 
	endDate (optional))
```

## Argumentos
<a name="periodToDateStDevP-function-arguments"></a>

 *medida*   
O argumento deve ser um campo. Valores nulos são omitidos nos resultados. Valores literais não funcionam.

 *dateTime*   
A dimensão Data na qual você está computando PeriodToDate agregações.

 *período*   
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`.

 *endDate*   
(Opcional) A dimensão da data em que você está encerrando periodToDate as agregações computacionais. Se omitida, assumirá `now()` como padrão.

## Exemplo
<a name="periodToDateStDevP-function-example"></a>

O exemplo a seguir calcula o valor week-to-date mínimo da tarifa por tipo de pagamento, para a semana de 30/06/21. Para simplificar o exemplo, filtramos um único pagamento. A data 30/6/21 é quarta-feira. O Quick começa a semana aos domingos. No nosso exemplo, essa data é 27/6/21.

```
periodToDateStDevP(fare_amount, pickUpDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy"))
```

![\[Esta é uma imagem dos resultados do cálculo de exemplo.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/PTDStDevPResults.png)


# periodToDateSum
<a name="periodToDateSum-function"></a>

A função `periodToDateSum` adiciona a medida especificada para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo, em relação a esse período.

## Sintaxe
<a name="periodToDateSum-function-syntax"></a>

```
periodToDateSum(
	measure, 
	dateTime, 
	period, 
	endDate)
```

## Argumentos
<a name="periodToDateSum-function-arguments"></a>

 *medida*   
O argumento deve ser um campo. Valores nulos são omitidos nos resultados. Valores literais não funcionam.

 *dateTime*   
A dimensão Data na qual você está computando PeriodToDate agregações.

 *período*   
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`.

 *endDate*   
(Opcional) A dimensão da data em que você está encerrando periodToDate as agregações computacionais. Se omitida, assumirá `now()` como padrão.

## Exemplo
<a name="periodToDateSum-function-example"></a>

A função a seguir calcula a soma semanal acumulada do valor da tarifa por pagamento, para a semana de 30/6/21. Para simplificar o exemplo, filtramos um único pagamento. A data 30/6/21 é quarta-feira. O Quick começa a semana aos domingos. No nosso exemplo, essa data é 27/6/21.

```
periodToDateSum(fare_amount, pickUpDateTime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy"))
```

![\[Esta é uma imagem dos resultados do exemplo, com ilustrações.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/PTDSumResults.png)


# periodToDateVar
<a name="periodToDateVar-function"></a>

A função `periodToDateVar` calcula a variação amostral do conjunto de números na medida especificada para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo nesse período.

## Sintaxe
<a name="periodToDateVar-function-syntax"></a>

```
periodToDateVar(
	measure, 
	dateTime, 
	period, 
	endDate (optional))
```

## Argumentos
<a name="periodToDateVar-function-arguments"></a>

 *medida*   
O argumento deve ser um campo. Valores nulos são omitidos nos resultados. Valores literais não funcionam.

 *dateTime*   
A dimensão Data na qual você está computando PeriodToDate agregações.

 *período*   
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`.

 *endDate*   
(Opcional) A dimensão da data em que você está encerrando periodToDate as agregações computacionais. Se omitida, assumirá `now()` como padrão.

## Exemplo
<a name="periodToDateVar-function-example"></a>

O exemplo a seguir calcula o valor week-to-date mínimo da tarifa por tipo de pagamento, para a semana de 30/06/21. Para simplificar o exemplo, filtramos um único pagamento. A data 30/6/21 é quarta-feira. O Quick começa a semana aos domingos. No nosso exemplo, essa data é 27/6/21.

```
periodToDateVar(fare_amount, pickUpDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy"))
```

![\[Esta é uma imagem dos resultados do cálculo de exemplo.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/PTDVarResults.png)


# periodToDateVarP
<a name="periodToDateVarP-function"></a>

A função `periodToDateVarP` calcula a variação populacional do conjunto de números na medida especificada para uma determinada granularidade de tempo (por exemplo, um quarto) até um ponto no tempo, relevante para esse período.

## Sintaxe
<a name="periodToDateVarP-function-syntax"></a>

```
periodToDateVarP(
	measure, 
	dateTime, 
	period, 
	endDate (optional))
```

## Argumentos
<a name="periodToDateVarP-function-arguments"></a>

 *medida*   
O argumento deve ser um campo. Valores nulos são omitidos nos resultados. Valores literais não funcionam.

 *dateTime*   
A dimensão Data na qual você está computando PeriodToDate agregações.

 *período*   
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`.

 *endDate*   
(Opcional) A dimensão da data em que você está encerrando periodToDate as agregações computacionais. Se omitida, assumirá `now()` como padrão.

## Exemplo
<a name="periodToDateVarP-function-example"></a>

O exemplo a seguir calcula o valor week-to-date mínimo da tarifa por tipo de pagamento, para a semana de 30/06/21. Para simplificar o exemplo, filtramos um único pagamento. A data 30/6/21 é quarta-feira. O Quick começa a semana aos domingos. No nosso exemplo, essa data é 27/6/21.

```
periodToDateVarP(fare_amount, pickUpDatetime, WEEK, parseDate("06-30-2021", "MM-dd-yyyy"))
```

![\[Esta é uma imagem dos resultados do cálculo de exemplo.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/PTDVarPResults.png)


# stdev
<a name="stdev-function"></a>

A função `stdev` calcula o desvio padrão do conjunto de números na medida especificada, agrupados pela dimensão ou dimensões escolhidas, com base em uma amostra.

## Sintaxe
<a name="stdev-function-syntax"></a>

```
stdev(measure, [group-by level])
```

## Argumentos
<a name="stdev-function-arguments"></a>

 *medida*   
O argumento deve ser uma medida. Valores nulos são omitidos nos resultados. Valores literais não funcionam. O argumento deve ser um campo.

 *nível por grupo*   
(Opcional) Especifica o nível pelo qual agrupar a agregação. O nível adicionado pode ser qualquer dimensão ou dimensões, independentemente das dimensões adicionadas ao elemento visual.  
O argumento deve ser um campo de dimensão. O nível por grupo deve estar entre colchetes `[ ]`. Para obter mais informações, consulte [Cálculo sensível ao nível - funções agregadas (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)).

## Exemplos
<a name="stdev-function-example"></a>

O exemplo a seguir retorna o desvio padrão das pontuações das provas de uma turma, usando uma amostra das pontuações registradas.

```
stdev({Score})
```

Você também pode especificar em que nível agrupar a computação usando uma ou mais dimensões na visualização ou no seu conjunto de dados. Isso é chamado de função LAC-A. Para obter mais informações sobre as funções LAC-A, consulte [Cálculo sensível ao nível - funções agregadas (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)). O exemplo a seguir calcula o desvio padrão das pontuações das provas no nível da disciplina, mas não em outras dimensões (turma) no elemento visual.

```
stdev({Score}, [Subject])
```

# stdevp
<a name="stdevp-function"></a>

A função `stdevp` calcula o desvio padrão da população do conjunto de números na medida especificada, agrupados pela dimensão ou dimensões escolhidas.

## Sintaxe
<a name="stdevp-function-syntax"></a>

```
stdevp(measure, [group-by level])
```

## Argumentos
<a name="stdevp-function-arguments"></a>

 *medida*   
O argumento deve ser uma medida. Valores nulos são omitidos nos resultados. Valores literais não funcionam. O argumento deve ser um campo.

 *nível por grupo*   
(Opcional) Especifica o nível pelo qual agrupar a agregação. O nível adicionado pode ser qualquer dimensão ou dimensões, independentemente das dimensões adicionadas ao elemento visual.  
O argumento deve ser um campo de dimensão. O nível por grupo deve estar entre colchetes `[ ]`. Para obter mais informações, consulte [Cálculo sensível ao nível - funções agregadas (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)).

## Exemplos
<a name="stdev-function-example"></a>

O exemplo a seguir retorna o desvio padrão das pontuações das provas de uma turma usando todas as pontuações registradas.

```
stdevp({Score})
```

Você também pode especificar em que nível agrupar a computação usando uma ou mais dimensões na visualização ou no seu conjunto de dados. Isso é chamado de função LAC-A. Para obter mais informações sobre as funções LAC-A, consulte [Cálculo sensível ao nível - funções agregadas (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)). O exemplo a seguir calcula o desvio padrão das pontuações das provas no nível da disciplina, mas não em outras dimensões (turma) no elemento visual, usando todas as pontuações registradas.

```
stdevp({Score}, [Subject])
```

# stdevIf
<a name="stdevIf-function"></a>

Com base em uma instrução condicional, a função `stdevIf` calcula o desvio padrão do conjunto de números na medida especificada, agrupados pela dimensão ou dimensões escolhidas, com base em uma amostra. 

## Sintaxe
<a name="stdevIf-function-syntax"></a>

```
stdevIf(measure, conditions)
```

## Argumentos
<a name="stdevIf-function-arguments"></a>

 *medida*   
O argumento deve ser uma medida. Valores nulos são omitidos nos resultados. Valores literais não funcionam. O argumento deve ser um campo.

 *condição*   
Uma ou mais condições em uma única declaração.

# stdevpIf
<a name="stdevpIf-function"></a>

Com base em uma instrução condicional, a função `stdevpIf` calcula o desvio padrão do conjunto de números na medida especificada, agrupados pela dimensão ou dimensões escolhidas, com base em uma população tendenciosa.

## Sintaxe
<a name="stdevpIf-function-syntax"></a>

```
stdevpIf(measure, conditions)
```

## Argumentos
<a name="stdevpIf-function-arguments"></a>

 *medida*   
O argumento deve ser uma medida. Valores nulos são omitidos nos resultados. Valores literais não funcionam. O argumento deve ser um campo.

 *condição*   
Uma ou mais condições em uma única declaração.

# sum
<a name="sum-function"></a>

A função `sum` adiciona o conjunto de números na medida especificada, agrupado pela dimensão ou dimensões escolhidas. Por exemplo, `sum(profit amount)` retorna o valor do lucro total agrupado pela dimensão escolhida (opcional).

## Sintaxe
<a name="sum-function-syntax"></a>

```
sum(measure, [group-by level])
```

## Argumentos
<a name="sum-function-arguments"></a>

 *medida*   
O argumento deve ser uma medida. Valores nulos são omitidos nos resultados. Valores literais não funcionam. O argumento deve ser um campo.

 *nível por grupo*   
(Opcional) Especifica o nível pelo qual agrupar a agregação. O nível adicionado pode ser qualquer dimensão ou dimensões, independentemente das dimensões adicionadas ao elemento visual.  
O argumento deve ser um campo de dimensão. O nível por grupo deve estar entre colchetes `[ ]`. Para obter mais informações, consulte [Cálculo sensível ao nível - funções agregadas (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)).

## Exemplos
<a name="sum-function-example"></a>

O exemplo a seguir retorna a soma das vendas.

```
sum({Sales})
```

Você também pode especificar em que nível agrupar a computação usando uma ou mais dimensões na visualização ou no seu conjunto de dados. Isso é chamado de função LAC-A. Para obter mais informações sobre as funções LAC-A, consulte [Cálculo sensível ao nível - funções agregadas (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)). O exemplo a seguir calcula a soma das vendas no nível do país, mas não em outras dimensões (região e produto) no elemento visual.

```
sum(Sales, [Country])
```

![\[A soma das vendas para cada país.\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/sum-function-example.png)


# sumIf
<a name="sumIf-function"></a>

Com base em uma declaração condicional, a função `sumIf` adiciona o conjunto de números na medida especificada, agrupados pela dimensão ou dimensões escolhidas. Por exemplo, `sumIf(ProdRev,CalendarDay >= ${BasePeriodStartDate} AND CalendarDay <= ${BasePeriodEndDate} AND SourcingType <> 'Indirect')` retorna o valor total dos lucros agrupado pela dimensão escolhida (opcional), desde que a condição seja verdadeira.

## Sintaxe
<a name="sumIf-function-syntax"></a>

```
sumIf(measure, conditions)
```

## Argumentos
<a name="sumIf-function-arguments"></a>

 *medida*   
O argumento deve ser uma medida. Valores nulos são omitidos nos resultados. Valores literais não funcionam. O argumento deve ser um campo.

 *condição*   
Uma ou mais condições em uma única declaração.

## Exemplos
<a name="sumIf-function-example"></a>

O exemplo a seguir usa um campo calculado com `sumIf` para exibir o valor das vendas, se `Segment` for igual a `SMB`.

```
sumIf(Sales, Segment=’SMB’)
```

![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/quick/latest/userguide/images/sumIfCalc.png)


O exemplo a seguir usa um campo calculado com `sumIf` para exibir o valor das vendas se `Segment` for igual `SMB` e `Order Date` maior que o ano de 2022.

```
sumIf(Sales, Segment=’SMB’ AND {Order Date} >=’2022-01-01’)
```

# var
<a name="var-function"></a>

A função `var` calcula a variação da amostra do conjunto de números na medida especificada, agrupados pela dimensão ou dimensões escolhidas.

## Sintaxe
<a name="var-function-syntax"></a>

```
var(measure, [group-by level])
```

## Argumentos
<a name="var-function-arguments"></a>

 *medida*   
O argumento deve ser uma medida. Valores nulos são omitidos nos resultados. Valores literais não funcionam. O argumento deve ser um campo.

 *nível por grupo*   
(Opcional) Especifica o nível pelo qual agrupar a agregação. O nível adicionado pode ser qualquer dimensão ou dimensões, independentemente das dimensões adicionadas ao elemento visual.  
O argumento deve ser um campo de dimensão. O nível por grupo deve estar entre colchetes `[ ]`. Para obter mais informações, consulte [Cálculo sensível ao nível - funções agregadas (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)).

## Exemplos
<a name="var-function-example"></a>

O exemplo a seguir retorna a variação de uma amostra de pontuações de provas.

```
var({Scores})
```

Você também pode especificar em que nível agrupar a computação usando uma ou mais dimensões na visualização ou no seu conjunto de dados. Isso é chamado de função LAC-A. Para obter mais informações sobre as funções LAC-A, consulte [Cálculo sensível ao nível - funções agregadas (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)). O exemplo a seguir retorna a variação de uma amostra de pontuações de provas no nível da disciplina, mas não em outras dimensões (turma) no elemento visual.

```
var({Scores}, [Subject]
```

# varIf
<a name="varIf-function"></a>

Com base em uma instrução condicional, a função `varIf` calcula a variação do conjunto de números na medida especificada, agrupados pela dimensão ou dimensões escolhidas, com base em uma amostra.

## Sintaxe
<a name="varIf-function-syntax"></a>

```
varIf(measure, conditions)
```

## Argumentos
<a name="varIf-function-arguments"></a>

 *medida*   
O argumento deve ser uma medida. Valores nulos são omitidos nos resultados. Valores literais não funcionam. O argumento deve ser um campo.

 *condição*   
Uma ou mais condições em uma única declaração.

# varp
<a name="varp-function"></a>

A função `varp` calcula a variação da população do conjunto de números na medida especificada, agrupados pela dimensão ou dimensões escolhidas.

## Sintaxe
<a name="varp-function-syntax"></a>

```
varp(measure, [group-by level])
```

## Argumentos
<a name="varp-function-arguments"></a>

 *medida*   
O argumento deve ser uma medida. Valores nulos são omitidos nos resultados. Valores literais não funcionam. O argumento deve ser um campo.

 *nível por grupo*   
(Opcional) Especifica o nível pelo qual agrupar a agregação. O nível adicionado pode ser qualquer dimensão ou dimensões, independentemente das dimensões adicionadas ao elemento visual.  
O argumento deve ser um campo de dimensão. O nível por grupo deve estar entre colchetes `[ ]`. Para obter mais informações, consulte [Cálculo sensível ao nível - funções agregadas (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)).

## Exemplos
<a name="varp-function-example"></a>

O exemplo a seguir retorna a variação de uma população de pontuações de provas.

```
varp({Scores})
```

Você também pode especificar em que nível agrupar a computação usando uma ou mais dimensões na visualização ou no seu conjunto de dados. Isso é chamado de função LAC-A. Para obter mais informações sobre as funções LAC-A, consulte [Cálculo sensível ao nível - funções agregadas (LAC-A](https://docs.aws.amazon.com/quicksight/latest/user/level-aware-calculations-aggregate.html)). O exemplo a seguir retorna a variação de uma população de pontuações de provas no nível da disciplina, mas não em outras dimensões (turma) no elemento visual.

```
varp({Scores}, [Subject]
```

# varpIf
<a name="varpIf-function"></a>

Com base em uma instrução condicional, a função `varpIf` calcula a variação do conjunto de números na medida especificada, agrupados pela dimensão ou dimensões escolhidas, com base em uma população tendenciosa.

## Sintaxe
<a name="varpIf-function-syntax"></a>

```
varpIf(measure, conditions)
```

## Argumentos
<a name="varpIf-function-arguments"></a>

 *medida*   
O argumento deve ser uma medida. Valores nulos são omitidos nos resultados. Valores literais não funcionam. O argumento deve ser um campo.

 *condição*   
Uma ou mais condições em uma única declaração.

# Funções de cálculos de tabela
<a name="table-calculation-functions"></a>

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 name="difference-function"></a>

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
<a name="difference-function-syntax"></a>

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
<a name="difference-function-arguments"></a>

 *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
<a name="difference-function-example"></a>

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 name="distinctCountOver-function"></a>

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
<a name="distinctCountOver-function-syntax"></a>

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
<a name="distinctCountOver-function-arguments"></a>

 *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
<a name="distinctCountOver-function-example"></a>

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 name="lag-function"></a>

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
<a name="lag-function-syntax"></a>

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
<a name="lag-function-arguments"></a>

*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
<a name="lag-function-example"></a>

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 name="lead-function"></a>

A função `lead` calcula o valor inicial (seguinte) para uma medida com base em partições e classificações especificadas.

## Sintaxe
<a name="lead-function-syntax"></a>

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
<a name="lead-function-arguments"></a>

*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
<a name="lead-function-example"></a>

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 name="percentDifference-function"></a>

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
<a name="percentDifference-function-syntax"></a>

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
<a name="percentDifference-function-arguments"></a>

 *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
<a name="percentDifference-function-example"></a>

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 name="avgOver-function"></a>

A função `avgOver` calcula a média de uma medida particionada por uma lista de dimensões. 

## Sintaxe
<a name="avgOver-function-syntax"></a>

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
<a name="avgOver-function-arguments"></a>

 *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
<a name="avgOver-function-example"></a>

O exemplo a seguir obtém a `sum(Sales)` média particionada por `City` e `State`. 

```
avgOver
(
     sum(Sales), 
     [City, State]
)
```

# countOver
<a name="countOver-function"></a>

A função `countOver` calcula a contagem de uma dimensão ou medida particionada por uma lista de dimensões. 

## Sintaxe
<a name="countOver-function-syntax"></a>

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
<a name="countOver-function-arguments"></a>

 *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
<a name="countOver-function-example"></a>

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 name="maxOver-function"></a>

A função `maxOver` calcula o máximo de uma medida ou data particionada por uma lista de dimensões. 

## Sintaxe
<a name="maxOver-function-syntax"></a>

São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.

```
maxOver
(
     measure 
     ,[ partition_field, ... ] 
     ,calculation level 
)
```

## Argumentos
<a name="maxOver-function-arguments"></a>

 *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
<a name="maxOver-function-example"></a>

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 name="minOver-function"></a>

A função `minOver` calcula o mínimo de uma medida ou data particionada por uma lista de dimensões. 

## Sintaxe
<a name="minOver-function-syntax"></a>

São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.

```
minOver
(
     measure 
     ,[ partition_field, ... ] 
     ,calculation level 
)
```

## Argumentos
<a name="minOver-function-arguments"></a>

*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
<a name="minOver-function-example"></a>

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 name="percentileOver-function"></a>

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 name="percentileContOver-function"></a>

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
<a name="percentileContOver-function-syntax"></a>

```
percentileContOver (
    measure
  , percentile-n
  , [partition-by, …]
  , calculation-level
)
```

## Argumentos
<a name="percentileContOver-function-arguments"></a>

 *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
<a name="percentileContOver-function-return-type"></a>

O resultado da função é um número. 

## Exemplo de percentileContOver
<a name="percentileContOver-examples"></a>

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 name="percentileDiscOver-function"></a>

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
<a name="percentileDiscOver-function-syntax"></a>

```
percentileDiscOver (
     measure
   , percentile-n
   , [partition-by, …]
   , calculation-level
)
```

## Argumentos
<a name="percentileDiscOver-function-arguments"></a>

 *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
<a name="percentileDiscOver-function-return-type"></a>

O resultado da função é um número. 

## Exemplo de percentileDiscOver
<a name="percentileDiscOver-examples"></a>

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 name="percentOfTotal-function"></a>

A função `percentOfTotal` calcula a porcentagem de contribuição de uma medida para o total, com base nas dimensões especificadas. 

## Sintaxe
<a name="percentOfTotal-function-syntax"></a>

São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.

```
percentOfTotal
(
     measure 
     ,[ partition_field, ... ] 
)
```

## Argumentos
<a name="percentOfTotal-function-arguments"></a>

 *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
<a name="percentOfTotal-function-example"></a>

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 name="periodOverPeriodDifference-function"></a>

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
<a name="periodOverPeriodDifference-function-syntax"></a>

```
periodOverPeriodDifference(
	measure, 
	date, 
	period, 
	offset)
```

## Argumentos
<a name="periodOverPeriodDifference-function-arguments"></a>

 *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
<a name="periodOverPeriodDifference-function-example"></a>

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 name="periodOverPeriodLastValue-function"></a>

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
<a name="periodOverPeriodLastValue-function-syntax"></a>

```
periodOverPeriodLastValue(
	measure, 
	date, 
	period, 
	offset)
```

## Argumentos
<a name="periodOverPeriodLastValue-function-arguments"></a>

 *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
<a name="periodOverPeriodLastValue-function-example"></a>

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 name="periodOverPeriodPercentDifference-function"></a>

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
<a name="periodOverPeriodPercentDifference-function-syntax"></a>

```
periodOverPeriodPercentDifference(
	measure, 
	date, 
	period, 
	offset)
```

## Argumentos
<a name="periodOverPeriodPercentDifference-function-arguments"></a>

 *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
<a name="periodOverPeriodPercentDifference-function-example"></a>

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 name="periodToDateAvgOverTime-function"></a>

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
<a name="periodToDateAvgOverTime-function-syntax"></a>

```
periodToDateAvgOverTime(
	measure, 
	dateTime,
	period)
```

## Argumentos
<a name="periodToDateAvgOverTime-function-arguments"></a>

 *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 name="periodToDateAvgOverTime-function-example"></a>

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 name="periodToDateCountOverTime-function"></a>

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
<a name="periodToDateCountOverTime-function-syntax"></a>

```
periodToDateCountOverTime(
	measure, 
	dateTime, 
	period)
```

## Argumentos
<a name="periodToDateCountOverTime-function-arguments"></a>

 *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 name="periodToDateCountOverTime-function-example"></a>

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 name="periodToDateMaxOverTime-function"></a>

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
<a name="periodToDateMaxOverTime-function-syntax"></a>

```
periodToDateMaxOverTime(
	measure, 
	dateTime, 
	period)
```

## Argumentos
<a name="periodToDateMaxOverTime-function-arguments"></a>

 *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 name="periodToDateMaxOverTime-function-example"></a>

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 name="periodToDateMinOverTime-function"></a>

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
<a name="periodToDateMinOverTime-function-syntax"></a>

```
periodToDateMinOverTime(
	measure, 
	dateTime, 
	period)
```

## Argumentos
<a name="periodToDateMinOverTime-function-arguments"></a>

 *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 name="periodToDateMinOverTime-function-example"></a>

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 name="periodToDateSumOverTime-function"></a>

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
<a name="periodToDateSumOverTime-function-syntax"></a>

```
periodToDateSumOverTime(
	measure, 
	dateTime, 
	period)
```

## Argumentos
<a name="periodToDateSumOverTime-function-arguments"></a>

 *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 name="periodToDateSumOverTime-function-example"></a>

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 name="stdevOver-function"></a>

A função `stdevOver` calcula o desvio padrão da medida especificada, particionado pelo atributo ou atributos escolhidos, com base em uma amostra. 

## Sintaxe
<a name="stdevOver-function-syntax"></a>

São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.

```
stdevOver
(
      measure 
     ,[ partition_field, ... ] 
     ,calculation level 
)
```

## Argumentos
<a name="stdevOver-function-arguments"></a>

*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
<a name="stdevOver-function-example"></a>

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 name="stdevpOver-function"></a>

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
<a name="stdevpOver-function-syntax"></a>

São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.

```
stdevpOver
(
     measure 
     ,[ partition_field, ... ] 
     ,calculation level 
)
```

## Argumentos
<a name="stdevpOver-function-arguments"></a>

*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
<a name="stdevpOver-function-example"></a>

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 name="varOver-function"></a>

A função `varOver` calcula a variação da medida especificada, particionada pelo atributo ou atributos escolhidos, com base em uma amostra. 

## Sintaxe
<a name="varOver-function-syntax"></a>

São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.

```
varOver
(
     measure 
     ,[ partition_field, ... ] 
     ,calculation level 
)
```

## Argumentos
<a name="varOver-function-arguments"></a>

*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
<a name="varOver-function-example"></a>

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 name="varpOver-function"></a>

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
<a name="varpOver-function-syntax"></a>

São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.

```
varpOver
(
     measure 
     ,[ partition_field, ... ] 
     ,calculation level 
)
```

## Argumentos
<a name="varpOver-function-arguments"></a>

*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
<a name="varpOver-function-example"></a>

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 name="sumOver-function"></a>

 A função `sumOver` calcula a soma de uma medida particionada por uma lista de dimensões. 

## Sintaxe
<a name="sumOver-function-syntax"></a>

São necessários colchetes. Para ver quais argumentos são opcionais, consulte as seguintes descrições.

```
sumOver
(
     measure 
     ,[ partition_field, ... ] 
     ,calculation level 
)
```

## Argumentos
<a name="sumOver-function-arguments"></a>

*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
<a name="sumOver-function-example"></a>

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 name="denseRank-function"></a>

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
<a name="denseRank-function-syntax"></a>

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
<a name="denseRank-function-arguments"></a>

 *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
<a name="denseRank-function-example"></a>

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 name="rank-function"></a>

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
<a name="rank-function-syntax"></a>

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
<a name="rank-function-arguments"></a>

 *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
<a name="rank-function-example"></a>

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 name="percentileRank-function"></a>

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
<a name="percentileRank-function-syntax"></a>

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
<a name="percentileRank-function-arguments"></a>

 *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
<a name="percentileRank-function-example"></a>

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 name="runningAvg-function"></a>

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
<a name="runningAvg-function-syntax"></a>

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
<a name="runningAvg-function-arguments"></a>

 *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
<a name="runningAvg-function-example"></a>

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 name="runningCount-function"></a>

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
<a name="runningCount-function-syntax"></a>

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
<a name="runningCount-function-arguments"></a>

 *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
<a name="runningCount-function-example"></a>

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 name="runningMax-function"></a>

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
<a name="runningMax-function-syntax"></a>

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
<a name="runningMax-function-arguments"></a>

 *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
<a name="runningMax-function-example"></a>

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 name="runningMin-function"></a>

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
<a name="runningMin-function-syntax"></a>

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
<a name="runningMin-function-arguments"></a>

 *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
<a name="runningMin-function-example"></a>

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 name="runningSum-function"></a>

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
<a name="runningSum-function-syntax"></a>

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
<a name="runningSum-function-arguments"></a>

 *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
<a name="runningSum-function-example"></a>

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 name="firstValue-function"></a>

A função `firstValue` calcula o primeiro valor da medida ou dimensão agregada particionada e classificada por atributos especificados.

## Sintaxe
<a name="firstValue-function-syntax"></a>

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
<a name="firstValue-function-arguments"></a>

*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
<a name="firstValue-function-example"></a>

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 name="lastValue-function"></a>

A função `lastValue` calcula o último valor da dimensão ou medida agregada particionada e classificada por atributos especificados.

## Sintaxe
<a name="lastValue-function-syntax"></a>

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
<a name="lastValue-function-arguments"></a>

*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
<a name="lastValue-function-example"></a>

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 name="windowAvg-function"></a>

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
<a name="windowAvg-function-syntax"></a>

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
<a name="windowAvg-function-arguments"></a>

*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
<a name="windowAvg-function-example"></a>

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 name="windowCount-function"></a>

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
<a name="windowCount-function-syntax"></a>

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
<a name="windowCount-function-arguments"></a>

*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
<a name="windowCount-function-example"></a>

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 name="windowMax-function"></a>

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
<a name="windowMax-function-syntax"></a>

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
<a name="windowMax-function-arguments"></a>

*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
<a name="windowMax-function-example"></a>

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 name="windowMin-function"></a>

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
<a name="windowMin-function-syntax"></a>

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
<a name="windowMin-function-arguments"></a>

*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
<a name="windowMin-function-example"></a>

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 name="windowSum-function"></a>

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
<a name="windowSum-function-syntax"></a>

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
<a name="windowSum-function-arguments"></a>

*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
<a name="windowSum-function-example"></a>

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)
