Informations de référence sur les fonctions (flux de données)

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]*)`	Retourne le nombre de rangées pour lesquelles une ou plusieurs expressions fournies sont toutes non nulles.	`COUNT(expr1)`
`COUNT(*)`	Retourne le nombre total de rangées extraites, y compris les rangées contenant une valeur nulle.	`COUNT(*)`
`MAX(value)`	Retourne la valeur maximale de l'argument.	`MAX(expr)`
`MIN(value)`	Retourne la valeur minimale de l'argument.	`MIN(expr)`
`SUM(numeric)`	Retourne la somme calculée à partir des valeurs d'un groupe.	`SUM(expr1)`
`AVG(numeric)`	Retourne 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 que vous voulez synchroniser ensemble dans le résultat. delimiter sépare les valeurs de column dans le résultat. Si aucun délimiteur n'est indiqué, un caractère vide est utilisé. order_by_clause détermine l'ordre dans lequel les valeurs concaténées sont retournées. Cette fonction ne peut être utilisée qu'en tant qu'agrégateur et elle peut être utilisée avec ou sans regroupement. Si vous l'utilisez sans regroupement, le résultat est une rangée unique. Si vous utilisez avec un regroupement, la fonction renvoie une rangée pour chaque groupe.	Considérez une table avec deux colonnes, `id`, `name`. La table comporte trois rangées. 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)` retourne la colonne `name` avec la valeur `A-B-C` `+--------+ \| name \| +--------+ \| A-B-C \| +--------+` Exemple 2 : Regrouper par `id` `LISTAGG(id, '-') WITHIN GROUP (ORDER BY id)` retourne la colonne `name` avec les valeurs `A` et `B-C` dans deux groupes. `+--------+ \| name \| +--------+ \| A \| +--------+ \| B-C \| +--------+`

Fonctions d'analyse


Fonction	Description	Exemple
`FIRST_VALUE(value) OVER ([ partition_clause ] order_by_clause [ windowFrame_clause ] )`	Retourne la valeur évaluée à la rangée qui est la première rangée 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)` retourne la première valeur de `BANK_ID` dans une fenêtre pour laquelle les rangées sont calculées comme étant la rangée courante et 1 rangée après celle-ci, avec un partitionnement par `BANK_ID` et en ordre croissant de `BANK_NAME`.
`LAG(value[, offset[, default]]) OVER ([ partition_clause ] order_by_clause)`	Retourne la valeur évaluée à la rangée à un décalage donné avant la rangée courante dans la partition. S'il n'existe pas de ligne de ce type, la valeur par défaut est renvoyée. Le décalage et la valeur par défaut sont évalués par rapport à la rangée courante. Si elle est omise, la valeur par défaut du décalage est 1 et la valeur par défaut est NULL.	`LAG(BANK_ID, 2, 'hello') OVER (PARTITION BY BANK_ID ORDER BY BANK_NAME DESC)` retourne la valeur de `BANK_ID` de la deuxième rangée avant la rangée courante, avec un partitionnement par `BANK_ID` et en ordre décroissant de `BANK_NAME`. Si une telle valeur n'existe pas, `hello` est retourné.
`LAST_VALUE(value) OVER ([ partition_clause ] order_by_clause [ windowFrame_clause ])`	Retourne la valeur évaluée à la rangée qui est la dernière rangée 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)` retourne la dernière valeur de `BANK_ID` dans une fenêtre pour laquelle les rangées sont calculées comme étant la rangée courante et 1 rangée après celle-ci, avec un partitionnement par `BANK_ID` et en ordre croissant de `BANK_NAME`.
`LEAD(value[, offset[, default]]) OVER ([ partition_clause ] order_by_clause)`	Retourne la valeur évaluée à la rangée à un décalage donné après la rangée courante dans la partition. S'il n'existe pas de ligne de ce type, la valeur par défaut est renvoyée. Le décalage et la valeur par défaut sont évalués par rapport à la rangée courante. Si elle est omise, la valeur par défaut du décalage est 1 et la valeur par défaut est NULL.	`LEAD(BANK_ID, 2, 'hello') OVER (PARTITION BY BANK_ID ORDER BY BANK_NAME)` retourne la valeur de `BANK_ID` de la deuxième rangée après la rangée courante, avec un partitionnement par `BANK_ID` et en ordre croissant de `BANK_NAME`. Si une telle valeur n'existe pas, `hello` est retourné.
`RANK() OVER([ partition_clause ] order_by_clause)`	Retourne le rang de la rangée courante avec les écarts, en comptant à partir de 1.	`RANK() OVER (PARTITION BY BANK_ID ORDER BY BANK_NAME)` retourne le rang de chaque rangée dans le groupe de partitions de `BANK_ID`, en ordre croissant de `BANK_NAME`.
`ROW_NUMBER() OVER([ partition_clause ] order_by_clause)`	Retourne le numéro unique de la rangée courante dans sa partition, en comptant à partir de 1.	`ROW_NUMBER() OVER (PARTITION BY BANK_ID ORDER BY BANK_NAME)` retourne le numéro unique de chaque rangée dans le groupe de partitions de `BANK_ID`, en ordre croissant de `BANK_NAME`.

