Referencia de Functions (Data Flow)

Las siguientes funciones se utilizan con operadores en un flujo de datos para permitir la creación de expresiones.


Función	Descripción	Ejemplo
`COUNT(value[, value]*)`	Devuelve el número de filas para las que una o más expresiones proporcionadas son no nulas.	`COUNT(expr1)`
`COUNT(*)`	Devuelve el número total de filas recuperadas, incluidas las filas que contienen un valor nulo.	`COUNT(*)`
`MAX(value)`	Devuelve el valor máximo del argumento.	`MAX(expr)`
`MIN(value)`	Devuelve el valor mínimo del argumento.	`MIN(expr)`
`SUM(numeric)`	Devuelve la suma calculada a partir de los valores de un grupo.	`SUM(expr1)`
`AVG(numeric)`	Devuelve la media de valores numéricos en una expresión.	`AVG(AGGREGATE_1.src1.attribute1)`
`LISTAGG(column[, delimiter]) WITHIN GROUP (order_by_clause)`	Concatena valores de la columna de entrada con el delimitador especificado, para cada grupo en función de la cláusula order. La columna contiene los valores que desea concatenar en el resultado. El delimitador separa los valores de columna del resultado. Si no se proporciona un delimitador, se utiliza un carácter vacío. order_by_clause determina el orden en que se devuelven los valores concatenados. Esta función solo se puede utilizar como agregador y se puede utilizar con agrupación o sin agrupación. Si se utiliza sin agrupación, el resultado es una sola fila. Si se utiliza con una agrupación, la función devuelve una fila para cada grupo.	Piense en una tabla con dos columnas, `id` y `name`. La tabla tiene tres filas. Los valores de la columna `id` son 101, 102, 102. Los valores de la columna `name` son A, B, C. `+-----+--------+ \| id \| name \| +-----+--------+ \| 101 \| A \| +-----+--------+ \| 102 \| B \| +-----+--------+ \| 102 \| C \| +-----+--------+` Ejemplo 1: Sin agrupación `LISTAGG(id, '-') WITHIN GROUP (ORDER BY id)` devuelve la columna `name` con el valor `A-B-C` `+--------+ \| name \| +--------+ \| A-B-C \| +--------+` Ejemplo 2: Agrupar por `id` `LISTAGG(id, '-') WITHIN GROUP (ORDER BY id)` devuelve la columna `name` con los valores `A` y `B-C` en dos grupos. `+--------+ \| name \| +--------+ \| A \| +--------+ \| B-C \| +--------+`

Funciones analíticas


Función	Descripción	Ejemplo
`FIRST_VALUE(value) OVER ([ partition_clause ] order_by_clause [ windowFrame_clause ] )`	Devuelve el valor evaluado en la fila que es la primera fila del marco de ventana.	`FIRST_VALUE(BANK_ID) OVER (PARTITION BY BANK_ID ORDER BY BANK_NAME ROWS BETWEEN CURRENT ROW AND 1 FOLLOWING)` devuelve el primer valor de `BANK_ID` en una ventana en la que las filas se calculan como la fila actual y 1 fila después de esa fila, particionada por `BANK_ID` y en orden ascendente por `BANK_NAME`.
`LAG(value[, offset[, default]]) OVER ([ partition_clause ] order_by_clause)`	Devuelve el valor evaluado en la fila en un desplazamiento determinado antes de la fila actual dentro de la partición. Si no existe dicha fila, se devuelve el valor por defecto. Tanto el desplazamiento como el valor por defecto se evalúan con respecto a la fila actual. Si se omite, el desplazamiento se define por defecto en 1 y por defecto en NULL.	`LAG(BANK_ID, 2, 'hello') OVER (PARTITION BY BANK_ID ORDER BY BANK_NAME DESC)` devuelve el valor de `BANK_ID` de la segunda fila antes de la fila actual, particionado por `BANK_ID` y en orden descendente por `BANK_NAME`. Si no existe dicho valor, se devuelve `hello`.
`LAST_VALUE(value) OVER ([ partition_clause ] order_by_clause [ windowFrame_clause ])`	Devuelve el valor evaluado en la fila que es la última fila del marco de ventana.	`LAST_VALUE(BANK_ID) OVER (PARTITION BY BANK_ID ORDER BY BANK_NAME ROWS BETWEEN CURRENT ROW AND 1 FOLLOWING)` devuelve el último valor de `BANK_ID` en una ventana en la que las filas se calculan como la fila actual y 1 fila después de esa fila, particionado por `BANK_ID` y en orden ascendente por `BANK_NAME`.
`LEAD(value[, offset[, default]]) OVER ([ partition_clause ] order_by_clause)`	Devuelve el valor evaluado en la fila en un desplazamiento determinado después de la fila actual dentro de la partición. Si no existe dicha fila, se devuelve el valor por defecto. Tanto el desplazamiento como el valor por defecto se evalúan con respecto a la fila actual. Si se omite, el desplazamiento se define por defecto en 1 y por defecto en NULL.	`LEAD(BANK_ID, 2, 'hello') OVER (PARTITION BY BANK_ID ORDER BY BANK_NAME)` devuelve el valor de `BANK_ID` de la segunda fila después de la fila actual, particionado por `BANK_ID` y en orden ascendente por `BANK_NAME`. Si no existe dicho valor, se devuelve `hello`.
`RANK() OVER([ partition_clause ] order_by_clause)`	Devuelve el rango de la fila actual con intervalos, contando desde 1.	`RANK() OVER (PARTITION BY BANK_ID ORDER BY BANK_NAME)` devuelve el rango de cada fila dentro del grupo de partición `BANK_ID`, en orden ascendente por `BANK_NAME`.
`ROW_NUMBER() OVER([ partition_clause ] order_by_clause)`	Devuelve el número único de la fila actual dentro de su partición, contando desde 1.	`ROW_NUMBER() OVER (PARTITION BY BANK_ID ORDER BY BANK_NAME)` devuelve el número de fila único de cada fila dentro del grupo de partición `BANK_ID`, en orden ascendente por `BANK_NAME`.

