Référence Functions (Data Flow)

Les fonctions suivantes sont utilisées avec les opérateurs d'un flux de données pour vous permettre de créer des expressions.

Fonctions d'agrégation


Fonction	Description	Exemple
`COUNT(value[, value]*)`	Renvoie le nombre de lignes pour lesquelles les expressions fournies ne sont pas NULL.	`COUNT(expr1)`
`COUNT(*)`	Renvoie le nombre total de lignes extraites, comprenant les lignes contenant la valeur NULL.	`COUNT(*)`
`MAX(value)`	Renvoie la valeur maximale de l'argument.	`MAX(expr)`
`MIN(value)`	Renvoie la valeur minimale de l'argument.	`MIN(expr)`
`SUM(numeric)`	Renvoie la somme calculée à partir des valeurs d'un groupe.	`SUM(expr1)`
`AVG(numeric)`	Renvoie la moyenne des valeurs numériques dans une expression.	`AVG(AGGREGATE_1.src1.attribute1)`
`LISTAGG(column[, delimiter]) WITHIN GROUP (order_by_clause)`	Concatène les valeurs de la colonne d'entrée avec le délimiteur spécifié, pour chaque groupe en fonction de la clause order. column contient les valeurs à concaténer dans le résultat. delimiter sépare les valeurs de column dans le résultat. Si aucun délimiteur n'est fourni, un caractère vide est utilisé. order_by_clause détermine l'ordre dans lequel les valeurs concaténées sont renvoyées. Cette fonction peut uniquement être employée comme opérateur d'agrégation, et elle peut être utilisée avec ou sans regroupement. Sans regroupement, le résultat apparaît sur une seule ligne. Avec regroupement, la fonction renvoie une ligne pour chaque groupe.	Prenons une table comportant deux colonnes : `id` et `name`. La table contient trois lignes. Les valeurs de la colonne `id` sont 101, 102, 102. Les valeurs de la colonne `name` sont A, B, C. `+-----+--------+ \| id \| name \| +-----+--------+ \| 101 \| A \| +-----+--------+ \| 102 \| B \| +-----+--------+ \| 102 \| C \| +-----+--------+` Exemple 1 : sans regroupement `LISTAGG(id, '-') WITHIN GROUP (ORDER BY id)` renvoie la colonne `name` avec la valeur `A-B-C` `+--------+ \| name \| +--------+ \| A-B-C \| +--------+` Exemple 2 : regroupement par `id` `LISTAGG(id, '-') WITHIN GROUP (ORDER BY id)` renvoie la colonne `name` avec les valeurs `A` et `B-C` en deux groupes. `+--------+ \| name \| +--------+ \| A \| +--------+ \| B-C \| +--------+`

Fonctions analytiques


Fonction	Description	Exemple
`FIRST_VALUE(value) OVER ([ partition_clause ] order_by_clause [ windowFrame_clause ] )`	Renvoie la valeur évaluée à la ligne qui est la première ligne du cadre de la fenêtre.	`FIRST_VALUE(BANK_ID) OVER (PARTITION BY BANK_ID ORDER BY BANK_NAME ROWS BETWEEN CURRENT ROW AND 1 FOLLOWING)` renvoie la première valeur de `BANK_ID` dans une fenêtre sur laquelle les lignes sont calculées selon la ligne en cours et une ligne après cette ligne, partitionnées par `BANK_ID` et dans l'ordre croissant selon `BANK_NAME`.
`LAG(value[, offset[, default]]) OVER ([ partition_clause ] order_by_clause)`	Renvoie la valeur évaluée à la ligne à un décalage donné avant la ligne en cours dans la partition. En l'absence de ligne de ce type, la valeur par défaut est renvoyée. Les valeurs de décalage et par défaut sont évaluées par rapport à la ligne en cours. S'il est omis, le décalage est défini par défaut sur 1 et sur NULL.	`LAG(BANK_ID, 2, 'hello') OVER (PARTITION BY BANK_ID ORDER BY BANK_NAME DESC)` renvoie la valeur `BANK_ID` de la deuxième ligne avant la ligne en cours, partitionnée par `BANK_ID` et dans l'ordre décroissant selon `BANK_NAME`. Si cette valeur n'existe pas, la valeur `hello` est renvoyé.
`LAST_VALUE(value) OVER ([ partition_clause ] order_by_clause [ windowFrame_clause ])`	Renvoie la valeur évaluée à la ligne qui est la dernière ligne du cadre de la fenêtre.	`LAST_VALUE(BANK_ID) OVER (PARTITION BY BANK_ID ORDER BY BANK_NAME ROWS BETWEEN CURRENT ROW AND 1 FOLLOWING)` renvoie la dernière valeur de `BANK_ID` dans une fenêtre sur laquelle les lignes sont calculées selon la ligne en cours et une ligne après cette ligne, partitionnées par `BANK_ID` et dans l'ordre croissant selon `BANK_NAME`.
`LEAD(value[, offset[, default]]) OVER ([ partition_clause ] order_by_clause)`	Renvoie la valeur évaluée à la ligne à un décalage donné après la ligne en cours dans la partition. En l'absence de ligne de ce type, la valeur par défaut est renvoyée. Les valeurs de décalage et par défaut sont évaluées par rapport à la ligne en cours. S'il est omis, le décalage est défini par défaut sur 1 et sur NULL.	`LEAD(BANK_ID, 2, 'hello') OVER (PARTITION BY BANK_ID ORDER BY BANK_NAME)` renvoie la valeur `BANK_ID` de la deuxième ligne après la ligne en cours, partitionnée par `BANK_ID` et dans l'ordre croissant selon `BANK_NAME`. Si cette valeur n'existe pas, la valeur `hello` est renvoyé.
`RANK() OVER([ partition_clause ] order_by_clause)`	Renvoie le rang de la ligne en cours avec les intervalles, à partir de 1.	`RANK() OVER (PARTITION BY BANK_ID ORDER BY BANK_NAME)` renvoie le rang de chaque ligne dans le groupe de partitions de `BANK_ID`, dans l'ordre croissant selon `BANK_NAME`.
`ROW_NUMBER() OVER([ partition_clause ] order_by_clause)`	Renvoie le numéro unique de la ligne en cours dans sa partition, à partir de 1.	`ROW_NUMBER() OVER (PARTITION BY BANK_ID ORDER BY BANK_NAME)` renvoie le numéro unique de chaque ligne dans le groupe de partitions de `BANK_ID`, dans l'ordre croissant selon `BANK_NAME`.