Fonctions arithmétiques


Fonction	Description	Exemple
`ABS(numeric)`	Retourne la valeur absolue de la valeur `numeric`.	`ABS(-1)`
`CEIL(numeric)`	Retourne le plus petit entier ne dépassant pas la valeur `numeric`	`CEIL(-1,2)`
`FLOOR(numeric)`	Retourne le plus grand nombre entier ne dépassant pas la valeur `numeric`.	`FLOOR(-1,2)`
`MOD(numeric1, numeric2)`	Retourne le reste après la division de `numeric1` par `numeric2`.	`MOD(8,2)`
`POWER(numeric1, numeric2)`	Élève `numeric1` à la puissance `numeric2`.	`POWER(2,3)`
`ROUND(numeric1, numeric2)`	Retourne la valeur `numeric1` arrondie à `numeric2` décimales.	`ROUND(2.5,0)`
`TRUNC(numeric1, numeric2)`	Retourne la valeur `numeric1` tronquée à `numeric2` décimales.	`TRUNC(2.5,0)`
`TO_NUMBER(expr[, format, locale])`	Convertit une expression `expr` en nombre, en fonction du `format` et des paramètres régionaux (`locale`) facultatifs fournis. Les paramètres régionaux par défaut sont `en-US`. Marqueurs de langue pris en charge. Modèles de format pris en charge : `0` : Un chiffre `#` : Un chiffre, zéro s'affiche comme absent `.` : Paramètre fictif pour le séparateur décimal `,` : Paramètre fictif pour le séparateur de regroupement `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 doublé, il est remplacé par le symbole monétaire international; s'il est présent dans un modèle, le séparateur décimal monétaire est utilisé au lieu du séparateur décimal	`TO_NUMBER('5467.12')` retourne `5467.12` `TO_NUMBER('-USD45,677.7', '¤¤##,###.#', 'en-US')` retourne `-45677.7`

Fonctions de tableau

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


Fonction	Description	Exemple
`ARRAY_POSITION(array(...), element)`	Retourne 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, mais elle commence par 1.	`ARRAY_POSITION(array(3, 2, 1, 4, 1), 1)` retourne `3`
`REVERSE(array(...))`	Retourne le tableau d'éléments indiqué dans un ordre inverse.	`REVERSE(array(2, 1, 4, 3))` retourne `[3,4,1,2]`
`ELEMENT_AT(array(...), index)`	Retourne l'élément du tableau donné à la position d'index indiquée. L'index n'est pas basé sur zéro, mais il commence par 1. Si `index = -1`, il retourne le dernier élément.	`ELEMENT_AT(array(1, 2, 3), 2)` retourne `2`

Fonctions conditionnelles


Fonction	Description	Exemple
`COALESCE(value, value [, value]*)`	Retourne le premier argument non nul, s'il existe, sinon retourne une valeur nulle.	`COALESCE(NULL, 1, NULL)` retourne `1`
`NULLIF(value, value)`	Retourne une valeur nulle si les deux valeurs sont égales, sinon retourne la première valeur.	`NULLIF('ABC','XYZ')` retourne `ABC`

Fonctions de date/heure


