Referência de Funções (Data Flow)

As funções a seguir são usadas com operadores em um fluxo de dados para permitir que você crie expressões.


Função	Descrição	Exemplo
`COUNT(value[, value]*)`	Retorna o número de linhas para as quais uma ou mais expressões fornecidas são todas não nulas.	`COUNT(expr1)`
`COUNT(*)`	Retorna o número total de linhas recuperadas, incluindo linhas contendo nulos.	`COUNT(*)`
`MAX(value)`	Retorna o valor máximo do argumento.	`MAX(expr)`
`MIN(value)`	Retorna o valor mínimo do argumento.	`MIN(expr)`
`SUM(numeric)`	Retorna a soma calculada com base nos valores de um grupo.	`SUM(expr1)`
`AVG(numeric)`	Retorna a média de valores numéricos em uma expressão.	`AVG(AGGREGATE_1.src1.attribute1)`
`LISTAGG(column[, delimiter]) WITHIN GROUP (order_by_clause)`	Concatena valores da coluna de entrada com o delimitador especificado, para cada grupo com base na cláusula de ordem. coluna contém os valores que você deseja concatenar juntos no resultado. O delimitador separa os valores de coluna no resultado. Se um delimitador não for fornecido, um caractere vazio será usado. order_by_clause determina a ordem em que os valores concatenados são retornados. Essa função só pode ser usada como agregador e pode ser usada com agrupamento ou sem agrupamento. Se você usar sem agrupamento, o resultado será uma única linha. Se você usar com um agrupamento, a função retornará uma linha para cada grupo.	Considere uma tabela com duas colunas, `id` e `name`. A tabela tem três linhas. Os valores da coluna `id` são 101, 102 e 102. Os valores da coluna `name` são A, B e C. `+-----+--------+ \| id \| name \| +-----+--------+ \| 101 \| A \| +-----+--------+ \| 102 \| B \| +-----+--------+ \| 102 \| C \| +-----+--------+` Exemplo 1: Sem agrupamento `LISTAGG(id, '-') WITHIN GROUP (ORDER BY id)` retorna a coluna `name` com o valor `A-B-C` `+--------+ \| name \| +--------+ \| A-B-C \| +--------+` Exemplo 2: Agrupar pelo `id` `LISTAGG(id, '-') WITHIN GROUP (ORDER BY id)` retorna a coluna `name` com os valores `A` e `B-C` em dois grupos. `+--------+ \| name \| +--------+ \| A \| +--------+ \| B-C \| +--------+`

Funções Analíticas


Função	Descrição	Exemplo
`FIRST_VALUE(value) OVER ([ partition_clause ] order_by_clause [ windowFrame_clause ] )`	Retorna o valor avaliado na linha que é a primeira do quadro da janela.	`FIRST_VALUE(BANK_ID) OVER (PARTITION BY BANK_ID ORDER BY BANK_NAME ROWS BETWEEN CURRENT ROW AND 1 FOLLOWING)` retorna o primeiro valor `BANK_ID` em uma janela na qual as linhas são calculadas como linha atual e 1 linha após essa linha, particionadas por `BANK_ID` e em ordem crescente de `BANK_NAME`.
`LAG(value[, offset[, default]]) OVER ([ partition_clause ] order_by_clause)`	Retorna o valor avaliado na linha em um determinado deslocamento antes da linha atual dentro da partição. Se não houver essa linha, o valor padrão será retornado. O deslocamento e o padrão são avaliados em relação à linha atual. Se omitido, o desvio é padronizado como 1 e o padrão é NULL.	`LAG(BANK_ID, 2, 'hello') OVER (PARTITION BY BANK_ID ORDER BY BANK_NAME DESC)` retorna o valor `BANK_ID` da segunda linha antes da linha atual, particionada por `BANK_ID` e em ordem decrescente de `BANK_NAME`. Se não houver esse valor, `hello` será retornado.
`LAST_VALUE(value) OVER ([ partition_clause ] order_by_clause [ windowFrame_clause ])`	Retorna o valor avaliado na linha que é a última do quadro da janela.	`LAST_VALUE(BANK_ID) OVER (PARTITION BY BANK_ID ORDER BY BANK_NAME ROWS BETWEEN CURRENT ROW AND 1 FOLLOWING)` retorna o último valor `BANK_ID` em uma janela na qual as linhas são calculadas como a linha atual e 1 linha após essa linha, particionada por `BANK_ID` e em ordem crescente de `BANK_NAME`.
`LEAD(value[, offset[, default]]) OVER ([ partition_clause ] order_by_clause)`	Retorna o valor avaliado na linha em um determinado deslocamento após a linha atual dentro da partição. Se não houver essa linha, o valor padrão será retornado. O deslocamento e o padrão são avaliados em relação à linha atual. Se omitido, o desvio é padronizado como 1 e o padrão é NULL.	`LEAD(BANK_ID, 2, 'hello') OVER (PARTITION BY BANK_ID ORDER BY BANK_NAME)` retorna o valor `BANK_ID` da segunda linha após a linha atual, particionada por `BANK_ID` e em ordem crescente de `BANK_NAME`. Se não houver esse valor, `hello` será retornado.
`RANK() OVER([ partition_clause ] order_by_clause)`	Retorna a classificação da linha atual com lacunas, contando a partir de 1.	`RANK() OVER (PARTITION BY BANK_ID ORDER BY BANK_NAME)` retorna a classificação de cada linha dentro do grupo de partições de `BANK_ID`, em ordem crescente de `BANK_NAME`.
`ROW_NUMBER() OVER([ partition_clause ] order_by_clause)`	Retorna o número exclusivo da linha atual dentro de sua partição, contando a partir de 1.	`ROW_NUMBER() OVER (PARTITION BY BANK_ID ORDER BY BANK_NAME)` retorna o número de linha exclusivo de cada linha dentro do grupo de partições de `BANK_ID`, em ordem crescente de `BANK_NAME`.

