Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Funciones
En esta sección encontrarás una lista de las funciones disponibles en Amazon Quick. Para ver una lista de funciones ordenadas por categoría, con breves definiciones, consulte [Funciones por categoría](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` suma o resta una unidad de tiempo a partir de valor de fecha y hora. Por ejemplo, `addDateTime(2,'YYYY',parseDate('02-JUL-2018', 'dd-MMM-yyyy') )` devuelve `02-JUL-2020`. Puede utilizar esta función para realizar cálculos de fecha en los datos de fecha y hora.
## Sintaxis
```
addDateTime(amount, period, datetime)
```
## Argumentos
*amount*
Un valor entero positivo o negativo que representa la cantidad de tiempo que desea sumar o restar en el campo de fecha y hora proporcionado.
*periodo*
Un valor positivo o negativo que representa la cantidad de tiempo que desea sumar o restar del campo de fecha y hora proporcionado. Los periodos válidos son los siguientes:
+ YYYY: devuelve la parte del año de la fecha.
+ Q: devuelve el trimestre al que pertenece la fecha (1 a 4).
+ MM: devuelve la parte del mes de la fecha.
+ DD: devuelve la parte del día de la fecha.
+ WK: devuelve la parte de la semana de la fecha. La semana comienza el domingo en Amazon Quick.
+ HH: devuelve la parte de la hora de la fecha.
+ MI: devuelve la parte de minutos de la fecha.
+ SS: devuelve la parte de segundos de la fecha.
+ MS: devuelve la parte de milisegundos de la fecha.
*datetime*
La fecha u hora en la que desea realizar cálculos de fecha.
## Tipo de devolución
Fecha y hora
## Ejemplo
Supongamos que tiene un campo llamado `purchase_date` que tiene los siguientes valores.
```
2018 May 13 13:24
2017 Jan 31 23:06
2016 Dec 28 06:45
```
Con los siguientes cálculos, `addDateTime` modifica los valores tal y como se muestra a continuación.
```
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` suma o resta un número designado de días laborables a un valor de fecha determinado. La función devuelve la fecha de un día laborable, es decir, un día laborable designado anterior o posterior a un valor de fecha de entrada determinado.
## Sintaxis
```
addWorkDays(initDate, numWorkDays)
```
## Argumentos
*initDate*
Una fecha válida que no sea NULL y que actúe como fecha de inicio del cálculo.
+ **Campo de conjunto de datos**: cualquier campo `date` del conjunto de datos al que vaya a agregar esta función.
+ **Función de fecha**: cualquier salida de fecha de otra función `date`, por ejemplo, `parseDate`, `epochDate`, `addDateTime`, etc.
**Example**
```
addWorkDays(epochDate(1659484800), numWorkDays)
```
+ **Campos calculados**: cualquier campo calculado rápidamente que devuelva un `date` valor.
**Example**
```
calcFieldStartDate = addDateTime(10, “DD”, startDate)
addWorkDays(calcFieldStartDate, numWorkDays)
```
+ **Parámetros**: cualquier `datetime` parámetro rápido.
**Example**
```
addWorkDays($paramStartDate, numWorkDays)
```
+ Cualquier combinación de los valores de los argumentos indicados anteriormente.
*numWorkDays*
Una número entero que no sea NULL y que actúe como fecha de finalización del cálculo.
+ **Literal**: número entero que se escribe directamente en el editor de expresiones.
**Example**
```
```
+ **Campo de conjunto de datos**: cualquier campo de fecha del conjunto de datos.
**Example**
```
```
+ **Función escalar o cálculo**: cualquier función rápida escalar que devuelva una salida entera de otra, por ejemplo `decimalToInt``abs`, y así sucesivamente.
**Example**
```
addWorkDays(initDate, decimalToInt(sqrt (abs(numWorkDays)) ) )
```
+ **Campo calculado: cualquier campo** calculado rápidamente que devuelva un `date` valor.
**Example**
```
someOtherIntegerCalcField = (num_days * 2) + 12
addWorkDays(initDate, someOtherIntegerCalcField)
```
+ **Parámetro**: cualquier `datetime` parámetro rápido.
**Example**
```
addWorkDays(initDate, $param_numWorkDays)
```
+ Cualquier combinación de los valores de los argumentos indicados anteriormente.
## Tipo de devolución
Entero
## Valores de salida
Los valores de salida esperados incluyen los siguientes:
+ Número entero positivo (cuando start\$1date < end\$1date)
+ Número entero negativo (cuando start\$1date > end\$1date)
+ NULL cuando uno o ambos argumentos obtienen un valor nulo de `dataset field`.
## Errores de entrada
Los valores de argumento no permitidos provocan errores, como se muestra en los siguientes ejemplos.
+ No se permite utilizar un valor NULL literal como argumento en la expresión.
**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.
```
+ No se permite utilizar una cadena literal como argumento, ni cualquier otro tipo de datos que no sea una fecha, en la expresión. En el ejemplo siguiente, la cadena **"2022-08-10"** tiene el aspecto de una fecha, pero en realidad es una cadena. Para usarla, tendría que usar una función que se convierta en un tipo de datos de fecha.
**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.
```
## Ejemplo
Un entero positivo como argumento `numWorkDays` producirá una fecha en el futuro de la fecha de entrada. Un entero negativo como argumento `numWorkDays` producirá una fecha resultante anterior a la fecha de entrada. Un valor cero para el argumento `numWorkDays` produce el mismo valor que la fecha de entrada, independientemente de que caiga en un día laborable o en un fin de semana.
La función `addWorkDays` funciona con el siguiente grado de detalle: `DAY`. La precisión no se puede preservar con un grado de detalle inferior o superior al nivel `DAY`.
```
addWorkDays(startDate, endDate)
```
Supongamos que hay un campo denominado `employmentStartDate` con los siguientes valores:
```
2022-08-10 2022-08-06 2022-08-07
```
Usando el campo anterior y los siguientes cálculos, `addWorkDays` devuelve los valores modificados como se muestra a continuación:
```
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
```
En el siguiente ejemplo se calcula la bonificación prorrateada total que se pagará a cada empleado durante 2 años en función del número de días que cada empleado haya trabajado realmente.
```
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/es_es/quick/latest/userguide/images/addWorkDays-function-example.png)
# Abs
`abs` devuelve el valor absoluto de una expresión dada.
## Sintaxis
```
abs(expression)
```
## Argumentos
*expresión*
La expresión debe ser numérica. Puede ser un nombre de campo, un valor literal u otra función.
# Ceil
`ceil` redondea un valor decimal al siguiente número entero más alto. Por ejemplo, `ceil(29.02)` devuelve `30`.
## Sintaxis
```
ceil(decimal)
```
## Argumentos
*decimal*
Un campo que utiliza el tipo de datos decimal, un valor literal como **17.62** o una llamada a otra función que genera un decimal.
## Tipo de devolución
Entero
## Ejemplo
En el siguiente ejemplo se redondea un campo decimal al siguiente número entero más alto.
```
ceil(salesAmount)
```
Los siguientes son los valores de los campos.
```
20.13
892.03
57.54
```
Para estos valores de campo, se devuelven los siguientes valores.
```
21
893
58
```
# Coalesce
`coalesce` devuelve el valor del primer argumento que no sea nulo. Cuando se encuentra un valor no nulo, los argumentos restantes de la lista no se evalúan. Si todos los argumentos son null el resultado es null. Las cadenas de longitud 0 son valores válidos y no se consideran equivalentes a null.
## Sintaxis
```
coalesce(expression1, expression2 [, expression3, ...])
```
## Argumentos
`coalesce` toma dos o más expresiones como argumentos. Todas las expresiones deben tener el mismo tipo de datos o podrán emitirse implícitamente para el mismo tipo de datos.
*expresión*
La expresión puede ser numérica, una fecha o una cadena. Puede ser un nombre de campo, un valor literal u otra función.
## Tipo de devolución
`coalesce` devuelve un valor del mismo tipo de datos que los argumentos de entrada.
## Ejemplo
En el siguiente ejemplo, se recupera una dirección de facturación del cliente si la hay o su dirección postal si no hay dirección de facturación, o se devuelve “No se ha indicado ninguna dirección” si ninguna de las dos direcciones está disponible.
```
coalesce(billingAddress, streetAddress, 'No address listed')
```
# Concat
`concat` concatena dos o más cadenas.
## Sintaxis
```
concat(expression1, expression2 [, expression3 ...])
```
## Argumentos
`concat` toma dos o más expresiones de cadena como argumentos.
*expresión*
La expresión debe ser una cadena. Puede ser el nombre de un campo que utiliza el tipo de datos de cadena, un valor literal como **'12 Main Street'** o una llamada a otra función que genera una cadena.
## Tipo de devolución
Cadena
## Ejemplos
El siguiente ejemplo concatena tres campos de cadena y añade los espacios apropiados.
```
concat(salutation, ' ', firstName, ' ', lastName)
```
Los siguientes son los valores de los campos.
```
salutation firstName lastName
-------------------------------------------------------
Ms. Li Juan
Dr. Ana Carolina Silva
Mr. Nikhil Jayashankar
```
Para estos valores de campo, se devuelven los siguientes valores.
```
Ms. Li Juan
Dr. Ana Carolina Silva
Mr. Nikhil Jayashankar
```
En el siguiente ejemplo, se concatenan dos literales de cadena.
```
concat('Hello', 'world')
```
Se devuelve el siguiente valor.
```
Helloworld
```
# contains
`contains` evalúa si la subcadena que especifique existe dentro de una expresión. Si la expresión contiene la subcadena, la función contains devuelve true y, en caso contrario, devuelve false.
## Sintaxis
```
contains(expression, substring, string-comparison-mode)
```
## Argumentos
*expresión*
La expresión debe ser una cadena. Puede ser el nombre de un campo que utiliza el tipo de datos de cadena, un valor literal como **'12 Main Street'** o una llamada a otra función que genera una cadena.
*subcadena*
El conjunto de caracteres que se comparan con la *expresión*. La subcadena puede aparecer una o más veces en la *expresión*.
*string-comparison-mode*
(Opcional) Especifica el modo de comparación de cadenas que se va a utilizar:
+ `CASE_SENSITIVE`: las comparaciones de cadenas distinguen entre mayúsculas y minúsculas.
+ `CASE_INSENSITIVE`: las comparaciones de cadenas no distinguen entre mayúsculas y minúsculas.
Este valor se establece de forma predeterminada en `CASE_SENSITIVE` cuando está en blanco.
## Tipo de devolución
Booleano
## Ejemplos
### Ejemplo de distinción entre mayúsculas y minúsculas predeterminado
En el siguiente ejemplo, que distingue entre mayúsculas y minúsculas, se evalúa si `state_nm` contiene **New**.
```
contains(state_nm, "New")
```
Los siguientes son los valores de los campos.
```
New York
new york
```
Para estos valores de campo, se devuelven los siguientes valores.
```
true
false
```
### Ejemplo que no distingue entre mayúsculas y minúsculas
En el siguiente ejemplo, que no distingue entre mayúsculas y minúsculas, se evalúa si `state_nm` contiene **new**.
```
contains(state_nm, "new", CASE_INSENSITIVE)
```
Los siguientes son los valores de los campos.
```
New York
new york
```
Para estos valores de campo, se devuelven los siguientes valores.
```
true
true
```
### Ejemplo con instrucciones condicionales
La función contains se puede utilizar como instrucción condicional en las siguientes funciones 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) y [varpIf](https://docs.aws.amazon.com/quicksight/latest/user/varpIf-function.html).
El siguiente ejemplo solo suma `Sales` si `state_nm` contiene **New**.
```
sumIf(Sales,contains(state_nm, "New"))
```
### NO contiene un ejemplo
El operador condicional `NOT` se puede usar para evaluar si la expresión no contiene la subcadena especificada.
```
NOT(contains(state_nm, "New"))
```
### Ejemplo de uso de valores numéricos
Los valores numéricos se pueden utilizar en los argumentos de la expresión o de la subcadena mediante la aplicación de la función `toString`.
```
contains(state_nm, toString(5) )
```
# decimalToInt
`decimalToInt` convierte un valor decimal en el tipo de datos entero eliminando el punto decimal y cualquier número situado a continuación. `decimalToInt` no redondea al alza. Por ejemplo, `decimalToInt(29.99)` devuelve `29`.
## Sintaxis
```
decimalToInt(decimal)
```
## Argumentos
*decimal*
Un campo que utiliza el tipo de datos decimal, un valor literal como **17.62** o una llamada a otra función que genera un decimal.
## Tipo de devolución
Entero
## Ejemplo
El siguiente ejemplo convierte un campo decimal en un entero.
```
decimalToInt(salesAmount)
```
Los siguientes son los valores de los campos.
```
20.13
892.03
57.54
```
Para estos valores de campo, se devuelven los siguientes valores.
```
20
892
57
```
# dateDiff
`dateDiff` devuelve la diferencia en días entre dos campos de fecha. Si incluye un valor para el periodo, `dateDiff` devuelve la diferencia en el intervalo del periodo, en lugar de en días.
## Sintaxis
```
dateDiff(date1, date2,[period])
```
## Argumentos
`dateDiff` toma dos fechas como argumentos. La especificación de un periodo es opcional.
*fecha 1*
La primera fecha de la comparación. Un campo de fecha o una llamada a otra función que genera una fecha.
*fecha 2*
La segunda fecha de la comparación. Un campo de fecha o una llamada a otra función que genera una fecha.
*periodo*
El periodo de diferencia que desea obtener, entre comillas. Los periodos válidos son los siguientes:
+ YYYY: devuelve la parte del año de la fecha.
+ Q: devuelve la fecha del primer día del trimestre al que pertenece la fecha.
+ MM: devuelve la parte del mes de la fecha.
+ DD: devuelve la parte del día de la fecha.
+ WK: devuelve la parte de la semana de la fecha. La semana comienza el domingo en Amazon Quick.
+ HH: devuelve la parte de la hora de la fecha.
+ MI: devuelve la parte de minutos de la fecha.
+ SS: devuelve la parte de segundos de la fecha.
+ MS: devuelve la parte de milisegundos de la fecha.
## Tipo de devolución
Entero
## Ejemplo
El siguiente ejemplo devuelve la diferencia entre dos fechas.
```
dateDiff(orderDate, shipDate, "MM")
```
Los siguientes son los valores de los campos.
```
orderDate shipdate
=============================
01/01/18 03/05/18
09/13/17 10/20/17
```
Para estos valores de campo, se devuelven los siguientes valores.
```
2
1
```
# endsWith
`endsWith` evalúa si la expresión finaliza con la subcadena que especifique. Si la expresión finaliza con la subcadena, `endsWith` devuelve true y, en caso contrario, devuelve false.
## Sintaxis
```
endsWith(expression, substring, string-comparison-mode)
```
## Argumentos
*expresión*
La expresión debe ser una cadena. Puede ser el nombre de un campo que utiliza el tipo de datos de cadena, un valor literal como **'12 Main Street'** o una llamada a otra función que genera una cadena.
*subcadena*
El conjunto de caracteres que se comparan con la *expresión*. La subcadena puede aparecer una o más veces en la *expresión*.
*string-comparison-mode*
(Opcional) Especifica el modo de comparación de cadenas que se va a utilizar:
+ `CASE_SENSITIVE`: las comparaciones de cadenas distinguen entre mayúsculas y minúsculas.
+ `CASE_INSENSITIVE`: las comparaciones de cadenas no distinguen entre mayúsculas y minúsculas.
Este valor se establece de forma predeterminada en `CASE_SENSITIVE` cuando está en blanco.
## Tipo de devolución
Booleano
## Ejemplos
### Ejemplo de distinción entre mayúsculas y minúsculas predeterminado
En el siguiente ejemplo, que distingue entre mayúsculas y minúsculas, se evalúa si `state_nm` endsWith **"York"**.
```
endsWith(state_nm, "York")
```
Los siguientes son los valores de los campos.
```
New York
new york
```
Para estos valores de campo, se devuelven los siguientes valores.
```
true
false
```
### Ejemplo que no distingue entre mayúsculas y minúsculas
En el siguiente ejemplo, que no distingue entre mayúsculas y minúsculas, se evalúa si `state_nm` endsWith **"york"**.
```
endsWith(state_nm, "york", CASE_INSENSITIVE)
```
Los siguientes son los valores de los campos.
```
New York
new york
```
Para estos valores de campo, se devuelven los siguientes valores.
```
true
true
```
### Ejemplo con instrucciones condicionales
La función `endsWith` se puede utilizar como instrucción condicional en las siguientes funciones 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) y [varpIf](https://docs.aws.amazon.com/quicksight/latest/user/varpIf-function.html).
El siguiente ejemplo solo suma `Sales` si `state_nm` finaliza con **"York"**.
```
sumIf(Sales,endsWith(state_nm, "York"))
```
### NO contiene un ejemplo
El operador condicional `NOT` se puede usar para evaluar si la expresión no comienza por la subcadena especificada.
```
NOT(endsWith(state_nm, "York"))
```
### Ejemplo de uso de valores numéricos
Los valores numéricos se pueden utilizar en los argumentos de la expresión o de la subcadena mediante la aplicación de la función `toString`.
```
endsWith(state_nm, toString(5) )
```
# epochDate
`epochDate`[convierte una fecha de época en una fecha estándar con el formato aaaa-mm-dd **T** kk:mm:ss.sss **Z**, utilizando la sintaxis de patrones de formato especificada en Class en la documentación del proyecto Joda. DateTimeFormat](http://www.joda.org/joda-time/apidocs/org/joda/time/format/DateTimeFormat.html) Un ejemplo es `2015-10-15T19:11:51.003Z`.
`epochDate`se admite para su uso con análisis basados en conjuntos de datos almacenados en Quick (). SPICE
## Sintaxis
```
epochDate(epochdate)
```
## Argumentos
*epochdate*
La fecha de inicio, que es una representación en un número entero de una fecha como el número de segundos desde 00:00:00 UTC el 1 de enero de 1970.
*epochdate* debe ser un número entero. Puede ser el nombre de un campo que utiliza el tipo de datos entero, un valor entero literal o una llamada a otra función que genera un entero. Si el valor entero es superior a 10 dígitos, los dígitos después de la décima posición se descartan.
## Tipo de devolución
Date
## Ejemplo
El ejemplo siguiente convierte una fecha de inicio en una fecha estándar.
```
epochDate(3100768000)
```
Se devuelve el siguiente valor.
```
2068-04-04T12:26:40.000Z
```
# Exp
`exp` devuelve la base de logaritmo natural e elevada a la potencia de una expresión dada.
## Sintaxis
```
exp(expression)
```
## Argumentos
*expresión*
La expresión debe ser numérica. Puede ser un nombre de campo, un valor literal u otra función.
# Extract
`extract` devuelve una parte especificada de un valor de fecha. Si solicita una parte relacionada con la hora de una fecha que no contiene información de tiempo, se devuelve 0.
## Sintaxis
```
extract(period, date)
```
## Argumentos
*periodo*
El periodo que desee que se extraiga del valor de fecha. Los periodos válidos son los siguientes:
+ YYYY: devuelve la parte del año de la fecha.
+ Q: devuelve el trimestre al que pertenece la fecha (1 a 4).
+ MM: devuelve la parte del mes de la fecha.
+ DD: devuelve la parte del día de la fecha.
+ WD: devuelve el día de la semana como un número entero, en el que el domingo es el 1.
+ HH: devuelve la parte de la hora de la fecha.
+ MI: devuelve la parte de minutos de la fecha.
+ SS: devuelve la parte de segundos de la fecha.
+ MS: devuelve la parte de milisegundos de la fecha.
**nota**
Las bases de datos de Presto anteriores a la versión 0.216 no admiten la extracción de milisegundos.
*date*
Un campo de fecha o una llamada a otra función que genera una fecha.
## Tipo de devolución
Entero
## Ejemplo
El siguiente ejemplo extrae el día de un valor de fecha.
```
extract('DD', orderDate)
```
Los siguientes son los valores de los campos.
```
orderDate
=========
01/01/14
09/13/16
```
Para estos valores de campo, se devuelven los siguientes valores.
```
01
13
```
# Floor
`floor` disminuye un valor decimal al siguiente número entero más bajo. Por ejemplo, `floor(29.08)` devuelve `29`.
## Sintaxis
```
floor(decimal)
```
## Argumentos
*decimal*
Un campo que utiliza el tipo de datos decimal, un valor literal como **17.62** o una llamada a otra función que genera un decimal.
## Tipo de devolución
Entero
## Ejemplo
En el siguiente ejemplo se disminuye un campo decimal al siguiente número entero más bajo.
```
floor(salesAmount)
```
Los siguientes son los valores de los campos.
```
20.13
892.03
57.54
```
Para estos valores de campo, se devuelven los siguientes valores.
```
20
892
57
```
# formatDate
`formatDate` da formato a una fecha utilizando el patrón que especifique. Cuando esté preparando datos, puede utilizar `formatDate` para cambiar el formato de la fecha. Para volver a dar formato a una fecha en un análisis, elija la opción de formato en el menú contextual del campo de fecha.
## Sintaxis
```
formatDate(date, ['format'])
```
## Argumentos
*date*
Un campo de fecha o una llamada a otra función que genera una fecha.
*format*
(Opcional) Una cadena que contiene el patrón de formato que se va a aplicar. Este argumento acepta los patrones de formato especificados en los [formatos de fecha admitidos](https://docs.aws.amazon.com/quicksight/latest/user/supported-date-formats.html).
Si no especifica un formato, el valor predeterminado de esta cadena es yyyy-MM-dd**T**kk: mm: ss: SSS.
## Tipo de devolución
Cadena
## Ejemplo
En el ejemplo siguiente se da formato a una fecha UTC.
```
formatDate(orderDate, 'dd-MMM-yyyy')
```
Los siguientes son los valores de los campos.
```
order date
=========
2012-12-14T00:00:00.000Z
2013-12-29T00:00:00.000Z
2012-11-15T00:00:00.000Z
```
Para estos valores de campo, se devuelven los siguientes valores.
```
13 Dec 2012
28 Dec 2013
14 Nov 2012
```
## Ejemplo
Si la fecha contiene comillas simples o apóstrofes, por ejemplo, `yyyyMMdd'T'HHmmss`, puede gestionar este formato de fecha mediante uno de los métodos siguientes.
+ Escriba la fecha completa entre comillas, tal como se muestra en el siguiente ejemplo:
```
formatDate({myDateField}, "yyyyMMdd'T'HHmmss")
```
+ Para evitar las comillas simples o los apóstrofes, añada una barra invertida (`\`) a su izquierda, como se muestra en el siguiente ejemplo:
```
formatDate({myDateField}, 'yyyyMMdd\'T\'HHmmss')
```
# Ifelse
`ifelse` evalúa un conjunto de pares de expresiones *if*, *then*; y devuelve el valor del argumento *then* durante el primer argumento *if* que se evalúa como verdadero. Si ninguno de los argumentos *if* se evalúa como verdadero, se devuelve el valor del argumento *else*.
## Sintaxis
```
ifelse(if-expression-1, then-expression-1 [, if-expression-n, then-expression-n ...], else-expression)
```
## Argumentos
`ifelse` requiere uno o más pares de expresiones *if*, *then* y requiere exactamente una expresión para el argumento *else*.
*if-expression*
La expresión que se evalúa como verdadera o no. Puede ser un nombre de campo como **address1**, un valor literal como **'Unknown'** u otra función como `toString(salesAmount)`. Un ejemplo es `isNotNull(FieldName)`.
Si utiliza varios operadores AND y OR en el argumento `if`, incluya las instrucciones entre paréntesis para identificar el orden de procesamiento. Por ejemplo, el siguiente argumento `if` devuelve registros con un mes de 1, 2 o 5 y un año de 2000.
```
ifelse((month = 5 OR month < 3) AND year = 2000, 'yes', 'no')
```
El siguiente argumento `if` utiliza los mismos operadores, pero devuelve registros con un mes de 5 y cualquier año, o con un mes de 1 o 2 y un año de 2000.
```
ifelse(month = 5 OR (month < 3 AND year = 2000), 'yes', 'no')
```
*then-expression*
La expresión que se va a devolver si su argumento *if* se evalúa como verdadero. Puede ser un nombre de campo como **address1**, un valor literal como **'Unknown'** o una llamada a otra función. La expresión debe tener el mismo tipo de datos que los otros argumentos `then` y el argumento `else`.
*else-expression*
La expresión que se va a devolver si ninguno de los argumentos *if* se evalúan como verdaderos. Puede ser un nombre de campo como **address1**, un valor literal como **'Unknown'** u otra función como `toString(salesAmount)`. La expresión debe tener el mismo tipo de datos que todos los argumentos `then`.
## Tipo de devolución
`ifelse` devuelve un valor del mismo tipo de datos que los valores de *then-expression*. Todos los datos que devolvieron las expresiones *then* y *else* deben ser del mismo tipo de datos o estar convertidos al mismo tipo de datos.
## Ejemplos
En el siguiente ejemplo se genera una columna de alias para el campo `country`.
```
ifelse(country = "United States", "US", country = "China", "CN", country = "India", "IN", "Others")
```
Para estos casos de uso, se evalúa cada valor de un campo comparándolo con una lista de literales y se devuelve el resultado correspondiente al primer valor coincidente. Se recomienda cambiar de función para simplificar el trabajo. El ejemplo anterior se puede reescribir en la siguiente instrucción mediante: [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")
```
En el siguiente ejemplo se clasifican las ventas por cliente en niveles legibles para las personas.
```
ifelse(salesPerCustomer < 1000, “VERY_LOW”, salesPerCustomer < 10000, “LOW”, salesPerCustomer < 100000, “MEDIUM”, “HIGH”)
```
En el ejemplo siguiente se utiliza AND, OR y NOT para comparar varias expresiones utilizando operadores condicionales e identificar los principales clientes que NO se encuentren en Washington ni en Oregón para una promoción especial, siempre que hayan realizado más de 10 pedidos. Si no se devuelven valores, se obtiene el valor `'n/a'`.
```
ifelse(( (NOT (State = 'WA' OR State = 'OR')) AND Orders > 10), 'Special Promotion XYZ', 'n/a')
```
Los ejemplos siguientes utilizan únicamente OR para generar una nueva columna que contenga el nombre del continente correspondiente a cada `country`.
```
ifelse(country = "United States" OR country = "Canada", "North America", country = "China" OR country = "India" OR country = "Japan", "Asia", "Others")
```
El ejemplo anterior se puede simplificar como se muestra en el siguiente ejemplo. En el siguiente ejemplo se utiliza `ifelse` y [https://docs.aws.amazon.com/quicksight/latest/user/in-function.html](https://docs.aws.amazon.com/quicksight/latest/user/in-function.html) para crear un valor en una columna nueva para cualquier fila en la que el valor probado esté en una lista literal. También se puede usar `ifelse` con [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")
```
Los autores pueden guardar una lista literal en un parámetro con varios valores y utilizarla en las funciones [https://docs.aws.amazon.com/quicksight/latest/user/in-function.html](https://docs.aws.amazon.com/quicksight/latest/user/in-function.html) o [https://docs.aws.amazon.com/quicksight/latest/user/notIn-function.html](https://docs.aws.amazon.com/quicksight/latest/user/notIn-function.html). El ejemplo siguiente es equivalente al ejemplo anterior, con la salvedad de que las listas literales se almacenan en dos parámetros con varios valores.
```
ifelse(in(country,${NorthAmericaCountryParam}), "North America", in(country,${AsiaCountryParam}),"Asia", "Others")
```
En el siguiente ejemplo se asigna un grupo a un registro de ventas basándose en el total de ventas. La estructura de cada frase `if-then` imita el comportamiento de *between*, una palabra clave que actualmente no funciona en las expresiones de campo calculadas. Por ejemplo, el resultado de la comparación `salesTotal >= 0 AND salesTotal < 500` devuelve los mismos valores que la comparación `salesTotal between 0 and 499` de SQL.
```
ifelse(salesTotal >= 0 AND salesTotal < 500, 'Group 1', salesTotal >= 500 AND salesTotal < 1000, 'Group 2', 'Group 3')
```
En el siguiente ejemplo se comprueba un valor NULL y se utiliza `coalesce` para devolver el primer valor que no sea NULL. En lugar de tener que recordar el significado de un valor NULL en un campo de fecha, puede utilizar una descripción legible. Si la fecha de desconexión es NULL, el ejemplo devuelve la fecha de suspensión, a menos que ambas sean NULL. A continuación, `coalesce(DiscoDate, SuspendDate, '12/31/2491')` devuelve `'12/31/2491'`. El valor devuelto debe coincidir con los demás tipos de datos. Esta fecha puede parecer un valor inusual, pero una fecha del siglo XXV simula razonablemente el “fin de los tiempos”, que se define como la fecha más alta de un data mart.
```
ifelse ( (coalesce(DiscoDate, SuspendDate, '12/31/2491') = '12/31/2491'), 'Active subscriber', 'Inactive subscriber')
```
A continuación se muestra un ejemplo más complejo en un formato más legible, solo para demostrar que no es necesario comprimir todo el código en una línea larga. En este ejemplo se proporcionan varias comparaciones del valor del resultado de una encuesta. Maneja los posibles valores NULL para este campo y clasifica dos rangos aceptables. También etiqueta un rango que necesita más pruebas y otro que no es válido (fuera del rango). Para todos los valores restantes, aplica la condición `else` y etiqueta la fila como si fuera necesaria una nueva prueba tres años después de la fecha indicada en esa fila.
```
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})
)
)
)
```
En el siguiente ejemplo se asigna un nombre de región creado “manualmente” a un grupo de estados. También se utiliza el espaciado y los comentarios, entre `/* */`, para facilitar el mantenimiento del 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'
)
```
La lógica del etiquetado de la región se desglosa de la siguiente manera:
1. Enumeramos los estados que queremos para cada región y escribimos cada lista entre comillas para hacer que cada lista sea una cadena, de la siguiente manera:
+ `'New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire'`
+ `'Georgia, Alabama, South Carolina, Louisiana'`
+ Puede agregar más conjuntos o usar países, ciudades, provincias o What3Words si lo desea.
1. Para preguntar si el valor de `State` (para cada fila) se encuentra en la lista, usamos la función `locate` para devolver un valor distinto de cero si el estado se encuentra en la lista, como se indica a continuación.
```
locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State})
and
locate('Georgia, Alabama, South Carolina, Louisiana',{State})
```
1. La función `locate` devuelve un número en lugar de un valor `TRUE` o `FALSE`, pero `ifelse` requiere el valor booleano `TRUE`/`FALSE`. Para evitar esto, podemos comparar el resultado de `locate` con un número. Si el estado está en la lista, el valor devuelto es mayor que cero.
1. Pregunte si el estado está presente.
```
locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) > 0
```
1. Si está presente en la región, etiquétela como la región específica, en este caso, una región del noreste.
```
/*The if expression:*/ locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) > 0,
/*The then expression:*/ 'Northeast',
```
1. Como tenemos estados que no están en una lista y `ifelse` requiere una expresión `else` única, utilizamos una etiqueta `'Other Region'` para los estados sobrantes.
```
/*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. Incluimos todo eso en la función `ifelse( )` para obtener la versión final. En el siguiente ejemplo se omiten los estados de la región sudeste que estaban en el original. Puede volver a agregarlos en lugar de la etiqueta *``*.
Si desea agregar más regiones, puede crear más copias de esas dos líneas y modificar la lista de estados para adaptarla a sus necesidades. Puede cambiar el nombre de la región por el que más le convenga y cambiar el nombre del campo `State` por el que necesite.
```
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**
Existen otras formas de realizar la comparación inicial de la expresión if. Por ejemplo, supongamos que plantea la pregunta “¿Qué estados no faltan en esta lista?” en lugar de “¿Qué estados están en la lista?” Si lo hace, podría expresarlo de otra manera. Puede comparar la instrucción locate con cero para buscar los valores que faltan en la lista y, a continuación, utilizar el operador NOT para clasificarlos como “no ausentes”, como se indica a continuación.
```
/*The if expression:*/ NOT (locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) = 0),
```
Ambas versiones son correctas. La versión que elija debería tener más sentido para usted y su equipo, de forma que pueda mantenerla fácilmente. Si todas las opciones parecen iguales, elija la más sencilla.
# in
`in` evalúa si existe una expresión en una lista literal. Si la lista contiene la expresión, devuelve true y, en caso contrario, devuelve false. `in` distingue entre mayúsculas y minúsculas para las entradas de tipo cadena.
`in` acepta dos tipos de listas literales: una es una lista que se introduce manualmente y la otra es un [parámetro con varios valores.](https://docs.aws.amazon.com/quicksight/latest/user/parameters-in-quicksight.html)
## Sintaxis
Uso de una lista introducida manualmente:
```
in(expression, [literal-1, ...])
```
Uso de un parámetro con varios valores:
```
in(expression, $multivalue_parameter)
```
## Argumentos
*expresión*
La expresión que se va a comparar con los elementos de la lista literal. Puede ser un nombre de campo, como `address`, un valor literal, como “**Unknown**”, un parámetro de un solo valor o una llamada a otra función escalar, siempre que esta función no sea una función de agregado o un cálculo de tabla.
*lista literal*
(Obligatorio) Puede ser una lista introducida manualmente o un parámetro con varios valores. Este argumento acepta hasta 5000 elementos. Sin embargo, en una consulta directa a un origen de datos de terceros, por ejemplo, Oracle o Teradata, la restricción puede ser menor.
+ ***lista introducida manualmente***: uno o más valores literales de una lista para compararlos con la expresión. La lista se debe escribir entre corchetes. Todos los literales que se van a comparar deben tener el mismo tipo de datos que la expresión.
+ ***parámetro con varios valores***: un parámetro con varios valores predefinido que se pasa como una lista literal. El parámetro con varios valores debe tener el mismo tipo de datos que la expresión.
## Tipo de devolución
Valor booleano TRUE o FALSE
## Ejemplo con una lista estática
En el siguiente ejemplo se evalúa el campo `origin_state_name` en busca de valores en una lista de cadenas. Al comparar una entrada de tipo cadena, `in` solo admite la comparación que distingue entre mayúsculas y minúsculas.
```
in(origin_state_name,["Georgia", "Ohio", "Texas"])
```
Los siguientes son los valores de los campos.
```
"Washington"
"ohio"
"Texas"
```
Para estos valores de campo, se devuelven los siguientes valores.
```
false
false
true
```
El tercer valor devuelto es true porque solo “Texas” es uno de los valores incluidos.
En el siguiente ejemplo se evalúa el campo `fl_date` en busca de valores en una lista de cadenas. Para que coincida con el tipo, `toString` se utiliza para convertir el tipo de fecha en un tipo de cadena.
```
in(toString(fl_date),["2015-05-14","2015-05-15","2015-05-16"])
```
![\[Imagen de los resultados del ejemplo de la función, que se muestra en forma de tabla.\]](http://docs.aws.amazon.com/es_es/quick/latest/userguide/images/in-function-example-manual-list.png)
Los valores literales y NULL se admiten en el argumento de expresión para compararlos con los literales de la lista. Los dos ejemplos siguientes generarán una nueva columna de valores TRUE.
```
in("Washington",["Washington","Ohio"])
```
```
in(NULL,[NULL,"Ohio"])
```
## Ejemplo con parámetro con varios valores
Supongamos que un autor crea un [parámetro con varios valores](https://docs.aws.amazon.com/quicksight/latest/user/parameters-in-quicksight.html) que contiene una lista de todos los nombres de los estados. Luego, el autor agrega un control para que el lector pueda seleccionar valores de la lista.
A continuación, el lector selecciona tres valores (“Georgia”, “Ohio” y “Texas”) del control de la lista desplegable del parámetro. En este caso, la siguiente expresión equivale al primer ejemplo, en el que esos tres nombres de estados se pasan como lista literal para compararlos con el campo `original_state_name`.
```
in (origin_state_name, ${stateName MultivalueParameter})
```
## Ejemplo con `ifelse`
`in` se puede anidar en otras funciones como un valor booleano. Un ejemplo es que los autores pueden evaluar cualquier expresión de una lista y devolver el valor que desean mediante `in` y `ifelse`. En el siguiente ejemplo se evalúa si el `dest_state_name` de un vuelo se encuentra en una lista determinada de estados de EE. UU. y se devuelven diferentes categorías de estados en función de la comparación.
```
ifelse(in(dest_state_name,["Washington", "Oregon","California"]), "WestCoastUSState", "Other US State")
```
![\[Imagen de los resultados del ejemplo de la función, que se muestra en forma de tabla.\]](http://docs.aws.amazon.com/es_es/quick/latest/userguide/images/in-function-with-ifelse.png)
# intToDecimal
`intToDecimal` convierte un valor entero en el tipo de datos decimal.
## Sintaxis
```
intToDecimal(integer)
```
## Argumentos
*int*
Un campo que utiliza el tipo de datos entero, un valor literal como **14** o una llamada a otra función que genera un entero.
## Tipo de devolución
Decimal (fijo) en la experiencia tradicional de preparación de datos.
Decimal (flotante) en la nueva experiencia de preparación de datos.
## Ejemplo
El siguiente ejemplo convierte un campo entero en un decimal.
```
intToDecimal(price)
```
Los siguientes son los valores de los campos.
```
20
892
57
```
Para estos valores de campo, se devuelven los siguientes valores.
```
20.0
892.0
58.0
```
Puede aplicar formato dentro de un análisis, por ejemplo, para formatear `price` como divisa.
# isNotNull
`isNotNull` evalúa una expresión para ver si no es nula. Si la expresión no es nula, `isNotNull` devuelve “true”; de lo contrario devuelve “false”.
## Sintaxis
```
isNotNull(expression)
```
## Argumentos
*expresión*
La expresión se evalúa como nula o no. Puede ser un nombre de campo como **address1**, o una llamada a otra función que genere una cadena.
## Tipo de devolución
Booleano
## Ejemplo
El siguiente ejemplo evalúa el campo sales\$1amount en busca de valores nulos.
```
isNotNull(salesAmount)
```
Los siguientes son los valores de los campos.
```
20.13
(null)
57.54
```
Para estos valores de campo, se devuelven los siguientes valores.
```
true
false
true
```
# isNull
`isNull` evalúa una expresión para ver si es nula. Si la expresión es nula, `isNull` devuelve “true”, de lo contrario devuelve “false”.
## Sintaxis
```
isNull(expression)
```
## Argumentos
*expresión*
La expresión se evalúa como nula o no. Puede ser un nombre de campo como **address1**, o una llamada a otra función que genere una cadena.
## Tipo de devolución
Booleano
## Ejemplo
El siguiente ejemplo evalúa el campo sales\$1amount en busca de valores nulos.
```
isNull(salesAmount)
```
Los siguientes son los valores de los campos.
```
20.13
(null)
57.54
```
Para estos valores de campo, se devuelven los siguientes valores.
```
false
true
false
```
En el siguiente ejemplo se comprueba si hay un valor NULL en una instrucción `ifelse` y, en su lugar, se devuelve un valor legible por humanos.
```
ifelse( isNull({ActiveFlag}) , 'Inactive', 'Active')
```
# isWorkDay
`isWorkDay` evalúa un valor de fecha y hora determinado para determinar si el valor es un día laborable o no.
`isWorkDay` asume una semana laboral estándar de 5 días que comienza el lunes y termina el viernes. Se supone que los sábados y domingos son fines de semana. La función siempre calcula su resultado con el grado de detalle `DAY` y no incluye la fecha de entrada dada.
## Sintaxis
```
isWorkDay(inputDate)
```
## Argumentos
*inputDate*
El valor de fecha y hora que desea evaluar. Los valores válidos son los siguientes:
+ Campos de conjunto de datos: cualquier campo `date` del conjunto de datos al que vaya a agregar esta función.
+ Función de fecha: cualquier salida de fecha de otra función `date`, por ejemplo, `parseDate`.
+ Campos calculados: cualquier campo calculado rápidamente que devuelva un `date` valor.
+ Parámetros: cualquier `DateTime` parámetro rápido.
## Tipo de devolución
Entero (`0` o `1`)
## Ejemplo
En el siguiente ejemplo se determina si el campo `application_date` es un día laborable o no.
Supongamos que hay un campo denominado `application_date` con los siguientes valores:
```
2022-08-10
2022-08-06
2022-08-07
```
Al usar estos campos y agregar los siguientes cálculos, `isWorkDay` devuelve los siguientes valores:
```
isWorkDay({application_date})
1
0
0
```
En el siguiente ejemplo se filtra a los empleados cuyo empleo termina un día laborable y se determina si su empleo comenzó un día laborable o un fin de semana mediante el formato 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/es_es/quick/latest/userguide/images/isWorkDay-example.png)
# Left
`left` devuelve los caracteres más a la izquierda de una cadena, incluidos los espacios. Deberá especificar el número de caracteres que quiere que se devuelvan.
## Sintaxis
```
left(expression, limit)
```
## Argumentos
*expresión*
La expresión debe ser una cadena. Puede ser el nombre de un campo que utiliza el tipo de datos de cadena, un valor literal como **'12 Main Street'** o una llamada a otra función que genera una cadena.
*limit*
El número de caracteres que se van a devolver de la *expresión*, a partir del primer carácter de la cadena.
## Tipo de devolución
Cadena
## Ejemplo
En el siguiente ejemplo, se devuelven los 3 primeros caracteres de una cadena.
```
left('Seattle Store #14', 3)
```
Se devuelve el siguiente valor.
```
Sea
```
# Locate
`locate` localiza la subcadena que especifique en otra cadena y devuelve el número de caracteres hasta el primer carácter de la subcadena. La función devuelve 0 si no encuentra la subcadena. La función se basa en 1.
## Sintaxis
```
locate(expression, substring, start)
```
## Argumentos
*expresión*
La expresión debe ser una cadena. Puede ser el nombre de un campo que utiliza el tipo de datos de cadena, un valor literal como **'12 Main Street'** o una llamada a otra función que genera una cadena.
*subcadena*
El conjunto de caracteres de *expression* que desee localizar. La subcadena puede aparecer una o más veces en *expression*.
*start*
(Opcional) Si la *subcadena* se produce más de una vez, utilice *start* para identificar en qué parte de la cadena debe empezar a buscar la subcadena la función. Por ejemplo, suponga que desea encontrar el segundo ejemplo de una subcadena y cree que normalmente aparece después de los primeros 10 caracteres. Puede especificar como valor de *inicio* 10. Debe empezar en 1.
## Tipo de devolución
Entero
## Ejemplos
El siguiente ejemplo devuelve información sobre dónde tiene lugar la primera aparición de la subcadena “and” en una cadena.
```
locate('1 and 2 and 3 and 4', 'and')
```
Se devuelve el siguiente valor.
```
3
```
El siguiente ejemplo devuelve información sobre dónde tiene lugar la primera aparición de la subcadena “and” en una cadena después del cuarto carácter.
```
locate('1 and 2 and 3 and 4', 'and', 4)
```
Se devuelve el siguiente valor.
```
9
```
# Log
`log` devuelve el logaritmo en base 10 de una expresión dada.
## Sintaxis
```
log(expression)
```
## Argumentos
*expresión*
La expresión debe ser numérica. Puede ser un nombre de campo, un valor literal u otra función.
# Ln
`ln` devuelve el logaritmo natural de una expresión dada.
## Sintaxis
```
ln(expression)
```
## Argumentos
*expresión*
La expresión debe ser numérica. Puede ser un nombre de campo, un valor literal u otra función.
# Ltrim
`ltrim` elimina los espacios en blanco situados antes de una cadena.
## Sintaxis
```
ltrim(expression)
```
## Argumentos
*expresión*
La expresión debe ser una cadena. Puede ser el nombre de un campo que utiliza el tipo de datos de cadena, un valor literal como **'12 Main Street'** o una llamada a otra función que genera una cadena.
## Tipo de devolución
Cadena
## Ejemplo
El siguiente ejemplo elimina los espacios precedentes de una cadena.
```
ltrim(' Seattle Store #14')
```
Se devuelve el siguiente valor.
```
Seattle Store #14
```
# Mod
Utilice la función `mod` para averiguar el resto después de dividir el número por el divisor. Puede utilizar la función `mod` o el operador de módulo (%) indistintamente.
## Sintaxis
```
mod(number, divisor)
```
```
number%divisor
```
## Argumentos
*número*
El número es el entero positivo que desea dividir para averiguar el resto.
*divisor*
El divisor es el entero positivo por el que se divide. Si el divisor es cero, esta función devuelve un error al dividir por 0.
## Ejemplo
Los siguientes ejemplos devuelven un módulo de 17 al dividir por 6. El primer ejemplo utiliza el operador % y el segundo la función mod.
```
17%6
```
```
mod( 17, 6 )
```
Se devuelve el siguiente valor.
```
5
```
# netWorkDays
`netWorkDays`devuelve el número de días laborables entre los dos campos de fecha proporcionados o incluso los valores de fecha personalizados generados mediante otras funciones de fecha rápida, como `parseDate` o `epochDate` como un entero.
`netWorkDays` asume una semana laboral estándar de 5 días que comienza el lunes y termina el viernes. Se supone que los sábados y domingos son fines de semana. El cálculo incluye los valores `startDate` y `endDate`. La función funciona y muestra los resultados del grado de detalle de DAY.
## Sintaxis
```
netWorkDays(startDate, endDate)
```
## Argumentos
*startDate*
Una fecha válida que no sea NULL y que actúe como fecha de inicio del cálculo.
+ Campos de conjunto de datos: cualquier campo `date` del conjunto de datos al que vaya a agregar esta función.
+ Función de fecha: cualquier salida de fecha de otra función `date`, por ejemplo, `parseDate`.
+ Campos calculados: cualquier campo calculado rápidamente que devuelva un `date` valor.
+ Parámetros: cualquier `DateTime` parámetro rápido.
+ Cualquier combinación de los valores de los argumentos indicados anteriormente.
*endDate*
Una fecha válida que no sea NULL y que actúe como fecha de finalización del cálculo.
+ Campos de conjunto de datos: cualquier campo `date` del conjunto de datos al que vaya a agregar esta función.
+ Función de fecha: cualquier salida de fecha de otra función `date`, por ejemplo, `parseDate`.
+ Campos calculados: cualquier campo calculado rápidamente que devuelva un `date` valor.
+ Parámetros: cualquier `DateTime` parámetro rápido.
+ Cualquier combinación de los valores de los argumentos indicados anteriormente.
## Tipo de devolución
Entero
## Valores de salida
Los valores de salida esperados incluyen los siguientes:
+ Número entero positivo (cuando start\$1date < end\$1date)
+ Número entero negativo (cuando start\$1date > end\$1date)
+ NULL cuando uno o ambos argumentos obtienen un valor nulo de `dataset field`.
## Ejemplo
En el siguiente ejemplo se devuelve la cantidad de días laborables entre dos fechas.
Supongamos que hay un campo denominado `application_date` con los siguientes valores:
```
netWorkDays({startDate}, {endDate})
```
Los siguientes son los valores de los campos.
```
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
```
En el siguiente ejemplo se calcula el número de días trabajados por cada empleado y el salario empleado por día para cada empleado:
```
days_worked = netWorkDays({employment_start_date}, {employment_end_date})
salary_per_day = {salary}/{days_worked}
```
En el siguiente ejemplo se filtra a los empleados cuyo empleo termina un día laborable y se determina si su empleo comenzó un día laborable o un fin de semana mediante el formato 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/es_es/quick/latest/userguide/images/netWorkDays-function-example.png)
# Now
Para conjuntos de datos de base de datos que consultan directamente la base de datos, `now` devuelve la fecha y hora actuales utilizando la configuración y el formato que especifica el servidor de base de datos. Para conjuntos de datos de SPICE y Salesforce, `now` devuelve la fecha y la hora UTC con el formato `yyyy-MM-ddTkk:mm:ss:SSSZ` (por ejemplo, 2015-10-15T19:11:51:003 Z).
## Sintaxis
```
now()
```
## Tipo de devolución
Date
# notIn
`notIn` evalúa si existe una expresión en una lista literal. Si la lista no contiene la expresión, `notIn` devuelve true y, en caso contrario, devuelve false. `notIn` distingue entre mayúsculas y minúsculas para las entradas de tipo cadena.
`notIn` acepta dos tipos de listas literales: una es una lista que se introduce manualmente y la otra es un [parámetro con varios valores.](https://docs.aws.amazon.com/quicksight/latest/user/parameters-in-quicksight.html)
## Sintaxis
Uso de una lista introducida manualmente:
```
notIn(expression, [literal-1, ...])
```
Uso de un parámetro con varios valores:
```
notIn(expression, $multivalue_parameter)
```
## Argumentos
*expresión*
La expresión que se va a comparar con los elementos de la lista literal. Puede ser un nombre de campo, como `address`, un valor literal, como “**Unknown**”, un parámetro de un solo valor o una llamada a otra función escalar, siempre que esta función no sea una función de agregado o un cálculo de tabla.
*lista literal*
(Obligatorio) Puede ser una lista introducida manualmente o un parámetro con varios valores. Este argumento acepta hasta 5000 elementos. Sin embargo, en una consulta directa a un origen de datos de terceros, por ejemplo, Oracle o Teradata, la restricción puede ser menor.
+ ***lista introducida manualmente***: uno o más valores literales de una lista para compararlos con la expresión. La lista se debe escribir entre corchetes. Todos los literales que se van a comparar deben tener el mismo tipo de datos que la expresión.
+ ***parámetro con varios valores***: un parámetro con varios valores predefinido que se pasa como una lista literal. El parámetro con varios valores debe tener el mismo tipo de datos que la expresión.
## Tipo de devolución
Valor booleano TRUE o FALSE
## Ejemplo con una lista introducida manualmente
En el siguiente ejemplo se evalúa el campo `origin_state_name` en busca de valores en una lista de cadenas. Al comparar una entrada de tipo cadena, `notIn` solo admite la comparación que distingue entre mayúsculas y minúsculas.
```
notIn(origin_state_name,["Georgia", "Ohio", "Texas"])
```
Los siguientes son los valores de los campos.
```
"Washington"
"ohio"
"Texas"
```
Para estos valores de campo, se devuelven los siguientes valores.
```
true
true
false
```
El tercer valor devuelto es false porque solo “Texas” es uno de los valores excluidos.
En el siguiente ejemplo se evalúa el campo `fl_date` en busca de valores en una lista de cadenas. Para que coincida con el tipo, `toString` se utiliza para convertir el tipo de fecha en un tipo de cadena.
```
notIn(toString(fl_date),["2015-05-14","2015-05-15","2015-05-16"])
```
![\[Imagen de los resultados del ejemplo de la función, que se muestra en forma de tabla.\]](http://docs.aws.amazon.com/es_es/quick/latest/userguide/images/notin-function-example-manual-list.png)
Los valores literales y NULL se admiten en el argumento de expresión para compararlos con los literales de la lista. Los dos ejemplos siguientes generarán una nueva columna de valores FALSE.
```
notIn("Washington",["Washington","Ohio"])
```
```
notIn(NULL,[NULL,"Ohio"])
```
## Ejemplo con parámetro con varios valores
Supongamos que un autor crea un [parámetro con varios valores](https://docs.aws.amazon.com/quicksight/latest/user/parameters-in-quicksight.html) que contiene una lista de todos los nombres de los estados. Luego, el autor agrega un control para que el lector pueda seleccionar valores de la lista.
A continuación, el lector selecciona tres valores (“Georgia”, “Ohio” y “Texas”) del control de la lista desplegable del parámetro. En este caso, la siguiente expresión equivale al primer ejemplo, en el que esos tres nombres de estados se pasan como lista literal para compararlos con el campo `original_state_name`.
```
notIn (origin_state_name, ${stateName MultivalueParameter})
```
## Ejemplo con `ifelse`
`notIn` se puede anidar en otras funciones como un valor booleano. Un ejemplo es que los autores pueden evaluar cualquier expresión de una lista y devolver el valor que desean mediante `notIn` y `ifelse`. En el siguiente ejemplo se evalúa si el `dest_state_name` de un vuelo se encuentra en una lista determinada de estados de EE. UU. y se devuelven diferentes categorías de estados en función de la comparación.
```
ifelse(notIn(dest_state_name,["Washington", "Oregon","California"]), "notWestCoastUSState", "WestCoastUSState")
```
![\[Imagen de los resultados del ejemplo de la función, que se muestra en forma de tabla.\]](http://docs.aws.amazon.com/es_es/quick/latest/userguide/images/notin-function-with-ifelse.png)
# nullIf
`nullIf` compara dos expresiones. Si son iguales, la función devuelve “null”. Si no son iguales, la función devuelve la primera expresión.
## Sintaxis
```
nullIf(expression1, expression2)
```
## Argumentos
`nullIf` toma dos expresiones como argumentos.
*expresión*
La expresión puede ser numérica, una fecha o una cadena. Puede ser un nombre de campo, un valor literal u otra función.
## Tipo de devolución
Cadena
## Ejemplo
El siguiente ejemplo devuelve valores nulos si se desconoce el motivo del retraso de un envío.
```
nullIf(delayReason, 'unknown')
```
Los siguientes son los valores de los campos.
```
delayReason
============
unknown
back ordered
weather delay
```
Para estos valores de campo, se devuelven los siguientes valores.
```
(null)
back ordered
weather delay
```
# parseDate
`parseDate`analiza una cadena para determinar si contiene un valor de fecha y devuelve una fecha estándar en ese formato `yyyy-MM-ddTkk:mm:ss.SSSZ` (utilizando la sintaxis de patrones de formato especificada en [Class DateTimeFormat](http://www.joda.org/joda-time/apidocs/org/joda/time/format/DateTimeFormat.html) en la documentación del proyecto Joda), por ejemplo 2015-10-15T 19:11:51.003 Z. Esta función devuelve todas las filas que contienen una fecha con un formato válido y omite las que no lo tienen, incluidas las filas que contienen valores nulos.
Quick admite fechas en el intervalo comprendido entre el 1 de enero de 1900 a las 00:00:00 UTC y el 31 de diciembre de 2037 a las 23:59:59 UTC. [Para obtener más información, consulta Formatos de fecha compatibles.](https://docs.aws.amazon.com/quicksight/latest/user/supported-date-formats.html)
## Sintaxis
```
parseDate(expression, ['format'])
```
## Argumentos
*expresión*
La expresión debe ser una cadena. Puede ser el nombre de un campo que utiliza el tipo de datos de cadena, un valor literal como **'1/1/2016'** o una llamada a otra función que genera una cadena.
*format*
(Opcional) Una cadena que contiene el patrón de formato con el que *date\$1string* debe coincidir. Por ejemplo, si utiliza un campo con datos como**01/03/2016**, debe especificar el formato 'MM/dd/yyyy'. Si no especifica un formato, el valor predeterminado es `yyyy-MM-dd`. Se omitirán las filas cuyos datos no se ajustan al *formato*.
Se admiten distintos formatos de fecha en función del tipo de conjunto de datos utilizado. Utilice la siguiente tabla para ver detalles de formatos de fecha admitidos.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/quick/latest/userguide/parseDate-function.html)
## Tipo de devolución
Date
## Ejemplo
En el siguiente ejemplo, se evalúa `prodDate` para determinar si contiene valores de fecha.
```
parseDate(prodDate, 'MM/dd/yyyy')
```
Los siguientes son los valores de los campos.
```
prodDate
--------
01-01-1999
12/31/2006
1/18/1982
7/4/2010
```
Para estos valores de campo, se devuelven las siguientes filas.
```
12-31-2006T00:00:00.000Z
01-18-1982T00:00:00.000Z
07-04-2010T00:00:00.000Z
```
# parseDecimal
`parseDecimal` analiza una cadena para determinar si contiene un valor decimal. Esta función devuelve todas las filas que contienen un valor decimal, entero o nulo y omite las que no lo tienen. Si la fila contiene un valor entero, se devuelve como un decimal con hasta cuatro cifras decimales. Por ejemplo, un valor “2” se devuelve como “2.0”.
## Sintaxis
```
parseDecimal(expression)
```
## Argumentos
*expresión*
La expresión debe ser una cadena. Puede ser el nombre de un campo que utiliza el tipo de datos de cadena, un valor literal como **'9.62'** o una llamada a otra función que genera una cadena.
## Tipo de devolución
Decimal (fijo) en la experiencia tradicional de preparación de datos.
Decimal (flotante) en la nueva experiencia de preparación de datos.
## Ejemplo
En el siguiente ejemplo, se evalúa `fee` para determinar si contiene valores decimales.
```
parseDecimal(fee)
```
Los siguientes son los valores de los campos.
```
fee
--------
2
2a
12.13
3b
3.9
(null)
198.353398
```
Para estos valores de campo, se devuelven las siguientes filas.
```
2.0
12.13
3.9
(null)
198.3533
```
# parseInt
`parseInt` analiza una cadena para determinar si contiene un valor entero. Esta función devuelve todas las filas que contienen un valor decimal, entero o nulo y omite las que no lo tienen. Si la fila contiene un valor decimal, se devuelve como el entero más cercano, redondeado a la baja. Por ejemplo, un valor “2.99” se devuelve como “2”.
## Sintaxis
```
parseInt(expression)
```
## Argumentos
*expresión*
La expresión debe ser una cadena. Puede ser el nombre de un campo que utiliza el tipo de datos de cadena, un valor literal como **'3'** o una llamada a otra función que genera una cadena.
## Tipo de devolución
Entero
## Ejemplo
En el siguiente ejemplo, se evalúa `feeType` para determinar si contiene valores enteros.
```
parseInt(feeType)
```
Los siguientes son los valores de los campos.
```
feeType
--------
2
2.1
2a
3
3b
(null)
5
```
Para estos valores de campo, se devuelven las siguientes filas.
```
2
2
3
(null)
5
```
# parseJson
Con `parseJson` puede extraer valores de un objeto JSON.
Si el conjunto de datos está almacenado en QuickSPICE, puede usarlo `parseJson` cuando prepare un conjunto de datos, pero no en los campos calculados durante el análisis.
En caso de una consulta directa, puede utilizar `parseJson` tanto durante la preparación de los datos como en el análisis. La función `parseJson` se aplica a cadenas o a los tipos de datos nativos JSON, dependiendo del dialecto, como se muestra en la siguiente tabla.
| Dialect | Tipo |
| --- | --- |
| PostgreSQL | JSON |
| Amazon Redshift | Cadena |
| Microsoft SQL Server | Cadena |
| MySQL | JSON |
| Teradata | JSON |
| Oracle | Cadena |
| Presto | Cadena |
| Snowflake | Objeto de tipo de datos semiestructurado y matriz |
| Hive | Cadena |
## Sintaxis
```
parseJson(fieldName, path)
```
## Argumentos
*fieldName*
El campo que contiene el objeto JSON que desea analizar.
*path*
La ruta del elemento de datos que desea analizar a partir del objeto JSON. Solo se permiten letras, números y espacios en blanco en el argumento de ruta. La sintaxis de ruta válida incluye:
+ *\$1*: objeto raíz
+ *.*: operador secundario
+ *[ ]*: operador de subíndice para matriz
## Tipo de devolución
Cadena
## Ejemplo
En el siguiente ejemplo se evalúa el JSON entrante para obtener el valor de la cantidad de elementos. Si se usa durante la preparación de los datos, es posible crear una tabla a partir del código JSON.
```
parseJson({jsonField}, “$.items.qty”)
```
El código JSON es el siguiente:
```
{
"customer": "John Doe",
"items": {
"product": "Beer",
"qty": 6
},
"list1": [
"val1",
"val2"
],
"list2": [
{
"list21key1": "list1value1"
}
]
}
```
Con este ejemplo se obtiene el valor siguiente:
```
6
```
## Ejemplo
En el siguiente ejemplo se evalúa `JSONObject1` para extraer el primer par clave-valor (KVP) con la etiqueta `"State"` y asignar el valor al campo calculado que está creando.
```
parseJson(JSONObject1, “$.state”)
```
Los siguientes son los valores de los campos.
```
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 estos valores de campo, se devuelven las siguientes filas.
```
New York
North Carolina
Utah
```
# Replace
`replace` sustituye parte de una cadena con otra cadena que especifique.
## Sintaxis
```
replace(expression, substring, replacement)
```
## Argumentos
*expresión*
La expresión debe ser una cadena. Puede ser el nombre de un campo que utiliza el tipo de datos de cadena, un valor literal como **'12 Main Street'** o una llamada a otra función que genera una cadena.
*subcadena*
El conjunto de caracteres en *expression* que desee reemplazar. La subcadena puede aparecer una o más veces en *expression*.
*replacement*
La cadena que desea que se sustituya para una *subcadena*.
## Tipo de devolución
Cadena
## Ejemplo
El siguiente ejemplo sustituye la subcadena “and” por “or”.
```
replace('1 and 2 and 3', 'and', 'or')
```
Se devuelve la siguiente cadena.
```
1 or 2 or 3
```
# Right
`right` devuelve los caracteres más a la derecha de una cadena, incluidos los espacios. Deberá especificar el número de caracteres que quiere que se devuelvan.
## Sintaxis
```
right(expression, limit)
```
## Argumentos
*expresión*
La expresión debe ser una cadena. Puede ser el nombre de un campo que utiliza el tipo de datos de cadena, un valor literal como **'12 Main Street'** o una llamada a otra función que genera una cadena.
*limit*
El número de caracteres que se va a devolver de la *expresión*, a partir del último carácter de la cadena.
## Tipo de devolución
Cadena
## Ejemplo
En el siguiente ejemplo, se devuelven los cinco últimos caracteres de una cadena.
```
right('Seattle Store#14', 12)
```
Se devuelve el siguiente valor.
```
tle Store#14
```
# Round
`round` redondea un valor decimal al número entero más cercano si no se especifica la escala, o al decimal más cercano si se especifica escala.
## Sintaxis
```
round(decimal, scale)
```
## Argumentos
*decimal*
Un campo que utiliza el tipo de datos decimal, un valor literal como **17.62** o una llamada a otra función que genera un decimal.
*scale*
El número de decimales que se va a utilizar para los valores de devolución.
## Tipo de devolución
| Operando | Escriba el texto de la experiencia antigua de preparación de datos | Escriba el tipo en la nueva experiencia de preparación de datos |
| --- | --- | --- |
| INT | DECIMAL (FIJO) | DECIMAL (FIJO) |
| DECIMAL (FIJO) | DECIMAL (FIJO) | DECIMAL (FIJO) |
| DECIMAL (FLOTANTE) | DECIMAL (FIJO) | DECIMAL (FLOTANTE) |
## Ejemplo
En el siguiente ejemplo se redondea un campo decimal al segundo decimal más cercano.
```
round(salesAmount, 2)
```
Los siguientes son los valores de los campos.
```
20.1307
892.0388
57.5447
```
Para estos valores de campo, se devuelven los siguientes valores.
```
20.13
892.04
58.54
```
# Rtrim
`rtrim` elimina los espacios en blanco situados después de una cadena.
## Sintaxis
```
rtrim(expression)
```
## Argumentos
*expresión*
La expresión debe ser una cadena. Puede ser el nombre de un campo que utiliza el tipo de datos de cadena, un valor literal como **'12 Main Street'** o una llamada a otra función que genera una cadena.
## Tipo de devolución
Cadena
## Ejemplo
El siguiente ejemplo elimina los espacios que siguen a una cadena.
```
rtrim('Seattle Store #14 ')
```
Para estos valores de campo, se devuelven los siguientes valores.
```
Seattle Store #14
```
# Split
`split` divide una cadena en una matriz de subcadenas basándose en el delimitador que se elija, y devuelve el elemento que especifica la posición.
Solo se puede añadir `split` a un campo calculado durante la preparación de datos, no a un análisis. Esta función no se admite en las consultas directas a Microsoft SQL Server.
## Sintaxis
```
split(expression, delimiter , position)
```
## Argumentos
*expresión*
La expresión debe ser una cadena. Puede ser el nombre de un campo que utiliza el tipo de datos de cadena, un valor literal como **'12 Main Street;1402 35th Ave;1818 Elm Ct;11 Janes Lane'** o una llamada a otra función que genera una cadena.
*delimiter*
El carácter que delimita el punto en el que la cadena se divide en subcadenas. Por ejemplo, `split('one|two|three', '|', 2)` se convierte en lo siguiente.
```
one
two
three
```
Si elige `position = 2`, `split` devuelve `'two'`.
*position*
(Obligatorio) La posición del elemento que se devuelve de la matriz. La posición del primer elemento de la matriz es 1.
## Tipo de devolución
Matriz de cadenas
## Ejemplo
En el siguiente ejemplo se divide una cadena en una matriz utilizando el punto y coma (;) como delimitador, y se devuelve el tercer elemento de la matriz.
```
split('123 Test St;1402 35th Ave;1818 Elm Ct;11 Janes Lane', ';', 3)
```
Se devuelve el siguiente elemento.
```
1818 Elm Ct
```
Esta función omitirá los elementos que contienen valores nulos o cadenas vacías.
# Sqrt
`sqrt` devuelve la raíz cuadrada de una expresión dada.
## Sintaxis
```
sqrt(expression)
```
## Argumentos
*expresión*
La expresión debe ser numérica. Puede ser un nombre de campo, un valor literal u otra función.
# startsWith
`startsWith` evalúa si la expresión comienza por la subcadena que especifique. Si la expresión comienza por la subcadena, `startsWith` devuelve true y, en caso contrario, devuelve false.
## Sintaxis
```
startsWith(expression, substring, string-comparison-mode)
```
## Argumentos
*expresión*
La expresión debe ser una cadena. Puede ser el nombre de un campo que utiliza el tipo de datos de cadena, un valor literal como **'12 Main Street'** o una llamada a otra función que genera una cadena.
*subcadena*
El conjunto de caracteres que se comparan con la *expresión*. La subcadena puede aparecer una o más veces en la *expresión*.
*string-comparison-mode*
(Opcional) Especifica el modo de comparación de cadenas que se va a utilizar:
+ `CASE_SENSITIVE`: las comparaciones de cadenas distinguen entre mayúsculas y minúsculas.
+ `CASE_INSENSITIVE`: las comparaciones de cadenas no distinguen entre mayúsculas y minúsculas.
Este valor se establece de forma predeterminada en `CASE_SENSITIVE` cuando está en blanco.
## Tipo de devolución
Booleano
## Ejemplos
### Ejemplo de distinción entre mayúsculas y minúsculas predeterminado
En el siguiente ejemplo, que distingue entre mayúsculas y minúsculas, se evalúa si `state_nm` startsWith **New**.
```
startsWith(state_nm, "New")
```
Los siguientes son los valores de los campos.
```
New York
new york
```
Para estos valores de campo, se devuelven los siguientes valores.
```
true
false
```
### Ejemplo que no distingue entre mayúsculas y minúsculas
En el siguiente ejemplo, que no distingue entre mayúsculas y minúsculas, se evalúa si `state_nm` startsWith **new**.
```
startsWith(state_nm, "new", CASE_INSENSITIVE)
```
Los siguientes son los valores de los campos.
```
New York
new york
```
Para estos valores de campo, se devuelven los siguientes valores.
```
true
true
```
### Ejemplo con instrucciones condicionales
La función `startsWith` se puede utilizar como instrucción condicional en las siguientes funciones 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) y [varpIf](https://docs.aws.amazon.com/quicksight/latest/user/varpIf-function.html).
El siguiente ejemplo solo suma `Sales` si state\$1nm comienza por **New**.
```
sumIf(Sales,startsWith(state_nm, "New"))
```
### NO contiene un ejemplo
El operador condicional `NOT` se puede usar para evaluar si la expresión no comienza por la subcadena especificada.
```
NOT(startsWith(state_nm, "New"))
```
### Ejemplo de uso de valores numéricos
Los valores numéricos se pueden utilizar en los argumentos de la expresión o de la subcadena mediante la aplicación de la función `toString`.
```
startsWith(state_nm, toString(5) )
```
# Strlen
`strlen` devuelve el número de caracteres de una cadena, incluidos los espacios.
## Sintaxis
```
strlen(expression)
```
## Argumentos
*expresión*
Una expresión puede ser el nombre de un campo que utiliza el tipo de datos de cadena como **address1**, un valor literal como **'Unknown'** u otra función como `substring(field_name,0,5)`.
## Tipo de devolución
Entero
## Ejemplo
El siguiente ejemplo devuelve la longitud de la cadena especificada.
```
strlen('1421 Main Street')
```
Se devuelve el siguiente valor.
```
16
```
# Substring
`substring` devuelve los caracteres en una cadena, a partir de la ubicación especificada en el argumento *start* y continuando por el número de caracteres especificado en los argumentos *length*.
## Sintaxis
```
substring(expression, start, length)
```
## Argumentos
*expresión*
Una expresión puede ser el nombre de un campo que utiliza el tipo de datos de cadena como **address1**, un valor literal como **'Unknown'** u otra función como `substring(field_name,1,5)`.
*start*
La ubicación de caracteres desde donde empezar. *start* es inclusivo, por lo que el carácter de la posición inicial es el primer carácter del valor devuelto. El valor mínimo para *start* es 1.
*longitud*
El número de caracteres adicionales que incluir después de *start*. *length* incluye *start*, por lo que el último carácter devuelto es (*length* - 1) tras el carácter inicial.
## Tipo de devolución
Cadena
## Ejemplo
El siguiente ejemplo devuelve desde el carácter 13.º al 19.º de una cadena. El principio de la cadena es el índice 1, por lo que se empieza a contar desde el primer carácter.
```
substring('Fantasy and Science Fiction',13,7)
```
Se devuelve el siguiente valor.
```
Science
```
# switch
`switch` compara *condition-expression* con las etiquetas literales, dentro de un conjunto de combinaciones de etiquetas literales y *return-expression*. A continuación, devuelve la expresión *return-expression* correspondiente a la primera etiqueta literal que es igual a la expresión *condition-expression*. Si ninguna etiqueta es igual a la expresión *condition-expression*, `switch` devuelve la expresión *default-expression*. Todas las expresiones *return-expression* y *default-expression* deben tener el mismo tipo de datos.
## Sintaxis
```
switch(condition-expression, label-1, return-expression-1 [, label-n, return-expression-n ...],
default-expression)
```
## Argumentos
`switch` requiere uno o más pares de expresiones *if*, *then* y requiere exactamente una expresión para el argumento *else*.
*condition-expression*
La expresión que se va a comparar con los literales de etiqueta. Puede ser un nombre de campo, como `address`, un valor literal, como `Unknown`, u otra función escalar, como `toString(salesAmount)`.
*etiqueta*
El literal que se va a comparar con el argumento de *condition-expression*. Todos los literales deben tener el mismo tipo de datos que el argumento *condition-expression*. `switch` acepta hasta 5000 etiquetas.
*return-expression*
La expresión que se devolverá si el valor de su etiqueta es igual al valor de la expresión *condition-expression*. Puede ser un nombre de campo, como `address`, un valor literal, como `Unknown`, u otra función escalar, como `toString(salesAmount)`. Todos los argumentos de *return-expression* deben tener el mismo tipo de datos que *default-expression*.
*default-expression*
La expresión que se devolverá si ningún valor de ningún argumento de la etiqueta es igual al valor de *condition-expression*. Puede ser un nombre de campo, como `address`, un valor literal, como `Unknown`, u otra función escalar, como `toString(salesAmount)`. *default-expression* debe tener el mismo tipo de datos que todos los argumentos de *return-expression*.
## Tipo de devolución
`switch` devuelve un valor del mismo tipo de datos que los valores de *return-expression*. Todos los datos que devolvieron las expresiones *return-expression* y *default-expression* deben ser del mismo tipo de datos o estar convertidos al mismo tipo de datos.
## Ejemplos generales
El siguiente ejemplo devuelve el Región de AWS código del nombre de la región 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")
```
Los siguientes son los valores de los campos.
```
"US East (N. Virginia)"
"US West (N. California)"
"Asia Pacific (Tokyo)"
```
Para estos valores de campo, se devuelven los siguientes valores.
```
"us-east-1"
"us-west-1"
"other regions"
```
## Uso del cambio para reemplazar `ifelse`
El siguiente caso de uso `ifelse` es equivalente al ejemplo anterior. En el caso de `ifelse`, para evaluar si los valores de un campo son iguales a valores literales diferentes, es una mejor opción usar `switch` en su lugar.
```
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")
```
## Expresión como valor devuelto
En el siguiente ejemplo se utilizan expresiones en *return-expressions*:
```
switch({origin_city_name},
"Albany, NY", {arr_delay} + 20,
"Alexandria, LA", {arr_delay} - 10,
"New York, NY", {arr_delay} * 2,
{arr_delay})
```
En el ejemplo anterior se cambia el tiempo de retraso previsto para cada vuelo desde una ciudad concreta.
![\[Imagen de los resultados del ejemplo de la función, que se muestra en forma de tabla.\]](http://docs.aws.amazon.com/es_es/quick/latest/userguide/images/switch-function-example.png)
# toLower
`toLower` da formato a una cadena en minúsculas. `toLower` omite las filas que contienen valores nulos.
## Sintaxis
```
toLower(expression)
```
## Argumentos
*expresión*
La expresión debe ser una cadena. Puede ser el nombre de un campo que utiliza el tipo de datos de cadena, un valor literal como **'12 Main Street'** o una llamada a otra función que genera una cadena.
## Tipo de devolución
Cadena
## Ejemplo
El siguiente ejemplo convierte un valor de cadena en minúsculas.
```
toLower('Seattle Store #14')
```
Se devuelve el siguiente valor.
```
seattle store #14
```
# toString
`toString` da formato a la expresión de entrada como una cadena. `toString` omite las filas que contienen valores nulos.
## Sintaxis
```
toString(expression)
```
## Argumentos
*expresión*
Una expresión puede ser un campo de cualquier tipo de datos, un valor literal como **14.62**, o una llamada a otra función que devuelve cualquier tipo de datos.
## Tipo de devolución
Cadena
## Ejemplo
En el siguiente ejemplo, se devuelven como cadenas los valores de `payDate` (que utiliza el tipo de datos `date`).
```
toString(payDate)
```
Los siguientes son los valores de los campos.
```
payDate
--------
1992-11-14T00:00:00.000Z
2012-10-12T00:00:00.000Z
1973-04-08T00:00:00.000Z
```
Para estos valores de campo, se devuelven las siguientes filas.
```
1992-11-14T00:00:00.000Z
2012-10-12T00:00:00.000Z
1973-04-08T00:00:00.000Z
```
# toUpper
`toUpper` da formato a una cadena en mayúsculas. `toUpper` omite las filas que contienen valores nulos.
## Sintaxis
```
toUpper(expression)
```
## Argumentos
*expresión*
La expresión debe ser una cadena. Puede ser el nombre de un campo que utiliza el tipo de datos de cadena, un valor literal como **'12 Main Street'** o una llamada a otra función que genera una cadena.
## Tipo de devolución
Cadena
## Ejemplo
El siguiente ejemplo convierte un valor de cadena en mayúsculas.
```
toUpper('Seattle Store #14')
```
Se devuelve el siguiente valor.
```
SEATTLE STORE #14
```
# trim
`trim` elimina los espacios en blanco situados antes y después de una cadena.
## Sintaxis
```
trim(expression)
```
## Argumentos
*expresión*
La expresión debe ser una cadena. Puede ser el nombre de un campo que utiliza el tipo de datos de cadena, un valor literal como **'12 Main Street'** o una llamada a otra función que genera una cadena.
## Tipo de devolución
Cadena
## Ejemplo
El siguiente ejemplo elimina los espacios que siguen a una cadena.
```
trim(' Seattle Store #14 ')
```
Para estos valores de campo, se devuelven los siguientes valores.
```
Seattle Store #14
```
# truncDate
`truncDate` devuelve un valor de fecha que representa una parte especificada de una fecha. Por ejemplo, solicitar la parte del año del valor 2012-09-02T00:00:00.000Z devuelve 2012-01-01T00:00:00.000Z. Especificar un período relacionado con la hora para una fecha que no contenga información de hora devuelve el valor de fecha inicial sin modificarse.
## Sintaxis
```
truncDate('period', date)
```
## Argumentos
*periodo*
El periodo de la fecha que desee que se devuelva. Los periodos válidos son los siguientes:
+ YYYY: devuelve la parte del año de la fecha.
+ Q: devuelve la fecha del primer día del trimestre al que pertenece la fecha.
+ MM: devuelve la parte del mes de la fecha.
+ DD: devuelve la parte del día de la fecha.
+ WK: devuelve la parte de la semana de la fecha. La semana comienza el domingo en Amazon Quick.
+ HH: devuelve la parte de la hora de la fecha.
+ MI: devuelve la parte de minutos de la fecha.
+ SS: devuelve la parte de segundos de la fecha.
+ MS: devuelve la parte de milisegundos de la fecha.
*date*
Un campo de fecha o una llamada a otra función que genera una fecha.
## Tipo de devolución
Date
## Ejemplo
En el siguiente ejemplo, se devuelve una fecha que representa el mes de la fecha del pedido.
```
truncDate('MM', orderDate)
```
Los siguientes son los valores de los campos.
```
orderDate
=========
2012-12-14T00:00:00.000Z
2013-12-29T00:00:00.000Z
2012-11-15T00:00:00.000Z
```
Para estos valores de campo, se devuelven los siguientes valores.
```
2012-12-01T00:00:00.000Z
2013-12-01T00:00:00.000Z
2012-11-01T00:00:00.000Z
```