Fonction	Description	Exemple
`CURRENT_DATE`	Retourne la date courante.	`CURRENT_DATE`retourne la date du jour, par exemple `2023-05-26`
`CURRENT_TIMESTAMP`	Retourne la date et l'heure courantes pour le fuseau horaire de la session.	`CURRENT_TIMESTAMP` retourne la date du jour et l'heure courante, par exemple `2023-05-26 12:34:56`
`DATE_ADD(date, number_of_days)`	Retourne la date correspondant au `number` de jours spécifié après la `date` spécifiée.	`DATE_ADD('2017-07-30', 1)` retourne `2017-07-31`
`DATE_FORMAT(expr, format[, locale])`	Formate une expression `expr` de date, en fonction du `format` et des paramètres régionaux (`locale`) facultatifs fournis. Les paramètres régionaux par défaut sont `en-US`. Marqueurs de langue pris 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, comme 1 pour janvier MM : Mois numérique, comme 01 pour janvier MMM : Mois abrégé, comme Jan MMMM : Mois complet, comme Janvier d : Jour numérique du mois, comme 1 pour le 1er juin dd : Jour numérique du mois, comme 01 pour le 1er juin DDD : Jour numérique de l'année de 001 à 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 : Nom abrégé du jour de la semaine, comme Dim pour dimanche SEEE : Jour désigné de la semaine, comme Dimanche HH : Format de 24 heures, de 00 à 23 H : Format de 0 à 23 pour 24 heures hhh : Format de 12 heures, de 01 à 12 h : Format de 12 heures, de 1 à 12 mm : Minutes de 00 à 59 ss : Secondes de 00 à 59 SSS : millisecondes de 000 à 999 a : AM ou PM z : fuseau horaire, par exemple PDT	`DATE_FORMAT(Date '2020-10-11', 'yyyy-MM-dd')` retourne `'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')` retourne `'2018/junio/17'`
`DAYOFMONTH(date)`	Retourne le jour du mois dans la date indiquée.	`DAYOFMONTH('2020-12-25')` retourne `25`
`DAYOFWEEK(date)`	Retourne le jour de la semaine dans la date indiquée.	`DAYOFWEEK('2020-12-25')` retourne `6` pour vendredi. Aux États-Unis, le dimanche est considéré comme 1, le lundi est 2, et ainsi de suite.
`DAYOFYEAR(date)`	Retourne le jour de l'année dans la date indiquée.	`DAYOFYEAR('2020-12-25')` retourne `360`
`WEEKOFYEAR(date)`	Retourne la semaine de la date dans l'année.	`WEEKOFYEAR('2022-07-28')` retourne `30` `WEEKOFYEAR('2022-07-28 13:24:30')` retourne `30`
`HOUR(datetime)`	Retourne la valeur d'heure de date/heure.	`HOUR('2020-12-25 15:10:30')` retourne `15`
`LAST_DAY(date)`	Retourne le dernier jour du mois de la date indiquée.	`LAST_DAY ('2020-12-25')` retourne `31`
`MINUTE(datetime)`	Retourne la valeur des minutes de date/heure.	`HOUR('2020-12-25 15:10:30')` retourne `10`
`MONTH(date)`	Retourne la valeur du mois de la date indiquée.	`MONTH ('2020-06-25')` retourne `6`
`QUARTER(date)`	Retourne le trimestre de l'année de la date indiquée.	`QUARTER('2020-12-25')` retourne `4`
`SECOND(datetime)`	Retourne la valeur des secondes de date/heure.	`SECOND('2020-12-25 15:10:30')` retourne `30`
`TO_DATE(string, format_string[, localeStr])`	Analyse l'expression de chaîne en considérant l'expression `format_string` comme une date. Les paramètres régionaux sont facultatifs. La valeur par défaut est `en-US`. Marqueurs de langue pris en charge. Dans les expressions de pipeline, `format_string` doit utiliser les codes de format strftime. Sinon, les chaînes de format sensibles à la casse prises en charge sont les suivantes : yy : Année à deux chiffres yyyy : Année à quatre chiffres M : Mois numérique, comme 1 pour janvier MM : Mois numérique, comme 01 pour janvier MMM : Mois abrégé, comme Jan MMMM : Mois complet, comme Janvier d : Jour numérique du mois, comme 1 pour le 1er juin dd : Jour numérique du mois, comme 01 pour le 1er juin DDD : Jour numérique de l'année de 001 à 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 : Nom abrégé du jour de la semaine, comme Dim pour dimanche SEEE : Jour désigné de la semaine, comme Dimanche HH : Format de 24 heures, de 00 à 23 H : Format de 0 à 23 pour 24 heures hhh : Format de 12 heures, de 01 à 12 h : Format de 12 heures, de 1 à 12 mm : Minutes de 00 à 59 ss : Secondes de 00 à 59 SSS : millisecondes de 000 à 999 a : AM ou PM z : fuseau horaire, par exemple PDT	`TO_DATE('31 December 2016', 'dd MMMM yyyy')` retourne une valeur de date de `2016-12-31` `TO_DATE('2018/junio/17', 'yyyy/MMMM/dd', 'es-ES')` retourne une valeur de date de `2018-06-17`
`TO_TIMESTAMP(expr, format_string[, localeStr])`	Convertit une `expr` de type VARCHAR en une valeur de type TIMESTAMP, en fonction de `format_string` et de `localeStr` (facultatif). 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, comme 1 pour janvier MM : Mois numérique, comme 01 pour janvier MMM : Mois abrégé, comme Jan MMMM : Mois complet, comme Janvier d : Jour numérique du mois, comme 1 pour le 1er juin dd : Jour numérique du mois, comme 01 pour le 1er juin DDD : Jour numérique de l'année de 001 à 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 : Nom abrégé du jour de la semaine, comme Dim pour dimanche SEEE : Jour désigné de la semaine, comme Dimanche HH : Format de 24 heures, de 00 à 23 H : Format de 0 à 23 pour 24 heures hhh : Format de 12 heures, de 01 à 12 h : Format de 12 heures, de 1 à 12 mm : Minutes de 00 à 59 ss : Secondes de 00 à 59 SSS : millisecondes de 000 à 999 a : AM ou PM z : fuseau horaire, par exemple PDT	`TO_TIMESTAMP('2020-10-11 11:10:10', 'yyyy-MM-dd HH:mm:ss')` retourne un objet TIMESTAMP représentant `11am 10:10 Oct 11th, 2020`
`WEEK(date)`	Retourne la valeur de semaine de la date indiquée.	`WEEK('2020-06-25')` retourne `4`
`YEAR(date)`	Retourne la valeur d'année de la date indiquée.	`YEAR('2020-06-25')` retourne `2020`
`ADD_MONTHS(date_expr, number_months)`	Retourne la date après l'ajout du nombre de mois spécifié à la date, la chaîne ou l'horodatage spécifié dans un format de type `yyyy-MM-dd` ou `yyyy-MM-dd HH:mm:ss.SSS`.	`ADD_MONTHS('2017-07-30', 1)` retourne `2017-08-30` `ADD_MONTHS('2017-07-30 09:07:21', 1)` retourne `2017-08-30`
`MONTHS_BETWEEN(start_date_expr, end_date_expr)`	Retourne le nombre de mois entre `start_date_expr` et `end_date_expr`. `start_date_expr` et `end_date_expr` peuvent être une date, un horodatage ou une chaîne dans un format de type `yyyy-MM-dd` ou `yyyy-MM-dd HH:mm:ss.SSS` Un nombre entier est retourné si les deux dates correspondent au même jour du mois, ou au dernier jour de leur mois respectif. Sinon, la différence est calculée sur la base de 31 jours par mois.	`MONTHS_BETWEEN('2022-01-01', '2022-01-31')` retourne 1 `MONTHS_BETWEEN('2022-07-28', '2020-07-25')` retourne 24 `MONTHS_BETWEEN('2022-07-28 13:24:30', '2020-07-25 13:24:30')` retourne 24
`FROM_UTC_TIMESTAMP(time_stamp, time_zone)`	Interprète une date, un horodatage ou une chaîne en tant que temps UTC et le convertit en horodatage dans le fuseau horaire spécifié. Pour une chaîne, utilisez un format tel que : `yyyy-MM-dd` ou `yyyy-MM-dd HH:mm:ss.SSS` Le format de fuseau horaire est soit un ID zone basé sur la région (tel que "zone/ville", par exemple "Asie/Séoul"), soit un décalage de fuseau horaire (par exemple, UTC+02).	`FROM_UTC_TIMESTAMP('2017-07-14 02:40:00.0', 'GMT+1')` retourne `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 une chaîne, utilisez un format tel que : `yyyy-MM-dd` ou `yyyy-MM-dd HH:mm:ss.SSS` Le format de fuseau horaire est soit un ID zone basé sur la région (tel que "zone/ville", par exemple "Asie/Séoul"), soit un décalage de fuseau horaire (par exemple, UTC+02).	`TO_UTC_TIMESTAMP('2017-07-14 02:40:00.0', 'GMT+1')` retourne `2017-07-14 01:40:00.0`
`FROM_UNIXTIME(unix_time[, fmt])`	Convertit l'heure ou l'heure de référence Unix spécifiée en chaîne qui représente l'horodatage de ce moment dans le fuseau horaire du système courant et dans le format spécifié. Note : L'heure Unix est le nombre de secondes écoulées depuis le 1er janvier 1970 00:00:000000 UTC. Si `fmt` est omis, le format par défaut est `yyyy-MM-dd HH:mm:ss`	`FROM_UNIXTIME(1255033470)` retourne `'2009-10-08 13:24:30'` `FROM_UNIXTIME(1637258854)` retourne `'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 courante ou spécifiée en horodatage Unix en secondes. `time_expr` est une date, un horodatage ou une chaîne dans un format tel que `yyyy-MM-dd` ou `yyyy-MM-dd HH:mm:ss.SSS` Si `time_expr` n'est pas indiqué, l'heure courante 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')` retourne `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 dans le champ année; il est compris entre 0 et 9. Si year_precision est omis, la valeur par défaut est 2 (elle doit être inférieure à 100 ans).	`INTERVAL '1' YEAR` retourne un intervalle de 1 an `INTERVAL '200' YEAR(3)` retourne un intervalle de 200 ans
`INTERVAL 'year month' YEAR[(year_precision)] TO MONTH`	Retourne 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 dans le champ année; il est compris entre 0 et 9. Si year_precision est omis, la valeur par défaut est 2 (elle doit être inférieure à 100 ans).	`INTERVAL '100-5' YEAR(3) TO MONTH` retourne un intervalle de 100 ans et 5 mois. Vous devez spécifier 3 en tant que valeur de précision de l'année de début.
`INTERVAL 'month' MONTH[(month_precision)]`	Retourne une période en mois. month_precision est le nombre de chiffres dans le champ mois; il est compris entre 0 et 9. Si month_precision est omis, la valeur par défaut est 2 (elle doit être inférieure à 100 ans).	`INTERVAL '200' MONTH(3)` retourne un intervalle de 200 mois. Vous devez spécifier 3 en tant que valeur de précision du mois.
`INTERVAL 'day time' DAY[(day_precision)] TO SECOND[(fractional_seconds_precision)]`	Retourne une période sous forme de jours, heures, minutes et secondes. day_precision est le nombre de chiffres dans le champ jour; il est compris entre 0 et 9. La valeur par défaut est 2. fractional_seconds_precision est le nombre de chiffres dans 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)` retourne un intervalle de 11 jours, 10 heures, 09 minutes, 08 secondes et 555 millièmes de seconde
`INTERVAL 'day time' DAY[(day_precision)] TO MINUTE[(minute_precision)]`	Retourne une période sous forme de jours, heures et minutes. day_precision est le nombre de chiffres dans le champ jour; il est compris entre 0 et 9. La valeur par défaut est 2. minute_precision est le nombre de chiffres dans le champ minute; il est compris entre 0 et 2. La valeur par défaut est 2.	`INTERVAL '11 10:09' DAY TO MINUTE` retourne un intervalle de 11 jours, 10 heures et 09 minutes
`INTERVAL 'day time' DAY[(day_precision)] TO HOUR[(hour_precision)]`	Retourne une période sous forme de jours et d'heures. day_precision est le nombre de chiffres dans le champ jour; il est compris entre 0 et 9. La valeur par défaut est 2. hour_precision est le nombre de chiffres dans le champ heure; il est compris entre 0 et 2. La valeur par défaut est 2.	`INTERVAL '100 10' DAY(3) TO HOUR` retourne un intervalle de 100 jours et 10 heures
`INTERVAL 'day' DAY[(day_precision)]`	Retourne une période sous forme de jours. day_precision est le nombre de chiffres dans le champ jour; il est compris entre 0 et 9. La valeur par défaut est 2.	`INTERVAL '999' DAY(3)` retourne un intervalle de 999 jours
`INTERVAL 'time' HOUR[(hour_precision)] TO SECOND[(fractional_seconds_precision)]`	Retourne une période sous forme d'heures, minutes et secondes. hour_precision est le nombre de chiffres dans le champ heure; il est compris entre 0 et 2. La valeur par défaut est 2. fractional_seconds_precision est le nombre de chiffres dans 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)` retourne un intervalle de 9 heures, 08 minutes et 7,6666666 secondes
`INTERVAL 'time' HOUR[(hour_precision)] TO MINUTE[(minute_precision)]`	Retourne une période sous forme d'heures et de minutes. hour_precision est le nombre de chiffres dans le champ heure; il est compris entre 0 et 2. La valeur par défaut est 2. minute_precision est le nombre de chiffres dans le champ minute; il est compris entre 0 et 2. La valeur par défaut est 2.	`INTERVAL '09:30' HOUR TO MINUTE` retourne un intervalle de 9 heures et 30 minutes
`INTERVAL 'hour' HOUR[(hour_precision)]`	Retourne une période sous forme d'heures. hour_precision est le nombre de chiffres dans le champ heure; il est compris entre 0 et 2. La valeur par défaut est 2.	`INTERVAL '40' HOUR` retourne un intervalle de 40 heures
`INTERVAL 'minute' MINUTE[(minute_precision)]`	Retourne une période sous forme de minutes. minute_precision est le nombre de chiffres dans le champ minute; il est compris entre 0 et 2. La valeur par défaut est 2.	`INTERVAL '15' MINUTE` retourne un intervalle de 15 minutes
`INTERVAL 'time' MINUTE[(minute_precision)] TO SECOND[(fractional_seconds_precision)]`	Retourne une période sous forme de minutes et secondes. minute_precision est le nombre de chiffres dans le champ minute; il est compris entre 0 et 2. La valeur par défaut est 2. fractional_seconds_precision est le nombre de chiffres dans la partie fractionnaire de la deuxième valeur du champ time; il est compris entre 0 et 9.	`INTERVAL '15:30' MINUTE TO SECOND` retourne un intervalle de 15 minutes et 30 secondes
`INTERVAL 'second' SECOND[(fractional_seconds_precision)]`	Retourne une période sous forme de secondes. fractional_seconds_precision est le nombre de chiffres dans la partie fractionnaire du champ second; il est compris entre 0 et 9. La valeur par défaut est 3.	`INTERVAL '15.678' SECOND` retourne un intervalle de 15,678 secondes