Fonctions arithmétiques


Fonction	Description	Exemple
`ABS(numeric)`	Renvoie la puissance absolue de la valeur `numeric`.	`ABS(-1)`
`CEIL(numeric)`	Renvoie l'entier le plus petit qui n'est pas supérieur à la valeur `numeric`	`CEIL(-1,2)`
`FLOOR(numeric)`	Renvoie l'entier le plus grand qui n'est pas supérieur à la valeur `numeric`	`FLOOR(-1,2)`
`MOD(numeric1, numeric2)`	Renvoie le reste après que `numeric1` est divisé par `numeric2`.	`MOD(8,2)`
`POWER(numeric1, numeric2)`	Place `numeric1` comme puissance de `numeric2`.	`POWER(2,3)`
`ROUND(numeric1, numeric2)`	Renvoie `numeric1` arrondi à `numeric2` décimales.	`ROUND(2.5,0)`
`TRUNC(numeric1, numeric2)`	Renvoie `numeric1` tronqué à `numeric2` décimales.	`TRUNC(2.5,0)`
`TO_NUMBER(expr[, format, locale])`	Convertit une valeur `expr` en nombre, en fonction des éléments `format` et `locale` (facultatif) fournis. L'environnement local par défaut est `en-US`. Balises de langue prises en charge. Modèles de format pris en charge : `0` : chiffre `#` : chiffre (zéro affiché comme absent) `.` : espace réservé pour le séparateur décimal `,` : espace réservé pour le séparateur de groupes `E` : sépare la mantisse et l'exposant pour les formats exponentiels `-` : préfixe négatif par défaut `¤` : signe de devise ; remplacé par le symbole de devise ; s'il est double, remplacé par le symbole de devise internationale ; s'il est présent dans un modèle, le séparateur décimal monétaire est utilisé à la place du séparateur décimal	`TO_NUMBER('5467.12') returns` renvoie `5467.12` `TO_NUMBER('-USD45,677.7', '¤¤##,###.#', 'en-US')` renvoie `-45677.7`

Fonctions de tableau

Seul l'opérateur Expression prend en charge les fonctions de tableau.


Fonction	Description	Exemple
`ARRAY_POSITION(array(...), element)`	Renvoie la position de la première occurrence de l'élément donné dans le tableau donné. La position n'est pas basée sur zéro, elle commence par 1.	`ARRAY_POSITION(array(3, 2, 1, 4, 1), 1)` renvoie `3`
`REVERSE(array(...))`	Renvoie le tableau d'éléments donné dans un ordre inverse.	`REVERSE(array(2, 1, 4, 3))` renvoie `[3,4,1,2]`
`ELEMENT_AT(array(...), index)`	Renvoie l'élément du tableau donné à la position d'index donnée. L'index n'est pas basé sur zéro, il commence par 1. Si `index = -1`, il renvoie le dernier élément.	`ELEMENT_AT(array(1, 2, 3), 2)` renvoie `2`

Fonctions conditionnelles


Fonction	Description	Exemple
`COALESCE(value, value [, value]*)`	Renvoie le premier argument non NULL, le cas échéant, sinon, renvoie la valeur NULL.	`COALESCE(NULL, 1, NULL)` renvoie `1`
`NULLIF(value, value)`	Renvoie la valeur NULL si les deux valeurs sont égales, sinon, renvoie la première valeur.	`NULLIF('ABC','XYZ')` renvoie `ABC`

Fonctions de date et d'heure