Funções Aritméticas


Função	Descrição	Exemplo
`ABS(numeric)`	Retorna a potência absoluta do valor `numeric`.	`ABS(-1)`
`CEIL(numeric)`	Retorna o menor inteiro não maior que o valor `numeric`	`CEIL(-1,2)`
`FLOOR(numeric)`	Retorna o maior inteiro não maior que o valor `numeric`.	`FLOOR(-1,2)`
`MOD(numeric1, numeric2)`	Retorna o resto depois que `numeric1` é dividido por `numeric2`.	`MOD(8,2)`
`POWER(numeric1, numeric2)`	Eleva `numeric1` à potência de `numeric2`.	`POWER(2,3)`
`ROUND(numeric1, numeric2)`	Retorna `numeric1` arredondado para `numeric2` casas decimais.	`ROUND(2.5,0)`
`TRUNC(numeric1, numeric2)`	Retorna `numeric1` truncado em `numeric2` casas decimais.	`TRUNC(2.5,0)`
`TO_NUMBER(expr[, format, locale])`	Converte um `expr` em um número, com base em `format` e em `locale` opcional fornecidos. A configuração regional padrão é `en-US`. Tags de idioma suportadas. Padrões de formato suportados: `0`: Um dígito `#`: Um dígito, zero mostra como ausente `.`: Espaço reservado para separador decimal `,`: Espaço reservado para separador de agrupamento `E`: Separa mantissa e expoente para formatos exponenciais `-`: Prefixo negativo padrão `¤`: Sinal de moeda; substituído pelo símbolo de moeda; se duplo, substituído pelo símbolo de moeda internacional; se presente em um padrão, o separador decimal monetário é usado no lugar do separador decimal	`TO_NUMBER('5467.12') returns` retorna `5467.12` `TO_NUMBER('-USD45,677.7', '¤¤##,###.#', 'en-US')` retorna `-45677.7`

Funções de Array

Somente o operador de Expressão suporta funções de matriz.


Função	Descrição	Exemplo
`ARRAY_POSITION(array(...), element)`	Retorna a posição da primeira ocorrência do elemento fornecido no array fornecido. A posição não é baseada em zero, em vez disso, começa com 1.	`ARRAY_POSITION(array(3, 2, 1, 4, 1), 1)` retorna `3`
`REVERSE(array(...))`	Retorna a matriz fornecida de elementos em uma ordem inversa.	`REVERSE(array(2, 1, 4, 3))` retorna `[3,4,1,2]`
`ELEMENT_AT(array(...), index)`	Retorna o elemento do array fornecido na posição de índice fornecida. O índice não é baseado em zero, em vez disso, começa com 1. Se `index = -1`, ele retornará o último elemento.	`ELEMENT_AT(array(1, 2, 3), 2)` retorna `2`

Funções Condicionais


Função	Descrição	Exemplo
`COALESCE(value, value [, value]*)`	Retorna o primeiro argumento não nulo, se ele existir; caso contrário, retorna um nulo.	`COALESCE(NULL, 1, NULL)` retorna `1`
`NULLIF(value, value)`	Retorna nulo se os dois valores forem iguais, caso contrário, retorna o primeiro valor.	`NULLIF('ABC','XYZ')` retorna `ABC`

Funções de Date e Hora