Funciones aritméticas


Función	Descripción	Ejemplo
`ABS(numeric)`	Devuelve la potencia absoluta del valor `numeric`.	`ABS(-1)`
`CEIL(numeric)`	Devuelve el entero más pequeño que no sea mayor que el valor `numeric`	`CEIL(-1,2)`
`FLOOR(numeric)`	Devuelve el entero más grande que no sea mayor que el valor `numeric`	`FLOOR(-1,2)`
`MOD(numeric1, numeric2)`	Devuelve el resto después de dividir `numeric1` por `numeric2`.	`MOD(8,2)`
`POWER(numeric1, numeric2)`	Eleva `numeric1` a la potencia `numeric2`.	`POWER(2,3)`
`ROUND(numeric1, numeric2)`	Devuelve `numeric1` redondeado a `numeric2` posiciones decimales.	`ROUND(2.5,0)`
`TRUNC(numeric1, numeric2)`	Devuelve `numeric1` truncado a `numeric2` posiciones decimales.	`TRUNC(2.5,0)`
`TO_NUMBER(expr[, format, locale])`	Convierte una `expr` a un número, según el valor de `format` y de `locale` opcional proporcionados. La configuración regional por defecto es `en-US`. Etiquetas de idioma soportadas. Patrones de formato soportados: `0`: un dígito `#`: un dígito, cero se muestra como ausente `.`: marcador de posición para el separador decimal `,`: marcador de posición para el separador de agrupación `E`: separa la mantisa y el exponente para formatos exponenciales `-`: prefijo negativo por defecto `¤`: signo de moneda; se sustituye por el símbolo de moneda; si se duplica, se sustituye por el símbolo de moneda internacional; si está presente en un patrón, se utiliza el separador decimal monetario en lugar del separador decimal	`TO_NUMBER('5467.12') returns` devuelve `5467.12` `TO_NUMBER('-USD45,677.7', '¤¤##,###.#', 'en-US')` devuelve `-45677.7`

Funciones de matriz

Solo el operador Expression soporta funciones de matriz.


Función	Descripción	Ejemplo
`ARRAY_POSITION(array(...), element)`	Devuelve la posición de la primera incidencia del elemento especificado en la matriz determinada. La posición no se basa en cero, sino que comienza con 1.	`ARRAY_POSITION(array(3, 2, 1, 4, 1), 1)` devuelve `3`
`REVERSE(array(...))`	Devuelve la matriz dada de elementos en un orden inverso.	`REVERSE(array(2, 1, 4, 3))` devuelve `[3,4,1,2]`
`ELEMENT_AT(array(...), index)`	Devuelve el elemento de la matriz indicada en la posición de índice especificada. El índice no se basa en cero, sino que comienza con 1. Si `index = -1`, devuelve el último elemento.	`ELEMENT_AT(array(1, 2, 3), 2)` devuelve `2`

Funciones condicionales


Función	Descripción	Ejemplo
`COALESCE(value, value [, value]*)`	Devuelve el primer argumento no nulo, si existe; de lo contrario, devuelve null.	`COALESCE(NULL, 1, NULL)` devuelve `1`
`NULLIF(value, value)`	Devuelve null si los dos valores son iguales entre sí; de lo contrario, devuelve el primer valor.	`NULLIF('ABC','XYZ')` devuelve `ABC`

Funciones de fecha y hora