Fonction	Description	Exemple
`CURRENT_DATE`	Renvoie la date actuelle.	`CURRENT_DATE`renvoie la date du jour, par exemple `2023-05-26`
`CURRENT_TIMESTAMP`	Renvoie la date et l'heure en cours du fuseau horaire de la session.	`CURRENT_TIMESTAMP` renvoie la date du jour et l'heure actuelle, par exemple `2023-05-26 12:34:56`
`DATE_ADD(date, number_of_days)`	Renvoie la date qui correspond au nombre (`number`) de jours indiqué après la valeur `date` spécifiée.	`DATE_ADD('2017-07-30', 1)` renvoie `2017-07-31`
`DATE_FORMAT(expr, format[, locale])`	Formate une valeur `expr` de date, en fonction des éléments `format` et `locale` (facultatif) fournis. L'environnement local par défaut est `en-US`. Balises de langue prises en charge. Modèles de format de date pris en charge : yy : année à deux chiffres yyyy : année à quatre chiffres M : mois numérique, par exemple 1 pour janvier MM : mois numérique, tel que 01 pour janvier MMM : mois abrégé, par exemple Jan MMMM : mois entier, par exemple janvier d : jour numérique du mois, par exemple 1 pour le 1er juin dd : jour numérique du mois, par exemple 01 pour le 1er juin DDD : jour numérique de l'année compris entre 001 et 366, par exemple 002 pour le 2 janvier F : jour numérique de la semaine dans un mois, par exemple 3 pour le 3e lundi de juin. EEE ou E : jour nommé abrégé de la semaine, par exemple dim pour le dimanche EEE : jour nommé de la semaine, par exemple dimanche HH : format 24 heures allant de 00 à 23 H : format 24 heures allant de 0 à 23 hh : format 12 heures allant de 01 à 12 h : format 12 heures allant de 1 à 12 mm : minutes allant de 00 à 59 ss : secondes allant de 00 à 59 SSS : millisecondes de 000 à 999 a : AM ou PM z : fuseau horaire tel que PDT	`DATE_FORMAT(Date '2020-10-11', 'yyyy-MM-dd')` renvoie `'2020-10-11'`. Le premier argument est un objet Date représentant le 11 octobre 2020. `DATE_FORMAT(Date '2018-junio-17', 'yyyy/MMMM/dd', 'es-ES')` renvoie `'2018/junio/17'`
`DAYOFMONTH(date)`	Renvoie le jour de la date dans le mois.	`DAYOFMONTH('2020-12-25')` renvoie `25`
`DAYOFWEEK(date)`	Renvoie le jour de la date dans la semaine.	`DAYOFWEEK('2020-12-25')` renvoie `6` pour vendredi. Aux États-Unis, dimanche est considéré comme 1, lundi est 2, et ainsi de suite.
`DAYOFYEAR(date)`	Renvoie le jour de la date dans l'année.	`DAYOFYEAR('2020-12-25')` renvoie `360`
`WEEKOFYEAR(date)`	Renvoie la semaine de la date dans l'année.	`WEEKOFYEAR('2022-07-28')` renvoie `30` `WEEKOFYEAR('2022-07-28 13:24:30')` renvoie `30`
`HOUR(datetime)`	Renvoie la valeur d'heure de la date et de l'heure.	`HOUR('2020-12-25 15:10:30')` renvoie `15`
`LAST_DAY(date)`	Renvoie le dernier jour du mois de la date.	`LAST_DAY('2020-12-25')` renvoie `31`
`MINUTE(datetime)`	Renvoie la valeur de minute de la date et de l'heure.	`HOUR('2020-12-25 15:10:30')` renvoie `10`
`MONTH(date)`	Renvoie la valeur de mois de la date.	`MONTH('2020-06-25')` renvoie `6`
`QUARTER(date)`	Renvoie le trimestre de l'année correspondant à la date.	`QUARTER('2020-12-25')` renvoie `4`
`SECOND(datetime)`	Renvoie la valeur de seconde de la date et de l'heure.	`SECOND('2020-12-25 15:10:30')` renvoie `30`
`TO_DATE(string, format_string[, localeStr])`	Analyse l'expression de chaîne avec l'expression `format_string` pour générer une date. L'environnement local est facultatif. La valeur par défaut est `en-US`. Balises de langue prises en charge. Dans les expressions de pipeline, `format_string` doit utiliser les codes de format strftime. Sinon, les chaînes de format distinguant les minuscules des majuscules prises en charge sont les suivantes : yy : année à deux chiffres yyyy : année à quatre chiffres M : mois numérique, par exemple 1 pour janvier MM : mois numérique, tel que 01 pour janvier MMM : mois abrégé, par exemple Jan MMMM : mois entier, par exemple janvier d : jour numérique du mois, par exemple 1 pour le 1er juin dd : jour numérique du mois, par exemple 01 pour le 1er juin DDD : jour numérique de l'année compris entre 001 et 366, par exemple 002 pour le 2 janvier F : jour numérique de la semaine dans un mois, par exemple 3 pour le 3e lundi de juin. EEE ou E : jour nommé abrégé de la semaine, par exemple dim pour le dimanche EEE : jour nommé de la semaine, par exemple dimanche HH : format 24 heures allant de 00 à 23 H : format 24 heures allant de 0 à 23 hh : format 12 heures allant de 01 à 12 h : format 12 heures allant de 1 à 12 mm : minutes allant de 00 à 59 ss : secondes allant de 00 à 59 SSS : millisecondes de 000 à 999 a : AM ou PM z : fuseau horaire tel que PDT	`TO_DATE('31 December 2016', 'dd MMMM yyyy')` renvoie la valeur Date `2016-12-31` `TO_DATE('2018/junio/17', 'yyyy/MMMM/dd', 'es-ES')` renvoie la valeur Date `2018-06-17`
`TO_TIMESTAMP(expr, format_string[, localeStr])`	Convertit une valeur `expr` VARCHAR en valeur TIMESTAMP, en fonction des éléments `format_string` et `localeStr` (facultatif) fournis. Dans les expressions de pipeline, `format_string` doit utiliser les codes de format strftime. Sinon, les modèles de format pris en charge sont les suivants : yy : année à deux chiffres yyyy : année à quatre chiffres M : mois numérique, par exemple 1 pour janvier MM : mois numérique, tel que 01 pour janvier MMM : mois abrégé, par exemple Jan MMMM : mois entier, par exemple janvier d : jour numérique du mois, par exemple 1 pour le 1er juin dd : jour numérique du mois, par exemple 01 pour le 1er juin DDD : jour numérique de l'année compris entre 001 et 366, par exemple 002 pour le 2 janvier F : jour numérique de la semaine dans un mois, par exemple 3 pour le 3e lundi de juin. EEE ou E : jour nommé abrégé de la semaine, par exemple dim pour le dimanche EEE : jour nommé de la semaine, par exemple dimanche HH : format 24 heures allant de 00 à 23 H : format 24 heures allant de 0 à 23 hh : format 12 heures allant de 01 à 12 h : format 12 heures allant de 1 à 12 mm : minutes allant de 00 à 59 ss : secondes allant de 00 à 59 SSS : millisecondes de 000 à 999 a : AM ou PM z : fuseau horaire tel que PDT	`TO_TIMESTAMP('2020-10-11 11:10:10', 'yyyy-MM-dd HH:mm:ss')` renvoie un objet TIMESTAMP représentant `11am 10:10 Oct 11th, 2020`
`WEEK(date)`	Renvoie la valeur de semaine de la date.	`WEEK('2020-06-25')` renvoie `4`
`YEAR(date)`	Renvoie la valeur d'année de la date.	`YEAR('2020-06-25')` renvoie `2020`
`ADD_MONTHS(date_expr, number_months)`	Renvoie la date après ajout du nombre de mois spécifié à la date, à la chaîne ou à l'horodatage spécifié avec un format tel que `yyyy-MM-dd` ou `yyyy-MM-dd HH:mm:ss.SSS`.	`ADD_MONTHS('2017-07-30', 1)` renvoie `2017-08-30` `ADD_MONTHS('2017-07-30 09:07:21', 1)` renvoie `2017-08-30`
`MONTHS_BETWEEN(start_date_expr, end_date_expr)`	Renvoie le nombre de mois entre `start_date_expr` et `end_date_expr`. `start_date_expr` et `end_date_expr` peuvent être des dates, des horodatages ou des chaînes avec un format tel que `yyyy-MM-dd` ou `yyyy-MM-dd HH:mm:ss.SSS` Un nombre entier est renvoyé si les deux dates sont le même jour du mois ou le dernier jour de leurs mois respectifs. Sinon, la différence est calculée sur la base de 31 jours par mois.	`MONTHS_BETWEEN('2022-01-01', '2022-01-31')` renvoie 1 `MONTHS_BETWEEN('2022-07-28', '2020-07-25')` renvoie 24 `MONTHS_BETWEEN('2022-07-28 13:24:30', '2020-07-25 13:24:30')` renvoie 24
`FROM_UTC_TIMESTAMP(time_stamp, time_zone)`	Interprète une date, un horodatage ou une chaîne en temps UTC, converti ensuite en horodatage dans le fuseau horaire spécifié. Pour la chaîne, utilisez un format tel que : `yyyy-MM-dd` ou `yyyy-MM-dd HH:mm:ss.SSS` Le format de fuseau horaire est un ID de zone basé sur la région (par exemple, "zone/ville" comme "Asie/Séoul") ou un décalage de fuseau horaire (par exemple, UTC+02).	`FROM_UTC_TIMESTAMP('2017-07-14 02:40:00.0', 'GMT+1')` renvoie `2017-07-14 03:40:00.0`
`TO_UTC_TIMESTAMP(time_stamp, time_zone)`	Convertit une date, un horodatage ou une chaîne dans le fuseau horaire spécifié en horodatage UTC. Pour la chaîne, utilisez un format tel que : `yyyy-MM-dd` ou `yyyy-MM-dd HH:mm:ss.SSS` Le format de fuseau horaire est un ID de zone basé sur la région (par exemple, "zone/ville" comme "Asie/Séoul") ou un décalage de fuseau horaire (par exemple, UTC+02).	`TO_UTC_TIMESTAMP('2017-07-14 02:40:00.0', 'GMT+1')` renvoie `2017-07-14 01:40:00.0`
`FROM_UNIXTIME(unix_time[, fmt])`	Convertit la période ou l'heure UNIX spécifiée en chaîne qui représente l'horodatage correspondant dans le fuseau horaire système en cours et dans le format spécifié. Remarque : l'heure Unix est le nombre de secondes qui s'est écoulé depuis le 1er janvier 1970 à 00:0:00 UTC. Si `fmt` est omis, le format par défaut est `yyyy-MM-dd HH:mm:ss`	`FROM_UNIXTIME(1255033470)` renvoie `'2009-10-08 13:24:30'` `FROM_UNIXTIME(1637258854)` renvoie `'2021-11-18 10:07:34'` Le fuseau horaire par défaut est PST dans les exemples
`UNIX_TIMESTAMP([time_expr[, fmt]])`	Convertit l'heure en cours ou spécifiée en horodatage Unix en secondes. `time_expr` est une date, un horodatage ou une chaîne avec un format tel que `yyyy-MM-dd` ou `yyyy-MM-dd HH:mm:ss.SSS` Si `time_expr` n'est pas fourni, l'heure en cours est convertie. Si `time_expr` est une chaîne et que `fmt` est omis, la valeur par défaut est `yyyy-MM-dd HH:mm:ss`	`UNIX_TIMESTAMP('1970-01-01 00:00:00', 'yyyy-MM-dd HH:mm:ss')` renvoie `28800` Le fuseau horaire par défaut est PST dans cet exemple
`INTERVAL 'year' YEAR[(year_precision)]`	Renvoie une période en années. year_precision est le nombre de chiffres du champ year ; il varie de 0 à 9. Si year_precision est omis, la valeur par défaut est 2 (doit être inférieure à 100 ans).	`INTERVAL '1' YEAR` renvoie un intervalle de 1 an `INTERVAL '200' YEAR(3)` renvoie un intervalle de 200 ans
`INTERVAL 'year month' YEAR[(year_precision)] TO MONTH`	Renvoie une période en années et en mois. Permet de stocker une période à l'aide des champs year et month. year_precision est le nombre de chiffres du champ year ; il varie de 0 à 9. Si year_precision est omis, la valeur par défaut est 2 (doit être inférieure à 100 ans).	`INTERVAL '100-5' YEAR(3) TO MONTH` renvoie un intervalle de 100 ans et 5 mois. Vous devez indiquer une précision de 3 pour l'année de début.
`INTERVAL 'month' MONTH[(month_precision)]`	Renvoie une période en mois. month_precision est le nombre de chiffres du champ mois ; il varie de 0 à 9. Si month_precision est omis, la valeur par défaut est 2 (doit être inférieure à 100 ans).	`INTERVAL '200' MONTH(3)` renvoie un intervalle de 200 mois. Vous devez indiquer une précision de 3 pour le mois.
`INTERVAL 'day time' DAY[(day_precision)] TO SECOND[(fractional_seconds_precision)]`	Renvoie une période en jours, heures, minutes et secondes. day_precision est le nombre de chiffres du champ day ; il varie de 0 à 9. Valeur par défaut : 2. fractional_seconds_precision est le nombre de chiffres de la partie fractionnaire de la deuxième valeur du champ time ; il est compris entre 0 et 9.	`INTERVAL '11 10:09:08.555' DAY TO SECOND(3)` renvoie un intervalle de 11 jours, 10 heures, 9 minutes, 8 secondes et 555 millièmes de seconde
`INTERVAL 'day time' DAY[(day_precision)] TO MINUTE[(minute_precision)]`	Renvoie une période en jours, heures et minutes. day_precision est le nombre de chiffres du champ day ; il varie de 0 à 9. Valeur par défaut : 2. minute_precision est le nombre de chiffres du champ minute ; il varie de 0 à 2. Valeur par défaut : 2.	`INTERVAL '11 10:09' DAY TO MINUTE` renvoie un intervalle de 11 jours, 10 heures et 9 minutes
`INTERVAL 'day time' DAY[(day_precision)] TO HOUR[(hour_precision)]`	Renvoie une période en jours et heures. day_precision est le nombre de chiffres du champ day ; il varie de 0 à 9. Valeur par défaut : 2. hour_precision est le nombre de chiffres du champ heure ; il varie de 0 à 2. Valeur par défaut : 2.	`INTERVAL '100 10' DAY(3) TO HOUR` renvoie un intervalle de 100 jours et 10 heures
`INTERVAL 'day' DAY[(day_precision)]`	Renvoie une période en jours. day_precision est le nombre de chiffres du champ day ; il varie de 0 à 9. Valeur par défaut : 2.	`INTERVAL '999' DAY(3)` renvoie un intervalle de 999 jours
`INTERVAL 'time' HOUR[(hour_precision)] TO SECOND[(fractional_seconds_precision)]`	Renvoie une période en heures, minutes et secondes. hour_precision est le nombre de chiffres du champ heure ; il varie de 0 à 2. Valeur par défaut : 2. fractional_seconds_precision est le nombre de chiffres de la partie fractionnaire de la deuxième valeur du champ time ; il est compris entre 0 et 9.	`INTERVAL '09:08:07.6666666' HOUR TO SECOND(7)` renvoie un intervalle de 9 heures, 8 minutes et 7,6666666 secondes
`INTERVAL 'time' HOUR[(hour_precision)] TO MINUTE[(minute_precision)]`	Renvoie une période en heures et minutes. hour_precision est le nombre de chiffres du champ heure ; il varie de 0 à 2. Valeur par défaut : 2. minute_precision est le nombre de chiffres du champ minute ; il varie de 0 à 2. Valeur par défaut : 2.	`INTERVAL '09:30' HOUR TO MINUTE` renvoie un intervalle de 9 heures et 30 minutes
`INTERVAL 'hour' HOUR[(hour_precision)]`	Renvoie une période en heures. hour_precision est le nombre de chiffres du champ heure ; il varie de 0 à 2. Valeur par défaut : 2.	`INTERVAL '40' HOUR` renvoie un intervalle de 40 heures
`INTERVAL 'minute' MINUTE[(minute_precision)]`	Renvoie une période en minutes. minute_precision est le nombre de chiffres du champ minute ; il varie de 0 à 2. Valeur par défaut : 2.	`INTERVAL '15' MINUTE` renvoie un intervalle de 15 minutes
`INTERVAL 'time' MINUTE[(minute_precision)] TO SECOND[(fractional_seconds_precision)]`	Renvoie une période en minutes et secondes. minute_precision est le nombre de chiffres du champ minute ; il varie de 0 à 2. Valeur par défaut : 2. fractional_seconds_precision est le nombre de chiffres de la partie fractionnaire de la deuxième valeur du champ time ; il est compris entre 0 et 9.	`INTERVAL '15:30' MINUTE TO SECOND` renvoie un intervalle de 15 minutes et 30 secondes
`INTERVAL 'second' SECOND[(fractional_seconds_precision)]`	Renvoie une période en secondes. fractional_seconds_precision est le nombre de chiffres de la partie fractionnaire du champ second ; il est compris entre 0 et 9. La valeur par défaut est 3.	`INTERVAL '15.678' SECOND` renvoie un intervalle de 15,678 secondes