Função	Descrição	Exemplo
`CURRENT_DATE`	Retorna a data atual.	`CURRENT_DATE`retorna a data de hoje, como `2023-05-26`
`CURRENT_TIMESTAMP`	Retorna a data atual e a hora do fuso horário da sessão.	`CURRENT_TIMESTAMP` retorna a data e a hora atuais de hoje, como `2023-05-26 12:34:56`
`DATE_ADD(date, number_of_days)`	Retorna a data que é o `number` especificado de dias após o `date` especificado.	`DATE_ADD('2017-07-30', 1)` retorna `2017-07-31`
`DATE_FORMAT(expr, format[, locale])`	Formata uma `expr` de Data, com base no `format` e no `locale` opcional fornecidos. A configuração regional padrão é `en-US`. Tags de idioma suportadas. Padrões de formato de data suportados: yy: ano com dois dígitos yyyy: ano com quatro dígitos M: Mês numérico, como 1 para janeiro MM: Mês numérico, como 01 para janeiro MMM: Mês resumido, como Jan MMMMMM: Mês completo, como Janeiro d: Dia numérico do mês, como 1 para 1 de junho dd: Dia numérico do mês, como 01 para 1 de junho DDD: Dia numérico do ano de 001 a 366, como 002 para 2 de janeiro F: Dia numérico da semana em um mês, como 3 para a 3a segunda-feira de junho. EEE ou E: Dia nomeado abreviado da semana, como Dom para domingo EEEE: Dia da semana nomeado, como Domingo HHH: formato de 24 horas de 00 a 23 H: formato de 0 a 23 horas 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: milissegundos de 000 a 999 a: AM ou PM z: fuso horário, como PDT	`DATE_FORMAT(Date '2020-10-11', 'yyyy-MM-dd')` retorna `'2020-10-11'`. O primeiro argumento é um objeto Date representando 11 de outubro de 2020. `DATE_FORMAT(Date '2018-junio-17', 'yyyy/MMMM/dd', 'es-ES')` retorna `'2018/junio/17'`
`DAYOFMONTH(date)`	Retorna o dia da data no mês.	`DAYOFMONTH('2020-12-25')` retorna `25`
`DAYOFWEEK(date)`	Retorna o dia da data na semana.	`DAYOFWEEK('2020-12-25')` retorna `6` para sexta-feira. Nos Estados Unidos, o domingo é considerado 1, a segunda-feira é 2 e assim por diante.
`DAYOFYEAR(date)`	Retorna o dia da data no ano.	`DAYOFYEAR('2020-12-25')` retorna `360`
`WEEKOFYEAR(date)`	Retorna a semana da data no ano.	`WEEKOFYEAR('2022-07-28')` retorna `30` `WEEKOFYEAR('2022-07-28 13:24:30')` retorna `30`
`HOUR(datetime)`	Retorna o valor da hora da data/hora.	`HOUR('2020-12-25 15:10:30')` retorna `15`
`LAST_DAY(date)`	Retorna o último dia do mês da data.	`LAST_DAY('2020-12-25')` retorna `31`
`MINUTE(datetime)`	Retorna o valor do minuto da data e hora.	`HOUR('2020-12-25 15:10:30')` retorna `10`
`MONTH(date)`	Retorna o valor do mês da data.	`MONTH('2020-06-25')` retorna `6`
`QUARTER(date)`	Retorna o trimestre do ano em que a data está.	`QUARTER('2020-12-25')` retorna `4`
`SECOND(datetime)`	Retorna o valor de segundo da data e hora.	`SECOND('2020-12-25 15:10:30')` retorna `30`
`TO_DATE(string, format_string[, localeStr])`	Faz parsing da expressão de string com a expressão `format_string` para uma data. A configuração regional é opcional. O padrão é `en-US`. Tags de idioma suportadas. Nas expressões do pipeline, `format_string` deve usar os códigos de formato strftime. Caso contrário, as strings de formato com distinção entre maiúscula/minúscula suportadas serão: yy: ano com dois dígitos yyyy: ano com quatro dígitos M: Mês numérico, como 1 para janeiro MM: Mês numérico, como 01 para janeiro MMM: Mês resumido, como Jan MMMMMM: Mês completo, como Janeiro d: Dia numérico do mês, como 1 para 1 de junho dd: Dia numérico do mês, como 01 para 1 de junho DDD: Dia numérico do ano de 001 a 366, como 002 para 2 de janeiro F: Dia numérico da semana em um mês, como 3 para a 3a segunda-feira de junho. EEE ou E: Dia nomeado abreviado da semana, como Dom para domingo EEEE: Dia da semana nomeado, como Domingo HHH: formato de 24 horas de 00 a 23 H: formato de 0 a 23 horas 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: milissegundos de 000 a 999 a: AM ou PM z: fuso horário, como PDT	`TO_DATE('31 December 2016', 'dd MMMM yyyy')` retorna um valor de Data igual a `2016-12-31` `TO_DATE('2018/junio/17', 'yyyy/MMMM/dd', 'es-ES')` retorna um valor de Data igual a `2018-06-17`
`TO_TIMESTAMP(expr, format_string[, localeStr])`	Converte um `expr` de VARCHAR em um valor de TIMESTAMP, com base no valor `format_string` e no valor `localeStr` opcional fornecidos. Nas expressões do pipeline, `format_string` deve usar os códigos de formato strftime. Caso contrário, os padrões de formato suportados serão: yy: ano com dois dígitos yyyy: ano com quatro dígitos M: Mês numérico, como 1 para janeiro MM: Mês numérico, como 01 para janeiro MMM: Mês resumido, como Jan MMMMMM: Mês completo, como Janeiro d: Dia numérico do mês, como 1 para 1 de junho dd: Dia numérico do mês, como 01 para 1 de junho DDD: Dia numérico do ano de 001 a 366, como 002 para 2 de janeiro F: Dia numérico da semana em um mês, como 3 para a 3a segunda-feira de junho. EEE ou E: Dia nomeado abreviado da semana, como Dom para domingo EEEE: Dia da semana nomeado, como Domingo HHH: formato de 24 horas de 00 a 23 H: formato de 0 a 23 horas 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: milissegundos de 000 a 999 a: AM ou PM z: fuso horário, como PDT	`TO_TIMESTAMP('2020-10-11 11:10:10', 'yyyy-MM-dd HH:mm:ss')` retorna um objeto TIMESTAMP que representa `11am 10:10 Oct 11th, 2020`
`WEEK(date)`	Retorna o valor da semana da data.	`WEEK('2020-06-25')` retorna `4`
`YEAR(date)`	Retorna o valor do ano da data.	`YEAR('2020-06-25')` retorna `2020`
`ADD_MONTHS(date_expr, number_months)`	Retorna a data após a adição do número especificado de meses à data, timestamp ou string especificada com um formato `yyyy-MM-dd` ou `yyyy-MM-dd HH:mm:ss.SSS`.	`ADD_MONTHS('2017-07-30', 1)` retorna `2017-08-30` `ADD_MONTHS('2017-07-30 09:07:21', 1)` retorna `2017-08-30`
`MONTHS_BETWEEN(start_date_expr, end_date_expr)`	Retorna o número de meses entre `start_date_expr` e `end_date_expr`. `start_date_expr` e `end_date_expr` podem ser uma data, um timestamp ou uma string com um formato `yyyy-MM-dd` ou `yyyy-MM-dd HH:mm:ss.SSS` Um número inteiro será retornado se as duas datas forem o mesmo dia do mês ou se ambas forem o último dia em seus respectivos meses. Caso contrário, a diferença será calculada com base em 31 dias por mês.	`MONTHS_BETWEEN('2022-01-01', '2022-01-31')` retorna 1 `MONTHS_BETWEEN('2022-07-28', '2020-07-25')` retorna 24 `MONTHS_BETWEEN('2022-07-28 13:24:30', '2020-07-25 13:24:30')` retorna 24
`FROM_UTC_TIMESTAMP(time_stamp, time_zone)`	Interpreta uma data, um timestamp ou uma string como horário UTC e converte esse horário em um timestamp no fuso horário especificado. Para string, use um formato como: `yyyy-MM-dd` ou `yyyy-MM-dd HH:mm:ss.SSS` O formato de fuso horário é um ID de zona baseado em região (por exemplo, 'área/cidade', como 'Asia/Seoul', ou um deslocamento de fuso horário (por exemplo, UTC+02).	`FROM_UTC_TIMESTAMP('2017-07-14 02:40:00.0', 'GMT+1')` retorna `2017-07-14 03:40:00.0`
`TO_UTC_TIMESTAMP(time_stamp, time_zone)`	Converte uma data, um timestamp ou uma string no fuso horário especificado em um timestamp UTC. Para string, use um formato como: `yyyy-MM-dd` ou `yyyy-MM-dd HH:mm:ss.SSS` O formato de fuso horário é um ID de zona baseado em região (por exemplo, 'área/cidade', como 'Asia/Seoul'), ou um deslocamento de fuso horário (por exemplo, UTC+02).	`TO_UTC_TIMESTAMP('2017-07-14 02:40:00.0', 'GMT+1')` retorna `2017-07-14 01:40:00.0`
`FROM_UNIXTIME(unix_time[, fmt])`	Converte a época ou o horário especificado do Unix em uma string que representa o timestamp desse momento no fuso horário do sistema atual e no formato especificado. Observação: O horário do Unix é o número de segundos decorridos desde 1o de janeiro de 1970 00:00:00 UTC. Se `fmt` for omitido, o formato padrão será `yyyy-MM-dd HH:mm:ss`	`FROM_UNIXTIME(1255033470)` retorna `'2009-10-08 13:24:30'` `FROM_UNIXTIME(1637258854)` retorna `'2021-11-18 10:07:34'` O fuso horário padrão é PST nos exemplos
`UNIX_TIMESTAMP([time_expr[, fmt]])`	Converte o horário atual ou especificado em um timestamp do Unix em segundos. `time_expr` é uma data, um timestamp ou uma string com um formato `yyyy-MM-dd` ou `yyyy-MM-dd HH:mm:ss.SSS` Se `time_expr` não for informado, o horário atual será convertido. Se `time_expr` for uma string e `fmt` for omitido, o padrão será `yyyy-MM-dd HH:mm:ss`	`UNIX_TIMESTAMP('1970-01-01 00:00:00', 'yyyy-MM-dd HH:mm:ss')` retorna `28800` O fuso horário padrão é PST neste exemplo
`INTERVAL 'year' YEAR[(year_precision)]`	Retorna um período em anos. year_precision é o número de dígitos no campo year; ele varia de 0 a 9. Se year_precision for omitido, o padrão será 2 (deve ser menor que 100 anos).	`INTERVAL '1' YEAR` retorna um intervalo de 1 ano `INTERVAL '200' YEAR(3)` retorna um intervalo de 200 anos
`INTERVAL 'year month' YEAR[(year_precision)] TO MONTH`	Retorna um período em anos e meses. Use para armazenar um período usando os campos year e month. year_precision é o número de dígitos no campo year; ele varia de 0 a 9. Se year_precision for omitido, o padrão será 2 (deve ser menor que 100 anos).	`INTERVAL '100-5' YEAR(3) TO MONTH` retorna um intervalo de 100 anos e 5 meses. Especifique a precisão do ano principal de 3.
`INTERVAL 'month' MONTH[(month_precision)]`	Retorna um período em meses. month_precision é o número de dígitos no campo mês; ele varia de 0 a 9. Se month_precision for omitido, o padrão será 2 (deve ser menor que 100 anos).	`INTERVAL '200' MONTH(3)` retorna um intervalo de 200 meses. Especifique a precisão do mês de 3.
`INTERVAL 'day time' DAY[(day_precision)] TO SECOND[(fractional_seconds_precision)]`	Retorna um período em termos de dias, horas, minutos e segundos. day_precision é o número de dígitos no campo day; ele varia de 0 a 9. O padrão é 2. fractional_seconds_precision é o número de dígitos na parte fracionária do valor do segundo no campo time; ele varia de 0 a 9.	`INTERVAL '11 10:09:08.555' DAY TO SECOND(3)` retorna um intervalo de 11 dias, 10 horas, 09 minutos, 08 segundos e 555 milésimos de segundo
`INTERVAL 'day time' DAY[(day_precision)] TO MINUTE[(minute_precision)]`	Retorna um período em termos de dias, horas e minutos. day_precision é o número de dígitos no campo day; ele varia de 0 a 9. O padrão é 2. minute_precision é o número de dígitos no campo minute; ele varia de 0 a 2. O padrão é 2.	`INTERVAL '11 10:09' DAY TO MINUTE` retorna um intervalo de 11 dias, 10 horas e 09 minutos
`INTERVAL 'day time' DAY[(day_precision)] TO HOUR[(hour_precision)]`	Retorna um período em termos de dias e horas. day_precision é o número de dígitos no campo day; ele varia de 0 a 9. O padrão é 2. hour_precision é o número de dígitos no campo hora; ele varia de 0 a 2. O padrão é 2.	`INTERVAL '100 10' DAY(3) TO HOUR` retorna um intervalo de 100 dias e 10 horas
`INTERVAL 'day' DAY[(day_precision)]`	Retorna um período em termos de dias. day_precision é o número de dígitos no campo day; ele varia de 0 a 9. O padrão é 2.	`INTERVAL '999' DAY(3)` retorna um intervalo de 999 dias
`INTERVAL 'time' HOUR[(hour_precision)] TO SECOND[(fractional_seconds_precision)]`	Retorna um período em termos de horas, minutos e segundos. hour_precision é o número de dígitos no campo hora; ele varia de 0 a 2. O padrão é 2. fractional_seconds_precision é o número de dígitos na parte fracionária do valor do segundo no campo time; ele varia de 0 a 9.	`INTERVAL '09:08:07.6666666' HOUR TO SECOND(7)` retorna um intervalo de 9 horas, 08 minutos e 7.6666666 segundos
`INTERVAL 'time' HOUR[(hour_precision)] TO MINUTE[(minute_precision)]`	Retorna um período em termos de horas e minutos. hour_precision é o número de dígitos no campo hora; ele varia de 0 a 2. O padrão é 2. minute_precision é o número de dígitos no campo minute; ele varia de 0 a 2. O padrão é 2.	`INTERVAL '09:30' HOUR TO MINUTE` retorna um intervalo de 9 horas e 30 minutos
`INTERVAL 'hour' HOUR[(hour_precision)]`	Retorna um período em termos de horas. hour_precision é o número de dígitos no campo hora; ele varia de 0 a 2. O padrão é 2.	`INTERVAL '40' HOUR` retorna um intervalo de 40 horas
`INTERVAL 'minute' MINUTE[(minute_precision)]`	Retorna um período em termos de minutos. minute_precision é o número de dígitos no campo minute; ele varia de 0 a 2. O padrão é 2.	`INTERVAL '15' MINUTE` retorna um intervalo de 15 minutos
`INTERVAL 'time' MINUTE[(minute_precision)] TO SECOND[(fractional_seconds_precision)]`	Retorna um período em termos de minutos e segundos. minute_precision é o número de dígitos no campo minute; ele varia de 0 a 2. O padrão é 2. fractional_seconds_precision é o número de dígitos na parte fracionária do valor do segundo no campo time; ele varia de 0 a 9.	`INTERVAL '15:30' MINUTE TO SECOND` retorna um intervalo de 15 minutos e 30 segundos
`INTERVAL 'second' SECOND[(fractional_seconds_precision)]`	Retorna um período em termos de segundos. fractional_seconds_precision é o número de dígitos na parte fracional do campo segundo; ele varia de 0 a 9. O padrão é 3.	`INTERVAL '15.678' SECOND` retorna um intervalo de 15,678 segundos

Funções de Hash


Função	Descrição	Exemplo
`MD5(all data types)`	Calcula uma soma de verificação `MD5` do tipo de dados e retorna um valor de string.	`MD5(column_name)`
`SHA1(all data types)`	Calcula um valor de hash `SHA-1` do tipo de dados e retorna um valor de string.	`SHA1(column_name)`
`SHA2(all data types, bitLength)`	Calcula um valor de hash `SHA-2` do tipo de dados e retorna um valor de string. `bitLength`é um número inteiro.	`SHA2 (column_name, bitLength can be set to 0 (equivalent to 256), 256, 384, or 512)`.
`ORA_HASH(expr, [max_bucket], [seed_value])`	Calcula um valor de hash para `expr` e retorna um valor NUMBER. `expr` pode ser uma expressão, uma coluna, um literal. `max_bucket` é o valor máximo de bucket retornado, entre 0 e 4294967295 (padrão). `seed_value` é um valor entre 0 (padrão) e 4294967295. A Oracle aplica a função hash à combinação de `expr` e `seed_value` para produzir muitos resultados diferentes para o mesmo conjunto de dados.	`ORA_HASH('1')` `ORA_HASH('b', 2)` `ORA_HASH(100, 10, 10)` `ORA_HASH(EXPRESSION_1.CUSTOMERS.SSN, 2)`

Funções Hierárquicas


Função	Descrição	Exemplo
`SCHEMA_OF_JSON(string)`	Faz parsing de uma string JSON e infere o esquema no formato DDL.	`SCHEMA_OF_JSON('[{\"Zipcode\":704,\"ZipCodeType\":\"STANDARD\",\"City\":\"ORACLECITY\",\"State\":\"OC\"}]')` retorna `'ARRAY<STRUCT<City:string,State:string,ZipCodeType:string,Zipcode:bigint>>'` `SCHEMA_OF_JSON('[{\"col\":0}]')` retorna `'ARRAY<STRUCT<col: BIGINT>>'`
`FROM_JSON(column, string)`	Faz parsing de uma coluna que contém uma string JSON em um dos tipos a seguir, com o esquema especificado. Map, com String como tipo de chave Struct Array	`FROM_JSON('{\"Zipcode\":704,\"City\":\"ORACLE CITY\"}', 'STRUCT<Zipcode: BIGINT, City: STRING>')` retorna uma coluna de tipo Struct com o esquema especificado: `{704, ORACLE CITY}` `FROM_JSON('{\"a\":1, \"b\":0.8}', 'STRUCT<a: BIGINT, b: DOUBLE>')` retorna uma coluna de tipo Struct com o esquema especificado: `{1, 0.8}`
`TO_JSON(column)`	Converte uma coluna que contém um tipo Struct ou Array de Structs ou um tipo Map ou Array de Map em uma string JSON.	`TO_JSON(TO_STRUCT('s1', TO_ARRAY(1,2,3), 's2', TO_MAP('key', 'value')))` retorna uma string JSON `{"s1":[1,2,3],"s2":{"key":"value"}}`
`TO_MAP(string,column[,string,column]*)`	Cria uma nova coluna do tipo Map. As colunas de entrada devem ser agrupadas como pares de chave/valor. As colunas de chave de entrada não podem ser nulas e devem ter todas o mesmo tipo de dados. As colunas de valor de entrada devem todas ter o mesmo tipo de dados.	`TO_MAP('Ename',Expression_1.attribute1)` retorna uma coluna de tipo Map: `{"ENAME" -> 100}` `TO_MAP('block', EXPRESSION_1.MYSOURCE.address.block, 'unit', EXPRESSION_1.MYSOURCE.address.unit)` retorna uma coluna de tipo Map: `{"block" -> 1,"unit" -> 1}`
`TO_STRUCT(string,column[,string,column]*)`	Cria uma nova coluna do tipo Struct. As colunas de entrada devem ser agrupadas como pares de chave/valor.	`TO_STRUCT('Ename',Expression_1.attribute1)` retorna `{100}` `TO_STRUCT('Id',Expression_1.attribute1, 'Name', Expression_1.attribute2)` retorna `{100, "John"}`
`TO_ARRAY(column[,column]*)`	Cria uma nova coluna como tipo Array. As colunas de entrada devem todas ter o mesmo tipo de dados.	`TO_Array(Expression_1.attribute1)` retorna `[100]` `TO_ARRAY(EXPRESSION_1.attribute2,EXPRESSION_1.attribute3)` retorna `["John","Friend"]`

Funções de Ordem Superior

Os operadores de fluxo de dados que suportam a criação de expressões e tipos de dados hierárquicos podem usar funções de ordem superior.

Estes são os operadores suportados:

Agregado
Expressão
Filtro
Associar
Lookup
Divisão
Deslocar


Função	Descrição	Exemplo
`TRANSFORM(column, lambda_function)`	Recebe uma matriz e uma função anônima e configura uma nova matriz aplicando a função a cada elemento e atribuindo o resultado à matriz de saída.	Para um array de entrada de inteiros `[1, 2, 3]`, `TRANSFORM(array, x -> x + 1)` retorna um novo array de `[2, 3, 4]`.
`TRANSFORM_KEYS(column, lambda_function)`	Usa um mapa e uma função com 2 argumentos (chave e valor) e retorna um mapa no qual as chaves têm o tipo do resultado da função lambda, e os valores têm o tipo dos valores de mapa da coluna.	Para um mapa de entrada com chaves inteiras e valores de string `{1 -> 'value1', 2 -> 'value2', 3 -> 'value3'}`, `TRANSFORM_KEYS(map, (k, v) -> k * 2 + 1)` retorna um novo mapa de `{3 -> 'value1', 5 -> 'value2', 7 -> 'value3'}`.
`TRANSFORM_VALUES(column, lambda_function)`	Usa um mapa e uma função com 2 argumentos (chave e valor) e retorna um mapa no qual os valores têm o tipo do resultado das funções lambda, e as chaves têm o tipo das chaves de mapa de coluna.	Para um mapa de entrada com chaves de string e valores de string `{'a' -> 'value1', 'b' -> 'value2', 'c' -> 'value3'}`, `TRANSFORM_VALUES(map, (k, v) -> k \|\| __ '' \|\| v)` retorna um novo mapa de `{'a' -> 'a_value1', 'b' -> 'b_value2', 'c' -> 'c_value3'}`.
`ARRAY_SORT(array(...), lambda_function)`	Somente o operador de Expressão suporta `ARRAY_SORT`. Recebe uma matriz e classifica de acordo com a função fornecida que recebe 2 argumentos. A função deve retornar -1, 0 ou 1, dependendo de o primeiro elemento ser menor que, igual a ou maior que o segundo elemento. Se a função for omitida, a matriz será classificada em ordem crescente.	`array_sort(to_array(5, 6, 1), (left, right) -> CASE WHEN left < right THEN -1 WHEN left > right THEN 1 ELSE 0 END)` A matriz retornada é: `[1,5,6]`

Funções do Operador (Comparação)


Função	Descrição	Exemplo
`CASE WHEN condition1 THEN result1 ELSE result2 END`	Retorna o valor cuja condição é atendida.	`CASE WHEN 1 > 0 THEN 'ABC' ELSE 'XYZ' END` retorna `ABC` se `1> 0`; caso contrário, retorna `XYZ`
`AND`	O operador lógico AND. Retorna verdadeiro se os dois operandos forem verdadeiros; caso contrário, retorna falso.	(x = 10 AND y = 20) retorna "true" se x for igual a 10 e y for igual a 20. Se um dos dois não for verdadeiro, retornará "false"
`OR`	O operador lógico OR. Retorna verdadeiro se um operando for verdadeiro ou ambos forem verdadeiros; caso contrário, retorna falso.	(x = 10 OR y = 20) retorna "false" se x não for igual a 10 e também y não for igual a 20. Se um for verdadeiro, retornará "true"
`NOT`	O operador lógico NOT.
`LIKE`	Executa correspondência de padrão de string, se string1 corresponder ao padrão em string2.
`=`	Verifica a igualdade. Retorna verdadeiro se expr1 for igual a expr2; caso contrário, retorna falso.	x = 10 retorna "true" quando o valor de x é 10, caso contrário, retorna "false"
`!=`	Verifica a desigualdade. Retorna verdadeiro se expr1 não for igual a expr2; caso contrário, retorna falso.	x != 10 retorna "false" se o valor de x for 10, caso contrário, retorna "true"
`>`	Verifica uma expressão maior que. Retorna verdadeiro se expr1 for maior que expr2.	x > 10 retorna "true" se o valor de x for maior que 10, caso contrário, retorna "false"
`>=`	Testa uma expressão maior que ou igual a. Retorna verdadeiro se expr1 for maior ou igual a expr2.	x > =10 retorna "true" se o valor de x for maior ou igual a 10, caso contrário, retorna "false"
`<`	Testa uma expressão menor que. Retorna verdadeiro se expr1 for menor que expr2.	x < 10 retorna "true" se o valor de x for menor que 10, caso contrário, retornará "false"
`<=`	Testa uma expressão menor que ou igual a. Retorna verdadeiro se expr1 for menor ou igual a expr2.	x <= 10 retorna "true" se o valor de x for menor que 10, caso contrário, retorna "false"
`\|\|`	Concatena duas strings.	`'XYZ' \|\| 'hello'` retorna `'XYZhello'`
`BETWEEN`	Avalia um intervalo.	`FILTER_1.BANK.BANK_ID BETWEEN 1003 AND 1007`
`IN`	Testa se uma expressão corresponde a uma lista de valores.	`FILTER_2.ORDERS.ORDER_ID IN (1003, 1007)`

Funções da String


Funções	Descrição	Exemplo
`CAST(value AS type)`	Retorna o valor especificado no tipo especificado.	`CAST("10" AS INT)` retorna `10`
`CONCAT(string, string)`	Retorna os valores combinados de strings ou colunas.	`CONCAT('Oracle','SQL')` retorna `OracleSQL`
`CONCAT_WS(separator, expression1, expression2, expression3,...)`	Retorna os valores combinados de strings ou colunas usando o separador especificado entre as strings ou colunas. Um separador é obrigatório e deve ser uma string. Pelo menos uma expressão deve ser fornecida após o separador. Por exemplo: `CONCAT_WS(',' col1)`	`CONCAT_WS('-', 'Hello', 'Oracle')` retorna `Hello-Oracle` `CONCAT_WS(' ', address, city, postal_code)` retorna `123 MyCity 987654` Se um filho da função for um array, o array será nivelado: `CONCAT_WS(',', 1,2,3, to_array(4,5,6), to_array(7,8), 9)` retorna `1,2,3,4,5,6,7,8,9`
`INITCAP(string)`	Retorna a string com a primeira letra de cada palavra em maiúscula, enquanto todas as outras letras ficam em minúsculas e cada palavra é delimitada por um espaço em branco.	`INITCAP('oRACLE sql')` retorna `Oracle Sql`
`INSTR(string, substring[start_position])`	Retorna o índice (baseado em 1) da primeira ocorrência de `substring` em `string`.	`INSTR('OracleSQL', 'SQL')` retorna `7`
`LOWER(string)`	Retorna a string com todas as letras alteradas para minúsculas.	`LOWER('ORACLE')` retorna `oracle`
`LENGTH(string)`	Retorna o tamanho do caractere da string ou o número de bytes de dados binários. O tamanho da string inclui espaços à direita.	`LENGTH('Oracle')` retorna `6`
`LTRIM(string)`	Retorna a string com espaços à esquerda removidos.	`LTRIM(' Oracle')`
`NVL(expr1, epxr2)`	Retorna o argumento que não é nulo.	`NVL(EXPRESSION_3.CUSTOMERS_JSON.CONTINENT_ID, ROWID())`
`REGEXP_SUBSTR(string, regexp[, RegexGroupIdx])`	Pesquisa e extrai a string que corresponde a um padrão de expressão regular da string de entrada. Se o índice do grupo de captura opcional for informado, a função extrairá o grupo específico.	`REGEXP_SUBSTR('https://www.oracle.com/products', 'https://([[:alnum:]]+\.?){3,4}/?')` retorna `https://www.oracle.com` `REGEXP_SUBSTR('22;33;44', '([0-9.]);([0-9.]);([0-9.]*)', 1)` retorna `22`
`REPLACE(string, search, replacement)`	Substitui todas as ocorrências de `search` por `replacement`. Se `search` não for encontrado na string, ela será retornada inalterada. Se `replacement` não for especificado ou for uma string vazia, nada substituirá `search` que é removido de `string`.	`REPLACE('ABCabc', 'abc', 'DEF')` retorna `ABCDEF`
`RTRIM(string)`	Retorna a string com espaços à esquerda removidos da direita.	`RTRIM('Oracle ')`
`SUBSTRING(string, position[, substring_length])`	Retorna a substring que começa na posição.	`SUBSTRING('Oracle SQL' FROM 2 FOR 3)` returns `rac`
Para números, `TO_CHAR(expr)` e datas `TO_CHAR(expr, format[, locale])`	Converte números e datas em strings. Para números, nenhum formato é necessário. Para datas, use o mesmo formato que `DATE_FORMAT` descrito em Funções de Data e Hora. A configuração regional padrão é `en-US`. Consulte tags de idioma suportadas. Nas expressões do pipeline, `format_string` deve usar os códigos de formato strftime. Caso contrário, os padrões de formato de data suportados são: yy: ano com dois dígitos yyyy: ano com quatro dígitos M: Mês numérico, como 1 para janeiro MM: Mês numérico, como 01 para janeiro MMM: Mês resumido, como Jan MMMMMM: Mês completo, como Janeiro d: Dia numérico do mês, como 1 para 1 de junho dd: Dia numérico do mês, como 01 para 1 de junho DDD: Dia numérico do ano de 001 a 366, como 002 para 2 de janeiro F: Dia numérico da semana em um mês, como 3 para a 3a segunda-feira de junho. EEE ou E: Dia nomeado abreviado da semana, como Dom para domingo EEEE: Dia da semana nomeado, como Domingo HHH: formato de 24 horas de 00 a 23 H: formato de 0 a 23 horas 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: milissegundos de 000 a 999 a: AM ou PM z: fuso horário, como PDT	Exemplo de número: `TO_CHAR(123)` retorna `123` Exemplo de data: `TO_CHAR(Date '2020-10-30', 'yyyy.MM.dd', 'en-US')` retorna a string `2020.10.30`. O primeiro argumento é um objeto Date representando 30 de outubro de 2020.
`UPPER(string)`	Retorna uma string com todas as letras alteradas para maiúsculas.	`UPPER('oracle')` retorna `ORACLE`
`LPAD(str, len[, pad])`	Retorna uma string preenchida à esquerda com caracteres especificados para um determinado tamanho. Se o caractere pad for omitido, o padrão será um espaço.	`LPAD('ABC', 5, '')` retorna `'*ABC'`
`RPAD(str, len[, pad])`	Retorna uma string preenchida à direita com caracteres especificados para um determinado tamanho. Se o caractere pad for omitido, o padrão será um espaço.	`RPAD('XYZ', 6, '+' ) returns 'XYZ+++'`

Funções de ID Exclusivo


Função	Descrição	Exemplo
`NUMERIC_ID()`	Gera um identificador exclusivo universal que é um número de 64 bits para cada linha.	`NUMERIC_ID()` retorna, por exemplo, `3458761969522180096` e `3458762008176885761`
`ROWID()`	Gera números monotonicamente crescentes de 64 bits.	`ROWID()` retorna, por exemplo, `0`, `1`, `2` e assim por diante
`UUID()`	Gera um identificador exclusivo universal que é uma String de 128 bit para cada linha.	`UUID()` retorna, por exemplo, `20d45c2f-0d56-4356-8910-162f4f40fb6d`
`MONOTONICALLY_INCREASING_ID()`	Gera inteiros exclusivos e monotonicamente crescentes de 64 bits que são números não consecutivos.	`MONOTONICALLY_INCREASING_ID()` retorna, por exemplo, `8589934592` e `25769803776`

Documentação do Oracle Cloud Infrastructure

Referência de Funções (Data Flow)