Función	Descripción	Ejemplo
`CURRENT_DATE`	Devuelve la fecha actual.	`CURRENT_DATE`devuelve la fecha de hoy, como `2023-05-26`
`CURRENT_TIMESTAMP`	Devuelve la hora y la fecha actuales de la zona horaria de la sesión.	`CURRENT_TIMESTAMP` devuelve la fecha actual y la hora actual, como `2023-05-26 12:34:56`
`DATE_ADD(date, number_of_days)`	Devuelve la fecha que es el valor `number` especificado de los días posteriores al valor `date` especificado.	`DATE_ADD('2017-07-30', 1)` devuelve `2017-07-31`
`DATE_FORMAT(expr, format[, locale])`	Aplica un formato `expr` de fecha según el valor de `format` y de `locale` opcional proporcionados. La configuración regional por defecto es `en-US`. Etiquetas de idioma soportadas. Patrones de formato de fecha soportados: yy: año de dos dígitos yyyy: año de cuatro dígitos M: mes numérico; por ejemplo, 1 para enero MM: mes numérico; por ejemplo, 01 para enero MMM: mes abreviado; por ejemplo, Jan MM: mes completo; por ejemplo, Enero d: día numérico del mes; por ejemplo, 1 para el 1 de junio dd: día numérico del mes; por ejemplo, 01 para el 1 de junio. DDD: día numérico del año del 001 al 366, como 002 para el 2 de enero F: día numérico de la semana de un mes, como 3 para el 3er lunes de junio. EEE o E: nombre de día de la semana abreviado; por ejemplo, Dom para el domingo. EEEE: nombre de día de la semana; por ejemplo, el domingo HH: formato de 24 horas de 00 a 23 H: formato de 24 horas de 0 a 23 hh: formato de 12 horas de 01 a 12 h: formato de 12 horas de 1 a 12 mm: minutos de 00 a 59 ss: segundos de 00 a 59 SSS: milisegundos de 000 a 999 a: AM o PM z: zona horaria como PDT	`DATE_FORMAT(Date '2020-10-11', 'yyyy-MM-dd')` devuelve `'2020-10-11'`. El primer argumento es un objeto Date que representa el 11 de octubre de 2020. `DATE_FORMAT(Date '2018-junio-17', 'yyyy/MMMM/dd', 'es-ES')` devuelve `'2018/junio/17'`
`DAYOFMONTH(date)`	Devuelve el día del mes de la fecha.	`DAYOFMONTH('2020-12-25')` devuelve `25`
`DAYOFWEEK(date)`	Devuelve el día de la semana de la fecha.	`DAYOFWEEK('2020-12-25')` devuelve `6` para Friday. En los Estados Unidos, el domingo se considera 1, el lunes es 2, y así sucesivamente.
`DAYOFYEAR(date)`	Devuelve el día del año de la fecha.	`DAYOFYEAR('2020-12-25')` devuelve `360`
`WEEKOFYEAR(date)`	Devuelve la semana del año de la fecha.	`WEEKOFYEAR('2022-07-28')` devuelve `30` `WEEKOFYEAR('2022-07-28 13:24:30')` returns `30`
`HOUR(datetime)`	Devuelve el valor de hora de la fecha y hora.	`HOUR('2020-12-25 15:10:30')` devuelve `15`
`LAST_DAY(date)`	Devuelve el último día del mes de la fecha.	`LAST_DAY('2020-12-25')` devuelve `31`
`MINUTE(datetime)`	Devuelve el valor de minutos de la fecha y hora.	`HOUR('2020-12-25 15:10:30')` devuelve `10`
`MONTH(date)`	Devuelve el valor de mes de la fecha.	`MONTH('2020-06-25')` devuelve `6`
`QUARTER(date)`	Devuelve el trimestre del año en el que se encuentra la fecha.	`QUARTER('2020-12-25')` devuelve `4`
`SECOND(datetime)`	Devuelve el segundo valor de la fecha y hora.	`SECOND('2020-12-25 15:10:30')` devuelve `30`
`TO_DATE(string, format_string[, localeStr])`	Analiza la expresión de cadena con la expresión `format_string` en una fecha. La configuración regional es opcional. El valor por defecto es `en-US`. Etiquetas de idioma soportadas. En las expresiones de pipeline, `format_string` debe utilizar los códigos de formato strftime. De lo contrario, las cadenas de formato sensibles a mayúsculas/minúsculas soportadas son: yy: año de dos dígitos yyyy: año de cuatro dígitos M: mes numérico; por ejemplo, 1 para enero MM: mes numérico; por ejemplo, 01 para enero MMM: mes abreviado; por ejemplo, Jan MM: mes completo; por ejemplo, Enero d: día numérico del mes; por ejemplo, 1 para el 1 de junio dd: día numérico del mes; por ejemplo, 01 para el 1 de junio. DDD: día numérico del año del 001 al 366, como 002 para el 2 de enero F: día numérico de la semana de un mes, como 3 para el 3er lunes de junio. EEE o E: nombre de día de la semana abreviado; por ejemplo, Dom para el domingo. EEEE: nombre de día de la semana; por ejemplo, el domingo HH: formato de 24 horas de 00 a 23 H: formato de 24 horas de 0 a 23 hh: formato de 12 horas de 01 a 12 h: formato de 12 horas de 1 a 12 mm: minutos de 00 a 59 ss: segundos de 00 a 59 SSS: milisegundos de 000 a 999 a: AM o PM z: zona horaria como PDT	`TO_DATE('31 December 2016', 'dd MMMM yyyy')` devuelve el valor de fecha `2016-12-31` `TO_DATE('2018/junio/17', 'yyyy/MMMM/dd', 'es-ES')` devuelve el valor de fecha `2018-06-17`
`TO_TIMESTAMP(expr, format_string[, localeStr])`	Convierte una `expr` de VARCHAR a un valor de TIMESTAMP, según el valor de `format_string` y de `localeStr` opcional proporcionados. En las expresiones de pipeline, `format_string` debe utilizar los códigos de formato strftime. De lo contrario, los patrones de formato soportados son: yy: año de dos dígitos yyyy: año de cuatro dígitos M: mes numérico; por ejemplo, 1 para enero MM: mes numérico; por ejemplo, 01 para enero MMM: mes abreviado; por ejemplo, Jan MM: mes completo; por ejemplo, Enero d: día numérico del mes; por ejemplo, 1 para el 1 de junio dd: día numérico del mes; por ejemplo, 01 para el 1 de junio. DDD: día numérico del año del 001 al 366, como 002 para el 2 de enero F: día numérico de la semana de un mes, como 3 para el 3er lunes de junio. EEE o E: nombre de día de la semana abreviado; por ejemplo, Dom para el domingo. EEEE: nombre de día de la semana; por ejemplo, el domingo HH: formato de 24 horas de 00 a 23 H: formato de 24 horas de 0 a 23 hh: formato de 12 horas de 01 a 12 h: formato de 12 horas de 1 a 12 mm: minutos de 00 a 59 ss: segundos de 00 a 59 SSS: milisegundos de 000 a 999 a: AM o PM z: zona horaria como PDT	`TO_TIMESTAMP('2020-10-11 11:10:10', 'yyyy-MM-dd HH:mm:ss')` devuelve un objeto TIMESTAMP que representa `11am 10:10 Oct 11th, 2020`
`WEEK(date)`	Devuelve el valor de semana de la fecha.	`WEEK('2020-06-25')` devuelve `4`
`YEAR(date)`	Devuelve el valor de año de la fecha.	`YEAR('2020-06-25')` devuelve `2020`
`ADD_MONTHS(date_expr, number_months)`	Devuelve la fecha después de agregar el número de meses especificado a la fecha, registro de hora o cadena especificados con un formato como `yyyy-MM-dd` o `yyyy-MM-dd HH:mm:ss.SSS`.	`ADD_MONTHS('2017-07-30', 1)` devuelve `2017-08-30` `ADD_MONTHS('2017-07-30 09:07:21', 1)` devuelve `2017-08-30`
`MONTHS_BETWEEN(start_date_expr, end_date_expr)`	Devuelve el número de meses entre `start_date_expr` y `end_date_expr`. `start_date_expr` y `end_date_expr` pueden ser una fecha, un registro de hora o una cadena con un formato como `yyyy-MM-dd` o `yyyy-MM-dd HH:mm:ss.SSS` Se devuelve un número entero si ambas fechas son el mismo día del mes o ambas son el último día de sus meses respectivos. De lo contrario, la diferencia se calcula en función de 31 días al mes.	`MONTHS_BETWEEN('2022-01-01', '2022-01-31')` devuelve 1 `MONTHS_BETWEEN('2022-07-28', '2020-07-25')` devuelve 24 `MONTHS_BETWEEN('2022-07-28 13:24:30', '2020-07-25 13:24:30')` devuelve 24
`FROM_UTC_TIMESTAMP(time_stamp, time_zone)`	Interpreta una fecha, un registro de hora o una cadena como hora UTC y la convierte en un registro de hora en la zona horaria especificada. Para la cadena, utilice un formato como: `yyyy-MM-dd` o `yyyy-MM-dd HH:mm:ss.SSS` El formato de zona horaria es un ID de zona basado en región (por ejemplo, 'área/ciudad' como 'Asia/Seúl' o un desfase de zona horaria (por ejemplo, UTC+02).	`FROM_UTC_TIMESTAMP('2017-07-14 02:40:00.0', 'GMT+1')` devuelve `2017-07-14 03:40:00.0`
`TO_UTC_TIMESTAMP(time_stamp, time_zone)`	Convierte una fecha, un registro de hora o una cadena en la zona horaria especificada en un registro de hora UTC. Para la cadena, utilice un formato como: `yyyy-MM-dd` o `yyyy-MM-dd HH:mm:ss.SSS` El formato de zona horaria es un ID de zona basado en región (por ejemplo, 'área/ciudad' como 'Asia/Seúl') o un desfase de zona horaria (por ejemplo, UTC+02).	`TO_UTC_TIMESTAMP('2017-07-14 02:40:00.0', 'GMT+1')` devuelve `2017-07-14 01:40:00.0`
`FROM_UNIXTIME(unix_time[, fmt])`	Convierte la hora o época de Unix especificada en una cadena que representa el registro de hora de ese momento en la zona horaria del sistema actual y en el formato especificado. Nota: La hora de Unix es el número de segundos transcurridos desde el 1 de enero de 1970 00:00:00 UTC. Si se omite `fmt`, el formato por defecto es `yyyy-MM-dd HH:mm:ss`	`FROM_UNIXTIME(1255033470)` devuelve `'2009-10-08 13:24:30'` `FROM_UNIXTIME(1637258854)` devuelve `'2021-11-18 10:07:34'` La zona horaria por defecto es PST en los ejemplos
`UNIX_TIMESTAMP([time_expr[, fmt]])`	Convierte la hora actual o especificada en un registro de hora de Unix en segundos. `time_expr` es una fecha, un registro de hora o una cadena con un formato como `yyyy-MM-dd` o `yyyy-MM-dd HH:mm:ss.SSS` Si no se proporciona `time_expr`, se convierte la hora actual. Si `time_expr` es una cadena y se omite `fmt`, el valor por defecto es `yyyy-MM-dd HH:mm:ss`	`UNIX_TIMESTAMP('1970-01-01 00:00:00', 'yyyy-MM-dd HH:mm:ss')` devuelve `28800` La zona horaria por defecto es PST en este ejemplo
`INTERVAL 'year' YEAR[(year_precision)]`	Devuelve un período de tiempo en años. year_precision es el número de dígitos del campo year; está comprendido entre 0 y 9. Si se suprime year_precision, el valor por defecto es 2 (debe ser inferior a 100 años).	`INTERVAL '1' YEAR` devuelve un intervalo de 1 año `INTERVAL '200' YEAR(3)` devuelve un intervalo de 200 años
`INTERVAL 'year month' YEAR[(year_precision)] TO MONTH`	Devuelve un período de tiempo en años y meses. Se utiliza para almacenar un período de tiempo utilizando los campos year y month. year_precision es el número de dígitos del campo year; está comprendido entre 0 y 9. Si se suprime year_precision, el valor por defecto es 2 (debe ser inferior a 100 años).	`INTERVAL '100-5' YEAR(3) TO MONTH` devuelve un intervalo de 100 años, 5 meses. Debe especificar una precisión de año inicial 3.
`INTERVAL 'month' MONTH[(month_precision)]`	Devuelve un período de tiempo en meses. month_precision es el número de dígitos del campo mes; está comprendido entre 0 y 9. Si se suprime month_precision, el valor por defecto es 2 (debe ser inferior a 100 años).	`INTERVAL '200' MONTH(3)` devuelve un intervalo de 200 meses. Debe especificar una precisión de mes 3.
`INTERVAL 'day time' DAY[(day_precision)] TO SECOND[(fractional_seconds_precision)]`	Devuelve un período de tiempo en días, horas, minutos y segundos. day_precision es el número de dígitos del campo day; está comprendido entre 0 y 9. El valor por defecto es 2. fractional_seconds_precision es el número de dígitos de la parte fraccional del valor second del campo time; está comprendido entre 0 y 9.	`INTERVAL '11 10:09:08.555' DAY TO SECOND(3)` devuelve un intervalo de 11 días, 10 horas, 09 minutos, 08 segundos y 555 milésimas de segundo
`INTERVAL 'day time' DAY[(day_precision)] TO MINUTE[(minute_precision)]`	Devuelve un período de tiempo en días, horas y minutos. day_precision es el número de dígitos del campo day; está comprendido entre 0 y 9. El valor por defecto es 2. minute_precision es el número de dígitos del campo minuto; está comprendido entre 0 y 2. El valor por defecto es 2.	`INTERVAL '11 10:09' DAY TO MINUTE` devuelve un intervalo de 11 días, 10 horas y 09 minutos
`INTERVAL 'day time' DAY[(day_precision)] TO HOUR[(hour_precision)]`	Devuelve un período de tiempo en días y horas. day_precision es el número de dígitos del campo day; está comprendido entre 0 y 9. El valor por defecto es 2. hour_precision es el número de dígitos del campo hora; está comprendido entre 0 y 2. El valor por defecto es 2.	`INTERVAL '100 10' DAY(3) TO HOUR` devuelve un intervalo de 100 días y 10 horas
`INTERVAL 'day' DAY[(day_precision)]`	Devuelve un período de tiempo en días. day_precision es el número de dígitos del campo day; está comprendido entre 0 y 9. El valor por defecto es 2.	`INTERVAL '999' DAY(3)` devuelve un intervalo de 999 días
`INTERVAL 'time' HOUR[(hour_precision)] TO SECOND[(fractional_seconds_precision)]`	Devuelve un período de tiempo en días, horas, minutos y segundos. hour_precision es el número de dígitos del campo hora; está comprendido entre 0 y 2. El valor por defecto es 2. fractional_seconds_precision es el número de dígitos de la parte fraccional del valor second del campo time; está comprendido entre 0 y 9.	`INTERVAL '09:08:07.6666666' HOUR TO SECOND(7)` devuelve un intervalo de 9 horas, 08 minutos y 76 666 666 segundos
`INTERVAL 'time' HOUR[(hour_precision)] TO MINUTE[(minute_precision)]`	Devuelve un período de tiempo en horas y minutos. hour_precision es el número de dígitos del campo hora; está comprendido entre 0 y 2. El valor por defecto es 2. minute_precision es el número de dígitos del campo minuto; está comprendido entre 0 y 2. El valor por defecto es 2.	`INTERVAL '09:30' HOUR TO MINUTE` devuelve un intervalo de 9 horas y 30 minutos
`INTERVAL 'hour' HOUR[(hour_precision)]`	Devuelve un período de tiempo en horas. hour_precision es el número de dígitos del campo hora; está comprendido entre 0 y 2. El valor por defecto es 2.	`INTERVAL '40' HOUR` devuelve un intervalo de 40 horas
`INTERVAL 'minute' MINUTE[(minute_precision)]`	Devuelve un período de tiempo en minutos. minute_precision es el número de dígitos del campo minuto; está comprendido entre 0 y 2. El valor por defecto es 2.	`INTERVAL '15' MINUTE` devuelve un intervalo de 15 minutos
`INTERVAL 'time' MINUTE[(minute_precision)] TO SECOND[(fractional_seconds_precision)]`	Devuelve un período de tiempo en minutos y segundos. minute_precision es el número de dígitos del campo minuto; está comprendido entre 0 y 2. El valor por defecto es 2. fractional_seconds_precision es el número de dígitos de la parte fraccional del valor second del campo time; está comprendido entre 0 y 9.	`INTERVAL '15:30' MINUTE TO SECOND` devuelve un intervalo de 15 minutos y 30 segundos
`INTERVAL 'second' SECOND[(fractional_seconds_precision)]`	Devuelve un período de tiempo en segundos. fractional_seconds_precision es el número de dígitos en la parte fraccional del campo second; oscila entre 0 y 9. El valor por defecto es 3.	`INTERVAL '15.678' SECOND` devuelve un intervalo de 15 678 segundos

Funciones hash


Función	Descripción	Ejemplo
`MD5(all data types)`	Calcula un total de control `MD5` del tipo de dato y devuelve un valor de cadena.	`MD5(column_name)`
`SHA1(all data types)`	Calcula un valor hash `SHA-1` del tipo de dato y devuelve un valor de cadena.	`SHA1(column_name)`
`SHA2(all data types, bitLength)`	Calcula un valor hash `SHA-2` del tipo de dato y devuelve un valor de cadena. `bitLength`es un entero.	`SHA2 (column_name, bitLength can be set to 0 (equivalent to 256), 256, 384, or 512)`.
`ORA_HASH(expr, [max_bucket], [seed_value])`	Calcula un valor hash para `expr` y devuelve un valor NUMBER. `expr` puede ser una expresión, una columna, un literal. `max_bucket` es el valor de cubo máximo devuelto, entre 0 y 4294967295 (valor por defecto). `seed_value` es un valor entre 0 (valor por defecto) y 4294967295. Oracle aplica la función hash a la combinación de `expr` y `seed_value` para producir muchos resultados diferentes para el mismo juego de datos.	`ORA_HASH('1')` `ORA_HASH('b', 2)` `ORA_HASH(100, 10, 10)` `ORA_HASH(EXPRESSION_1.CUSTOMERS.SSN, 2)`

Funciones jerárquicas


Función	Descripción	Ejemplo
`SCHEMA_OF_JSON(string)`	Analiza una cadena JSON e infiere el esquema en formato DDL.	`SCHEMA_OF_JSON('[{\"Zipcode\":704,\"ZipCodeType\":\"STANDARD\",\"City\":\"ORACLECITY\",\"State\":\"OC\"}]')` devuelve `'ARRAY<STRUCT<City:string,State:string,ZipCodeType:string,Zipcode:bigint>>'` `SCHEMA_OF_JSON('[{\"col\":0}]')` devuelve `'ARRAY<STRUCT<col: BIGINT>>'`
`FROM_JSON(column, string)`	Analiza una columna que contiene una cadena JSON en uno de los siguientes tipos, con el esquema especificado. Map, con String como tipo de clave Estruc Array	`FROM_JSON('{\"Zipcode\":704,\"City\":\"ORACLE CITY\"}', 'STRUCT<Zipcode: BIGINT, City: STRING>')` devuelve una columna de tipo Struct con el esquema especificado: `{704, ORACLE CITY}` `FROM_JSON('{\"a\":1, \"b\":0.8}', 'STRUCT<a: BIGINT, b: DOUBLE>')` devuelve una columna de tipo Struct con el esquema especificado: `{1, 0.8}`
`TO_JSON(column)`	Convierte una columna que contiene un tipo Struct o Array of Structs, o Map o Array of Map en una cadena JSON.	`TO_JSON(TO_STRUCT('s1', TO_ARRAY(1,2,3), 's2', TO_MAP('key', 'value')))` devuelve una cadena JSON `{"s1":[1,2,3],"s2":{"key":"value"}}`
`TO_MAP(string,column[,string,column]*)`	Crea una nueva columna de tipo Asignación. Las columnas de entrada se deben agrupar como pares clave-valor. Las columnas de clave de entrada no pueden ser nulas y todas deben tener el mismo tipo de datos. Todas las columnas de valor de entrada deben tener el mismo tipo de datos.	`TO_MAP('Ename',Expression_1.attribute1)` devuelve una columna de tipo Map: `{"ENAME" -> 100}` `TO_MAP('block', EXPRESSION_1.MYSOURCE.address.block, 'unit', EXPRESSION_1.MYSOURCE.address.unit)` devuelve una columna de tipo Map: `{"block" -> 1,"unit" -> 1}`
`TO_STRUCT(string,column[,string,column]*)`	Crea una nueva columna de tipo Struct. Las columnas de entrada se deben agrupar como pares clave-valor.	`TO_STRUCT('Ename',Expression_1.attribute1)` devuelve `{100}` `TO_STRUCT('Id',Expression_1.attribute1, 'Name', Expression_1.attribute2)` devuelve `{100, "John"}`
`TO_ARRAY(column[,column]*)`	Crea una nueva columna como tipo Array. Todas las columnas de entrada deben tener el mismo tipo de datos.	`TO_Array(Expression_1.attribute1)` devuelve `[100]` `TO_ARRAY(EXPRESSION_1.attribute2,EXPRESSION_1.attribute3)` devuelve `["John","Friend"]`

Funciones de orden superior

Los operadores de flujo de datos que soportan la creación de expresiones y tipos de dato jerárquicos pueden utilizar funciones de orden superior.

Los operadores soportados son:

Agregar
Expresión
Filtro
Entrar
Consulta
Dividir
Girar


Función	Descripción	Ejemplo
`TRANSFORM(column, lambda_function)`	Toma una matriz y una función anónima, y configura una nueva matriz aplicando la función a cada elemento y asignando el resultado a la matriz de salida.	Para una matriz de entrada de enteros `[1, 2, 3]`, `TRANSFORM(array, x -> x + 1)` devuelve una nueva matriz de `[2, 3, 4]`.
`TRANSFORM_KEYS(column, lambda_function)`	Toma una asignación y una función con 2 argumentos (clave y valor), y devuelve una asignación en la que las claves tienen el tipo del resultado de la función lambda, y los valores tienen el tipo de los valores de asignación de columna.	Para una asignación de entrada con claves enteras y valores de cadena de `{1 -> 'value1', 2 -> 'value2', 3 -> 'value3'}`, `TRANSFORM_KEYS(map, (k, v) -> k * 2 + 1)` devuelve una nueva asignación de `{3 -> 'value1', 5 -> 'value2', 7 -> 'value3'}`.
`TRANSFORM_VALUES(column, lambda_function)`	Toma un mapa y una función con 2 argumentos (clave y valor), y devuelve un mapa en el que los valores tienen el tipo del resultado de las funciones lambda, y las claves tienen el tipo de las claves del mapa de columnas.	Para una asignación de entrada con claves de cadena y valores de cadena de `{'a' -> 'value1', 'b' -> 'value2', 'c' -> 'value3'}`, `TRANSFORM_VALUES(map, (k, v) -> k \|\| __ '' \|\| v)` devuelve una nueva asignación de `{'a' -> 'a_value1', 'b' -> 'b_value2', 'c' -> 'c_value3'}`.
`ARRAY_SORT(array(...), lambda_function)`	Solo el operador de expresión soporta `ARRAY_SORT`. Toma una matriz y la ordena según la función dada que toma 2 argumentos. La función debe devolver -1, 0 o 1 en función de si el primer elemento es menor que, igual a o mayor que el segundo elemento. Si se omite la función, la matriz se ordena en orden ascendente.	`array_sort(to_array(5, 6, 1), (left, right) -> CASE WHEN left < right THEN -1 WHEN left > right THEN 1 ELSE 0 END)` La matriz devuelta es: `[1,5,6]`

Funciones de operador (de comparación)


Función	Descripción	Ejemplo
`CASE WHEN condition1 THEN result1 ELSE result2 END`	Devuelve el valor para el que se cumple una condición.	`CASE WHEN 1 > 0 THEN 'ABC' ELSE 'XYZ' END` devuelve `ABC` si `1> 0`, de lo contrario, devuelve `XYZ`
`AND`	Operador lógico AND. Devuelve true si ambos operandos son verdaderos; de lo contrario, devuelve false.	(x = 10 AND y = 20) devuelve "true" si x es igual a 10 e y es igual a 20. Si uno de las dos no es verdadero, devuelve "false"
`OR`	Operador lógico OR. Devuelve true si cualquiera de los operandos es true o ambos son true; de lo contrario, devuelve false.	(x = 10 OR y = 20) devuelve "false" si x no es igual a 10 y, también, si y no es igual a 20. Si cualquiera de ellos es verdadero, devuelve "true"
`NOT`	Operador lógico NOT.
`LIKE`	Realiza una coincidencia de patrones de cadena, si string1 coincide con el patrón de string2.
`=`	Comprueba la igualdad. Devuelve true si expr1 es igual a expr2; de lo contrario, devuelve false.	x = 10 devuelve "true" cuando el valor de x es 10; de lo contrario, devuelve "false"
`!=`	Comprueba la desigualdad. Devuelve true si expr1 no es igual a expr2; de lo contrario, devuelve false.	x != 10 devuelve "false" si el valor de x es 10; de lo contrario, devuelve "true"
`>`	Comprueba si una expresión es mayor que. Devuelve true si expr1 es mayor que expr2.	x > 10 devuelve "true" si el valor de x es mayor que 10; de lo contrario, devuelve "false"
`>=`	Comprueba si una expresión es mayor o igual que. Devuelve true si expr1 es mayor o igual que expr2.	x > =10 devuelve "true" si el valor de x es mayor o igual que 10; de lo contrario, devuelve "false"
`<`	Comprueba si una expresión es menor que. Devuelve true si expr1 es menor que expr2.	x < 10 devuelve "true" si el valor de x es menor que 10; de lo contrario, devuelve "false"
`<=`	Comprueba si una expresión es menor o igual que. Devuelve true si expr1 es menor o igual que expr2.	x <= 10 devuelve "true" si el valor de x es menor que 10; de lo contrario, devuelve "false"
`\|\|`	Concatena dos cadenas.	`'XYZ' \|\| 'hello'` devuelve `'XYZhello'`
`BETWEEN`	Evalúa un rango.	`FILTER_1.BANK.BANK_ID BETWEEN 1003 AND 1007`
`IN`	Prueba si una expresión coincide con una lista de valores.	`FILTER_2.ORDERS.ORDER_ID IN (1003, 1007)`

Funciones de Cadena


Funciones	Descripción	Ejemplo
`CAST(value AS type)`	Devuelve el valor especificado en el tipo especificado.	`CAST("10" AS INT)` devuelve `10`
`CONCAT(string, string)`	Devuelve los valores combinados de cadenas o columnas.	`CONCAT('Oracle','SQL')` devuelve `OracleSQL`
`CONCAT_WS(separator, expression1, expression2, expression3,...)`	Devuelve los valores combinados de cadenas o columnas utilizando el separador especificado entre las cadenas o columnas. Se necesita un separador y debe ser una cadena. Se debe proporcionar al menos una expresión después del separador. Por ejemplo: `CONCAT_WS(',' col1)`	`CONCAT_WS('-', 'Hello', 'Oracle')` devuelve `Hello-Oracle` `CONCAT_WS(' ', address, city, postal_code)` devuelve `123 MyCity 987654` Si un secundario de la función es una matriz, la matriz se simplifica: `CONCAT_WS(',', 1,2,3, to_array(4,5,6), to_array(7,8), 9)` devuelve `1,2,3,4,5,6,7,8,9`
`INITCAP(string)`	Devuelve la cadena con la primera letra de cada palabra en mayúsculas, mientras que el resto de letras están en minúsculas, y cada palabra está delimitada por un espacio en blanco.	`INITCAP('oRACLE sql')` devuelve `Oracle Sql`
`INSTR(string, substring[start_position])`	Devuelve el índice (basado en 1) de la primera ocurrencia de `substring` en `string`.	`INSTR('OracleSQL', 'SQL')` devuelve `7`
`LOWER(string)`	Devuelve la cadena con todas las letras cambiadas a minúsculas.	`LOWER('ORACLE')` devuelve `oracle`
`LENGTH(string)`	Devuelve la longitud de caracteres de la cadena o el número de bytes de datos binarios. La longitud de la cadena incluye los espacios finales.	`LENGTH('Oracle')` devuelve `6`
`LTRIM(string)`	Devuelve la cadena con los espacios iniciales eliminados de la izquierda.	`LTRIM(' Oracle')`
`NVL(expr1, epxr2)`	Devuelve el argumento que no es nulo.	`NVL(EXPRESSION_3.CUSTOMERS_JSON.CONTINENT_ID, ROWID())`
`REGEXP_SUBSTR(string, regexp[, RegexGroupIdx])`	Busca y extrae la cadena que coincide con un patrón de expresión regular de la cadena de entrada. Si se ha proporcionado el índice de grupo de captura opcional, la función extrae el grupo específico.	`REGEXP_SUBSTR('https://www.oracle.com/products', 'https://([[:alnum:]]+\.?){3,4}/?')` devuelve `https://www.oracle.com` `REGEXP_SUBSTR('22;33;44', '([0-9.]);([0-9.]);([0-9.]*)', 1)` devuelve `22`
`REPLACE(string, search, replacement)`	Sustituye todas las ocurrencias de `search` por `replacement`. Si no se encuentra `search` en la cadena, la cadena se devuelve sin cambios. Si no se especifica `replacement` o es una cadena vacía, nada sustituye a `search`, que se elimina de `string`.	`REPLACE('ABCabc', 'abc', 'DEF')` devuelve `ABCDEF`
`RTRIM(string)`	Devuelve la cadena con los espacios iniciales eliminados de la derecha.	`RTRIM('Oracle ')`
`SUBSTRING(string, position[, substring_length])`	Devuelve la subcadena que empieza en la posición.	`SUBSTRING('Oracle SQL' FROM 2 FOR 3)` devuelve `rac`
Para números, `TO_CHAR(expr)` y para fechas `TO_CHAR(expr, format[, locale])`	Convierte números y fechas en cadenas. Para los números, no es necesario ningún formato. Para las fechas, utilice el mismo formato que `DATE_FORMAT` descrito en Funciones de fecha y hora. La configuración regional por defecto es `en-US`. Consulte las etiquetas de idioma soportadas. En las expresiones de pipeline, `format_string` debe utilizar los códigos de formato strftime. De lo contrario, los patrones de formato de fecha soportados son: yy: año de dos dígitos yyyy: año de cuatro dígitos M: mes numérico; por ejemplo, 1 para enero MM: mes numérico; por ejemplo, 01 para enero MMM: mes abreviado; por ejemplo, Jan MM: mes completo; por ejemplo, Enero d: día numérico del mes; por ejemplo, 1 para el 1 de junio dd: día numérico del mes; por ejemplo, 01 para el 1 de junio. DDD: día numérico del año del 001 al 366, como 002 para el 2 de enero F: día numérico de la semana de un mes, como 3 para el 3er lunes de junio. EEE o E: nombre de día de la semana abreviado; por ejemplo, Dom para el domingo. EEEE: nombre de día de la semana; por ejemplo, el domingo HH: formato de 24 horas de 00 a 23 H: formato de 24 horas de 0 a 23 hh: formato de 12 horas de 01 a 12 h: formato de 12 horas de 1 a 12 mm: minutos de 00 a 59 ss: segundos de 00 a 59 SSS: milisegundos de 000 a 999 a: AM o PM z: zona horaria como PDT	Ejemplo de número: `TO_CHAR(123)` devuelve `123` Ejemplo de fecha: `TO_CHAR(Date '2020-10-30', 'yyyy.MM.dd', 'en-US')` devuelve la cadena `2020.10.30`. El primer argumento es un objeto Date que representa el 30 de octubre de 2020,
`UPPER(string)`	Devuelve una cadena con todas las letras cambiadas a mayúsculas.	`UPPER('oracle')` devuelve `ORACLE`
`LPAD(str, len[, pad])`	Devuelve una cadena que está rellena a la izquierda con caracteres especificados a una longitud determinada. Si se deja el carácter pad, el valor por defecto es un espacio.	`LPAD('ABC', 5, '')` devuelve `'*ABC'`
`RPAD(str, len[, pad])`	Devuelve una cadena que está rellenada a la derecha con caracteres especificados a una longitud determinada. Si se deja el carácter pad, el valor por defecto es un espacio.	`RPAD('XYZ', 6, '+' ) returns 'XYZ+++'`

Funciones de identificador único


Función	Descripción	Ejemplo
`NUMERIC_ID()`	Genera un identificador único universal que es un número de 64 bits para cada fila.	`NUMERIC_ID()` devuelve, por ejemplo, `3458761969522180096` y `3458762008176885761`
`ROWID()`	Genera números de 64 bits monótonamente.	`ROWID()` devuelve, por ejemplo, `0`, `1`, `2`, etc.
`UUID()`	Genera un identificador único universal que es una cadena de 128 bits para cada fila.	`UUID()` devuelve, por ejemplo, `20d45c2f-0d56-4356-8910-162f4f40fb6d`
`MONOTONICALLY_INCREASING_ID()`	Genera números enteros únicos que aumentan monótonamente 64 bits que no son números consecutivos.	`MONOTONICALLY_INCREASING_ID()` returns for example, `8589934592` and `25769803776`

Documentación de Oracle Cloud Infrastructure

Referencia de Functions (Data Flow)