Fonctions de hachage


Fonction	Description	Exemple
`MD5(all data types)`	Calcule un checksum `MD5` du type de données et renvoie une valeur de chaîne.	`MD5(column_name)`
`SHA1(all data types)`	Calcule une valeur de hachage `SHA-1` du type de données et renvoie une valeur de chaîne.	`SHA1(column_name)`
`SHA2(all data types, bitLength)`	Calcule une valeur de hachage `SHA-2` du type de données et renvoie une valeur de chaîne. `bitLength` est un entier.	`SHA2 (column_name, bitLength can be set to 0 (equivalent to 256), 256, 384, or 512)`.
`ORA_HASH(expr, [max_bucket], [seed_value])`	Calcule une valeur de hachage pour `expr` et renvoie une valeur NUMBER. `expr` peut être une expression, une colonne ou un littéral. `max_bucket` est la valeur de bucket maximale renvoyée, comprise entre 0 et 4294967295 (valeur par défaut). `seed_value` est une valeur comprise entre 0 (valeur par défaut) et 4294967295. Oracle applique la fonction de hachage à la combinaison de `expr` et `seed_value` afin de produire de nombreux résultats différents pour le même ensemble de données.	`ORA_HASH('1')` `ORA_HASH('b', 2)` `ORA_HASH(100, 10, 10)` `ORA_HASH(EXPRESSION_1.CUSTOMERS.SSN, 2)`