Fonctions de hachage


Fonction	Description	Exemple
`MD5(all data types)`	Calcule un total de contrôle `MD5` pour le type de données et retourne une valeur de chaîne.	`MD5(column_name)`
`SHA1(all data types)`	Calcule une valeur de hachage `SHA-1` pour le type de données et retourne une valeur de chaîne.	`SHA1(column_name)`
`SHA2(all data types, bitLength)`	Calcule une valeur de hachage `SHA-2` pour le type de données et retourne une valeur de chaîne. `bitLength` est un nombre entier.	`SHA2 (column_name, bitLength peut être réglé à 0 (équivaut à 256), 256, 384 ou 512).`
`ORA_HASH(expr, [max_bucket], [seed_value])`	Calcule une valeur de hachage pour `expr` et retourne une valeur NUMBER. `expr` peut être une expression, une colonne, un littéral. `max_bucket` est la valeur maximale de seau retournée, entre 0 et 4294967295 (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` pour produire de nombreux résultats différents pour le même jeu 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 en tire le schéma au format LDD.	`SCHEMA_OF_JSON('[{\"Zipcode\":704,\"ZipCodeType\":\"STANDARD\",\"City\":\"ORACLECITY\",\"State\":\"OC\"}]')` retourne `'ARRAY<STRUCT<City:string,State:string,ZipCodeType:string,Zipcode:bigint>>'` `SCHEMA_OF_JSON('[{\"col\":0}]')` retourne `'ARRAY<STRUCT<col: BIGINT>>'`
`FROM_JSON(column, string)`	Analyse une colonne contenant une chaîne JSON dans l'un des types suivants, avec le schéma spécifié. Map, avec String comme type de clé Struct Array	`FROM_JSON('{\"Zipcode\":704,\"City\":\"ORACLE CITY\"}', 'STRUCT<Zipcode: BIGINT, City: STRING>')` retourne une colonne de type Struct avec le schéma spécifié : `{704, ORACLE CITY}` `FROM_JSON('{\"a\":1, \"b\":0.8}', 'STRUCT<a: BIGINT, b: DOUBLE>')` retourne une colonne de type Struct avec le schéma spécifié : `{1, 0.8}`
`TO_JSON(column)`	Convertit une colonne contenant le type Struct ou Array of Structs, ou Map ou Array of Maps, en chaîne JSON.	`TO_JSON(TO_STRUCT('s1', TO_ARRAY(1,2,3), 's2', TO_MAP('key', 'value')))` retourne 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 nulles et elles doivent toutes avoir le même type de données. Les colonnes de valeur d'entrée doivent toutes avoir le même type de données.	`TO_MAP('Ename',Expression_1.attribute1)` retourne une colonne de Map : `{"ENAME" -> 100}` `TO_MAP('block', EXPRESSION_1.MYSOURCE.address.block, 'unit', EXPRESSION_1.MYSOURCE.address.unit)` retourne 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)` retourne `{100}` `TO_STRUCT('Id',Expression_1.attribute1, 'Name', Expression_1.attribute2)` retourne `{100, "John"}`
`TO_ARRAY(column[,column]*)`	Crée une colonne de type Array. Les colonnes d'entrée doivent toutes avoir le même type de données.	`TO_Array(Expression_1.attribute1)` retourne `[100]` `TO_ARRAY(EXPRESSION_1.attribute2,EXPRESSION_1.attribute3)` retourne `["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 :

Regrouper
Expression
Filtre
Jointure
Consulter
Split
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 de nombres entiers `[1, 2, 3]`, `TRANSFORM(array, x -> x + 1)` retourne 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 retourne 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 mappage de colonne.	Pour un mappage 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)` retourne un nouveau mappage 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 retourne 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 carte de colonne.	Pour un mappage 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)` retourne un nouveau mappage de `{'a' -> 'a_value1', 'b' -> 'b_value2', 'c' -> 'c_value3'}`.
`ARRAY_SORT(array(...), lambda_function)`	Seul l'opérateur 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 retourner -1, 0 ou 1 selon que le premier élément est inférieur, égal ou supérieur au deuxième élément. Si la fonction est omise, le tableau est trié dans l'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 retourné est le suivant : `[1,5,6]`

