Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Fonctions Dans cette section, vous trouverez une liste des fonctions disponibles dans Amazon Quick. Pour consulter la liste des fonctions triées par catégorie, avec de brèves définitions, voir [Fonctions par catégorie](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` ajoute ou soustrait une unité de temps à partir d’une valeur datetime. Par exemple, `addDateTime(2,'YYYY',parseDate('02-JUL-2018', 'dd-MMM-yyyy') )` renvoie `02-JUL-2020`. Vous pouvez utiliser cette fonction pour effectuer des calculs de date sur vos données de date et d’heure. ## Syntaxe ``` addDateTime(amount, period, datetime) ``` ## Arguments *amount* Une valeur entière positive ou négative qui représente la durée que vous souhaitez ajouter ou soustraire du champ datetime fourni. *point* Une valeur positive ou négative qui représente la durée que vous souhaitez ajouter ou soustraire du champ datetime fourni. Les périodes valides sont les suivantes : + AAAA : renvoie la partie de la date correspondant à l’année. + Q : Cela renvoie le trimestre auquel appartient la date (1–4). + MM : renvoie la partie de la date correspondant au mois. + DD : renvoie la partie de la date correspondant au jour. + WK : renvoie la partie de la date correspondant à la semaine. La semaine commence le dimanche sur Amazon Quick. + HH : renvoie la partie de la date correspondant à l’heure. + MI : renvoie la partie de la date correspondant à la minute. + SS : renvoie la deuxième partie de la date. + MS : renvoie la partie milliseconde de la date. *datetime* La date ou l’heure à laquelle vous souhaitez effectuer les calculs de date. ## Type de retour Datetime ## Exemple Supposons que vous ayez un champ appelé `purchase_date` avec les valeurs suivantes. ``` 2018 May 13 13:24 2017 Jan 31 23:06 2016 Dec 28 06:45 ``` À l’aide des calculs suivants, `addDateTime` modifie les valeurs comme illustré ci-après. ``` 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` Ajoute ou soustrait un nombre déterminé de jours ouvrables à une valeur de date donnée. La fonction renvoie une date pour un jour ouvrable, qui tombe un nombre désigné de jours ouvrables après ou avant une valeur de date d’entrée donnée. ## Syntaxe ``` addWorkDays(initDate, numWorkDays) ``` ## Arguments *initDate* Il s’agit d’une date valide non NULL qui sert de date de début pour le calcul. + **Champ du jeu de données** – Tout champ `date` du jeu de données auquel vous ajoutez cette fonction. + **Fonction date** – Toute date produite par une autre fonction `date`, par exemple `parseDate`, `epochDate`, `addDateTime`, etc. **Example** ``` addWorkDays(epochDate(1659484800), numWorkDays) ``` + **Champs calculés** : tout champ calculé rapidement qui renvoie une `date` valeur. **Example** ``` calcFieldStartDate = addDateTime(10, “DD”, startDate) addWorkDays(calcFieldStartDate, numWorkDays) ``` + **Paramètres** — N'importe quel `datetime` paramètre rapide. **Example** ``` addWorkDays($paramStartDate, numWorkDays) ``` + Toute combinaison des valeurs d’argument énoncées ci-dessus. *numWorkDays* Un entier non NULL qui sert de date de fin pour le calcul. + **Littéral** – Un entier littéral saisi directement dans l’éditeur d’expression. **Example** ``` ``` + **Champ du jeu de données** – Tout champ de date du jeu de données **Example** ``` ``` + **Fonction ou calcul scalaire** — Toute fonction rapide scalaire qui renvoie un entier en sortie depuis une autre`decimalToInt`, par exemple`abs`, etc. **Example** ``` addWorkDays(initDate, decimalToInt(sqrt (abs(numWorkDays)) ) ) ``` + **Champ calculé** : tout champ calculé rapidement qui renvoie une `date` valeur. **Example** ``` someOtherIntegerCalcField = (num_days * 2) + 12 addWorkDays(initDate, someOtherIntegerCalcField) ``` + **Paramètre** : n'importe quel `datetime` paramètre rapide. **Example** ``` addWorkDays(initDate, $param_numWorkDays) ``` + Toute combinaison des valeurs d’argument énoncées ci-dessus. ## Type de retour Entier ## Valeurs de sortie Les valeurs de sortie attendues sont les suivantes : + Nombre entier positif (lorsque start\$1date < end\$1date) + Nombre entier négatif (lorsque start\$1date > end\$1date) + NULL lorsque l'un ou les deux arguments reçoivent une valeur nulle de la fonction `dataset field`. ## Erreurs d’entrée Les valeurs d’argument non autorisées provoquent des erreurs, comme le montrent les exemples suivants. + L’utilisation d’un littéral NULL comme argument dans l’expression n’est pas autorisée. **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. ``` + L’utilisation d’une chaîne littérale comme argument, ou de tout autre type de données autre qu’une date, dans l’expression n’est pas autorisée. Dans l’exemple suivant, la chaîne **"2022-08-10"** ressemble à une date, mais il s’agit en fait d’une chaîne de caractères. Pour l’utiliser, vous devez utiliser une fonction qui convertit le type de données en date. **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. ``` ## Exemple Un entier positif en tant qu’argument `numWorkDays` produira une date dans le futur de la date d’entrée. Un entier négatif comme argument `numWorkDays` donnera une date résultante dans le passé de la date d’entrée. Une valeur nulle pour l’argument `numWorkDays` donne la même valeur que la date d’entrée, qu’elle tombe ou non un jour ouvrable ou un week-end. La fonction `addWorkDays` opère à la granularité : `DAY`. La précision ne peut être préservée à une granularité inférieure ou supérieure au niveau `DAY`. ``` addWorkDays(startDate, endDate) ``` Supposons qu’il existe un champ nommé `employmentStartDate` avec les valeurs suivantes : ``` 2022-08-10 2022-08-06 2022-08-07 ``` En utilisant le champ ci-dessus et les calculs suivants, `addWorkDays` renvoie les valeurs modifiées comme indiqué ci-dessous : ``` 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 ``` L’exemple suivant calcule la prime totale au prorata à verser à chaque employé pour deux ans, en fonction du nombre de jours de travail effectif de chaque employé. ``` 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/fr_fr/quick/latest/userguide/images/addWorkDays-function-example.png) # Abs `abs` renvoie la valeur absolue d’une expression donnée. ## Syntaxe ``` abs(expression) ``` ## Arguments *expression* L’expression doit être numérique. Il peut s’agir d’un nom de champ, d’une valeur littérale ou d’une autre fonction. # Ceil `ceil` arrondi une valeur décimale à l’entier supérieur le plus proche. Par exemple, `ceil(29.02)` renvoie `30`. ## Syntaxe ``` ceil(decimal) ``` ## Arguments *decimal* Un champ qui utilise le type de données décimale, une valeur littérale comme **17.62** ou un appel à une autre fonction qui génère un nombre décimal. ## Type de retour Entier ## Exemple L’exemple suivant arrondit un champ décimal à la valeur supérieure la plus proche. ``` ceil(salesAmount) ``` Les valeurs suivantes sont celles du champ donné. ``` 20.13 892.03 57.54 ``` Pour ces valeurs, les valeurs suivantes sont renvoyées. ``` 21 893 58 ``` # Coalesce `coalesce` renvoie la valeur du premier argument qui n’est pas null. Lorsqu’une valeur non null est trouvée, les autres arguments de la liste ne sont pas évalués. Si tous les arguments sont nuls, le résultat est nul. Les chaînes de longueur 0 sont des valeurs valides et ne sont pas considérées comme équivalentes à null. ## Syntaxe ``` coalesce(expression1, expression2 [, expression3, ...]) ``` ## Arguments `coalesce` prend deux expressions ou plus comme arguments. Toutes les expressions doivent posséder le même type de données ou pouvoir être implicitement converties dans le même type de données. *expression* L’expression peut être de type numérique, datetime ou chaîne. Il peut s’agir d’un nom de champ, d’une valeur littérale ou d’une autre fonction. ## Type de retour `coalesce` renvoie une valeur du même type de données que les arguments en entrée. ## Exemple L’exemple suivant récupère l’adresse de facturation d’un client si elle existe, l’adresse physique si aucune adresse de facturation n’existe, ou renvoie « No address listed » si aucune adresse n’est disponible. ``` coalesce(billingAddress, streetAddress, 'No address listed') ``` # Concat `concat` concatène deux chaînes et plus. ## Syntaxe ``` concat(expression1, expression2 [, expression3 ...]) ``` ## Arguments `concat`La fonction prend deux ou plus expressions de chaîne comme arguments. *expression* L’expression doit être une chaîne. Il peut s’agir du nom d’un champ qui utilise le type de données de chaîne, d’une valeur littérale comme **'12 Main Street'** ou d’un appel à une autre fonction qui renvoie une chaîne. ## Type de retour String ## Exemples L’exemple suivant concatène trois champs de chaînes et ajoute les espaces correspondants. ``` concat(salutation, ' ', firstName, ' ', lastName) ``` Les valeurs suivantes sont celles du champ donné. ``` salutation firstName lastName ------------------------------------------------------- Ms. Li Juan Dr. Ana Carolina Silva Mr. Nikhil Jayashankar ``` Pour ces valeurs, les valeurs suivantes sont renvoyées. ``` Ms. Li Juan Dr. Ana Carolina Silva Mr. Nikhil Jayashankar ``` L’exemple suivant concatène deux littéraux de chaîne. ``` concat('Hello', 'world') ``` La valeur suivante est renvoyée. ``` Helloworld ``` # contains `contains` évalue si la sous-chaîne que vous spécifiez existe dans une expression. Si l’expression contient la sous-chaîne, contains renvoie un résultat vrai, sinon il renvoie un résultat faux. ## Syntaxe ``` contains(expression, substring, string-comparison-mode) ``` ## Arguments *expression* L’expression doit être une chaîne. Il peut s’agir du nom d’un champ qui utilise le type de données de chaîne, d’une valeur littérale comme **'12 Main Street'** ou d’un appel à une autre fonction qui renvoie une chaîne. *substring* L’ensemble des caractères à vérifier par rapport à l’*expression*. La sous-chaîne peut être contenue une ou plusieurs fois dans l’*expression*. *string-comparison-mode* (Facultatif) Spécifie le mode de comparaison de chaînes à utiliser : + `CASE_SENSITIVE` – Les comparaisons de chaînes sont sensibles à la casse. + `CASE_INSENSITIVE` – Les comparaisons de chaînes sont insensibles à la casse. La valeur par défaut est `CASE_SENSITIVE` lorsqu’elle est vide. ## Type de retour Booléen ## Exemples ### Exemple de sensibilité à la casse par défaut L’exemple suivant, sensible à la casse, évalue si `state_nm` contient **New**. ``` contains(state_nm, "New") ``` Les valeurs suivantes sont celles du champ donné. ``` New York new york ``` Pour ces valeurs, les valeurs suivantes sont renvoyées. ``` true false ``` ### Exemple insensible à la casse L’exemple suivant, insensible à la casse, évalue si `state_nm` contient **new**. ``` contains(state_nm, "new", CASE_INSENSITIVE) ``` Les valeurs suivantes sont celles du champ donné. ``` New York new york ``` Pour ces valeurs, les valeurs suivantes sont renvoyées. ``` true true ``` ### Exemple avec des instructions conditionnelles La fonction contains peut être utilisée comme instruction conditionnelle dans les fonctions If suivantes : [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) et [varpIf](https://docs.aws.amazon.com/quicksight/latest/user/varpIf-function.html). L’exemple suivant additionne `Sales` uniquement si `state_nm` contient **New**. ``` sumIf(Sales,contains(state_nm, "New")) ``` ### Exemple « ne contient PAS » L’opérateur conditionnel `NOT` peut être utilisé pour évaluer si l’expression ne contient pas la sous-chaîne spécifiée. ``` NOT(contains(state_nm, "New")) ``` ### Exemple d’utilisation de valeurs numériques Des valeurs numériques peuvent être utilisées dans les arguments d’expression ou de sous-chaîne en appliquant la fonction `toString`. ``` contains(state_nm, toString(5) ) ``` # decimalToInt `decimalToInt` convertit une valeur décimale au type de données d’entier en supprimant la virgule et tous les chiffres après. `decimalToInt` ne s’arrondit pas. Par exemple, `decimalToInt(29.99)` renvoie `29`. ## Syntaxe ``` decimalToInt(decimal) ``` ## Arguments *decimal* Un champ qui utilise le type de données décimale, une valeur littérale comme **17.62** ou un appel à une autre fonction qui génère un nombre décimal. ## Type de retour Entier ## Exemple L’exemple suivant convertit un champ décimal en nombre entier. ``` decimalToInt(salesAmount) ``` Les valeurs suivantes sont celles du champ donné. ``` 20.13 892.03 57.54 ``` Pour ces valeurs, les valeurs suivantes sont renvoyées. ``` 20 892 57 ``` # dateDiff `dateDiff` renvoie la différence en nombre de jours entre deux champs de date. Si vous incluez une valeur pour la période, `dateDiff` renvoie la différence sous forme d’intervalle de la période, plutôt qu’en jours. ## Syntaxe ``` dateDiff(date1, date2,[period]) ``` ## Arguments `dateDiff` prend deux dates comme arguments. La spécification d’une période est facultative. *date 1* La première date de la comparaison. Un champ de date ou un appel à une autre fonction qui génère une date. *date 2* La deuxième date de la comparaison. Un champ de date ou un appel à une autre fonction qui génère une date. *point* La période de différence que vous voulez renvoyer, entre guillemets. Les périodes valides sont les suivantes : + AAAA : renvoie la partie de la date correspondant à l’année. + Q : Cela renvoie la date du premier jour du trimestre auquel la date appartient. + MM : renvoie la partie de la date correspondant au mois. + DD : renvoie la partie de la date correspondant au jour. + WK : renvoie la partie de la date correspondant à la semaine. La semaine commence le dimanche sur Amazon Quick. + HH : renvoie la partie de la date correspondant à l’heure. + MI : renvoie la partie de la date correspondant à la minute. + SS : renvoie la deuxième partie de la date. + MS : renvoie la partie milliseconde de la date. ## Type de retour Entier ## Exemple L’exemple suivant retourne la différence entre deux dates. ``` dateDiff(orderDate, shipDate, "MM") ``` Les valeurs suivantes sont celles du champ donné. ``` orderDate shipdate ============================= 01/01/18 03/05/18 09/13/17 10/20/17 ``` Pour ces valeurs, les valeurs suivantes sont renvoyées. ``` 2 1 ``` # endsWith `endsWith` évalue si l’expression se termine par une sous-chaîne que vous spécifiez. Si l’expression se termine par la sous-chaîne, `endsWith` renvoie vrai, sinon il renvoie faux. ## Syntaxe ``` endsWith(expression, substring, string-comparison-mode) ``` ## Arguments *expression* L’expression doit être une chaîne. Il peut s’agir du nom d’un champ qui utilise le type de données de chaîne, d’une valeur littérale comme **'12 Main Street'** ou d’un appel à une autre fonction qui renvoie une chaîne. *substring* L’ensemble des caractères à vérifier par rapport à l’*expression*. La sous-chaîne peut être contenue une ou plusieurs fois dans l’*expression*. *string-comparison-mode* (Facultatif) Spécifie le mode de comparaison de chaînes à utiliser : + `CASE_SENSITIVE` – Les comparaisons de chaînes sont sensibles à la casse. + `CASE_INSENSITIVE` – Les comparaisons de chaînes sont insensibles à la casse. La valeur par défaut est `CASE_SENSITIVE` lorsqu’elle est vide. ## Type de retour Booléen ## Exemples ### Exemple de sensibilité à la casse par défaut L’exemple suivant, sensible à la casse, évalue si `state_nm` se termine par **"York"**. ``` endsWith(state_nm, "York") ``` Les valeurs suivantes sont celles du champ donné. ``` New York new york ``` Pour ces valeurs, les valeurs suivantes sont renvoyées. ``` true false ``` ### Exemple insensible à la casse L’exemple suivant, insensible à la casse, évalue si `state_nm` se termine par **"york"**. ``` endsWith(state_nm, "york", CASE_INSENSITIVE) ``` Les valeurs suivantes sont celles du champ donné. ``` New York new york ``` Pour ces valeurs, les valeurs suivantes sont renvoyées. ``` true true ``` ### Exemple avec des instructions conditionnelles La fonction `endsWith` peut être utilisée comme instruction conditionnelle dans les fonctions If suivantes : [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) et [varpIf](https://docs.aws.amazon.com/quicksight/latest/user/varpIf-function.html). L’exemple suivant additionne `Sales` uniquement si `state_nm` se termine par **"York"**. ``` sumIf(Sales,endsWith(state_nm, "York")) ``` ### Exemple « ne contient PAS » L’opérateur conditionnel `NOT` peut être utilisé pour évaluer si l’expression ne commence pas par la sous-chaîne spécifiée. ``` NOT(endsWith(state_nm, "York")) ``` ### Exemple d’utilisation de valeurs numériques Des valeurs numériques peuvent être utilisées dans les arguments d’expression ou de sous-chaîne en appliquant la fonction `toString`. ``` endsWith(state_nm, toString(5) ) ``` # epochDate `epochDate`[convertit une date d'époque en une date standard au format YYYY-MM-DD **T** KK:MM:SS.sss **Z**, en utilisant la syntaxe du modèle de format spécifiée dans Class dans la documentation du projet Joda. DateTimeFormat](http://www.joda.org/joda-time/apidocs/org/joda/time/format/DateTimeFormat.html) Par exemple : `2015-10-15T19:11:51.003Z`. `epochDate`est compatible avec des analyses basées sur des ensembles de données stockés dans Quick (SPICE). ## Syntaxe ``` epochDate(epochdate) ``` ## Arguments *epochdate* Date d’époque, qui est une représentation sous forme d’un nombre entier d’une date en tant que nombre de secondes depuis 00:00:00 UTC, le 1er janvier 1970. *epochdate* doit être un entier. Ce peut être le nom d’un champ qui utilise le type de données entier, une valeur d’entier littérale ou un appel à une autre fonction qui génère un nombre entier. Si la valeur entière est supérieure à 10 chiffres, les chiffres après la 10e place sont ignorés. ## Type de retour Date ## Exemple L’exemple suivant convertit une date d’époque en date standard. ``` epochDate(3100768000) ``` La valeur suivante est renvoyée. ``` 2068-04-04T12:26:40.000Z ``` # Exp `exp` renvoie la base du journal naturel e élevé à la puissance d’une expression donnée. ## Syntaxe ``` exp(expression) ``` ## Arguments *expression* L’expression doit être numérique. Il peut s’agir d’un nom de champ, d’une valeur littérale ou d’une autre fonction. # Extract `extract` renvoie une partie spécifiée d’une valeur de date. Demander une partie liée à l’heure d’une date qui ne contient pas d’informations sur le temps retourne 0. ## Syntaxe ``` extract(period, date) ``` ## Arguments *point* Période que vous souhaitez extraire de la valeur de date. Les périodes valides sont les suivantes : + AAAA : renvoie la partie de la date correspondant à l’année. + Q : Cela renvoie le trimestre auquel appartient la date (1–4). + MM : renvoie la partie de la date correspondant au mois. + DD : renvoie la partie de la date correspondant au jour. + WD : renvoie le jour de la semaine sous la forme d’un nombre entier, dimanche étant 1. + HH : renvoie la partie de la date correspondant à l’heure. + MI : renvoie la partie de la date correspondant à la minute. + SS : renvoie la deuxième partie de la date. + MS : renvoie la partie milliseconde de la date. **Note** L’extraction des millisecondes n’est pas prise en charge dans les bases de données Presto inférieures à la version 0.216. *date* Un champ de date ou un appel à une autre fonction qui génère une date. ## Type de retour Entier ## Exemple L’exemple suivant extrait le jour d’une valeur de date. ``` extract('DD', orderDate) ``` Les valeurs suivantes sont celles du champ donné. ``` orderDate ========= 01/01/14 09/13/16 ``` Pour ces valeurs, les valeurs suivantes sont renvoyées. ``` 01 13 ``` # Floor `floor` diminue une décimale valeur à l’entier inférieur le plus proche. Par exemple, `floor(29.08)` renvoie `29`. ## Syntaxe ``` floor(decimal) ``` ## Arguments *decimal* Un champ qui utilise le type de données décimale, une valeur littérale comme **17.62** ou un appel à une autre fonction qui génère un nombre décimal. ## Type de retour Entier ## Exemple L’exemple suivant diminue un champ décimal à l’entier inférieur le plus proche. ``` floor(salesAmount) ``` Les valeurs suivantes sont celles du champ donné. ``` 20.13 892.03 57.54 ``` Pour ces valeurs, les valeurs suivantes sont renvoyées. ``` 20 892 57 ``` # formatDate `formatDate` met en forme une date à l’aide d’un modèle que vous spécifiez. Lorsque vous préparez des données, vous pouvez utiliser `formatDate` pour reformater la date. Pour reformater une date dans une analyse, vous choisissez l’option de format dans le menu contextuel du champ de date. ## Syntaxe ``` formatDate(date, ['format']) ``` ## Arguments *date* Un champ de date ou un appel à une autre fonction qui génère une date. *format* (Facultatif) Chaîne contenant le modèle de format à appliquer. Cet argument accepte les modèles de format spécifiés dans [Formats de date pris en charge](https://docs.aws.amazon.com/quicksight/latest/user/supported-date-formats.html). Si vous ne spécifiez aucun format, le format par défaut est AAAA-MM-JJ**T**kk:mm:ss:SSS. ## Type de retour String ## Exemple L’exemple suivant met en forme une date UTC. ``` formatDate(orderDate, 'dd-MMM-yyyy') ``` Les valeurs suivantes sont celles du champ donné. ``` order date ========= 2012-12-14T00:00:00.000Z 2013-12-29T00:00:00.000Z 2012-11-15T00:00:00.000Z ``` Pour ces valeurs, les valeurs suivantes sont renvoyées. ``` 13 Dec 2012 28 Dec 2013 14 Nov 2012 ``` ## Exemple Si la date contient des guillemets simples ou des apostrophes, par exemple `yyyyMMdd'T'HHmmss`, vous pouvez gérer ce format de date en utilisant l’une des méthodes suivantes. + Mettez la date entière entre guillemets doubles, comme indiqué dans l’exemple suivant : ``` formatDate({myDateField}, "yyyyMMdd'T'HHmmss") ``` + Mettez une barre oblique inverse ( `\` ) à gauche des guillemets simples ou des apostrophes, comme indiqué dans l’exemple suivant : ``` formatDate({myDateField}, 'yyyyMMdd\'T\'HHmmss') ``` # Ifelse `ifelse` évalue un ensemble de paires d’expressions *if*, *then* et renvoie la valeur de l’argument *then* pour le premier argument *if* ayant la valeur true. Si aucun des arguments *if* n’a la valeur true, la valeur de l’argument *else* est renvoyée. ## Syntaxe ``` ifelse(if-expression-1, then-expression-1 [, if-expression-n, then-expression-n ...], else-expression) ``` ## Arguments L’opérateur `ifelse` nécessite une ou plusieurs paires d’expressions *if*,*then* et requiert exactement une expression pour l’argument *else*. *if-expression* Expression à évaluer comme ayant ou non la valeur true. Il peut s’agir d’un nom de champ comme **address1**, d’une valeur littérale comme **'Unknown'** ou d’une autre fonction comme `toString(salesAmount)`. Par exemple : `isNotNull(FieldName)`. Si vous utilisez plusieurs opérateurs AND et OR dans l’argument `if`, placez les instructions entre parenthèses pour identifier l’ordre de traitement. Par exemple, l’argument `if` suivant renvoie des enregistrements avec un mois 1, 2 ou 5 et l’année 2000. ``` ifelse((month = 5 OR month < 3) AND year = 2000, 'yes', 'no') ``` L’argument `if` suivant utilise les mêmes opérateurs, mais renvoie des enregistrements avec un mois 5 et n’importe quelle année, ou avec un mois 1 ou 2 et l’année 2000. ``` ifelse(month = 5 OR (month < 3 AND year = 2000), 'yes', 'no') ``` *then-expression* L’expression à renvoyer si aucun des arguments *if* n’a la valeur « true ». Il peut s’agir d’un nom de champ comme **address1**, d’une valeur littérale comme **'Unknown'** ou d’un appel à une autre fonction. L’expression doit avoir le même type de données que les autres arguments `then` et l’argument `else`. *else-expression* Expression à renvoyer si aucun des arguments *if* n’a la valeur true. Il peut s’agir d’un nom de champ comme **address1**, d’une valeur littérale comme **'Unknown'** ou d’une autre fonction comme `toString(salesAmount)`. L’expression doit avoir le même type de données que tous les arguments `then`. ## Type de retour `ifelse` renvoie une valeur du même type de données que les valeurs de *then-expression*. Toutes les données renvoyées par les expressions *then* et *else* doivent être du même type de données ou être converties dans le même type de données. ## Exemples L’exemple suivant génère une colonne d’alias pour le champ `country`. ``` ifelse(country = "United States", "US", country = "China", "CN", country = "India", "IN", "Others") ``` Pour de tels cas d’utilisation, il est recommandé d’évaluer chaque valeur d’un champ par rapport à une liste de littéraux et de renvoyer le résultat correspondant à la première valeur correspondante, ce qui simplifie votre travail. L’exemple précédent peut être réécrit sous la forme suivante en utilisant [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") ``` L’exemple suivant classe les ventes par client en niveaux lisibles par l’homme. ``` ifelse(salesPerCustomer < 1000, “VERY_LOW”, salesPerCustomer < 10000, “LOW”, salesPerCustomer < 100000, “MEDIUM”, “HIGH”) ``` L’exemple suivant utilise AND, OR et NOT pour comparer plusieurs expressions à l’aide d’opérateurs conditionnels afin de baliser les meilleurs clients hors (NOT) Washington et Oregon bénéficiant d’une promotion spéciale, qui ont réalisé plus de 10 commandes. Si aucune valeur n’est retournée, la valeur `'n/a'` est utilisée. ``` ifelse(( (NOT (State = 'WA' OR State = 'OR')) AND Orders > 10), 'Special Promotion XYZ', 'n/a') ``` Les exemples suivants utilisent uniquement OR pour générer une nouvelle colonne contenant le nom du continent correspondant à chaque `country`. ``` ifelse(country = "United States" OR country = "Canada", "North America", country = "China" OR country = "India" OR country = "Japan", "Asia", "Others") ``` L’exemple précédent peut être simplifié comme le montre l’exemple suivant. L’exemple suivant utilise `ifelse` et [https://docs.aws.amazon.com/quicksight/latest/user/in-function.html](https://docs.aws.amazon.com/quicksight/latest/user/in-function.html) pour créer une valeur dans une nouvelle colonne pour toute ligne où la valeur testée se trouve dans une liste littérale. Vous pouvez également utiliser `ifelse` avec [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") ``` Les auteurs peuvent enregistrer une liste littérale dans un paramètre multivaleur et l’utiliser dans les fonctions [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). L’exemple suivant est un équivalent de l’exemple précédent, sauf que les listes littérales sont stockées dans deux paramètres multivaleur. ``` ifelse(in(country,${NorthAmericaCountryParam}), "North America", in(country,${AsiaCountryParam}),"Asia", "Others") ``` L’exemple suivant attribue un groupe à un enregistrement de vente basé sur le total des ventes. La structure de chaque phrase `if-then` imite le comportement de *between*, un mot-clé qui ne fonctionne pas actuellement dans les expressions de champs calculés. Par exemple, le résultat de la comparaison `salesTotal >= 0 AND salesTotal < 500` renvoie les mêmes valeurs que la comparaison SQL `salesTotal between 0 and 499`. ``` ifelse(salesTotal >= 0 AND salesTotal < 500, 'Group 1', salesTotal >= 500 AND salesTotal < 1000, 'Group 2', 'Group 3') ``` L’exemple suivant teste la présence d’une valeur NULL en utilisant `coalesce` pour renvoyer la première valeur non NULL. Au lieu de devoir vous souvenir de la signification d’une valeur NULL dans un champ de date, vous pouvez utiliser une description lisible. Si la date de déconnexion est NULL, l’exemple renvoie la date de suspension, sauf si les deux sont NULL. Dans ce cas, `coalesce(DiscoDate, SuspendDate, '12/31/2491')` renvoie `'12/31/2491'`. La valeur de retour doit correspondre aux autres types de données. Cette date peut sembler une valeur inhabituelle, mais une date du 25e siècle simule raisonnablement la « fin des temps », définie comme la date la plus élevée dans un datamart. ``` ifelse ( (coalesce(DiscoDate, SuspendDate, '12/31/2491') = '12/31/2491'), 'Active subscriber', 'Inactive subscriber') ``` Le texte suivant présente un exemple plus complexe dans un format plus lisible, afin de montrer qu’il n’est pas nécessaire de comprimer votre code en une seule longue ligne. Cet exemple prévoit des comparaisons multiples de la valeur d’un résultat d’enquête. Il gère les valeurs NULL potentielles pour ce champ et catégorise deux plages acceptables. Il identifie également une plage qui nécessite davantage de tests et une autre qui n’est pas valide (hors plage). Pour toutes les valeurs restantes, il applique la condition `else` et indique que la ligne doit faire l’objet d’un nouveau test trois ans après la date qui y figure. ``` 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}) ) ) ) ``` L’exemple suivant attribue un nom de région créé « manuellement » à un groupe d’états. Il utilise également des espaces et des commentaires, enveloppés dans `/* */`, pour faciliter la maintenance du code. ``` 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 logique du marquage des régions se décompose comme suit : 1. Nous dressons la liste des états que nous voulons pour chaque région, en plaçant chaque liste entre guillemets pour en faire une chaîne de caractères, comme suit : + `'New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire'` + `'Georgia, Alabama, South Carolina, Louisiana'` + Vous pouvez ajouter d’autres ensembles, ou utiliser des pays, des villes, des provinces ou des What3Words si vous le voulez. 1. Nous demandons si la valeur de `State` (pour chaque ligne) se trouve dans la liste, en utilisant la fonction `locate` pour renvoyer une valeur non nulle si l’état se trouve dans la liste, comme suit. ``` locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) and locate('Georgia, Alabama, South Carolina, Louisiana',{State}) ``` 1. La fonction `locate` renvoie un nombre au lieu de `TRUE` ou `FALSE`, mais `ifelse` nécessite la valeur booléenne `TRUE`/`FALSE`. Pour contourner ce problème, nous pouvons comparer le résultat de `locate` à un nombre. Si l’état est dans la liste, la valeur de retour est supérieure à zéro. 1. Demandez si l’état est présent. ``` locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) > 0 ``` 1. S’il est présent dans la région, indiquez qu’il s’agit d’une région spécifique, dans ce cas la région du Nord-Est. ``` /*The if expression:*/ locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) > 0, /*The then expression:*/ 'Northeast', ``` 1. Parce que nous avons des états qui ne sont pas dans une liste, et parce que `ifelse` nécessite une seule expression `else`, nous fournissons `'Other Region'` comme étiquette pour les états restants. ``` /*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. Nous enveloppons tout cela dans la fonction `ifelse( )` pour obtenir la version finale. L’exemple suivant ne tient pas compte des états de la région du Sud-Est qui figuraient dans l’original. Vous pouvez les ajouter à la place de la balise *``*. Si vous voulez ajouter d’autres régions, vous pouvez construire d’autres copies de ces deux lignes et modifier la liste des états en fonction de vos besoins. Vous pouvez changer le nom de la région pour quelque chose qui vous convient, et changer le nom du champ `State` pour tout ce dont vous avez besoin. ``` 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' ) ``` **Note** Il existe d’autres façons d’effectuer la comparaison initiale de l’expression if. Par exemple, supposons que vous posiez la question « Quels sont les États qui ne manquent pas dans cette liste ? » plutôt que « Quels sont les États qui figurent sur la liste ? » Dans ce cas, vous pouvez la formuler différemment. Vous pourriez comparer l’instruction locate à zéro pour trouver les valeurs manquantes dans la liste, puis utiliser l’opérateur NOT pour les classer comme « non manquantes », comme suit. ``` /*The if expression:*/ NOT (locate('New York, New Jersey, Connecticut, Vermont, Maine, Rhode Island, New Hampshire',{State}) = 0), ``` Les deux versions sont correctes. La version que vous choisissez doit être la plus logique pour vous et votre équipe, afin que vous puissiez la maintenir facilement. Si toutes les options semblent équivalentes, choisissez la plus simple. # in `in` évalue si une expression existe dans une liste littérale. Si la liste contient l’expression, in renvoie vrai, sinon il renvoie faux. `in` est sensible à la casse pour les entrées de type chaîne de caractères. `in` accepte deux types de listes littérales : une liste saisie manuellement et un [paramètre multivaleur](https://docs.aws.amazon.com/quicksight/latest/user/parameters-in-quicksight.html). ## Syntaxe Utilisation d’une liste saisie manuellement : ``` in(expression, [literal-1, ...]) ``` Utilisation d’un paramètre multivaleur : ``` in(expression, $multivalue_parameter) ``` ## Arguments *expression* L’expression à comparer aux éléments de la liste littérale. Il peut s’agir d’un nom de champ comme `address`, d’une valeur littérale comme « **Unknown** », d’un paramètre à valeur unique ou d’un appel à une autre fonction scalaire, à condition que cette fonction ne soit pas une fonction d’agrégation ou un calcul de table. *liste littérale* (obligatoire) Il peut s’agir d’une liste saisie manuellement ou d’un paramètre multivaleur. Cet argument accepte jusqu’à 5 000 éléments. Toutefois, dans le cas d’une interrogation directe d’une source de données tierce, par exemple Oracle ou Teradata, la restriction peut être inférieure. + ***liste saisie manuellement*** – Une ou plusieurs valeurs littérales dans une liste à comparer à l’expression. La liste doit être placée entre crochets. Toutes les valeurs littérales à comparer doivent avoir le même type de données que l’expression. + ***paramètre multivaleur*** – Un paramètre multivaleur prédéfini transmis sous la forme d’une liste littérale. Le paramètre multivaleur doit avoir le même type de données que l’expression. ## Type de retour Valeur booléenne : TRUE/FALSE ## Exemple avec une liste statique L’exemple suivant évalue le champ `origin_state_name` pour les valeurs d’une liste de chaînes de caractères. Lors de la comparaison des entrées de type chaîne de caractères, `in` ne prend en charge que la comparaison sensible à la casse. ``` in(origin_state_name,["Georgia", "Ohio", "Texas"]) ``` Les valeurs suivantes sont celles du champ donné. ``` "Washington" "ohio" "Texas" ``` Pour ces valeurs, les valeurs suivantes sont renvoyées. ``` false false true ``` La troisième valeur de retour est vraie car seul « Texas » fait partie des valeurs incluses. L’exemple suivant évalue le champ `fl_date` pour les valeurs d’une liste de chaînes de caractères. Afin de faire correspondre le type, `toString` est utilisé pour convertir le type de date en type de chaîne. ``` in(toString(fl_date),["2015-05-14","2015-05-15","2015-05-16"]) ``` ![\[Une image des résultats de l’exemple de fonction, présentés sous forme de tableau.\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/in-function-example-manual-list.png) Les valeurs littérales et les valeurs NULL sont prises en charge dans l’argument de l’expression pour être comparées aux valeurs littérales de la liste. Les deux exemples suivants génèrent une nouvelle colonne de valeurs VRAIES. ``` in("Washington",["Washington","Ohio"]) ``` ``` in(NULL,[NULL,"Ohio"]) ``` ## Exemple avec un paramètre mutivaleur Supposons qu’un auteur crée un [paramètre multivaleur](https://docs.aws.amazon.com/quicksight/latest/user/parameters-in-quicksight.html) contenant une liste de tous les noms d’état. Il ajoute ensuite un contrôle permettant au lecteur de sélectionner des valeurs dans la liste. Ensuite, le lecteur sélectionne trois valeurs (« Georgia », « Ohio » et « Texas ») dans le contrôle de liste déroulante du paramètre. Dans ce cas, l’expression suivante est équivalente au premier exemple, où ces trois noms d’état sont transmis en tant que liste littérale à comparer avec le champ `original_state_name`. ``` in (origin_state_name, ${stateName MultivalueParameter}) ``` ## Exemple avec `ifelse` Le champ `in` peut être imbriqué dans d’autres fonctions en tant que valeur booléenne. Par exemple, les auteurs peuvent évaluer n’importe quelle expression dans une liste et renvoyer la valeur qu’ils veulent en utilisant `in` et `ifelse`. L’exemple suivant évalue si le `dest_state_name` d’un vol se trouve dans une liste particulière d’états américains et renvoie différentes catégories d’états sur la base de la comparaison. ``` ifelse(in(dest_state_name,["Washington", "Oregon","California"]), "WestCoastUSState", "Other US State") ``` ![\[Une image des résultats de l’exemple de fonction, présentés sous forme de tableau.\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/in-function-with-ifelse.png) # intToDecimal `intToDecimal` convertit une valeur d’entier en type de données décimales. ## Syntaxe ``` intToDecimal(integer) ``` ## Arguments *int* Un champ qui utilise le type de données d’entier, une valeur littérale comme **14** ou un appel à une autre fonction qui génère un entier. ## Type de retour Décimal (fixe) dans l'ancienne expérience de préparation des données. Décimal (flottant) dans la nouvelle expérience de préparation des données. ## Exemple L’exemple suivant convertit un champ d’entier en décimal. ``` intToDecimal(price) ``` Les valeurs suivantes sont celles du champ donné. ``` 20 892 57 ``` Pour ces valeurs, les valeurs suivantes sont renvoyées. ``` 20.0 892.0 58.0 ``` Vous pouvez appliquer un formatage dans une analyse, par exemple pour formater `price` comme devise. # isNotNull `isNotNull` évalue une expression pour voir si elle a la valeur not null. Si l’expression dispose d’une valeur non nulle, `isNotNull` renvoie la valeur « true », sinon, elle renvoie « false ». ## Syntaxe ``` isNotNull(expression) ``` ## Arguments *expression* Expression à évaluer comme ayant ou non la valeur null. Il peut s’agir d’un nom de champ comme **address1** ou d’un appel à une autre fonction qui génère une chaîne. ## Type de retour Booléen ## Exemple L’exemple suivant évalue le champ sales\$1amount pour voir s’il contient des valeurs null. ``` isNotNull(salesAmount) ``` Les valeurs suivantes sont celles du champ donné. ``` 20.13 (null) 57.54 ``` Pour ces valeurs, les valeurs suivantes sont renvoyées. ``` true false true ``` # isNull `isNull` évalue une expression pour voir si elle a la valeur null. Si l’expression dispose d’une valeur nulle, `isNull` renvoie la valeur « true », sinon, elle renvoie « false ». ## Syntaxe ``` isNull(expression) ``` ## Arguments *expression* Expression à évaluer comme ayant ou non la valeur null. Il peut s’agir d’un nom de champ comme **address1** ou d’un appel à une autre fonction qui génère une chaîne. ## Type de retour Booléen ## Exemple L’exemple suivant évalue le champ sales\$1amount pour voir s’il contient des valeurs null. ``` isNull(salesAmount) ``` Les valeurs suivantes sont celles du champ donné. ``` 20.13 (null) 57.54 ``` Pour ces valeurs, les valeurs suivantes sont renvoyées. ``` false true false ``` L’exemple suivant teste la présence d’une valeur NULL dans une instruction `ifelse` et renvoie à la place une valeur lisible par l’homme. ``` ifelse( isNull({ActiveFlag}) , 'Inactive', 'Active') ``` # isWorkDay `isWorkDay` évalue une valeur date-heure donnée pour déterminer s’il s’agit d’un jour ouvrable ou non. `isWorkDay` suppose une semaine de travail standard de 5 jours commençant le lundi et se terminant le vendredi. Le samedi et le dimanche sont considérés comme des week-ends. La fonction calcule toujours son résultat à la granularité `DAY` et ne tient pas compte de la date d’entrée donnée. ## Syntaxe ``` isWorkDay(inputDate) ``` ## Arguments *inputDate* La valeur date-heure que vous voulez évaluer. Les valeurs valides sont les suivantes : + Champs du jeu de données : tout champ `date` du jeu de données auquel vous ajoutez cette fonction. + Fonctions de date : toute date produite par une autre fonction `date`, par exemple `parseDate`. + Champs calculés : tout champ calculé rapidement qui renvoie une `date` valeur. + Paramètres : n'importe quel `DateTime` paramètre rapide. ## Type de retour Entier (`0` ou `1`) ## Exemple L’exemple suivant détermine si le champ `application_date` est un jour ouvrable ou non. Supposons qu’il existe un champ nommé `application_date` avec les valeurs suivantes : ``` 2022-08-10 2022-08-06 2022-08-07 ``` Lorsque vous utilisez ces champs et ajoutez les calculs suivants, `isWorkDay` renvoie les valeurs ci-dessous : ``` isWorkDay({application_date}) 1 0 0 ``` L’exemple suivant filtre les employés dont l’emploi se termine un jour ouvrable et détermine si leur emploi a commencé un jour ouvrable ou un week-end à l’aide d’une mise en forme conditionnelle : ``` 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/fr_fr/quick/latest/userguide/images/isWorkDay-example.png) # Left `left` retourne les caractères les plus à gauche d’une chaîne, y compris les espaces. Vous spécifiez le nombre de caractères à renvoyer. ## Syntaxe ``` left(expression, limit) ``` ## Arguments *expression* L’expression doit être une chaîne. Il peut s’agir du nom d’un champ qui utilise le type de données de chaîne, d’une valeur littérale comme **'12 Main Street'** ou d’un appel à une autre fonction qui renvoie une chaîne. *limit* Nombre de caractères à renvoyer d’une *expression*, à partir du premier caractère de la chaîne. ## Type de retour String ## Exemple L’exemple suivant renvoie les 3 premiers caractères d’une chaîne. ``` left('Seattle Store #14', 3) ``` La valeur suivante est renvoyée. ``` Sea ``` # Locate `locate` localise une sous-chaîne que vous spécifiez dans une autre chaîne et renvoie le nombre de caractères jusqu’au premier caractère de la sous-chaîne. La fonction renvoie 0 si elle ne trouve pas la sous-chaîne. La fonction est basée sur 1. ## Syntaxe ``` locate(expression, substring, start) ``` ## Arguments *expression* L’expression doit être une chaîne. Il peut s’agir du nom d’un champ qui utilise le type de données de chaîne, d’une valeur littérale comme **'12 Main Street'** ou d’un appel à une autre fonction qui renvoie une chaîne. *substring* Jeu de caractères dans l’*expression* que vous souhaitez rechercher. La sous-chaîne peut être contenue une ou plusieurs fois dans l’*expression*. *début* (Facultatif) Si *substring* se produit plus d’une fois, utilisez *start* pour identifier dans la chaîne l’emplacement où la fonction doit commencer à chercher la sous-chaîne. Par exemple, imaginons que vous voulez trouver le deuxième exemple d’une sous-chaîne et que vous pensez qu’il se produit généralement après les 10 premiers caractères. Vous devez spécifier une valeur *start* de 10. Elle doit commencer à 1. ## Type de retour Entier ## Exemples L’exemple suivant renvoie des informations sur l’emplacement où la première occurrence de la sous-chaîne « and » apparaît dans une chaîne. ``` locate('1 and 2 and 3 and 4', 'and') ``` La valeur suivante est renvoyée. ``` 3 ``` L’exemple suivant renvoie des informations sur l’emplacement de la première occurrence de la sous-chaîne « and » dans une chaîne après le quatrième caractère. ``` locate('1 and 2 and 3 and 4', 'and', 4) ``` La valeur suivante est renvoyée. ``` 9 ``` # Log `log` renvoie le logarithme de base 10 d’une expression donnée. ## Syntaxe ``` log(expression) ``` ## Arguments *expression* L’expression doit être numérique. Il peut s’agir d’un nom de champ, d’une valeur littérale ou d’une autre fonction. # Ln `ln` renvoie le logarithme naturel d’une expression donnée. ## Syntaxe ``` ln(expression) ``` ## Arguments *expression* L’expression doit être numérique. Il peut s’agir d’un nom de champ, d’une valeur littérale ou d’une autre fonction. # Ltrim `ltrim` supprime l’espace blanc précédent d’une chaîne. ## Syntaxe ``` ltrim(expression) ``` ## Arguments *expression* L’expression doit être une chaîne. Il peut s’agir du nom d’un champ qui utilise le type de données de chaîne, d’une valeur littérale comme **'12 Main Street'** ou d’un appel à une autre fonction qui renvoie une chaîne. ## Type de retour String ## Exemple L’exemple suivant supprime les espaces précédents d’une chaîne. ``` ltrim(' Seattle Store #14') ``` La valeur suivante est renvoyée. ``` Seattle Store #14 ``` # Mod Utilisez la fonction `mod` pour trouver la partie restante après avoir divisé le nombre par le diviseur. Vous pouvez utiliser la fonction `mod` ou l’opérateur modulo (%) de manière interchangeable. ## Syntaxe ``` mod(number, divisor) ``` ``` number%divisor ``` ## Arguments *number* Le nombre est l’entier positif que vous voulez diviser et pour lequel vous souhaitez trouver la partie restante. *divisor* Le diviseur est l’entier positif que vous utilisez pour diviser. Si le diviseur correspond à zéro, cette fonction renvoie une erreur lors de la division par 0. ## Exemple Les exemples suivants renvoient le modulo de 17 lors de la division par 6. Le premier exemple utilise l’opérateur % et le second utilise la fonction mod. ``` 17%6 ``` ``` mod( 17, 6 ) ``` La valeur suivante est renvoyée. ``` 5 ``` # netWorkDays `netWorkDays`renvoie le nombre de jours ouvrables entre les deux champs de date fournis ou même les valeurs de date personnalisées générées à l'aide d'autres fonctions de date rapide telles que `parseDate` ou `epochDate` sous forme de nombre entier. `netWorkDays` suppose une semaine de travail standard de 5 jours commençant le lundi et se terminant le vendredi. Le samedi et le dimanche sont considérés comme des week-ends. Le calcul inclut à la fois `startDate` et `endDate`. La fonction opère et affiche les résultats pour la granularité DAY. ## Syntaxe ``` netWorkDays(startDate, endDate) ``` ## Arguments *startDate* Il s’agit d’une date valide non NULL qui sert de date de début pour le calcul. + Champs du jeu de données : tout champ `date` du jeu de données auquel vous ajoutez cette fonction. + Fonctions de date : toute date produite par une autre fonction `date`, par exemple `parseDate`. + Champs calculés : tout champ calculé rapidement qui renvoie une `date` valeur. + Paramètres : n'importe quel `DateTime` paramètre rapide. + Toute combinaison des valeurs d’argument énoncées ci-dessus. *endDate* Une date valide non NULL qui sert de date de fin pour le calcul. + Champs du jeu de données : tout champ `date` du jeu de données auquel vous ajoutez cette fonction. + Fonctions de date : toute date produite par une autre fonction `date`, par exemple `parseDate`. + Champs calculés : tout champ calculé rapidement qui renvoie une `date` valeur. + Paramètres : n'importe quel `DateTime` paramètre rapide. + Toute combinaison des valeurs d’argument énoncées ci-dessus. ## Type de retour Entier ## Valeurs de sortie Les valeurs de sortie attendues sont les suivantes : + Nombre entier positif (lorsque start\$1date < end\$1date) + Nombre entier négatif (lorsque start\$1date > end\$1date) + NULL lorsque l’un ou les deux arguments reçoivent une valeur nulle de la fonction `dataset field`. ## Exemple L’exemple suivant renvoie le nombre de jours ouvrables compris entre deux dates. Supposons qu’il existe un champ nommé `application_date` avec les valeurs suivantes : ``` netWorkDays({startDate}, {endDate}) ``` Les valeurs suivantes sont celles du champ donné. ``` 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 ``` L’exemple suivant calcule le nombre de jours travaillés par chaque employé et le salaire dépensé par jour pour chaque employé : ``` days_worked = netWorkDays({employment_start_date}, {employment_end_date}) salary_per_day = {salary}/{days_worked} ``` L’exemple suivant filtre les employés dont l’emploi se termine un jour ouvrable et détermine si leur emploi a commencé un jour ouvrable ou un week-end à l’aide d’une mise en forme conditionnelle : ``` 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/fr_fr/quick/latest/userguide/images/netWorkDays-function-example.png) # Now Pour les jeux de données de base de données qui interrogent directement la base de données, `now` retourne la date et l’heure à l’aide des paramètres et du format spécifiés par le serveur de base de données. Pour les jeux de données SPICE et Salesforce, `now` retourne la date et l’heure UTC au format `yyyy-MM-ddTkk:mm:ss:SSSZ` (par exemple, 2015-10-15T19:11:51:003Z). ## Syntaxe ``` now() ``` ## Type de retour Date # notIn `notIn` évalue si une expression existe dans une liste littérale. Si la liste ne contient pas l’expression, `notIn` renvoie vrai, sinon il renvoie faux. `notIn` est sensible à la casse pour les entrées de type chaîne de caractères. `notIn` accepte deux types de listes littérales : une liste saisie manuellement et un [paramètre multivaleur](https://docs.aws.amazon.com/quicksight/latest/user/parameters-in-quicksight.html). ## Syntaxe Utilisation d’une liste saisie manuellement : ``` notIn(expression, [literal-1, ...]) ``` Utilisation d’un paramètre multivaleur : ``` notIn(expression, $multivalue_parameter) ``` ## Arguments *expression* L’expression à comparer aux éléments de la liste littérale. Il peut s’agir d’un nom de champ comme `address`, d’une valeur littérale comme « **Unknown** », d’un paramètre à valeur unique ou d’un appel à une autre fonction scalaire, à condition que cette fonction ne soit pas une fonction d’agrégation ou un calcul de table. *liste littérale* (obligatoire) Il peut s’agir d’une liste saisie manuellement ou d’un paramètre multivaleur. Cet argument accepte jusqu’à 5 000 éléments. Toutefois, dans le cas d’une interrogation directe d’une source de données tierce, par exemple Oracle ou Teradata, la restriction peut être inférieure. + ***liste saisie manuellement*** – Une ou plusieurs valeurs littérales dans une liste à comparer à l’expression. La liste doit être placée entre crochets. Toutes les valeurs littérales à comparer doivent avoir le même type de données que l’expression. + ***paramètre multivaleur*** – Un paramètre multivaleur prédéfini transmis sous la forme d’une liste littérale. Le paramètre multivaleur doit avoir le même type de données que l’expression. ## Type de retour Valeur booléenne : TRUE/FALSE ## Exemple avec une liste saisie manuellement L’exemple suivant évalue le champ `origin_state_name` pour les valeurs d’une liste de chaînes de caractères. Lors de la comparaison des entrées de type chaîne de caractères, `notIn` ne prend en charge que la comparaison sensible à la casse. ``` notIn(origin_state_name,["Georgia", "Ohio", "Texas"]) ``` Les valeurs suivantes sont celles du champ donné. ``` "Washington" "ohio" "Texas" ``` Pour ces valeurs, les valeurs suivantes sont renvoyées. ``` true true false ``` La troisième valeur de retour est fausse car seul « Texas » fait partie des valeurs exclues. L’exemple suivant évalue le champ `fl_date` pour les valeurs d’une liste de chaînes de caractères. Afin de faire correspondre le type, `toString` est utilisé pour convertir le type de date en type de chaîne. ``` notIn(toString(fl_date),["2015-05-14","2015-05-15","2015-05-16"]) ``` ![\[Une image des résultats de l’exemple de fonction, présentés sous forme de tableau.\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/notin-function-example-manual-list.png) Les valeurs littérales et les valeurs NULL sont prises en charge dans l’argument de l’expression pour être comparées aux valeurs littérales de la liste. Les deux exemples suivants génèrent une nouvelle colonne de valeurs FAUX. ``` notIn("Washington",["Washington","Ohio"]) ``` ``` notIn(NULL,[NULL,"Ohio"]) ``` ## Exemple avec un paramètre mutivaleur Supposons qu’un auteur crée un [paramètre multivaleur](https://docs.aws.amazon.com/quicksight/latest/user/parameters-in-quicksight.html) contenant une liste de tous les noms d’état. Il ajoute ensuite un contrôle permettant au lecteur de sélectionner des valeurs dans la liste. Ensuite, le lecteur sélectionne trois valeurs (« Georgia », « Ohio » et « Texas ») dans le contrôle de liste déroulante du paramètre. Dans ce cas, l’expression suivante est équivalente au premier exemple, où ces trois noms d’état sont transmis en tant que liste littérale à comparer avec le champ `original_state_name`. ``` notIn (origin_state_name, ${stateName MultivalueParameter}) ``` ## Exemple avec `ifelse` Le champ `notIn` peut être imbriqué dans d’autres fonctions en tant que valeur booléenne. Par exemple, les auteurs peuvent évaluer n’importe quelle expression dans une liste et renvoyer la valeur qu’ils veulent en utilisant `notIn` et `ifelse`. L’exemple suivant évalue si le `dest_state_name` d’un vol se trouve dans une liste particulière d’états américains et renvoie différentes catégories d’états sur la base de la comparaison. ``` ifelse(notIn(dest_state_name,["Washington", "Oregon","California"]), "notWestCoastUSState", "WestCoastUSState") ``` ![\[Une image des résultats de l’exemple de fonction, présentés sous forme de tableau.\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/notin-function-with-ifelse.png) # nullIf `nullIf` compare deux expressions. Si elles sont égales, la fonction retourne null. Si elles ne sont pas égales, la fonction renvoie la première expression. ## Syntaxe ``` nullIf(expression1, expression2) ``` ## Arguments `nullIf` prend deux expressions comme arguments. *expression* L’expression peut être de type numérique, datetime ou chaîne. Il peut s’agir d’un nom de champ, d’une valeur littérale ou d’une autre fonction. ## Type de retour String ## Exemple L’exemple suivant retourne des valeurs nulles si la raison pour un délai d’expédition est inconnue. ``` nullIf(delayReason, 'unknown') ``` Les valeurs suivantes sont celles du champ donné. ``` delayReason ============ unknown back ordered weather delay ``` Pour ces valeurs, les valeurs suivantes sont renvoyées. ``` (null) back ordered weather delay ``` # parseDate `parseDate`analyse une chaîne pour déterminer si elle contient une valeur de date et renvoie une date standard au format `yyyy-MM-ddTkk:mm:ss.SSSZ` (en utilisant la syntaxe du modèle de format spécifiée dans [Class DateTimeFormat](http://www.joda.org/joda-time/apidocs/org/joda/time/format/DateTimeFormat.html) dans la documentation du projet Joda), par exemple 2015-10-15T 19:11:51.003 Z. Cette fonction retourne toutes les lignes qui contiennent une date dans un format valide et ignore toutes les lignes qui n’en contiennent pas, y compris les lignes qui contiennent des valeurs null. Quick prend en charge des dates comprises entre le 1er janvier 1900 00:00:00 UTC et le 31 décembre 2037 23:59:59 UTC. Pour plus d'informations, consultez la section [Formats de date pris en charge](https://docs.aws.amazon.com/quicksight/latest/user/supported-date-formats.html). ## Syntaxe ``` parseDate(expression, ['format']) ``` ## Arguments *expression* L’expression doit être une chaîne. Il peut s’agir du nom d’un champ qui utilise le type de données de chaîne, d’une valeur littérale comme **'1/1/2016'** ou d’un appel à une autre fonction qui renvoie une chaîne. *format* (Facultatif) Une chaîne contenant le modèle de format auquel *date\$1string* doit correspondre. Par exemple, si vous utilisez un champ contenant des données telles que**01/03/2016**, vous spécifiez le format « MM/dd/yyyy ». Si vous ne spécifiez pas de format, la valeur par défaut est `yyyy-MM-dd`. Les lignes dont les données ne sont pas conformes au *format* sont ignorées. Différents formats de date sont pris en charge en fonction du type de jeu de données utilisé. Consultez le tableau suivant pour obtenir des détails sur les formats de date pris en charge. **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/parseDate-function.html) ## Type de retour Date ## Exemple L’exemple suivant évalue `prodDate` pour déterminer si elle contient des valeurs de date. ``` parseDate(prodDate, 'MM/dd/yyyy') ``` Les valeurs suivantes sont celles du champ donné. ``` prodDate -------- 01-01-1999 12/31/2006 1/18/1982 7/4/2010 ``` Pour ces valeurs de champs, les lignes suivantes sont renvoyées. ``` 12-31-2006T00:00:00.000Z 01-18-1982T00:00:00.000Z 07-04-2010T00:00:00.000Z ``` # parseDecimal `parseDecimal` analyse une chaîne pour déterminer si elle contient une valeur décimale. Cette fonction renvoie toutes les lignes contenant une valeur décimale, d’entier ou null et ignore toutes les lignes qui n’en contiennent pas. Si la ligne contient une valeur entière, elle est retournée sous forme décimale avec un maximum de 4 décimales. Par exemple, une valeur de « 2 » est retournée sous la forme « 2.0 ». ## Syntaxe ``` parseDecimal(expression) ``` ## Arguments *expression* L’expression doit être une chaîne. Il peut s’agir du nom d’un champ qui utilise le type de données de chaîne, d’une valeur littérale comme **'9.62'** ou d’un appel à une autre fonction qui renvoie une chaîne. ## Type de retour Décimal (fixe) dans l'ancienne expérience de préparation des données. Décimal (flottant) dans la nouvelle expérience de préparation des données. ## Exemple L’exemple suivant évalue `fee` pour déterminer si elle contient des valeurs décimales. ``` parseDecimal(fee) ``` Les valeurs suivantes sont celles du champ donné. ``` fee -------- 2 2a 12.13 3b 3.9 (null) 198.353398 ``` Pour ces valeurs de champs, les lignes suivantes sont renvoyées. ``` 2.0 12.13 3.9 (null) 198.3533 ``` # parseInt `parseInt` analyse une chaîne pour déterminer si elle contient une valeur d’entier. Cette fonction renvoie toutes les lignes contenant une valeur décimale, d’entier ou null et ignore toutes les lignes qui n’en contiennent pas. Si la ligne contient une valeur décimale, l’entier le plus proche est retourné, arrondi à une valeur inférieure. Par exemple, une valeur de « 2.99 » est retournée sous la forme « 2 ». ## Syntaxe ``` parseInt(expression) ``` ## Arguments *expression* L’expression doit être une chaîne. Il peut s’agir du nom d’un champ qui utilise le type de données de chaîne, d’une valeur littérale comme **'3'** ou d’un appel à une autre fonction qui renvoie une chaîne. ## Type de retour Entier ## Exemple L’exemple suivant évalue `feeType` pour déterminer si elle contient des valeurs entières. ``` parseInt(feeType) ``` Les valeurs suivantes sont celles du champ donné. ``` feeType -------- 2 2.1 2a 3 3b (null) 5 ``` Pour ces valeurs de champs, les lignes suivantes sont renvoyées. ``` 2 2 3 (null) 5 ``` # parseJson Utilisez `parseJson` pour extraire des valeurs d’un objet JSON. Si votre jeu de données est stocké dans QuickSPICE, vous pouvez l'utiliser `parseJson` lorsque vous préparez un ensemble de données, mais pas dans des champs calculés lors de l'analyse. Pour les requêtes directes, vous pouvez utiliser `parseJson` à la fois pendant la préparation des données et l’analyse. La fonction `parseJson` s’applique à des chaînes ou à des types de données JSON natif, selon le langage, comme indiqué dans le tableau suivant. | Langage | Type | | --- | --- | | PostgreSQL | JSON | | Amazon Redshift | String | | Microsoft SQL Server | String | | MySQL | JSON | | Teradata | JSON | | Oracle | String | | Presto | String | | Snowflake | Objet de type de données semi-structuré et tableau | | Hive | String | ## Syntaxe ``` parseJson(fieldName, path) ``` ## Arguments *fieldName* Champ contenant l’objet JSON que vous souhaitez analyser. *chemin* Chemin d’accès à l’élément de données que vous souhaitez analyser à partir de l’objet JSON. Seuls les lettres, les chiffres et les espaces vides sont pris en charge dans l’argument de chemin. Exemples de syntaxe de chemin valide : + *\$1* – Objet racine + *.* – Opérateur enfant + *[ ]* – Opérateur d’indice pour un tableau ## Type de retour String ## Exemple L’exemple suivant évalue le format JSON entrant pour récupérer une valeur pour la quantité d’éléments. En utilisant ces informations pendant la préparation des données, vous pouvez créer une table en dehors de JSON. ``` parseJson({jsonField}, “$.items.qty”) ``` L’exemple suivant illustre le format JSON. ``` { "customer": "John Doe", "items": { "product": "Beer", "qty": 6 }, "list1": [ "val1", "val2" ], "list2": [ { "list21key1": "list1value1" } ] } ``` Dans cet exemple, la valeur suivante est renvoyée. ``` 6 ``` ## Exemple L’exemple suivant évalue `JSONObject1` afin d’extraire la première paire clé-valeur (KVP), nommée `"State"`, et d’attribuer la valeur au champ calculé que vous créez. ``` parseJson(JSONObject1, “$.state”) ``` Les valeurs suivantes sont celles du champ donné. ``` 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"} ``` Pour ces valeurs de champs, les lignes suivantes sont renvoyées. ``` New York North Carolina Utah ``` # Replace `replace` remplace la partie d’une chaîne par une autre chaîne que vous spécifiez. ## Syntaxe ``` replace(expression, substring, replacement) ``` ## Arguments *expression* L’expression doit être une chaîne. Il peut s’agir du nom d’un champ qui utilise le type de données de chaîne, d’une valeur littérale comme **'12 Main Street'** ou d’un appel à une autre fonction qui renvoie une chaîne. *substring* Jeu de caractères dans l’*expression* que vous souhaitez remplacer. La sous-chaîne peut être contenue une ou plusieurs fois dans l’*expression*. *replacement* La chaîne que vous voulez remplacer pour *substring*. ## Type de retour String ## Exemple L’exemple suivant remplace la sous-chaîne « and » par « or ». ``` replace('1 and 2 and 3', 'and', 'or') ``` La chaîne suivante est retournée. ``` 1 or 2 or 3 ``` # Right `right` retourne les caractères les plus à droite d’une chaîne, y compris les espaces. Vous spécifiez le nombre de caractères à renvoyer. ## Syntaxe ``` right(expression, limit) ``` ## Arguments *expression* L’expression doit être une chaîne. Il peut s’agir du nom d’un champ qui utilise le type de données de chaîne, d’une valeur littérale comme **'12 Main Street'** ou d’un appel à une autre fonction qui renvoie une chaîne. *limit* Nombre de caractères à renvoyer d’une *expression*, à partir du dernier caractère de la chaîne. ## Type de retour String ## Exemple L’exemple suivant retourne les cinq derniers caractères d’une chaîne. ``` right('Seattle Store#14', 12) ``` La valeur suivante est renvoyée. ``` tle Store#14 ``` # Round `round` arrondit une valeur décimale au nombre entier plus proche si aucun ajustement n’est spécifié, ou à la décimale la plus proche si l’ajustement est sélectionné. ## Syntaxe ``` round(decimal, scale) ``` ## Arguments *decimal* Un champ qui utilise le type de données décimale, une valeur littérale comme **17.62** ou un appel à une autre fonction qui génère un nombre décimal. *échelle* Le nombre de décimales à utiliser pour les valeurs retournées. ## Type de retour | Opérande | Type de retour dans l'ancienne expérience de préparation des données | Type de retour dans la nouvelle expérience de préparation des données | | --- | --- | --- | | INT | DÉCIMAL (FIXE) | DÉCIMAL (FIXE) | | DÉCIMAL (FIXE) | DÉCIMAL (FIXE) | DÉCIMAL (FIXE) | | DÉCIMAL (FLOTTANT) | DÉCIMAL (FIXE) | DÉCIMAL (FLOTTANT) | ## Exemple L’exemple suivant arrondit un champ décimal à la deuxième décimale la plus proche. ``` round(salesAmount, 2) ``` Les valeurs suivantes sont celles du champ donné. ``` 20.1307 892.0388 57.5447 ``` Pour ces valeurs, les valeurs suivantes sont renvoyées. ``` 20.13 892.04 58.54 ``` # Rtrim `rtrim` supprime l’espace blanc suivant d’une chaîne. ## Syntaxe ``` rtrim(expression) ``` ## Arguments *expression* L’expression doit être une chaîne. Il peut s’agir du nom d’un champ qui utilise le type de données de chaîne, d’une valeur littérale comme **'12 Main Street'** ou d’un appel à une autre fonction qui renvoie une chaîne. ## Type de retour String ## Exemple L’exemple suivant supprime les espaces suivants d’une chaîne. ``` rtrim('Seattle Store #14 ') ``` Pour ces valeurs, les valeurs suivantes sont renvoyées. ``` Seattle Store #14 ``` # Split `split` fractionne une chaîne en un tableau de sous-chaînes, sur la base d’un séparateur que vous choisissez, et renvoie l’élément spécifié par la position. Vous pouvez ajouter `split` uniquement à un champ calculé lors de la préparation des données, et non à une analyse. Cette fonction n’est pas prise en charge dans les requêtes directes vers Microsoft SQL Server. ## Syntaxe ``` split(expression, delimiter , position) ``` ## Arguments *expression* L’expression doit être une chaîne. Il peut s’agir du nom d’un champ qui utilise le type de données de chaîne, d’une valeur littérale comme **'12 Main Street;1402 35th Ave;1818 Elm Ct;11 Janes Lane'** ou d’un appel à une autre fonction qui renvoie une chaîne. *delimiter* Le caractère délimitant les endroits où la chaîne est divisée en sous-chaînes. Par exemple, `split('one|two|three', '|', 2)` change comme suit. ``` one two three ``` Si vous choisissez `position = 2`, `split` renvoie `'two'`. *position* (Obligatoire) La position de l’élément à renvoyer à partir du tableau. La position du premier élément du tableau est 1. ## Type de retour Tableau de chaînes ## Exemple L’exemple suivant scinde une chaîne dans un tableau, en utilisant le caractère point-virgule (;) comme délimiteur et renvoie le troisième élément du tableau. ``` split('123 Test St;1402 35th Ave;1818 Elm Ct;11 Janes Lane', ';', 3) ``` L’objet suivant est renvoyé. ``` 1818 Elm Ct ``` Cette fonction ignore les éléments contenant des valeurs nulles ou des chaînes vides. # Sqrt `sqrt` renvoie la racine carrée d’une expression donnée. ## Syntaxe ``` sqrt(expression) ``` ## Arguments *expression* L’expression doit être numérique. Il peut s’agir d’un nom de champ, d’une valeur littérale ou d’une autre fonction. # startsWith `startsWith` évalue si l’expression commence par une sous-chaîne que vous spécifiez. Si l’expression commence par la sous-chaîne, `startsWith` renvoie un résultat positif, sinon il renvoie un résultat négatif. ## Syntaxe ``` startsWith(expression, substring, string-comparison-mode) ``` ## Arguments *expression* L’expression doit être une chaîne. Il peut s’agir du nom d’un champ qui utilise le type de données de chaîne, d’une valeur littérale comme **'12 Main Street'** ou d’un appel à une autre fonction qui renvoie une chaîne. *substring* L’ensemble des caractères à vérifier par rapport à l’*expression*. La sous-chaîne peut être contenue une ou plusieurs fois dans l’*expression*. *string-comparison-mode* (Facultatif) Spécifie le mode de comparaison de chaînes à utiliser : + `CASE_SENSITIVE` – Les comparaisons de chaînes sont sensibles à la casse. + `CASE_INSENSITIVE` – Les comparaisons de chaînes sont insensibles à la casse. La valeur par défaut est `CASE_SENSITIVE` lorsqu’elle est vide. ## Type de retour Booléen ## Exemples ### Exemple de sensibilité à la casse par défaut L’exemple suivant, sensible à la casse, évalue si `state_nm` commence par **New**. ``` startsWith(state_nm, "New") ``` Les valeurs suivantes sont celles du champ donné. ``` New York new york ``` Pour ces valeurs, les valeurs suivantes sont renvoyées. ``` true false ``` ### Exemple insensible à la casse L’exemple suivant, insensible à la casse, évalue si `state_nm` commence par **new**. ``` startsWith(state_nm, "new", CASE_INSENSITIVE) ``` Les valeurs suivantes sont celles du champ donné. ``` New York new york ``` Pour ces valeurs, les valeurs suivantes sont renvoyées. ``` true true ``` ### Exemple avec des instructions conditionnelles La fonction `startsWith` peut être utilisée comme instruction conditionnelle dans les fonctions If suivantes : [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) et [varpIf](https://docs.aws.amazon.com/quicksight/latest/user/varpIf-function.html). L’exemple suivant additionne `Sales` uniquement si state\$1nm commence par **New**. ``` sumIf(Sales,startsWith(state_nm, "New")) ``` ### Exemple « ne contient PAS » L’opérateur conditionnel `NOT` peut être utilisé pour évaluer si l’expression ne commence pas par la sous-chaîne spécifiée. ``` NOT(startsWith(state_nm, "New")) ``` ### Exemple d’utilisation de valeurs numériques Des valeurs numériques peuvent être utilisées dans les arguments d’expression ou de sous-chaîne en appliquant la fonction `toString`. ``` startsWith(state_nm, toString(5) ) ``` # Strlen `strlen` retourne le nombre de caractères dans une chaîne, y compris les espaces. ## Syntaxe ``` strlen(expression) ``` ## Arguments *expression* Une expression peut être le nom d’un champ qui utilise le type de données string comme **address1**, une valeur littérale comme **'Unknown'** ou une autre fonction comme `substring(field_name,0,5)`. ## Type de retour Entier ## Exemple L’exemple suivant renvoie la longueur de chaîne spécifiée. ``` strlen('1421 Main Street') ``` La valeur suivante est renvoyée. ``` 16 ``` # Substring `substring` renvoie les caractères contenus dans une chaîne, en commençant à l’emplacement spécifié par l’argument *start* en poursuivant pour obtenir le nombre de caractères spécifié par les arguments *length*. ## Syntaxe ``` substring(expression, start, length) ``` ## Arguments *expression* Une expression peut être le nom d’un champ qui utilise le type de données string comme **address1**, une valeur littérale comme **'Unknown'** ou une autre fonction comme `substring(field_name,1,5)`. *début* Emplacement du caractère de départ. *start* est inclusif, ce qui signifie que le caractère de départ est le premier caractère dans la valeur retournée. La valeur minimale pour *début* est 1. *longueur* Nombre de caractères supplémentaires à inclure après *start*. *length* est inclusif de *start*, ce qui signifie que le dernier caractère renvoyé est (*length* - 1) après le caractère de départ. ## Type de retour String ## Exemple L’exemple suivant retourne les caractères de la 13e à la 19e position dans une chaîne. Le début de la chaîne est l’indice 1, vous commencez donc à compter à partir du premier caractère. ``` substring('Fantasy and Science Fiction',13,7) ``` La valeur suivante est renvoyée. ``` Science ``` # switch `switch` compare une *expression-condition* avec les étiquettes littérales, dans un ensemble de paires d’étiquettes littérales et de *return-expression*. Il renvoie ensuite l’expression *return-expression* correspondant à la première étiquette littérale qui est égale à l’expression *condition-expression*. Si aucune étiquette n’est égale à l’expression *condition-expression*, `switch` renvoie l’expression *default-expression*. Chaque *return-expression* et *default-expression* doit avoir le même type de données. ## Syntaxe ``` switch(condition-expression, label-1, return-expression-1 [, label-n, return-expression-n ...], default-expression) ``` ## Arguments L’opérateur `switch` nécessite une ou plusieurs paires d’expressions *if*,*then* et requiert exactement une expression pour l’argument *else*. *condition-expression* L’expression à comparer avec l’étiquette-littérale. Il peut s’agir d’un nom de champ comme `address`, d’une valeur littérale comme « `Unknown` » ou d’une autre fonction scalaire comme `toString(salesAmount)`. *étiquette* Le littéral à comparer avec l’argument de *condition-expression*, tous les littéraux doivent avoir le même type de données que l’argument de *condition-expression*. L’expression `switch` accepte jusqu’à 5000 étiquettes. *return-expression* L’expression à retourner si la valeur de son étiquette est égale à la valeur de *condition-expression*. Il peut s’agir d’un nom de champ comme `address`, d’une valeur littérale comme « `Unknown` » ou d’une autre fonction scalaire comme `toString(salesAmount)`. Tous les arguments de *return-expression* doivent avoir le même type de données que *default-expression*. *default-expression* L’expression à renvoyer si aucune valeur des arguments de l’étiquette n’est égale à la valeur de *condition-expression*. Il peut s’agir d’un nom de champ comme `address`, d’une valeur littérale comme « `Unknown` » ou d’une autre fonction scalaire comme `toString(salesAmount)`. *default-expression* doit avoir le même type de données que tous les arguments de *return-expression*. ## Type de retour `switch` renvoie une valeur du même type de données que les valeurs de *return-expression*. Toutes les données renvoyées par *return-expression* et *default-expression* doivent être du même type de données ou être converties dans le même type de données. ## Exemples généraux L'exemple suivant renvoie le Région AWS code du nom de la région d'entrée. ``` switch(region_name, "US East (N. Virginia)", "us-east-1", "Europe (Ireland)", "eu-west-1", "US West (N. California)", "us-west-1", "other regions") ``` Les valeurs suivantes sont celles du champ donné. ``` "US East (N. Virginia)" "US West (N. California)" "Asia Pacific (Tokyo)" ``` Pour ces valeurs, les valeurs suivantes sont renvoyées. ``` "us-east-1" "us-west-1" "other regions" ``` ## Utilisation d’un commutateur pour remplacer `ifelse` Le cas d’utilisation `ifelse` suivant est un équivalent de l’exemple précédent, mais pour `ifelse` évaluer si les valeurs d’un champ sont égales à des valeurs littérales différentes, il est préférable d’utiliser `switch` à la place. ``` 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") ``` ## Expression comme valeur de retour L’exemple suivant utilise des expressions dans des *return-expressions* : ``` switch({origin_city_name}, "Albany, NY", {arr_delay} + 20, "Alexandria, LA", {arr_delay} - 10, "New York, NY", {arr_delay} * 2, {arr_delay}) ``` L’exemple précédent modifie le temps de retard prévu pour chaque vol au départ d’une ville donnée. ![\[Une image des résultats de l’exemple de fonction, présentés sous forme de tableau.\]](http://docs.aws.amazon.com/fr_fr/quick/latest/userguide/images/switch-function-example.png) # toLower `toLower` met en forme une chaîne tout en minuscules. `toLower` ignore les lignes contenant des valeurs nulles. ## Syntaxe ``` toLower(expression) ``` ## Arguments *expression* L’expression doit être une chaîne. Il peut s’agir du nom d’un champ qui utilise le type de données de chaîne, d’une valeur littérale comme **'12 Main Street'** ou d’un appel à une autre fonction qui renvoie une chaîne. ## Type de retour String ## Exemple L’exemple suivant convertit une valeur de chaîne en minuscules. ``` toLower('Seattle Store #14') ``` La valeur suivante est renvoyée. ``` seattle store #14 ``` # toString `toString` met en forme l’expression en entrée tout en minuscules. `toString` ignore les lignes contenant des valeurs nulles. ## Syntaxe ``` toString(expression) ``` ## Arguments *expression* Une expression peut être un champ de n’importe quel type de donnée, une valeur littérale comme **14.62** ou un appel à une autre fonction qui renvoie n’importe quel type de données. ## Type de retour String ## Exemple L’exemple suivant renvoie les valeurs de `payDate` (qui utilise le type de données `date`) sous forme de chaînes. ``` toString(payDate) ``` Les valeurs suivantes sont celles du champ donné. ``` payDate -------- 1992-11-14T00:00:00.000Z 2012-10-12T00:00:00.000Z 1973-04-08T00:00:00.000Z ``` Pour ces valeurs de champs, les lignes suivantes sont renvoyées. ``` 1992-11-14T00:00:00.000Z 2012-10-12T00:00:00.000Z 1973-04-08T00:00:00.000Z ``` # toUpper `toUpper` met en forme une chaîne tout en majuscules. `toUpper` ignore les lignes contenant des valeurs nulles. ## Syntaxe ``` toUpper(expression) ``` ## Arguments *expression* L’expression doit être une chaîne. Il peut s’agir du nom d’un champ qui utilise le type de données de chaîne, d’une valeur littérale comme **'12 Main Street'** ou d’un appel à une autre fonction qui renvoie une chaîne. ## Type de retour String ## Exemple L’exemple suivant convertit une valeur de chaîne en majuscules. ``` toUpper('Seattle Store #14') ``` La valeur suivante est renvoyée. ``` SEATTLE STORE #14 ``` # trim `trim` supprime les espaces blancs précédents et suivants d’une chaîne. ## Syntaxe ``` trim(expression) ``` ## Arguments *expression* L’expression doit être une chaîne. Il peut s’agir du nom d’un champ qui utilise le type de données de chaîne, d’une valeur littérale comme **'12 Main Street'** ou d’un appel à une autre fonction qui renvoie une chaîne. ## Type de retour String ## Exemple L’exemple suivant supprime les espaces suivants d’une chaîne. ``` trim(' Seattle Store #14 ') ``` Pour ces valeurs, les valeurs suivantes sont renvoyées. ``` Seattle Store #14 ``` # truncDate `truncDate` retourne une valeur de date qui représente une partie spécifiée d’une date. Par exemple, demander la partie de l’année de la valeur 2012-09-02T00:00:00.000Z retourne 2012-01-01T00:00:00.000Z. Spécifier une période horaire pour une date qui ne contient pas d’informations horaires retourne la valeur de date initiale sans modification. ## Syntaxe ``` truncDate('period', date) ``` ## Arguments *point* La période de la date à laquelle vous voulez retournée. Les périodes valides sont les suivantes : + AAAA : renvoie la partie de la date correspondant à l’année. + Q : Cela renvoie la date du premier jour du trimestre auquel la date appartient. + MM : renvoie la partie de la date correspondant au mois. + DD : renvoie la partie de la date correspondant au jour. + WK : renvoie la partie de la date correspondant à la semaine. La semaine commence le dimanche sur Amazon Quick. + HH : renvoie la partie de la date correspondant à l’heure. + MI : renvoie la partie de la date correspondant à la minute. + SS : renvoie la deuxième partie de la date. + MS : renvoie la partie milliseconde de la date. *date* Un champ de date ou un appel à une autre fonction qui génère une date. ## Type de retour Date ## Exemple L’exemple suivant retourne une date représentant le mois de la date de commande. ``` truncDate('MM', orderDate) ``` Les valeurs suivantes sont celles du champ donné. ``` orderDate ========= 2012-12-14T00:00:00.000Z 2013-12-29T00:00:00.000Z 2012-11-15T00:00:00.000Z ``` Pour ces valeurs, les valeurs suivantes sont renvoyées. ``` 2012-12-01T00:00:00.000Z 2013-12-01T00:00:00.000Z 2012-11-01T00:00:00.000Z ```