Fonctions hiérarchiques


Fonction	Description	Exemple
`SCHEMA_OF_JSON(string)`	Analyse une chaîne JSON et déduit le schéma au format DDL.	`SCHEMA_OF_JSON('[{\"Zipcode\":704,\"ZipCodeType\":\"STANDARD\",\"City\":\"ORACLECITY\",\"State\":\"OC\"}]')` renvoie `'ARRAY<STRUCT<City:string,State:string,ZipCodeType:string,Zipcode:bigint>>'` `SCHEMA_OF_JSON('[{\"col\":0}]')` renvoie `'ARRAY<STRUCT<col: BIGINT>>'`
`FROM_JSON(column, string)`	Analyse une colonne contenant une chaîne JSON vers l'un des types suivants, avec le schéma indiqué. Map, avec le type de clé String Struct Array	`FROM_JSON('{\"Zipcode\":704,\"City\":\"ORACLE CITY\"}', 'STRUCT<Zipcode: BIGINT, City: STRING>')` renvoie une colonne de type Struct avec le schéma indiqué : `{704, ORACLE CITY}` `FROM_JSON('{\"a\":1, \"b\":0.8}', 'STRUCT<a: BIGINT, b: DOUBLE>')` renvoie une colonne de type Struct avec le schéma indiqué : `{1, 0.8}`
`TO_JSON(column)`	Convertit une colonne contenant le type Struct, Array of Structs, Map ou Array of Maps en chaîne JSON.	`TO_JSON(TO_STRUCT('s1', TO_ARRAY(1,2,3), 's2', TO_MAP('key', 'value')))` renvoie une chaîne JSON `{"s1":[1,2,3],"s2":{"key":"value"}}`
`TO_MAP(string,column[,string,column]*)`	Crée une colonne de type Map. Les colonnes d'entrée doivent être regroupées en paires clé-valeur. Les colonnes de clé d'entrée ne peuvent pas être NULL et doivent toutes comporter le même type de données. Les colonnes de valeur d'entrée doivent toutes comporter le même type de données.	`TO_MAP('Ename',Expression_1.attribute1)` renvoie une colonne de type Map : `{"ENAME" -> 100}` `TO_MAP('block', EXPRESSION_1.MYSOURCE.address.block, 'unit', EXPRESSION_1.MYSOURCE.address.unit)` renvoie une colonne de type Map : `{"block" -> 1,"unit" -> 1}`
`TO_STRUCT(string,column[,string,column]*)`	Crée une colonne de type Struct. Les colonnes d'entrée doivent être regroupées en paires clé-valeur.	`TO_STRUCT('Ename',Expression_1.attribute1)` renvoie `{100}` `TO_STRUCT('Id',Expression_1.attribute1, 'Name', Expression_1.attribute2)` renvoie `{100, "John"}`
`TO_ARRAY(column[,column]*)`	Crée une colonne de type Array. Les colonnes d'entrée doivent toutes comporter le même type de données.	`TO_Array(Expression_1.attribute1)` renvoie `[100]` `TO_ARRAY(EXPRESSION_1.attribute2,EXPRESSION_1.attribute3)` renvoie `["John","Friend"]`

Fonctions d'ordre supérieur

Les opérateurs de flux de données qui prennent en charge la création d'expressions et de types de données hiérarchiques peuvent utiliser des fonctions d'ordre supérieur.

Les opérateurs pris en charge sont les suivants :

Agréger
Expression
Filtre
Jointure
Code express
Fractionner
Faire pivoter


Fonction	Description	Exemple
`TRANSFORM(column, lambda_function)`	Prend un tableau et une fonction anonyme, et configure un nouveau tableau en appliquant la fonction à chaque élément, et en affectant le résultat au tableau de sortie.	Pour un tableau d'entrée d'entiers `[1, 2, 3]`, `TRANSFORM(array, x -> x + 1)` renvoie un nouveau tableau de `[2, 3, 4]`.
`TRANSFORM_KEYS(column, lambda_function)`	Prend une carte et une fonction avec 2 arguments (clé et valeur), et renvoie une carte dans laquelle les clés ont le type du résultat de la fonction lambda, et les valeurs ont le type des valeurs de la correspondance de colonne.	Pour une correspondance d'entrée avec des clés entières et des valeurs de chaîne de `{1 -> 'value1', 2 -> 'value2', 3 -> 'value3'}`, `TRANSFORM_KEYS(map, (k, v) -> k * 2 + 1)` renvoie une nouvelle correspondance de `{3 -> 'value1', 5 -> 'value2', 7 -> 'value3'}`.
`TRANSFORM_VALUES(column, lambda_function)`	Prend une carte et une fonction avec 2 arguments (clé et valeur), et renvoie une carte dans laquelle les valeurs ont le type du résultat des fonctions lambda, et les clés ont le type des clés de correspondance de colonne.	Pour une correspondance d'entrée avec des clés de chaîne et des valeurs de chaîne de `{'a' -> 'value1', 'b' -> 'value2', 'c' -> 'value3'}`, `TRANSFORM_VALUES(map, (k, v) -> k \|\| __ '' \|\| v)` renvoie une nouvelle correspondance de `{'a' -> 'a_value1', 'b' -> 'b_value2', 'c' -> 'c_value3'}`.
`ARRAY_SORT(array(...), lambda_function)`	Seul l'opérateur d'expression prend en charge `ARRAY_SORT`. Prend un tableau et trie en fonction de la fonction donnée qui prend 2 arguments. La fonction doit renvoyer -1, 0 ou 1 selon que le premier élément est inférieur, égal ou supérieur au second. Si la fonction est omise, le tableau est trié par ordre croissant.	`array_sort(to_array(5, 6, 1), (left, right) -> CASE WHEN left < right THEN -1 WHEN left > right THEN 1 ELSE 0 END)` Le tableau renvoyé est : `[1,5,6]`

Fonctions d'opérateur (comparaison)


Fonction	Description	Exemple
`CASE WHEN condition1 THEN result1 ELSE result2 END`	Renvoie la valeur pour laquelle une condition est remplie.	`CASE WHEN 1 > 0 THEN 'ABC' ELSE 'XYZ' END` renvoie `ABC` si `1> 0`, sinon, renvoie `XYZ`
`AND`	Opérateur AND logique. Renvoie true si les deux opérandes ont la valeur True, sinon, renvoie false.	(x = 10 AND y = 20) renvoie "true" si x est égal à 10 et y est égal à 20. Si l'une des conditions n'est pas remplie, la fonction renvoie "false".
`OR`	Opérateur OR logique. Renvoie true si l'une des opérandes ou les deux opérandes ont la valeur True, sinon, renvoie false.	(x = 10 OR y = 20) renvoie "false" si x n'est pas égal à 10 et que y n'est pas égal à 20. Si l'une des conditions est remplie, la fonction renvoie "true".
`NOT`	Opérateur NOT logique.
`LIKE`	Exécute la correspondance de modèle de chaîne, si string1 correspond au modèle dans string2.
`=`	Recherche l'égalité. Renvoie true si la valeur expr1 est égale à expr2. Sinon, renvoie false.	x = 10 renvoie "true" lorsque la valeur de x est 10, sinon, renvoie "false"
`!=`	Recherche l'inégalité. Renvoie true si la valeur expr1 est différente de expr2. Sinon, renvoie false.	x != 10 renvoie "false" lorsque la valeur de x est 10, sinon, renvoie "true"
`>`	Recherche une expression supérieure. Renvoie true si la valeur expr1 est supérieure à expr2.	x > 10 renvoie "true" lorsque la valeur de x est supérieure à 10, sinon, renvoie "false"
`>=`	Recherche une expression supérieure ou égale. Renvoie true si la valeur expr1 est supérieure ou égale à expr2.	x > 10 renvoie "true" lorsque la valeur de x est supérieure ou égale à 10, sinon, renvoie "false"
`<`	Recherche une expression inférieure. Renvoie true si la valeur expr1 est inférieure à expr2.	x < 10 renvoie "true" lorsque la valeur de x est inférieure à 10, sinon, renvoie "false"
`<=`	Recherche une expression inférieure ou égale. Renvoie true si la valeur expr1 est inférieure ou égale à expr2.	x <= 10 renvoie "true" lorsque la valeur de x est inférieure ou égale à 10, sinon, renvoie "false"
`\|\|`	Concatène deux chaînes.	`'XYZ' \|\| 'hello'` renvoie `'XYZhello'`
`BETWEEN`	Evalue une plage.	`FILTER_1.BANK.BANK_ID BETWEEN 1003 AND 1007`
`IN`	Vérifie si une expression correspond à une liste de valeurs.	`FILTER_2.ORDERS.ORDER_ID IN (1003, 1007)`

Fonctions de chaîne


Fonctions	Description	Exemple
`CAST(value AS type)`	Renvoie la valeur indiquée dans le type spécifié.	`CAST("10" AS INT)` renvoie `10`
`CONCAT(string, string)`	Renvoie les valeurs combinées des chaînes ou des colonnes.	`CONCAT('Oracle','SQL')` renvoie `OracleSQL`
`CONCAT_WS(separator, expression1, expression2, expression3,...)`	Renvoie les valeurs combinées des chaînes ou des colonnes à l'aide du séparateur indiqué entre les chaînes ou les colonnes. Un séparateur est requis et doit être une chaîne. Au moins une expression doit être fournie après le séparateur. Par exemple : `CONCAT_WS(',' col1)`	`CONCAT_WS('-', 'Hello', 'Oracle')` renvoie `Hello-Oracle` `CONCAT_WS(' ', address, city, postal_code)` renvoie `123 MyCity 987654` Si un enfant de la fonction est un tableau, ce dernier est mis à plat : `CONCAT_WS(',', 1,2,3, to_array(4,5,6), to_array(7,8), 9)` renvoie `1,2,3,4,5,6,7,8,9`
`INITCAP(string)`	Renvoie la chaîne avec la première lettre de chaque mot en majuscule, tandis que toutes les autres sont en minuscules et chaque mot est délimité par un caractère non imprimable.	`INITCAP('oRACLE sql')` renvoie `Oracle Sql`
`INSTR(string, substring[start_position])`	Renvoie l'index (base 1) de la première occurrence de `substring` dans `string`.	`INSTR('OracleSQL', 'SQL')` renvoie `7`
`LOWER(string)`	Renvoie la chaîne avec toutes les lettres passées en minuscules.	`LOWER('ORACLE')` renvoie `oracle`
`LENGTH(string)`	Renvoie la longueur (en caractères) de la chaîne ou le nombre d'octets des données binaires. La longueur de la chaîne inclut les espaces de fin.	`LENGTH('Oracle')` renvoie `6`
`LTRIM(string)`	Renvoie la chaîne avec les espaces de début enlevés à gauche.	`LTRIM(' Oracle')`
`NVL(expr1, epxr2)`	Renvoie l'argument qui n'est pas NULL.	`NVL(EXPRESSION_3.CUSTOMERS_JSON.CONTINENT_ID, ROWID())`
`REGEXP_SUBSTR(string, regexp[, RegexGroupIdx])`	Recherche et extrait la chaîne qui correspond à un modèle d'expression régulière dans la chaîne d'entrée. Si l'index de groupe de capture (facultatif) est fourni, la fonction extrait le groupe spécifique.	`REGEXP_SUBSTR('https://www.oracle.com/products', 'https://([[:alnum:]]+\.?){3,4}/?')` renvoie `https://www.oracle.com` `REGEXP_SUBSTR('22;33;44', '([0-9.]);([0-9.]);([0-9.]*)', 1)` renvoie `22`
`REPLACE(string, search, replacement)`	Remplace toutes les occurrences de `search` par `replacement`. Si `search` est introuvable dans la chaîne, la chaîne est renvoyée sans modification. Si `replacement` n'est pas spécifié ou est une chaîne vide, rien ne remplace l'élément `search`, qui est enlevé de `string`.	`REPLACE('ABCabc', 'abc', 'DEF')` renvoie `ABCDEF`
`RTRIM(string)`	Renvoie la chaîne avec les espaces de fin enlevés à droite.	`RTRIM('Oracle ')`
`SUBSTRING(string, position[, substring_length])`	Renvoie la sous-chaîne commençant à la position indiquée.	`SUBSTRING('Oracle SQL' FROM 2 FOR 3)` renvoie `rac`
Pour les nombres, `TO_CHAR(expr)` et pour les dates `TO_CHAR(expr, format[, locale])`	Convertit des nombres et des dates en chaînes. Pour les nombres, aucun format n'est requis. Pour les dates, utilisez le même format que `DATE_FORMAT` décrit dans Fonctions de date et d'heure. L'environnement local par défaut est `en-US`. Reportez-vous aux balises de langue prises en charge. Dans les expressions de pipeline, `format_string` doit utiliser les codes de format strftime. Sinon, les modèles de format de date pris en charge sont les suivants : yy : année à deux chiffres yyyy : année à quatre chiffres M : mois numérique, par exemple 1 pour janvier MM : mois numérique, tel que 01 pour janvier MMM : mois abrégé, par exemple Jan MMMM : mois entier, par exemple janvier d : jour numérique du mois, par exemple 1 pour le 1er juin dd : jour numérique du mois, par exemple 01 pour le 1er juin DDD : jour numérique de l'année compris entre 001 et 366, par exemple 002 pour le 2 janvier F : jour numérique de la semaine dans un mois, par exemple 3 pour le 3e lundi de juin. EEE ou E : jour nommé abrégé de la semaine, par exemple dim pour le dimanche EEE : jour nommé de la semaine, par exemple dimanche HH : format 24 heures allant de 00 à 23 H : format 24 heures allant de 0 à 23 hh : format 12 heures allant de 01 à 12 h : format 12 heures allant de 1 à 12 mm : minutes allant de 00 à 59 ss : secondes allant de 00 à 59 SSS : millisecondes de 000 à 999 a : AM ou PM z : fuseau horaire tel que PDT	Exemple de nombre : `TO_CHAR(123)` renvoie `123` Exemple de date : `TO_CHAR(Date '2020-10-30', 'yyyy.MM.dd', 'en-US')` renvoie la chaîne `2020.10.30`. Le premier argument est un objet Date représentant le 30 octobre 2020.
`UPPER(string)`	Renvoie la chaîne avec toutes les lettres passées en majuscules.	`UPPER('oracle')` renvoie `ORACLE`
`LPAD(str, len[, pad])`	Renvoie une chaîne complétée à gauche avec les caractères spécifiés jusqu'à une certaine longueur. Si le caractère pad est supprimé, la valeur par défaut est un espace.	`LPAD('ABC', 5, '')` renvoie `'*ABC'`
`RPAD(str, len[, pad])`	Renvoie une chaîne complétée à droite avec les caractères spécifiés jusqu'à une certaine longueur. Si le caractère pad est supprimé, la valeur par défaut est un espace.	`RPAD('XYZ', 6, '+' ) returns 'XYZ+++'`

Fonctions d'ID unique


Fonction	Description	Exemple
`NUMERIC_ID()`	Génère un identificateur universel unique qui est un numéro 64 bits pour chaque ligne.	`NUMERIC_ID()` renvoie, par exemple, `3458761969522180096` et `3458762008176885761`
`ROWID()`	Génère une augmentation monotone des numéros 64 bits.	`ROWID()` renvoie, par exemple, `0`, `1`, `2`, etc.
`UUID()`	Génère un identificateur universel unique qui est une chaîne 128 bits pour chaque ligne.	`UUID()` renvoie, par exemple, `20d45c2f-0d56-4356-8910-162f4f40fb6d`
`MONOTONICALLY_INCREASING_ID()`	Génère des entiers 64 bits uniques croissants de manière monotone qui ne sont pas des nombres consécutifs.	`MONOTONICALLY_INCREASING_ID()` renvoie, par exemple, `8589934592` et `25769803776`

Documentation Oracle Cloud Infrastructure

Référence Functions (Data Flow)