Fonctions d'opérateur (comparaison)


Fonction	Description	Exemple
`CASE WHEN condition1 THEN result1 ELSE result2 END`	Retourne la valeur pour laquelle une condition est satisfaite.	`CASE WHEN 1 > 0 THEN 'ABC' ELSE 'XYZ' END` retourne `ABC` si `1> 0`, sinon retourne `XYZ`
`AND`	Opérateur logique AND. Retourne Vrai si les deux opérandes sont vrais, sinon retourne Faux.	(x = 10 AND y = 20) retourne "Vrai" si x est égal à 10 et y égal à 20. Si l'un ou l'autre n'est pas vrai, alors "Faux" est retourné
`OR`	Opérateur logique OR. Retourne Vrai si l'un ou l'autre opérande est vrai ou si les deux sont vrais, sinon retourne Faux.	(x = 10 OR y = 20) retourne "Faux" si x n'est pas égal à 10 et y n'est pas égal à 20. Si l'un ou l'autre est vrai, alors "Vrai" est retourné
`NOT`	Opérateur logique NOT.
`LIKE`	Met en correspondance des modèles de chaîne, si string1 correspond au modèle dans string2.
`=`	Teste l'égalité. Retourne Vrai si expr1 est égal à expr2, sinon retourne Faux.	x = 10 retourne "Vrai" lorsque la valeur de x est 10, sinon "Faux" est retourné
`!=`	Teste l'inégalité. Retourne Vrai si expr1 n'est pas égal à expr2, sinon retourne Faux.	x != 10 retourne "Faux" si la valeur de x est 10, sinon "Vrai" est retourné
`>`	Teste si une expression est supérieure. Retourne Vrai si expr1 est supérieur à expr2.	x > 10 retourne "Vrai" si la valeur de x est supérieure à 10, sinon "Faux" est retourné
`>=`	Teste si une expression est supérieure ou égale. Retourne Vrai si expr1 est supérieur ou égal à expr2.	x > =10 retourne "Vrai" si la valeur de x est supérieure ou égale à 10, sinon "Faux" est retourné
`<`	Teste si une expression est inférieure. Retourne Vrai si expr1 est inférieur à expr2.	x < 10 retourne "Vrai" si la valeur de x est inférieure à 10, sinon "Faux" est retourné
`<=`	Teste si une expression est inférieure ou égale. Retourne Vrai si expr1 est inférieur ou égal à expr2.	x <= 10 retourne "Vrai" si la valeur de x est inférieure à 10, sinon "Faux" est retourné
`\|\|`	Concatène deux chaînes.	`'XYZ' \|\| 'hello'` retourne `'XYZhello'`
`BETWEEN`	Évalue un intervalle.	`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)`	Retourne la valeur indiquée dans le type indiqué.	`CAST("10" AS INT)` retourne `10`
`CONCAT(string, string)`	Retourne les valeurs combinées des chaînes ou des colonnes.	`CONCAT('Oracle','SQL')` retourne `OracleSQL`
`CONCAT_WS(separator, expression1, expression2, expression3,...)`	Retourne les valeurs combinées des chaînes ou des colonnes à l'aide du séparateur spécifié 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')` retourne `Hello-Oracle` `CONCAT_WS(' ', address, city, postal_code)` retourne `123 MyCity 987654` Si un enfant de la fonction est un tableau, le tableau est aplati : `CONCAT_WS(',', 1,2,3, to_array(4,5,6), to_array(7,8), 9)` retourne `1,2,3,4,5,6,7,8,9`
`INITCAP(string)`	Retourne la chaîne avec une majuscule à la première lettre de chaque mot, tandis que toutes les autres lettres sont en minuscules, et chaque mot est délimité par une espace.	`INITCAP('oRACLE sql')` retourne `Oracle Sql`
`INSTR(string, substring[start_position])`	Retourne l'index (à partir de 1) de la première occurrence de la sous-chaîne (`substring`) dans la chaîne `string`.	`INSTR('OracleSQL', 'SQL')` retourne `7`
`LOWER(string)`	Retourne la chaîne avec toutes les lettres en minuscules.	`LOWER('ORACLE')` retourne `oracle`
`LENGTH(string)`	Retourne la longueur de la chaîne en nombre de caractères ou le nombre d'octets dans le cas de données binaires. La longueur de la chaîne comprend les espaces de fin.	`LENGTH('Oracle')` retourne `6`
`LTRIM(string)`	Retourne la chaîne avec les espaces de début supprimés à partir de la gauche.	`LTRIM(' Oracle')`
`NVL(expr1, epxr2)`	Retourne l'argument qui n'est pas vide.	`NVL(EXPRESSION_3.CUSTOMERS_JSON.CONTINENT_ID, ROWID())`
`REGEXP_SUBSTR(string, regexp[, RegexGroupIdx])`	Recherche et extrait de la chaîne d'entrée la chaîne qui correspond à un modèle d'expression rationnelle. Si l'index de groupe de saisie facultatif est fourni, la fonction extrait le groupe particulier.	`REGEXP_SUBSTR('https://www.oracle.com/products', 'https://([[:alnum:]]+\.?){3,4}/?')` retourne `https://www.oracle.com` `REGEXP_SUBSTR('22;33;44', '([0-9.]);([0-9.]);([0-9.]*)', 1)` retourne `22`
`REPLACE(string, search, replacement)`	Remplace toutes les occurrences de la chaîne recherchée `search` par la chaîne de remplacement `replacement`. Si `search` est introuvable dans la chaîne, celle-ci est retournée inchangée. Si la chaîne de remplacement `replacement` n'est pas indiquée ou est une chaîne vide, rien ne remplace la chaîne recherchée `search` qui est alors supprimée de la chaîne `string`.	`REPLACE('ABCabc', 'abc', 'DEF')` retourne `ABCDEF`
`RTRIM(string)`	Retourne la chaîne avec les espaces de début supprimés à partir de la droite.	`RTRIM('Oracle ')`
`SUBSTRING(string, position[, substring_length])`	Retourne la sous-chaîne à partir de la position indiquée.	`SUBSTRING('Oracle SQL' FROM 2 FOR 3)` retourne `rac`
Pour les chiffres, `TO_CHAR(expr)` et pour les dates `TO_CHAR(expr, format[, locale])`	Convertit les nombres et les 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. Les paramètres régionaux par défaut sont `en-US`. Voir les étiquettes 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, comme 1 pour janvier MM : Mois numérique, comme 01 pour janvier MMM : Mois abrégé, comme Jan MMMM : Mois complet, comme Janvier d : Jour numérique du mois, comme 1 pour le 1er juin dd : Jour numérique du mois, comme 01 pour le 1er juin DDD : Jour numérique de l'année de 001 à 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 : Nom abrégé du jour de la semaine, comme Dim pour dimanche SEEE : Jour désigné de la semaine, comme Dimanche HH : Format de 24 heures, de 00 à 23 H : Format de 0 à 23 pour 24 heures hhh : Format de 12 heures, de 01 à 12 h : Format de 12 heures, de 1 à 12 mm : Minutes de 00 à 59 ss : Secondes de 00 à 59 SSS : millisecondes de 000 à 999 a : AM ou PM z : fuseau horaire, par exemple PDT	Exemple de nombre : `TO_CHAR(123)` retourne `123` Exemple de date : `TO_CHAR(Date '2020-10-30', 'yyyy.MM.dd', 'en-US')` retourne la chaîne `2020.10.30`. Le premier argument est un objet Date représentant le 30 octobre 2020.
`UPPER(string)`	Retourne une chaîne avec toutes les lettres en majuscules.	`UPPER('oracle')` retourne `ORACLE`
`LPAD(str, len[, pad])`	Retourne une chaîne avec remplissage à gauche avec les caractères spécifiés jusqu'à une certaine longueur. Si le caractère pad est omis, la valeur par défaut est un espace.	`LPAD('ABC', 5, '')` retourne `'*ABC'`
`RPAD(str, len[, pad])`	Retourne une chaîne avec remplissage à droite avec les caractères spécifiés jusqu'à une certaine longueur. Si le caractère pad est omis, la valeur par défaut est un espace.	`RPAD('XYZ', 6, '+' ) returns 'XYZ+++'`

Fonctions de création d'ID unique


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

Documentation sur Oracle Cloud Infrastructure

Informations de référence sur les fonctions (flux de données)