As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Funções 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 `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 ``` addDateTime(amount, period, datetime) ``` ## Argumentos *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 Datetime ## Exemplo 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 `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 ``` addWorkDays(initDate, numWorkDays) ``` ## Argumentos *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 Inteiro ## Valores de saída 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 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 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 O `abs` retorna o valor absoluto de uma determinada expressão. ## Sintaxe ``` abs(expression) ``` ## Argumentos *expressão* A expressão deve ser numérica. Pode ser um nome de campo, um valor literal ou outra função. # Ceil `ceil` arredonda uma casa decimal para o próximo inteiro. Por exemplo, `ceil(29.02)` exibe `30`. ## Sintaxe ``` ceil(decimal) ``` ## Argumentos *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 Inteiro ## Exemplo 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 `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 ``` coalesce(expression1, expression2 [, expression3, ...]) ``` ## Argumentos `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 `coalesce` retorna um valor do mesmo tipo de dados como argumentos de entrada. ## Exemplo 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 `concat` concatena duas ou mais strings. ## Sintaxe ``` concat(expression1, expression2 [, expression3 ...]) ``` ## Argumentos `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 String ## Exemplos 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 `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 ``` contains(expression, substring, string-comparison-mode) ``` ## 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. *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 Booleano ## Exemplos ### Exemplo padrão de diferenciação entre maiúsculas e minúsculas 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 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 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 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 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 `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 ``` decimalToInt(decimal) ``` ## Argumentos *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 Inteiro ## Exemplo 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 `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 ``` dateDiff(date1, date2,[period]) ``` ## Argumentos `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 Inteiro ## Exemplo 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 `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 ``` endsWith(expression, substring, string-comparison-mode) ``` ## 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. *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 Booleano ## Exemplos ### Exemplo padrão de diferenciação entre maiúsculas e minúsculas 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 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 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 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 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 `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 ``` epochDate(epochdate) ``` ## Argumentos *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 Data ## Exemplo 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 O `exp` retorna a base de logaritmo natural e elevada à potência de uma determinada expressão. ## Sintaxe ``` exp(expression) ``` ## Argumentos *expressão* A expressão deve ser numérica. Pode ser um nome de campo, um valor literal ou outra função. # Extract `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 ``` extract(period, date) ``` ## Argumentos *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 Inteiro ## Exemplo 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 `floor` diminui um valor decimal até o próximo inteiro mais baixo. Por exemplo, `floor(29.08)` exibe `29`. ## Sintaxe ``` floor(decimal) ``` ## Argumentos *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 Inteiro ## Exemplo 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 `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 ``` formatDate(date, ['format']) ``` ## Argumentos *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 String ## Exemplo 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 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 `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 ``` ifelse(if-expression-1, then-expression-1 [, if-expression-n, then-expression-n ...], else-expression) ``` ## Argumentos `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 `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 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 *``*. 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', /**/ /*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 `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 Usando uma lista inserida manualmente: ``` in(expression, [literal-1, ...]) ``` Usando um parâmetro de vários valores: ``` in(expression, $multivalue_parameter) ``` ## Argumentos *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 Booleano: TRUE ou FALSE ## Exemplo com uma lista estática 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 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` `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 `intToDecimal` converte um valor inteiro no tipo de dados decimal. ## Sintaxe ``` intToDecimal(integer) ``` ## Argumentos *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 Decimal (fixo) na experiência antiga de preparação de dados. Decimal (Float) na nova experiência de preparação de dados. ## Exemplo 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 `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 ``` isNotNull(expression) ``` ## Argumentos *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 Booleano ## Exemplo 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 `isNull` avalia uma expressão para ver se é nula. Se a expressão for nula, `isNull` retornará verdadeiro; do contrário, retornará falso. ## Sintaxe ``` isNull(expression) ``` ## Argumentos *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 Booleano ## Exemplo 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 `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 ``` isWorkDay(inputDate) ``` ## Argumentos *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 Número inteiro (`0` ou `1`) ## Exemplo 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 `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 ``` left(expression, limit) ``` ## 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. *limit* O número de caracteres a ser retornado da *expressão*, a partir do primeiro caractere na string. ## Tipo de retorno String ## Exemplo 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 `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 ``` locate(expression, substring, start) ``` ## 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. *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 Inteiro ## Exemplos 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 O `log` retorna o logaritmo de base 10 de uma determinada expressão. ## Sintaxe ``` log(expression) ``` ## Argumentos *expressão* A expressão deve ser numérica. Pode ser um nome de campo, um valor literal ou outra função. # Ln O `ln` retorna o logaritmo natural de uma determinada expressão. ## Sintaxe ``` ln(expression) ``` ## Argumentos *expressão* A expressão deve ser numérica. Pode ser um nome de campo, um valor literal ou outra função. # Ltrim `ltrim` remove o espaço em branco anterior de uma string. ## Sintaxe ``` ltrim(expression) ``` ## 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 String ## Exemplo 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 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 ``` mod(number, divisor) ``` ``` number%divisor ``` ## Argumentos *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 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 `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 ``` netWorkDays(startDate, endDate) ``` ## Argumentos *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 Inteiro ## Valores de saída 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 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 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 ``` now() ``` ## Tipo de retorno Data # notIn `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 Usando uma lista inserida manualmente: ``` notIn(expression, [literal-1, ...]) ``` Usando um parâmetro de vários valores: ``` notIn(expression, $multivalue_parameter) ``` ## Argumentos *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 Booleano: TRUE ou FALSE ## Exemplo com uma lista inserida manualmente 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 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` `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 `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 ``` nullIf(expression1, expression2) ``` ## Argumentos `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 String ## Exemplo 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 `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 ``` parseDate(expression, ['format']) ``` ## 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 **'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 Data ## Exemplo 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 `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 ``` parseDecimal(expression) ``` ## 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 **'9.62'**, ou uma chamada para outra função que gere uma string. ## Tipo de retorno Decimal (fixo) na experiência antiga de preparação de dados. Decimal (Float) na nova experiência de preparação de dados. ## Exemplo 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 `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 ``` parseInt(expression) ``` ## 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 **'3'**, ou uma chamada para outra função que gere uma string. ## Tipo de retorno Inteiro ## Exemplo 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 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 ``` parseJson(fieldName, path) ``` ## Argumentos *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 String ## Exemplo 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 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 `replace` substitui parte de uma string por outra string que você especificar. ## Sintaxe ``` replace(expression, substring, replacement) ``` ## 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. *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 String ## Exemplo 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 `right` retorna os caracteres mais à direita de uma string, incluindo espaços. Você especifica o número de caracteres a ser retornado. ## Sintaxe ``` right(expression, limit) ``` ## 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. *limit* O número de caracteres a ser retornado da *expressão*, a partir do último caractere na string. ## Tipo de retorno String ## Exemplo 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 `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 ``` round(decimal, scale) ``` ## Argumentos *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 | 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 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 `rtrim` remove o espaço em branco posterior de uma string. ## Sintaxe ``` rtrim(expression) ``` ## 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 String ## Exemplo 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 `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 ``` split(expression, delimiter , position) ``` ## 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;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 Matriz de strings ## Exemplo 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 O `sqrt` retorna a raiz quadrada de uma determinada expressão. ## Sintaxe ``` sqrt(expression) ``` ## Argumentos *expressão* A expressão deve ser numérica. Pode ser um nome de campo, um valor literal ou outra função. # startsWith `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 ``` startsWith(expression, substring, string-comparison-mode) ``` ## 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. *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 Booleano ## Exemplos ### Exemplo padrão de diferenciação entre maiúsculas e minúsculas 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 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 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 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 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 `strlen` retorna os caracteres em uma string, incluindo espaços. ## Sintaxe ``` strlen(expression) ``` ## Argumentos *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 Inteiro ## Exemplo O exemplo a seguir retorna o comprimento da string especificada. ``` strlen('1421 Main Street') ``` O valor a seguir é retornado. ``` 16 ``` # Substring `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 ``` substring(expression, start, length) ``` ## Argumentos *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 String ## Exemplo 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 `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 ``` switch(condition-expression, label-1, return-expression-1 [, label-n, return-expression-n ...], default-expression) ``` ## Argumentos `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 `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 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` 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 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 `toLower` formata uma string toda em minúsculas. `toLower` ignora linhas que contêm valores nulos. ## Sintaxe ``` toLower(expression) ``` ## 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 String ## Exemplo 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 `toString` formata a expressão de entrada como uma string. `toString` ignora linhas que contêm valores nulos. ## Sintaxe ``` toString(expression) ``` ## Argumentos *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 String ## Exemplo 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 `toUpper` formata uma string toda em maiúsculas. `toUpper` ignora linhas que contêm valores nulos. ## Sintaxe ``` toUpper(expression) ``` ## 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 String ## Exemplo 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 `trim` remove o espaço em branco anterior e posterior de uma string. ## Sintaxe ``` trim(expression) ``` ## 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 String ## Exemplo 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 `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 ``` truncDate('period', date) ``` ## Argumentos *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 Data ## Exemplo 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 ```