Expressões de transformação de dados no fluxo de dados de mapeamento

APLICA-SE A: Azure Data Factory Azure Synapse Analytics

Funções de expressão

Na Data Factory, utilize a linguagem de expressão da funcionalidade de fluxo de dados de mapeamento para configurar as transformações de dados.


abs

abs(<value1> : number) => number

Valor absoluto de um número.

  • abs(-20) -> 20
  • abs(10) -> 10

acos

acos(<value1> : number) => double

Calcula um valor inverso de cosine.

  • acos(1) -> 0.0

add

add(<value1> : any, <value2> : any) => any

Adiciona um par de cordas ou números. Acrescenta uma data a vários dias. Adiciona uma duração a uma hora de duração. Anexa uma matriz de tipo semelhante a outra. O mesmo que o operador +.

  • add(10, 20) -> 30
  • 10 + 20 -> 30
  • add('ice', 'cream') -> 'icecream'
  • 'ice' + 'cream' + ' cone' -> 'icecream cone'
  • add(toDate('2012-12-12'), 3) -> toDate('2012-12-15')
  • toDate('2012-12-12') + 3 -> toDate('2012-12-15')
  • [10, 20] + [30, 40] -> [10, 20, 30, 40]
  • toTimestamp('2019-02-03 05:19:28.871', 'yyyy-MM-dd HH:mm:ss.SSS') + (days(1) + hours(2) - seconds(10)) -> toTimestamp('2019-02-04 07:19:18.871', 'yyyy-MM-dd HH:mm:ss.SSS')

addDays

addDays(<date/timestamp> : datetime, <days to add> : integral) => datetime

Adicione dias a uma data ou hora marcada. O mesmo que o operador + para a data.

  • addDays(toDate('2016-08-08'), 1) -> toDate('2016-08-09')

addMonths

addMonths(<date/timestamp> : datetime, <months to add> : integral, [<value3> : string]) => datetime

Adicione meses a uma data ou hora marcada. Pode opcionalmente passar por um timezone.

  • addMonths(toDate('2016-08-31'), 1) -> toDate('2016-09-30')
  • addMonths(toTimestamp('2016-09-30 10:10:10'), -1) -> toTimestamp('2016-08-31 10:10:10')

and

and(<value1> : boolean, <value2> : boolean) => boolean

Lógico e operador. O mesmo que &&.

  • and(true, false) -> false
  • true && false -> false

asin

asin(<value1> : number) => double

Calcula um valor seno inverso.

  • asin(0) -> 0.0

atan

atan(<value1> : number) => double

Calcula um valor tangente inverso.

  • atan(0) -> 0.0

atan2

atan2(<value1> : number, <value2> : number) => double

Devolve o ângulo em radiais entre o eixo x positivo de um plano e o ponto dado pelas coordenadas.

  • atan2(0, 0) -> 0.0

between

between(<value1> : any, <value2> : any, <value3> : any) => boolean

Verifica se o primeiro valor está entre dois outros valores de forma inclusiva. Valores numéricos, cordas e datas podem ser comparados * between(10, 5, 24)

  • true
  • between(currentDate(), currentDate() + 10, currentDate() + 20)
  • false

bitwiseAnd

bitwiseAnd(<value1> : integral, <value2> : integral) => integral

Bitwise E operador em todos os tipos integrais. O mesmo que & operador * bitwiseAnd(0xf4, 0xef)

  • 0xe4
  • (0xf4 & 0xef)
  • 0xe4

bitwiseOr

bitwiseOr(<value1> : integral, <value2> : integral) => integral

Bitwise Ou operador em todos os tipos integrais. O mesmo que | operador * bitwiseOr(0xf4, 0xef)

  • 0xff
  • (0xf4 | 0xef)
  • 0xff

bitwiseXor

bitwiseXor(<value1> : any, <value2> : any) => any

Bitwise Ou operador em todos os tipos integrais. O mesmo que | operador * bitwiseXor(0xf4, 0xef)

  • 0x1b
  • (0xf4 ^ 0xef)
  • 0x1b
  • (true ^ false)
  • true
  • (true ^ true)
  • false

blake2b

blake2b(<value1> : integer, <value2> : any, ...) => string

Calcula a digestão Blake2 de conjunto de colunas de dados primitivos variados dado um pouco de comprimento que só pode ser múltiplos de 8 entre 8 & 512. Pode ser usado para calcular uma impressão digital para uma linha * blake2b(256, 'gunchus', 8.2, 'bojjus', true, toDate('2010-4-4'))

  • 'c9521a5080d8da30dffb430c50ce253c345cc4c4effc315dab2162dac974711d'

blake2bBinary

blake2bBinary(<value1> : integer, <value2> : any, ...) => binary

Calcula a digestão Blake2 de conjunto de colunas de dados primitivos variados dado um pouco de comprimento que só pode ser múltiplos de 8 entre 8 & 512. Pode ser usado para calcular uma impressão digital para uma linha * blake2bBinary(256, 'gunchus', 8.2, 'bojjus', true, toDate('2010-4-4'))

  • unHex('c9521a5080d8da30dffb430c50ce253c345cc4c4effc315dab2162dac974711d')

case

case(<condition> : boolean, <true_expression> : any, <false_expression> : any, ...) => any

Com base em condições alternadas aplica-se um valor ou outro. Se o número de entradas estiver igual, o outro é incumprido para NU PARA a última condição.

  • case(10 + 20 == 30, 'dumbo', 'gumbo') -> 'dumbo'
  • case(10 + 20 == 25, 'bojjus', 'do' < 'go', 'gunchus') -> 'gunchus'
  • isNull(case(10 + 20 == 25, 'bojjus', 'do' > 'go', 'gunchus')) -> true
  • case(10 + 20 == 25, 'bojjus', 'do' > 'go', 'gunchus', 'dumbo') -> 'dumbo'

cbrt

cbrt(<value1> : number) => double

Calcula a raiz do cubo de um número.

  • cbrt(8) -> 2.0

ceil

ceil(<value1> : number) => number

Devolve o número inteiro mais pequeno não menor que o número.

  • ceil(-0.1) -> 0

coalesce

coalesce(<value1> : any, ...) => any

Devolve o primeiro valor não nulo de um conjunto de entradas. Todas as entradas devem ser do mesmo tipo.

  • coalesce(10, 20) -> 10
  • coalesce(toString(null), toString(null), 'dumbo', 'bo', 'go') -> 'dumbo'

columnNames

columnNames(<value1> : string) => array

Obtém os nomes de todas as colunas de saída para um fluxo. Pode passar um nome de fluxo opcional como segundo argumento.

  • columnNames()
  • columnNames('DeriveStream')

columns

columns([<stream name> : string]) => any

Obtém os valores de todas as colunas de saída para um fluxo. Pode passar um nome de fluxo opcional como segundo argumento.

  • columns()
  • columns('DeriveStream')

compare

compare(<value1> : any, <value2> : any) => integer

Compara dois valores do mesmo tipo. Devolve número inteiro negativo se o valor 1 < valor2, 0 se o valor 1 == valor2, valor positivo se o valor 1 > valor2.

  • (compare(12, 24) < 1) -> true
  • (compare('dumbo', 'dum') > 0) -> true

concat

concat(<this> : string, <that> : string, ...) => string

Concatenates um número variável de cordas juntos. O mesmo que o operador + com cordas.

  • concat('dataflow', 'is', 'awesome') -> 'dataflowisawesome'
  • 'dataflow' + 'is' + 'awesome' -> 'dataflowisawesome'
  • isNull('sql' + null) -> true

concatWS

concatWS(<separator> : string, <this> : string, <that> : string, ...) => string

Concatenates um número variável de cordas juntamente com um separador. O primeiro parâmetro é o separador.

  • concatWS(' ', 'dataflow', 'is', 'awesome') -> 'dataflow is awesome'
  • isNull(concatWS(null, 'dataflow', 'is', 'awesome')) -> true
  • concatWS(' is ', 'dataflow', 'awesome') -> 'dataflow is awesome'

cos

cos(<value1> : number) => double

Calcula um valor cosine.

  • cos(10) -> -0.8390715290764524

cosh

cosh(<value1> : number) => double

Calcula um cosão hiperbólico de um valor.

  • cosh(0) -> 1.0

crc32

crc32(<value1> : any, ...) => long

Calcula o hash CRC32 de conjunto de colunas de dados primitivos variados, dado um pouco de comprimento que só pode ser dos valores 0(256), 224, 256, 384, 512. Pode ser usado para calcular uma impressão digital por uma linha.

  • crc32(256, 'gunchus', 8.2, 'bojjus', true, toDate('2010-4-4')) -> 3630253689L

currentDate

currentDate([<value1> : string]) => date

Tem a data atual quando este trabalho começar a funcionar. Você pode passar um timezone opcional sob a forma de 'GMT', 'PST', 'UTC', 'America/Cayman'. O intervalo local é usado como padrão. Consulte a classe de Java SimpleDateFormat para formatos disponíveis. https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html.

  • currentDate() == toDate('2250-12-31') -> false
  • currentDate('PST') == toDate('2250-12-31') -> false
  • currentDate('America/New_York') == toDate('2250-12-31') -> false

currentTimestamp

currentTimestamp() => timestamp

Obtém a atual hora quando o trabalho começa a funcionar com o fuso horário local.

  • currentTimestamp() == toTimestamp('2250-12-31 12:12:12') -> false

currentUTC

currentUTC([<value1> : string]) => timestamp

Obtém a atual hora como UTC. Se quiser que o seu tempo atual seja interpretado num fuso horário diferente do seu fuso horário do cluster, pode passar um fuso horário opcional sob a forma de 'GMT', 'PST', 'UTC', 'America/Cayman'. Está em incumprimento do atual timezone. Consulte a classe de Java SimpleDateFormat para formatos disponíveis. https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html. Para converter o tempo UTC para uma utilização diferente do timezone fromUTC() .

  • currentUTC() == toTimestamp('2050-12-12 19:18:12') -> false
  • currentUTC() != toTimestamp('2050-12-12 19:18:12') -> true
  • fromUTC(currentUTC(), 'Asia/Seoul') != toTimestamp('2050-12-12 19:18:12') -> true

dayOfMonth

dayOfMonth(<value1> : datetime) => integer

Recebe o dia do mês dada uma data.

  • dayOfMonth(toDate('2018-06-08')) -> 8

dayOfWeek

dayOfWeek(<value1> : datetime) => integer

Recebe o dia da semana dado uma data. 1 - Domingo, 2 - Segunda..., 7 - Sábado.

  • dayOfWeek(toDate('2018-06-08')) -> 6

dayOfYear

dayOfYear(<value1> : datetime) => integer

Recebe o dia do ano com uma data.

  • dayOfYear(toDate('2016-04-09')) -> 100

days

days(<value1> : integer) => long

Duração em milissegundos durante o número de dias.

  • days(2) -> 172800000L

degrees

degrees(<value1> : number) => double

Converte radianos em graus.

  • degrees(3.141592653589793) -> 180

divide

divide(<value1> : any, <value2> : any) => any

Divide um par de números. O mesmo que o / operador.

  • divide(20, 10) -> 2
  • 20 / 10 -> 2

endsWith

endsWith(<string> : string, <substring to check> : string) => boolean

Verifique se a corda termina com a corda fornecida.

  • endsWith('dumbo', 'mbo') -> true

equals

equals(<value1> : any, <value2> : any) => boolean

A comparação é igual a um operador. O mesmo que == operador.

  • equals(12, 24) -> false
  • 12 == 24 -> false
  • 'bad' == 'bad' -> true
  • isNull('good' == toString(null)) -> true
  • isNull(null == null) -> true

equalsIgnoreCase

equalsIgnoreCase(<value1> : string, <value2> : string) => boolean

A comparação é igual ao operador ignorando o caso. O mesmo que <= operador de>.

  • 'abc'<=>'Abc' -> true
  • equalsIgnoreCase('abc', 'Abc') -> true

escape

escape(<string_to_escape> : string, <format> : string) => string

Escapa de uma corda de acordo com um formato. Os valores literais para formato aceitável são 'json', 'xml', 'ecmascript', 'html', 'java'.


expr

expr(<expr> : string) => any

Resulta numa expressão de uma corda. Isto é o mesmo que escrever esta expressão de uma forma não literal. Isto pode ser usado para passar parâmetros como representações de cordas.

  • expr ('preço * desconto') => qualquer ___

factorial

factorial(<value1> : number) => long

Calcula o fatorial de um número.

  • factorial(5) -> 120

false

false() => boolean

Devolve sempre um valor falso. Utilize a função syntax(false()) se houver uma coluna chamada "falso".

  • (10 + 20 > 30) -> false
  • (10 + 20 > 30) -> false()

floor

floor(<value1> : number) => number

Devolve o maior número inteiro não maior que o número.

  • floor(-0.1) -> -1

fromBase64

fromBase64(<value1> : string) => string

Codifica a cadeia dada na base64.

  • fromBase64('Z3VuY2h1cw==') -> 'gunchus'

fromUTC

fromUTC(<value1> : timestamp, [<value2> : string]) => timestamp

Converte-se à hora da UTC. Você pode opcionalmente passar o timezone sob a forma de 'GMT', 'PST', 'UTC', 'America/Cayman'. Está em incumprimento do atual timezone. Consulte a classe de Java SimpleDateFormat para formatos disponíveis. https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html.

  • fromUTC(currentTimestamp()) == toTimestamp('2050-12-12 19:18:12') -> false
  • fromUTC(currentTimestamp(), 'Asia/Seoul') != toTimestamp('2050-12-12 19:18:12') -> true

greater

greater(<value1> : any, <value2> : any) => boolean

Comparação de maior operador. O mesmo que > operador.

  • greater(12, 24) -> false
  • ('dumbo' > 'dum') -> true
  • (toTimestamp('2019-02-05 08:21:34.890', 'yyyy-MM-dd HH:mm:ss.SSS') > toTimestamp('2019-02-03 05:19:28.871', 'yyyy-MM-dd HH:mm:ss.SSS')) -> true

greaterOrEqual

greaterOrEqual(<value1> : any, <value2> : any) => boolean

Comparação superior ou igual ao operador. O mesmo que >= operador.

  • greaterOrEqual(12, 12) -> true
  • ('dumbo' >= 'dum') -> true

greatest

greatest(<value1> : any, ...) => any

Devolve o maior valor entre a lista de valores como entrada saltando valores nulos. Devoluções nulas se todas as entradas forem nulas.

  • greatest(10, 30, 15, 20) -> 30
  • greatest(10, toInteger(null), 20) -> 20
  • greatest(toDate('2010-12-12'), toDate('2011-12-12'), toDate('2000-12-12')) -> toDate('2011-12-12')
  • greatest(toTimestamp('2019-02-03 05:19:28.871', 'yyyy-MM-dd HH:mm:ss.SSS'), toTimestamp('2019-02-05 08:21:34.890', 'yyyy-MM-dd HH:mm:ss.SSS')) -> toTimestamp('2019-02-05 08:21:34.890', 'yyyy-MM-dd HH:mm:ss.SSS')

hasColumn

hasColumn(<column name> : string, [<stream name> : string]) => boolean

Verifica o valor da coluna pelo nome no fluxo. Pode passar um nome de fluxo opcional como segundo argumento. Os nomes das colunas conhecidos na hora do design devem ser abordados apenas pelo seu nome. As entradas computadas não são suportadas, mas pode utilizar substituições de parâmetros.

  • hasColumn('parent')

hour

hour(<value1> : timestamp, [<value2> : string]) => integer

Obtém o valor de uma hora de um tempo. Você pode passar um timezone opcional sob a forma de 'GMT', 'PST', 'UTC', 'America/Cayman'. O intervalo local é usado como padrão. Consulte a classe de Java SimpleDateFormat para formatos disponíveis. https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html.

  • hour(toTimestamp('2009-07-30 12:58:59')) -> 12
  • hour(toTimestamp('2009-07-30 12:58:59'), 'PST') -> 12

hours

hours(<value1> : integer) => long

Duração em milissegundos por número de horas.

  • hours(2) -> 7200000L

iif

iif(<condition> : boolean, <true_expression> : any, [<false_expression> : any]) => any

Com base numa condição, aplica-se um valor ou outro. Se outro não for especificado, é considerado NU. Ambos os valores devem ser compatíveis (numérico, corda...). * iif(10 + 20 == 30, 'dumbo', 'gumbo') -> 'dumbo'

  • iif(10 > 30, 'dumbo', 'gumbo') -> 'gumbo'
  • iif(month(toDate('2018-12-01')) == 12, 345.12, 102.67) -> 345.12

iifNull

iifNull(<value1> : any, [<value2> : any], ...) => any

Verifica se o primeiro parâmetro é nulo. Se não for nulo, o primeiro parâmetro é devolvido. Se nulo, o segundo parâmetro é devolvido. Se forem especificados três parâmetros, o comportamento é o mesmo que iif (isNull (valor1), valor2, valor3) e o terceiro parâmetro é devolvido se o primeiro valor não for nulo.

  • iifNull(10, 20) -> 10
  • iifNull(null, 20, 40) -> 20
  • iifNull('azure', 'data', 'factory') -> 'factory'
  • iifNull(null, 'data', 'factory') -> 'data'

initCap

initCap(<value1> : string) => string

Converte a primeira letra de cada palavra para maiúscula. As palavras são identificadas como separadas pelo espaço branco.

  • initCap('cool iceCREAM') -> 'Cool Icecream'

instr

instr(<string> : string, <substring to find> : string) => integer

Encontra a posição(1 baseada) do sublaminho dentro de uma corda. 0 é devolvido se não for encontrado.

  • instr('dumbo', 'mbo') -> 3
  • instr('microsoft', 'o') -> 5
  • instr('good', 'bad') -> 0

isDelete

isDelete([<value1> : integer]) => boolean

Verifique se a linha está marcada para apagar. Para transformações que tomem mais de um fluxo de entrada, pode passar o índice (1 base) do fluxo. O índice de fluxo deve ser 1 ou 2 e o valor predefinido é 1.

  • isDelete()
  • isDelete(1)

isError

isError([<value1> : integer]) => boolean

Verifique se a linha está marcada como erro. Para transformações que tomem mais de um fluxo de entrada, pode passar o índice (1 base) do fluxo. O índice de fluxo deve ser 1 ou 2 e o valor predefinido é 1.

  • isError()
  • isError(1)

isIgnore

isIgnore([<value1> : integer]) => boolean

Verifica se a linha está marcada para ser ignorada. Para transformações que tomem mais de um fluxo de entrada, pode passar o índice (1 base) do fluxo. O índice de fluxo deve ser 1 ou 2 e o valor predefinido é 1.

  • isIgnore()
  • isIgnore(1)

isInsert

isInsert([<value1> : integer]) => boolean

Verifique se a linha está marcada para inserção. Para transformações que tomem mais de um fluxo de entrada, pode passar o índice (1 base) do fluxo. O índice de fluxo deve ser 1 ou 2 e o valor predefinido é 1.

  • isInsert()
  • isInsert(1)

isMatch

isMatch([<value1> : integer]) => boolean

Verifica se a linha é igualada na procura. Para transformações que tomem mais de um fluxo de entrada, pode passar o índice (1 base) do fluxo. O índice de fluxo deve ser 1 ou 2 e o valor predefinido é 1.

  • isMatch()
  • isMatch(1)

isNull

isNull(<value1> : any) => boolean

Verifica se o valor é NU.

  • isNull(NULL()) -> true
  • isNull('') -> false

isUpdate

isUpdate([<value1> : integer]) => boolean

Verifique se a linha está marcada para atualização. Para transformações que tomem mais de um fluxo de entrada, pode passar o índice (1 base) do fluxo. O índice de fluxo deve ser 1 ou 2 e o valor predefinido é 1.

  • isUpdate()
  • isUpdate(1)

isUpsert

isUpsert([<value1> : integer]) => boolean

Verifique se a linha está marcada para inserção. Para transformações que tomem mais de um fluxo de entrada, pode passar o índice (1 base) do fluxo. O índice de fluxo deve ser 1 ou 2 e o valor predefinido é 1.

  • isUpsert()
  • isUpsert(1)

lastDayOfMonth

lastDayOfMonth(<value1> : datetime) => date

Recebe a última data do mês dada uma data.

  • lastDayOfMonth(toDate('2009-01-12')) -> toDate('2009-01-31')

least

least(<value1> : any, ...) => any

Comparação inferior ou igual ao operador. O mesmo que <= operador.

  • least(10, 30, 15, 20) -> 10
  • least(toDate('2010-12-12'), toDate('2011-12-12'), toDate('2000-12-12')) -> toDate('2000-12-12')

left

left(<string to subset> : string, <number of characters> : integral) => string

Extrai um início de substring no índice 1 com número de caracteres. O mesmo que SUBSTRING (str, 1, n).

  • left('bojjus', 2) -> 'bo'
  • left('bojjus', 20) -> 'bojjus'

length

length(<value1> : string) => integer

Devolve o comprimento da corda.

  • length('dumbo') -> 5

lesser

lesser(<value1> : any, <value2> : any) => boolean

Comparação menos operador. O mesmo que < operador.

  • lesser(12, 24) -> true
  • ('abcd' < 'abc') -> false
  • (toTimestamp('2019-02-03 05:19:28.871', 'yyyy-MM-dd HH:mm:ss.SSS') < toTimestamp('2019-02-05 08:21:34.890', 'yyyy-MM-dd HH:mm:ss.SSS')) -> true

lesserOrEqual

lesserOrEqual(<value1> : any, <value2> : any) => boolean

Comparação inferior ou igual ao operador. O mesmo que <= operador.

  • lesserOrEqual(12, 12) -> true
  • ('dumbo' <= 'dum') -> false

levenshtein

levenshtein(<from string> : string, <to string> : string) => integer

Obtém a distância levenshtein entre duas cordas.

  • levenshtein('boys', 'girls') -> 4

like

like(<string> : string, <pattern match> : string) => boolean

O padrão é uma corda que é correspondida literalmente. As exceções são os seguintes símbolos especiais: _ corresponde a qualquer personagem na entrada (semelhante a . em posix expressões regulares) % corresponde a zero ou mais caracteres na entrada (semelhante a .* em posix expressões regulares). O personagem de fuga é "". Se um personagem de fuga preceder um símbolo especial ou outro personagem de fuga, o seguinte personagem é combinado literalmente. É inválido escapar de qualquer outro personagem.

  • like('icecream', 'ice%') -> true

locate

locate(<substring to find> : string, <string> : string, [<from index - 1-based> : integral]) => integer

Encontra a posição(1 com base) do sublaminho dentro de uma corda que inicia uma determinada posição. Se a posição for omitida, é considerada desde o início da cadeia. 0 é devolvido se não for encontrado.

  • locate('mbo', 'dumbo') -> 3
  • locate('o', 'microsoft', 6) -> 7
  • locate('bad', 'good') -> 0

log

log(<value1> : number, [<value2> : number]) => double

Calcula o valor do registo. Uma base opcional pode ser fornecida mais um número Euler se usado.

  • log(100, 10) -> 2

log10

log10(<value1> : number) => double

Calcula o valor do registo com base em 10 base.

  • log10(100) -> 2

lower

lower(<value1> : string) => string

Minúsculas uma corda.

  • lower('GunChus') -> 'gunchus'

lpad

lpad(<string to pad> : string, <final padded length> : integral, <padding> : string) => string

A esquerda escolte a corda pelo estofamento fornecido até ter um certo comprimento. Se a corda for igual ou superior ao comprimento, então é aparada ao comprimento.

  • lpad('dumbo', 10, '-') -> '-----dumbo'
  • lpad('dumbo', 4, '-') -> 'dumb'
  • ''lpad', 8, '<>') - > '<><dumbo'``

ltrim

ltrim(<string to trim> : string, [<trim characters> : string]) => string

Esquerda apara uma série de personagens principais. Se o segundo parâmetro não for especificado, apara o espaço em branco. Caso contrário, apara qualquer personagem especificado no segundo parâmetro.

  • ltrim(' dumbo ') -> 'dumbo '
  • ltrim('!--!du!mbo!', '-!') -> 'du!mbo!'

md5

md5(<value1> : any, ...) => string

Calcula a digestão MD5 de conjunto de colunas de tipos de dados primitivos variados e devolve uma cadeia hexagonal de 32 caracteres. Pode ser usado para calcular uma impressão digital por uma linha.

  • md5(5, 'gunchus', 8.2, 'bojjus', true, toDate('2010-4-4')) -> '4ce8a880bd621a1ffad0bca905e1bc5a'

millisecond

millisecond(<value1> : timestamp, [<value2> : string]) => integer

Obtém o valor milissegundo de uma data. Você pode passar um timezone opcional sob a forma de 'GMT', 'PST', 'UTC', 'America/Cayman'. O intervalo local é usado como padrão. Consulte a classe de Java SimpleDateFormat para formatos disponíveis. https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html.

  • millisecond(toTimestamp('2009-07-30 12:58:59.871', 'yyyy-MM-dd HH:mm:ss.SSS')) -> 871

milliseconds

milliseconds(<value1> : integer) => long

Duração em milissegundos para o número de milissegundos.

  • milliseconds(2) -> 2L

minus

minus(<value1> : any, <value2> : any) => any

Subtrai os números. Subtraia o número de dias de uma data. Subtrair a duração de uma hora. Subtrair dois vezes para obter a diferença em milissegundos. O mesmo que o operador.

  • minus(20, 10) -> 10
  • 20 - 10 -> 10
  • minus(toDate('2012-12-15'), 3) -> toDate('2012-12-12')
  • toDate('2012-12-15') - 3 -> toDate('2012-12-12')
  • toTimestamp('2019-02-03 05:19:28.871', 'yyyy-MM-dd HH:mm:ss.SSS') + (days(1) + hours(2) - seconds(10)) -> toTimestamp('2019-02-04 07:19:18.871', 'yyyy-MM-dd HH:mm:ss.SSS')
  • toTimestamp('2019-02-03 05:21:34.851', 'yyyy-MM-dd HH:mm:ss.SSS') - toTimestamp('2019-02-03 05:21:36.923', 'yyyy-MM-dd HH:mm:ss.SSS') -> -2072

minute

minute(<value1> : timestamp, [<value2> : string]) => integer

Obtém o valor minúsculo de um tempotando. Você pode passar um timezone opcional sob a forma de 'GMT', 'PST', 'UTC', 'America/Cayman'. O intervalo local é usado como padrão. Consulte a classe de Java SimpleDateFormat para formatos disponíveis. https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html.

  • minute(toTimestamp('2009-07-30 12:58:59')) -> 58
  • minute(toTimestamp('2009-07-30 12:58:59'), 'PST') -> 58

minutes

minutes(<value1> : integer) => long

Duração em milissegundos durante o número de minutos.

  • minutes(2) -> 120000L

mod

mod(<value1> : any, <value2> : any) => any

Modulus de par de números. O mesmo que o operador de %.

  • mod(20, 8) -> 4
  • 20 % 8 -> 4

month

month(<value1> : datetime) => integer

Obtém o valor mensal de uma data ou hora marcada.

  • month(toDate('2012-8-8')) -> 8

monthsBetween

monthsBetween(<from date/timestamp> : datetime, <to date/timestamp> : datetime, [<roundoff> : boolean], [<time zone> : string]) => double

Obtém o número de meses entre dois encontros. Pode completar os cálculos. Você pode passar um timezone opcional sob a forma de 'GMT', 'PST', 'UTC', 'America/Cayman'. O intervalo local é usado como padrão. Consulte a classe de Java SimpleDateFormat para formatos disponíveis. https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html.

  • monthsBetween(toTimestamp('1997-02-28 10:30:00'), toDate('1996-10-30')) -> 3.94959677

multiply

multiply(<value1> : any, <value2> : any) => any

Multiplica o par de números. O mesmo que o operador.

  • multiply(20, 10) -> 200
  • 20 * 10 -> 200

negate

negate(<value1> : number) => number

Nega um número. Transforma os números positivos em negativos e vice-versa.

  • negate(13) -> -13

nextSequence

nextSequence() => long

Devolve a próxima sequência única. O número é consecutivo apenas dentro de uma divisória e é prefixado pela partitionId.

  • nextSequence() == 12313112 -> false

normalize

normalize(<String to normalize> : string) => string

Normaliza o valor das cordas para separar caracteres de unicódigo acentuados.

  • regexReplace(normalize('bo²s'), `\p{M}`, '') -> 'boys'

not

not(<value1> : boolean) => boolean

Operador de negação lógica.

  • not(true) -> false
  • not(10 == 20) -> true

notEquals

notEquals(<value1> : any, <value2> : any) => boolean

A comparação não é igual a operador. O mesmo que != operador.

  • 12 != 24 -> true
  • 'bojjus' != 'bo' + 'jjus' -> false

notNull

notNull(<value1> : any) => boolean

Verifica se o valor não é NULO.

  • notNull(NULL()) -> false
  • notNull('') -> true

null

null() => null

Devolve um valor NUDO. Utilize a função syntax(null()) se houver uma coluna chamada "nulo". Qualquer operação que utilize resultará num NULO.

  • isNull('dumbo' + null) -> true
  • isNull(10 * null) -> true
  • isNull('') -> false
  • isNull(10 + 20) -> false
  • isNull(10/0) -> true

or

or(<value1> : boolean, <value2> : boolean) => boolean

Operador de OR lógico. O mesmo que ||.

  • or(true, false) -> true
  • true || false -> true

pMod

pMod(<value1> : any, <value2> : any) => any

Modulus positivo de par de números.

  • pmod(-20, 8) -> 4

partitionId

partitionId() => integer

Devolve a partição atual id em que a linha de entrada está dentro.

  • partitionId()

power

power(<value1> : number, <value2> : number) => double

Eleva um número ao poder de outro.

  • power(10, 2) -> 100

random

random(<value1> : integral) => long

Devolve um número aleatório dado uma semente opcional dentro de uma divisória. A semente deve ser um valor fixo e é usada em conjunto com a partitionId para produzir valores aleatórios * random(1) == 1 -> false


regexExtract

regexExtract(<string> : string, <regex to find> : string, [<match group 1-based index> : integral]) => string

Extraia um sub-eixo correspondente para um determinado padrão regx. O último parâmetro identifica o grupo de correspondência e é incumprido para 1 se omitido. Utilize ' (citação traseira) para combinar com uma corda sem escapar.

  • regexExtract('Cost is between 600 and 800 dollars', '(\\d+) and (\\d+)', 2) -> '800'
  • regexExtract('Cost is between 600 and 800 dollars', `(\d+) and (\d+)`, 2) -> '800'

regexMatch

regexMatch(<string> : string, <regex to match> : string) => boolean

Verifica se a corda corresponde ao padrão regex dado. Utilize ' (citação traseira) para combinar com uma corda sem escapar.

  • regexMatch('200.50', '(\\d+).(\\d+)') -> true
  • regexMatch('200.50', `(\d+).(\d+)`) -> true

regexReplace

regexReplace(<string> : string, <regex to find> : string, <substring to replace> : string) => string

Substitua todas as ocorrências de um padrão regex por outro sub-eixo na corda dada Use ' (citação traseira) para combinar com uma corda sem escapar.

  • regexReplace('100 and 200', '(\\d+)', 'bojjus') -> 'bojjus and bojjus'
  • regexReplace('100 and 200', `(\d+)`, 'gunchus') -> 'gunchus and gunchus'

regexSplit

regexSplit(<string to split> : string, <regex expression> : string) => array

Divide uma corda baseada num limonteiro baseado no regex e devolve uma variedade de cordas.

  • regexSplit('bojjusAgunchusBdumbo', `[CAB]`) -> ['bojjus', 'gunchus', 'dumbo']
  • regexSplit('bojjusAgunchusBdumboC', `[CAB]`) -> ['bojjus', 'gunchus', 'dumbo', '']
  • (regexSplit('bojjusAgunchusBdumboC', `[CAB]`)[1]) -> 'bojjus'
  • isNull(regexSplit('bojjusAgunchusBdumboC', `[CAB]`)[20]) -> true

replace

replace(<string> : string, <substring to find> : string, [<substring to replace> : string]) => string

Substitua todas as ocorrências de um sublamamento por outro sublípesto na corda dada. Se o último parâmetro for omitido, é padrão para a corda vazia.

  • replace('doggie dog', 'dog', 'cat') -> 'catgie cat'
  • replace('doggie dog', 'dog', '') -> 'gie '
  • replace('doggie dog', 'dog') -> 'gie '

reverse

reverse(<value1> : string) => string

Inverte uma corda.

  • reverse('gunchus') -> 'suhcnug'

right(<string to subset> : string, <number of characters> : integral) => string

Extrai um sub-adc de posição com número de caracteres da direita. O mesmo que SUBSTRING (str, LENGTH(str) - n, n).

  • right('bojjus', 2) -> 'us'
  • right('bojjus', 20) -> 'bojjus'

rlike

rlike(<string> : string, <pattern match> : string) => boolean

Verifica se a corda corresponde ao padrão regex dado.

  • rlike('200.50', `(\d+).(\d+)`) -> true
  • rlike('bogus', `M[0-9]+.*`) -> false

round

round(<number> : number, [<scale to round> : number], [<rounding option> : integral]) => double

Arredonda um número dado uma escala opcional e um modo de arredondamento opcional. Se a balança for omitida, é desagredida a 0. Se o modo for omitido, é incumprido ROUND_HALF_UP(5). Os valores para arredondamento incluem 1 - ROUND_UP 2 - ROUND_DOWN 3 - ROUND_CEILING 4 - ROUND_FLOOR 5 - ROUND_HALF_UP 6 - ROUND_HALF_DOWN 7 - ROUND_HALF_EVEN 8 - ROUND_UNNECESSARY.

  • round(100.123) -> 100.0
  • round(2.5, 0) -> 3.0
  • round(5.3999999999999995, 2, 7) -> 5.40

rpad

rpad(<string to pad> : string, <final padded length> : integral, <padding> : string) => string

A direita encolhia a corda pelo estofamento fornecido até ter um certo comprimento. Se a corda for igual ou superior ao comprimento, então é aparada ao comprimento.

  • rpad('dumbo', 10, '-') -> 'dumbo-----'
  • rpad('dumbo', 4, '-') -> 'dumb'
  • rpad('dumbo', 8, '<>') -> 'dumbo<><'

rtrimrtrim

rtrim(<string to trim> : string, [<trim characters> : string]) => string

A direita apara uma série de personagens em fuga. Se o segundo parâmetro não for especificado, apara o espaço em branco. Caso contrário, apara qualquer personagem especificado no segundo parâmetro.

  • rtrim(' dumbo ') -> ' dumbo'
  • rtrim('!--!du!mbo!', '-!') -> '!--!du!mbo'

second

second(<value1> : timestamp, [<value2> : string]) => integer

Obtém o segundo valor de uma data. Você pode passar um timezone opcional sob a forma de 'GMT', 'PST', 'UTC', 'America/Cayman'. O intervalo local é usado como padrão. Consulte a classe de Java SimpleDateFormat para formatos disponíveis. https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html.

  • second(toTimestamp('2009-07-30 12:58:59')) -> 59

seconds

seconds(<value1> : integer) => long

Duração em milissegundos durante o número de segundos.

  • seconds(2) -> 2000L

sha1

sha1(<value1> : any, ...) => string

Calcula a digestão SHA-1 de conjunto de colunas de tipos de dados primitivos variados e devolve uma cadeia hexagonal de 40 caracteres. Pode ser usado para calcular uma impressão digital por uma linha.

  • sha1(5, 'gunchus', 8.2, 'bojjus', true, toDate('2010-4-4')) -> '46d3b478e8ec4e1f3b453ac3d8e59d5854e282bb'

sha2

sha2(<value1> : integer, <value2> : any, ...) => string

Calcula a digestão SHA-2 de conjunto de colunas de dados primitivos variados, dado um pouco de comprimento que só pode ser dos valores 0(256), 224, 256, 384, 512. Pode ser usado para calcular uma impressão digital por uma linha.

  • sha2(256, 'gunchus', 8.2, 'bojjus', true, toDate('2010-4-4')) -> 'afe8a553b1761c67d76f8c31ceef7f71b66a1ee6f4e6d3b5478bf68b47d06bd3'

sin

sin(<value1> : number) => double

Calcula um valor seno.

  • sin(2) -> 0.9092974268256817

sinh

sinh(<value1> : number) => double

Calcula um valor hiperbólico de seno.

  • sinh(0) -> 0.0

soundex

soundex(<value1> : string) => string

Obtém o soundex código da cadeia.

  • soundex('genius') -> 'G520'

split

split(<string to split> : string, <split characters> : string) => array

Divide uma corda com base num delimiter e devolve uma série de cordas.

  • split('bojjus,guchus,dumbo', ',') -> ['bojjus', 'guchus', 'dumbo']
  • split('bojjus,guchus,dumbo', '|') -> ['bojjus,guchus,dumbo']
  • split('bojjus, guchus, dumbo', ', ') -> ['bojjus', 'guchus', 'dumbo']
  • split('bojjus, guchus, dumbo', ', ')[1] -> 'bojjus'
  • isNull(split('bojjus, guchus, dumbo', ', ')[0]) -> true
  • isNull(split('bojjus, guchus, dumbo', ', ')[20]) -> true
  • split('bojjusguchusdumbo', ',') -> ['bojjusguchusdumbo']

sqrt

sqrt(<value1> : number) => double

Calcula a raiz quadrada de um número.

  • sqrt(9) -> 3

startsWith

startsWith(<string> : string, <substring to check> : string) => boolean

Verifique se a corda começa com a corda fornecida.

  • startsWith('dumbo', 'du') -> true

subDays

subDays(<date/timestamp> : datetime, <days to subtract> : integral) => datetime

Subtrair dias a partir de uma data ou hora marcada. O mesmo que o operador para a data.

  • subDays(toDate('2016-08-08'), 1) -> toDate('2016-08-07')

subMonths

subMonths(<date/timestamp> : datetime, <months to subtract> : integral) => datetime

Subtrair meses de uma data ou hora marcada.

  • subMonths(toDate('2016-09-30'), 1) -> toDate('2016-08-31')

substring

substring(<string to subset> : string, <from 1-based index> : integral, [<number of characters> : integral]) => string

Extrai um sublaminho de um certo comprimento de uma posição. A posição é 1 baseada. Se o comprimento for omitido, é padrão para a extremidade da corda.

  • substring('Cat in the hat', 5, 2) -> 'in'
  • substring('Cat in the hat', 5, 100) -> 'in the hat'
  • substring('Cat in the hat', 5) -> 'in the hat'
  • substring('Cat in the hat', 100, 100) -> ''

tan

tan(<value1> : number) => double

Calcula um valor tangente.

  • tan(0) -> 0.0

tanh

tanh(<value1> : number) => double

Calcula um valor tangente hiperbólico.

  • tanh(0) -> 0.0

translate

translate(<string to translate> : string, <lookup characters> : string, <replace characters> : string) => string

Substitua um conjunto de caracteres por outro conjunto de caracteres na corda. Os caracteres têm 1 a 1 substituição.

  • translate('(bojjus)', '()', '[]') -> '[bojjus]'
  • translate('(gunchus)', '()', '[') -> '[gunchus'

trim

trim(<string to trim> : string, [<trim characters> : string]) => string

Apara uma série de personagens principais e em fuga. Se o segundo parâmetro não for especificado, apara o espaço em branco. Caso contrário, apara qualquer personagem especificado no segundo parâmetro.

  • trim(' dumbo ') -> 'dumbo'
  • trim('!--!du!mbo!', '-!') -> 'du!mbo'

true

true() => boolean

Sempre devolve um valor verdadeiro. Utilize a função syntax(true()) se houver uma coluna chamada "verdadeira".

  • (10 + 20 == 30) -> true
  • (10 + 20 == 30) -> true()

typeMatch

typeMatch(<type> : string, <base type> : string) => boolean

Corresponde ao tipo da coluna. Só pode ser usado em expressões de padrão.número corresponde curto, inteiro, longo, duplo, flutuante ou decimal, combinações integrais curtas, inteiros, longas, fracionárias partidas duplas, flutuantes, decimais e datas de data tipo de data ou tipo de hora limite.

  • typeMatch(type, 'number')
  • typeMatch('date', 'datetime')

unescape

unescape(<string_to_escape> : string, <format> : string) => string

Unescapes uma corda de acordo com um formato. Os valores literais para formato aceitável são 'json', 'xml', 'ecmascript', 'html', 'java'.

  • unescape('{\\\\\"value\\\\\": 10}', 'json')
  • '{\\\"value\\\": 10}'

upper

upper(<value1> : string) => string

Maiúsculas uma corda.

  • upper('bojjus') -> 'BOJJUS'

uuid

uuid() => string

Devolve o UUID gerado.

  • uuid()

weekOfYear

weekOfYear(<value1> : datetime) => integer

Recebe a semana do ano dada uma data.

  • weekOfYear(toDate('2008-02-20')) -> 8

weeks

weeks(<value1> : integer) => long

Duração em milissegundos durante o número de semanas.

  • weeks(2) -> 1209600000L

xor

xor(<value1> : boolean, <value2> : boolean) => boolean

Operador lógico XOR. O mesmo que ^ operador.

  • xor(true, false) -> true
  • xor(true, true) -> false
  • true ^ false -> true

year

year(<value1> : datetime) => integer

Obtém o valor do ano de uma data.

  • year(toDate('2012-8-8')) -> 2012

Funções de agregação

As seguintes funções só estão disponíveis em transformações agregadas, pivôs, não-marfim e janelas.


avg

avg(<value1> : number) => number

Obtém a média de valores de uma coluna.

  • avg(sales)

avgIf

avgIf(<value1> : boolean, <value2> : number) => number

Com base num critério obtém a média de valores de uma coluna.

  • avgIf(region == 'West', sales)

collect

collect(<value1> : any) => array

Recolhe todos os valores da expressão no grupo agregado numa matriz. As estruturas podem ser recolhidas e transformadas em estruturas alternativas durante este processo. O número de itens será igual ao número de linhas nesse grupo e pode conter valores nulos. O número de artigos recolhidos deve ser reduzido.

  • collect(salesPerson)
  • collect(firstName + lastName))
  • collect(@(name = salesPerson, sales = salesAmount) )

count

count([<value1> : any]) => long

Obtém a contagem agregada de valores. Se a coluna(s) opcional for especificada, ignora os valores NULOS na contagem.

  • count(custId)
  • count(custId, custName)
  • count()
  • count(iif(isNull(custId), 1, NULL))

countDistinct

countDistinct(<value1> : any, [<value2> : any], ...) => long

Obtém a contagem agregada de valores distintos de um conjunto de colunas.

  • countDistinct(custId, custName)

countIf

countIf(<value1> : boolean, [<value2> : any]) => long

Com base num critério obtém-se a contagem agregada de valores. Se a coluna opcional for especificada, ignora os valores NULOS na contagem.

  • countIf(state == 'CA' && commission < 10000, name)

covariancePopulation

covariancePopulation(<value1> : number, <value2> : number) => double

Obtém a covariância populacional entre duas colunas.

  • covariancePopulation(sales, profit)

covariancePopulationIf

covariancePopulationIf(<value1> : boolean, <value2> : number, <value3> : number) => double

Com base num critério, obtém a covariância populacional de duas colunas.

  • covariancePopulationIf(region == 'West', sales)

covarianceSample

covarianceSample(<value1> : number, <value2> : number) => double

Obtém a amostra de covariância de duas colunas.

  • covarianceSample(sales, profit)

covarianceSampleIf

covarianceSampleIf(<value1> : boolean, <value2> : number, <value3> : number) => double

Com base num critério, obtém a amostra de covariância de duas colunas.

  • covarianceSampleIf(region == 'West', sales, profit)

first

first(<value1> : any, [<value2> : boolean]) => any

Obtém o primeiro valor de um grupo de colunas. Se o segundo parâmetro ignorarNulls é omitido, é assumido falso.

  • first(sales)
  • first(sales, false)

isDistinct

isDistinct(<value1> : any , <value1> : any) => boolean

Descobre se uma coluna ou conjunto de colunas é distinto. Não conta nulo como um valor distinto * isDistinct(custId, custName) => boolean


kurtosis

kurtosis(<value1> : number) => double

Fica com a kurtose de uma coluna.

  • kurtosis(sales)

kurtosisIf

kurtosisIf(<value1> : boolean, <value2> : number) => double

Com base num critério, obtém a kurtose de uma coluna.

  • kurtosisIf(region == 'West', sales)

last

last(<value1> : any, [<value2> : boolean]) => any

Obtém o último valor de um grupo de colunas. Se o segundo parâmetro ignorarNulls é omitido, é assumido falso.

  • last(sales)
  • last(sales, false)

max

max(<value1> : any) => any

Obtém o valor máximo de uma coluna.

  • max(sales)

maxIf

maxIf(<value1> : boolean, <value2> : any) => any

Com base num critério, obtém o valor máximo de uma coluna.

  • maxIf(region == 'West', sales)

mean

mean(<value1> : number) => number

Obtém a média dos valores de uma coluna. O mesmo que a AVG.

  • mean(sales)

meanIf

meanIf(<value1> : boolean, <value2> : number) => number

Com base num critério obtém-se a média de valores de uma coluna. O mesmo que avgIf.

  • meanIf(region == 'West', sales)

min

min(<value1> : any) => any

Obtém o valor mínimo de uma coluna.

  • min(sales)

minIf

minIf(<value1> : boolean, <value2> : any) => any

Com base num critério, obtém o valor mínimo de uma coluna.

  • minIf(region == 'West', sales)

skewness

skewness(<value1> : number) => double

Fica com a vermelhidão de uma coluna.

  • skewness(sales)

skewnessIf

skewnessIf(<value1> : boolean, <value2> : number) => double

Com base num critério, obtém-se a distorção de uma coluna.

  • skewnessIf(region == 'West', sales)

stddev

stddev(<value1> : number) => double

Obtém o desvio padrão de uma coluna.

  • stdDev(sales)

stddevIf

stddevIf(<value1> : boolean, <value2> : number) => double

Com base num critério, obtém o desvio padrão de uma coluna.

  • stddevIf(region == 'West', sales)

stddevPopulation

stddevPopulation(<value1> : number) => double

Obtém o desvio padrão da população de uma coluna.

  • stddevPopulation(sales)

stddevPopulationIf

stddevPopulationIf(<value1> : boolean, <value2> : number) => double

Com base num critério, obtém o desvio padrão da população de uma coluna.

  • stddevPopulationIf(region == 'West', sales)

stddevSample

stddevSample(<value1> : number) => double

Obtém o desvio padrão da amostra de uma coluna.

  • stddevSample(sales)

stddevSampleIf

stddevSampleIf(<value1> : boolean, <value2> : number) => double

Com base num critério, obtém-se o desvio padrão da amostra de uma coluna.

  • stddevSampleIf(region == 'West', sales)

sum

sum(<value1> : number) => number

Recebe a soma agregada de uma coluna numérica.

  • sum(col)

sumDistinct

sumDistinct(<value1> : number) => number

Obtém a soma agregada de valores distintos de uma coluna numérica.

  • sumDistinct(col)

sumDistinctIf

sumDistinctIf(<value1> : boolean, <value2> : number) => number

Com base em critérios obtém a soma agregada de uma coluna numérica. A condição pode ser baseada em qualquer coluna.

  • sumDistinctIf(state == 'CA' && commission < 10000, sales)
  • sumDistinctIf(true, sales)

sumIf

sumIf(<value1> : boolean, <value2> : number) => number

Com base em critérios obtém a soma agregada de uma coluna numérica. A condição pode ser baseada em qualquer coluna.

  • sumIf(state == 'CA' && commission < 10000, sales)
  • sumIf(true, sales)

variance

variance(<value1> : number) => double

Obtém a variância de uma coluna.

  • variance(sales)

varianceIf

varianceIf(<value1> : boolean, <value2> : number) => double

Com base num critério, obtém-se a variação de uma coluna.

  • varianceIf(region == 'West', sales)

variancePopulation

variancePopulation(<value1> : number) => double

Obtém a variação populacional de uma coluna.

  • variancePopulation(sales)

variancePopulationIf

variancePopulationIf(<value1> : boolean, <value2> : number) => double

Com base num critério, obtém a variação populacional de uma coluna.

  • variancePopulationIf(region == 'West', sales)

varianceSample

varianceSample(<value1> : number) => double

Obtém a variação imparcial de uma coluna.

  • varianceSample(sales)

varianceSampleIf

varianceSampleIf(<value1> : boolean, <value2> : number) => double

Com base num critério, obtém-se a variação imparcial de uma coluna.

  • varianceSampleIf(region == 'West', sales)

Funções de matriz

As funções de matriz realizam transformações em estruturas de dados que são matrizes. Estas incluem palavras-chave especiais para abordar elementos de matriz e índices:

  • #acc representa um valor que deseja incluir na sua única saída ao reduzir uma matriz
  • #index representa o índice de matriz atual, juntamente com os números do índice de matriz #index2, #index3 ...
  • #item representa o valor do elemento atual na matriz

array

array([<value1> : any], ...) => array

Cria uma variedade de itens. Todos os itens devem ser do mesmo tipo. Se não forem especificados itens, um conjunto de cordas vazio é o padrão. O mesmo que um operador de criação.

  • array('Seattle', 'Washington')
  • ['Seattle', 'Washington']
  • ['Seattle', 'Washington'][1]
  • 'Washington'

contains

contains(<value1> : array, <value2> : unaryfunction) => boolean

Retorna verdadeira se qualquer elemento na matriz fornecida avaliar como verdadeiro no predicado fornecido. Contém espera uma referência a um elemento na função predicado como #item.

  • contains([1, 2, 3, 4], #item == 3) -> true
  • contains([1, 2, 3, 4], #item > 5) -> false

filter

filter(<value1> : array, <value2> : unaryfunction) => array

Filtra elementos fora da matriz que não satisfazem o predicado fornecido. O filtro espera uma referência a um elemento na função predicado como #item.

  • filter([1, 2, 3, 4], #item > 2) -> [3, 4]
  • filter(['a', 'b', 'c', 'd'], #item == 'a' || #item == 'b') -> ['a', 'b']

find

find(<value1> : array, <value2> : unaryfunction) => any

Encontre o primeiro item de uma matriz que corresponda à condição. É necessário uma função de filtro onde pode endereçar o item na matriz à medida que #item. Para mapas profundamente aninhados, você pode se referir aos mapas dos pais usando a notação #item_n (#item_1, #item_2...).

  • find([10, 20, 30], #item > 10) -> 20
  • find(['azure', 'data', 'factory'], length(#item) > 4) -> 'azure'
  • find([ @( name = 'Daniel', types = [ @(mood = 'jovial', behavior = 'terrific'), @(mood = 'grumpy', behavior = 'bad') ] ), @( name = 'Mark', types = [ @(mood = 'happy', behavior = 'awesome'), @(mood = 'calm', behavior = 'reclusive') ] ) ], contains(#item.types, #item.mood=='happy') /*Filter out the happy kid*/ )
  • @( name = 'Mark', types = [ @(mood = 'happy', behavior = 'awesome'), @(mood = 'calm', behavior = 'reclusive') ] )

in

in(<array of items> : array, <item to find> : any) => boolean</código>

Verifica se um item is in the array.

  • in([10, 20, 30], 10) -> true
  • in(['good', 'kid'], 'bad') -> false

map

map(<value1> : array, <value2> : unaryfunction) => any</código>

Mapeia cada elemento da matriz para um novo elemento usando a expressão fornecida. Mapa espera uma referência a um elemento na expressão function as #item.

  • map([1, 2, 3, 4], #item + 2) -> [3, 4, 5, 6]
  • map(['a', 'b', 'c', 'd'], #item + '_processed') -> ['a_processed', 'b_processed', 'c_processed', 'd_processed']

mapIf

mapIf (<value1> : array, <value2> : binaryfunction, <value3>: binaryFunction) => any</código>

Mapas condicionalmente uma matriz para outra matriz de comprimento igual ou menor. Os valores podem ser de qualquer tipo de dados, incluindo tipos de estrutura. Requer uma função de mapeamento onde pode endereçar o item na matriz como #item e índice atual como #index. Para mapas profundamente aninhados, você pode se referir ao paren t maps using the #item_[n](#item_1 , #index_1...) notation.

  • mapIf([10, 20, 30], #item > 10, #item + 5) -> [25, 35]
  • mapIf(['icecream', 'cake', 'soda'], length(#item) > 4, upper(#item)) -> ['ICECREAM', 'CAKE']

mapIndex

mapIndex(<value1> : array, <value2> : binaryfunction) => any</código>

Mapeia cada elemento da matriz para um novo elemento usando a expressão fornecida. O mapa espera uma referência a um elemento na função de expressão como #item e uma referência ao elemento index as #index.

  • mapIndex([1, 2, 3, 4], #item + 2 + #index) -> [4, 6, 8, 10]

mapLoop

mapLoop(<value1> : integer, <value2> : unaryfunction) => any</código>

Loops através de 1 para comprimento para criar uma matriz desse comprimento. É necessária uma função de mapeamento onde pode abordar o índice na matriz à medida que #index. Para mapas profundamente aninhados, você pode consultar os mapas dos pais usando o #index_n (#index_1, #index_2...) notation.

  • mapLoop(3, #index * 10) -> [10, 20, 30]

reduce

reduce(<value1> : array, <value2> : any, <value3> : binaryfunction, <value4> : unaryfunction) => any</código>

Acumula elementos numa matriz. Reduzir espera uma referência a um acumulador e um elemento na primeira função de expressão como #acc e #item e espera que o valor resultante como #result seja usado no segundo expression function.

  • toString(reduce(['1', '2', '3', '4'], '0', #acc + #item, #result)) -> '01234'

size

size(<value1> : any) => integer</código>

Encontra o tamanho de um array or map type

  • size(['element1', 'element2']) -> 2
  • size([1,2,3]) -> 3

slice

slice(<array to slice> : array, <from 1-based index> : integral, [<number of items> : integral]) => array</código>

Extrai um subconjunto de uma matriz a partir de uma posição. A posição é 1 baseada. Se o comprimento for omitido, é incumprido para end of the string.

  • slice([10, 20, 30, 40], 1, 2) -> [10, 20]
  • slice([10, 20, 30, 40], 2) -> [20, 30, 40]
  • slice([10, 20, 30, 40], 2)[1] -> 20
  • isNull(slice([10, 20, 30, 40], 2)[0]) -> true
  • isNull(slice([10, 20, 30, 40], 2)[20]) -> true
  • slice(['a', 'b', 'c', 'd'], 8) -> []

sort

sort(<value1> : array, <value2> : binaryfunction) => array</código>

Classifica a matriz utilizando a função predicado fornecida. O Sort espera uma referência a dois elementos consecutivos na função de expressão como #item1 and #item2.

  • sort([4, 8, 2, 3], compare(#item1, #item2)) -> [2, 3, 4, 8]
  • sort(['a3', 'b2', 'c1'], iif(right(#item1, 1) >= right(#item2, 1), 1, -1)) -> ['c1', 'b2', 'a3']* @( name = 'Mark', types = [ @(mood = 'happy', behavior = 'awesome'), @(mood = 'calm', behavior = 'reclusive') ] )

in

in(<array of items> : array, <item to find> : any) => boolean

Checks if an item is in the array.

  • in([10, 20, 30], 10) -> true
  • in(['good', 'kid'], 'bad') -> false

map

map(<value1> : array, <value2> : unaryfunction) => any

Maps each element of the array to a new element using the provided expression. Map expects a reference to one element in the expression function as #item.

  • map([1, 2, 3, 4], #item + 2) -> [3, 4, 5, 6]
  • map(['a', 'b', 'c', 'd'], #item + '_processed') -> ['a_processed', 'b_processed', 'c_processed', 'd_processed']

mapIf

mapIf (<value1> : array, <value2> : binaryfunction, <value3>: binaryFunction) => any

Conditionally maps an array to another array of same or smaller length. The values can be of any datatype including structTypes. It takes a mapping function where you can address the item in the array as #item and current index as #index. For deeply nested maps you can refer to the parent maps using the #item_[n](#item_1, #index_1...) notation.

  • mapIf([10, 20, 30], #item > 10, #item + 5) -> [25, 35]
  • mapIf(['icecream', 'cake', 'soda'], length(#item) > 4, upper(#item)) -> ['ICECREAM', 'CAKE']

mapIndex

mapIndex(<value1> : array, <value2> : binaryfunction) => any

Maps each element of the array to a new element using the provided expression. Map expects a reference to one element in the expression function as #item and a reference to the element index as #index.

  • mapIndex([1, 2, 3, 4], #item + 2 + #index) -> [4, 6, 8, 10]

mapLoop

mapLoop(<value1> : integer, <value2> : unaryfunction) => any

Loops through from 1 to length to create an array of that length. It takes a mapping function where you can address the index in the array as #index. For deeply nested maps you can refer to the parent maps using the #index_n(#index_1, #index_2...) notation.

  • mapLoop(3, #index * 10) -> [10, 20, 30]

reduce

reduce(<value1> : array, <value2> : any, <value3> : binaryfunction, <value4> : unaryfunction) => any

Accumulates elements in an array. Reduce expects a reference to an accumulator and one element in the first expression function as #acc and #item and it expects the resulting value as #result to be used in the second expression function.

  • toString(reduce(['1', '2', '3', '4'], '0', #acc + #item, #result)) -> '01234'

size

size(<value1> : any) => integer

Finds the size of an array or map type

  • size(['element1', 'element2']) -> 2
  • size([1,2,3]) -> 3

slice

slice(<array to slice> : array, <from 1-based index> : integral, [<number of items> : integral]) => array

Extracts a subset of an array from a position. Position is 1 based. If the length is omitted, it is defaulted to end of the string.

  • slice([10, 20, 30, 40], 1, 2) -> [10, 20]
  • slice([10, 20, 30, 40], 2) -> [20, 30, 40]
  • slice([10, 20, 30, 40], 2)[1] -> 20
  • isNull(slice([10, 20, 30, 40], 2)[0]) -> true
  • isNull(slice([10, 20, 30, 40], 2)[20]) -> true
  • slice(['a', 'b', 'c', 'd'], 8) -> []

sort

sort(<value1> : array, <value2> : binaryfunction) => array

Sorts the array using the provided predicate function. Sort expects a reference to two consecutive elements in the expression function as #item1 and #item2.

  • sort([4, 8, 2, 3], compare(#item1, #item2)) -> [2, 3, 4, 8]
  • sort(['a3', 'b2', 'c1'], iif(right(#item1, 1) >= right(#item2, 1), 1, -1)) -> ['c1', 'b2', 'a3']

Funções de procura em cache

As seguintes funções só estão disponíveis quando se utiliza uma procura em cache quando tiver incluído uma pia em cache.


lookup

lookup(key, key2, ...) => complex[]

Procura a primeira linha da pia em cache usando as teclas especificadas que combinam com as chaves da pia em cache.

  • cacheSink#lookup(movieId)

mlookup

mlookup(key, key2, ...) => complex[]

Procura todas as linhas correspondentes da pia em cache usando as teclas especificadas que combinam com as chaves da pia em cache.

  • cacheSink#mlookup(movieId)

output

output() => any

Devolve a primeira linha dos resultados da pia cache * cacheSink#output()


outputs

output() => any

Devolve todo o conjunto de linha de saída dos resultados da pia cache * cacheSink#outputs()


Funções de conversão

As funções de conversão são usadas para converter dados e testar tipos de dados

isBitSet

isBitSet (<value1> : array, <value2>:integer ) => boolean

Verifica se uma posição de um pouco é definida neste conjunto * isBitSet(toBitSet([10, 32, 98]), 10) => true


setBitSet

setBitSet (<value1>: array, <value2>:array) => array

Define posições de bit neste conjunto * setBitSet(toBitSet([10, 32]), [98]) => [4294968320L, 17179869184L]


isBoolean

isBoolean(<value1>: string) => boolean

Verifica se o valor da corda é um valor boolean de acordo com as regras de toBoolean()

  • isBoolean('true') -> true
  • isBoolean('no') -> true
  • isBoolean('microsoft') -> false

isByte

isByte(<value1> : string) => boolean

Verifica se o valor da cadeia é um valor byte dado um formato opcional de acordo com as regras de toByte()

  • isByte('123') -> true
  • isByte('chocolate') -> false

isDate

isDate (<value1> : string, [: string]) => boolean

Verifique se a cadeia de data de entrada é uma data utilizando um formato de data de entrada opcional. Consulte o SimpleDateFormat da Java para os formatos disponíveis. Se o formato da data de entrada for omitido, o formato predefinido é yyyy-[M]M-[d]d . Os formatos aceites são [ yyyy, yyyy-[M]M, yyyy-[M]M-[d]d, yyyy-[M]M-[d]dT* ]

  • isDate('2012-8-18') -> true
  • isDate('12/18--234234' -> 'MM/dd/yyyy') -> false

isShort

isShort (<value1> : string, [: string]) => boolean

Verificações do valor da cadeia é um valor curto dado um formato opcional de acordo com as regras de toShort()

  • isShort('123') -> true
  • isShort('$123' -> '$###') -> true
  • isShort('microsoft') -> false

isInteger

isInteger (<value1> : string, [: string]) => boolean

Verificação do valor da cadeia é um valor inteiro dado um formato opcional de acordo com as regras de toInteger()

  • isInteger('123') -> true
  • isInteger('$123' -> '$###') -> true
  • isInteger('microsoft') -> false

isLong

isLong (<value1> : string, [: string]) => boolean

Verificações do valor da cadeia é um valor longo dado um formato opcional de acordo com as regras de toLong()

  • isLong('123') -> true
  • isLong('$123' -> '$###') -> true
  • isLong('gunchus') -> false

isFloat

isFloat (<value1> : string, [: string]) => boolean

Verificações do valor da cadeia é um valor flutuante dado um formato opcional de acordo com as regras de toFloat()

  • isFloat('123') -> true
  • isFloat('$123.45' -> '$###.00') -> true
  • isFloat('icecream') -> false

isDouble

isDouble (<value1> : string, [: string]) => boolean

Verificações do valor da cadeia é um valor duplo dado um formato opcional de acordo com as regras de toDouble()

  • isDouble('123') -> true
  • isDouble('$123.45' -> '$###.00') -> true
  • isDouble('icecream') -> false

isDecimal

isDecimal (<value1> : string) => boolean

Verificação do valor da cadeia é um valor decimal dado um formato opcional de acordo com as regras de toDecimal()

  • isDecimal('123.45') -> true
  • isDecimal('12/12/2000') -> false

isTimestamp

isTimestamp (<value1> : string, [: string]) => boolean

Verifique se a cadeia de data de entrada é um timetamp utilizando um formato de tempo de entrada opcional. Consulte o SimpleDateFormat da Java para obter formatos disponíveis. Se a estampação de tempo for omitida, o padrão predefinido yyyy-[M]M-[d]d hh:mm:ss[.f...] é utilizado. Você pode passar um timezone opcional sob a forma de 'GMT', 'PST', 'UTC', 'America/Cayman'. O timetamp suporta até milissegundo precisão com o valor de 999 Consulte o SimpleDateFormat de Java para formatos disponíveis.

  • isTimestamp('2016-12-31 00:12:00') -> true
  • isTimestamp('2016-12-31T00:12:00' -> 'yyyy-MM-dd\\'T\\'HH:mm:ss' -> 'PST') -> true
  • isTimestamp('2012-8222.18') -> false

toBase64

toBase64(<value1> : string) => string

Codifica a cadeia dada na base64.

  • toBase64('bojjus') -> 'Ym9qanVz'

toBinary

toBinary(<value1> : any) => binary

Converte qualquer numérico/data/timetamp/string para representação binária.

  • toBinary(3) -> [0x11]

toBoolean

toBoolean(<value1> : string) => boolean

Converte um valor de ('t', 'true', 'y', 'sim', '1') para verdadeiro e ('f', 'falso', 'n', 'não', '0') a falso e NUO por qualquer outro valor.

  • toBoolean('true') -> true
  • toBoolean('n') -> false
  • isNull(toBoolean('truthy')) -> true

toByte

toByte(<value> : any, [<format> : string], [<locale> : string]) => byte

Converte qualquer numérico ou corda para um valor byte. Um formato decimal java opcional pode ser usado para a conversão.

  • toByte(123)
  • 123
  • toByte(0xFF)
  • -1
  • toByte('123')
  • 123

toDate

toDate(<string> : any, [<date format> : string]) => date

Converte o string da data de entrada até à data utilizando um formato de data de entrada opcional. Consulte a classe de Java SimpleDateFormat para formatos disponíveis. Se o formato da data de entrada for omitido, o formato predefinido é yyyy-[M]M-[d]d. Os formatos aceites são :[yyyyyy-[M]M, yyyy-[M]M-[d]d,yyyy-[M]M-[d]dT*] ].

  • toDate('2012-8-18') -> toDate('2012-08-18')
  • toDate('12/18/2012', 'MM/dd/yyyy') -> toDate('2012-12-18')

toDecimal

toDecimal(<value> : any, [<precision> : integral], [<scale> : integral], [<format> : string], [<locale> : string]) => decimal(10,0)

Converte qualquer numérico ou corda para um valor decimal. Se a precisão e a escala não forem especificadas, é incumprida (10,2). Um formato decimal java opcional pode ser usado para a conversão. Um formato local opcional sob a forma de idioma BCP47 como en-US, de, zh-CN.

  • toDecimal(123.45) -> 123.45
  • toDecimal('123.45', 8, 4) -> 123.4500
  • toDecimal('$123.45', 8, 4,'$###.00') -> 123.4500
  • toDecimal('Ç123,45', 10, 2, 'Ç###,##', 'de') -> 123.45

toDouble

toDouble(<value> : any, [<format> : string], [<locale> : string]) => double

Converte qualquer numérico ou corda para um valor duplo. Um formato decimal java opcional pode ser usado para a conversão. Um formato local opcional sob a forma de idioma BCP47 como en-US, de, zh-CN.

  • toDouble(123.45) -> 123.45
  • toDouble('123.45') -> 123.45
  • toDouble('$123.45', '$###.00') -> 123.45
  • toDouble('Ç123,45', 'Ç###,##', 'de') -> 123.45

toFloat

toFloat(<value> : any, [<format> : string], [<locale> : string]) => float

Converte qualquer numérico ou corda para um valor flutuante. Um formato decimal java opcional pode ser usado para a conversão. Truncates qualquer duplo.

  • toFloat(123.45) -> 123.45f
  • toFloat('123.45') -> 123.45f
  • toFloat('$123.45', '$###.00') -> 123.45f

toInteger

toInteger(<value> : any, [<format> : string], [<locale> : string]) => integer

Converte qualquer numérico ou corda para um valor inteiro. Um formato decimal java opcional pode ser usado para a conversão. Truncates qualquer longo, flutuar, duplo.

  • toInteger(123) -> 123
  • toInteger('123') -> 123
  • toInteger('$123', '$###') -> 123

toLong

toLong(<value> : any, [<format> : string], [<locale> : string]) => long

Converte qualquer numérico ou corda a um valor longo. Um formato decimal java opcional pode ser usado para a conversão. Truncates qualquer boia, duplo.

  • toLong(123) -> 123
  • toLong('123') -> 123
  • toLong('$123', '$###') -> 123

toShort

toShort(<value> : any, [<format> : string], [<locale> : string]) => short

Converte qualquer numérico ou corda a um valor curto. Um formato decimal java opcional pode ser usado para a conversão. Truncates qualquer inteiro, longo, flutuante, duplo.

  • toShort(123) -> 123
  • toShort('123') -> 123
  • toShort('$123', '$###') -> 123

toString

toString(<value> : any, [<number format/date format> : string]) => string

Converte um tipo de dados primitivo a uma corda. Para números e data, um formato pode ser especificado. Se não for especificado, o sistema por defeito é escolhido. O formato decimal de Java é utilizado para números. Consulte o Java SimpleDateFormat para todos os formatos possíveis de data; o formato predefinido é yyy-MM-dd.

  • toString(10) -> '10'
  • toString('engineer') -> 'engineer'
  • toString(123456.789, '##,###.##') -> '123,456.79'
  • toString(123.78, '000000.000') -> '000123.780'
  • toString(12345, '##0.#####E0') -> '12.345E3'
  • toString(toDate('2018-12-31')) -> '2018-12-31'
  • isNull(toString(toDate('2018-12-31', 'MM/dd/yy'))) -> true
  • toString(4 == 20) -> 'false'

toTimestamp

toTimestamp(<string> : any, [<timestamp format> : string], [<time zone> : string]) => timestamp

Converte uma corda para um timetamp dado um formato de timetamp opcional. Se a estampação de tempo for omitida, é utilizado o padrão padrão yyyy-[M]M-[d]d hh:mm:mm:ss[.f...] Você pode passar um timezone opcional sob a forma de 'GMT', 'PST', 'UTC', 'America/Cayman'. O timetamp suporta até milissegundo precisão com o valor de 999. Consulte a classe de Java SimpleDateFormat para formatos disponíveis. https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html.

  • toTimestamp('2016-12-31 00:12:00') -> toTimestamp('2016-12-31 00:12:00')
  • toTimestamp('2016-12-31T00:12:00', 'yyyy-MM-dd\'T\'HH:mm:ss', 'PST') -> toTimestamp('2016-12-31 00:12:00')
  • toTimestamp('12/31/2016T00:12:00', 'MM/dd/yyyy\'T\'HH:mm:ss') -> toTimestamp('2016-12-31 00:12:00')
  • millisecond(toTimestamp('2019-02-03 05:19:28.871', 'yyyy-MM-dd HH:mm:ss.SSS')) -> 871

toUTC

toUTC(<value1> : timestamp, [<value2> : string]) => timestamp

Converte a hora de tempo para UTC. Você pode passar um timezone opcional sob a forma de 'GMT', 'PST', 'UTC', 'America/Cayman'. Está em incumprimento do atual timezone. Consulte a classe de Java SimpleDateFormat para formatos disponíveis. https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html.

  • toUTC(currentTimestamp()) == toTimestamp('2050-12-12 19:18:12') -> false
  • toUTC(currentTimestamp(), 'Asia/Seoul') != toTimestamp('2050-12-12 19:18:12') -> true

Metafunções

As metafunções funcionam principalmente nos metadados no fluxo de dados

byItem

byItem(<parent column> : any, <column name> : string) => any

Encontre um sub-item dentro de uma estrutura ou matriz de estrutura Se houver vários fósforos, o primeiro fósforo é devolvido. Se não corresponder, devolve um valor NUDO. O valor devolvido tem de ser digitado por uma das ações de conversão do tipo(? data, ? corda...). Os nomes das colunas conhecidos na hora do design devem ser abordados apenas pelo seu nome. As entradas computadas não são suportadas, mas pode utilizar substituições de parâmetros * byItem( byName('customer'), 'orderItems') ? (itemName as string, itemQty as integer)

  • byItem( byItem( byName('customer'), 'orderItems'), 'itemName') ? string

byOrigin

byOrigin(<column name> : string, [<origin stream name> : string]) => any

Seleciona um valor de coluna pelo nome no fluxo de origem. O segundo argumento é o nome do fluxo de origem. Se houver vários fósforos, o primeiro jogo é devolvido. Se não corresponder, devolve um valor NUDO. O valor devolvido tem de ser digitado por uma das funções de conversão do tipo (TO_DATE, TO_STRING...). Os nomes das colunas conhecidos na hora do design devem ser abordados apenas pelo seu nome. As entradas computadas não são suportadas, mas pode utilizar substituições de parâmetros.

  • toString(byOrigin('ancestor', 'ancestorStream'))

byOrigins

byOrigins(<column names> : array, [<origin stream name> : string]) => any

Seleciona uma série de colunas pelo nome no fluxo. O segundo argumento é o fluxo de onde se originou. Se houver vários fósforos, o primeiro jogo é devolvido. Se não corresponder, devolve um valor NUDO. O valor devolvido tem de ser digitado por uma das funções de conversão do tipo (TO_DATE, TO_STRING ...) Os nomes das colunas conhecidos na hora do design devem ser abordados apenas pelo seu nome. As entradas computadas não são suportadas, mas pode utilizar substituições de parâmetros.

  • toString(byOrigins(['ancestor1', 'ancestor2'], 'ancestorStream'))

byName

byName(<column name> : string, [<stream name> : string]) => any

Seleciona um valor de coluna pelo nome no fluxo. Pode passar um nome de fluxo opcional como segundo argumento. Se houver vários fósforos, o primeiro jogo é devolvido. Se não corresponder, devolve um valor NUDO. O valor devolvido tem de ser digitado por uma das funções de conversão do tipo (TO_DATE, TO_STRING...). Os nomes das colunas conhecidos na hora do design devem ser abordados apenas pelo seu nome. As entradas computadas não são suportadas, mas pode utilizar substituições de parâmetros.

  • toString(byName('parent'))
  • toLong(byName('income'))
  • toBoolean(byName('foster'))
  • toLong(byName($debtCol))
  • toString(byName('Bogus Column'))
  • toString(byName('Bogus Column', 'DeriveStream'))

byNames

byNames(<column names> : array, [<stream name> : string]) => any

Selecione uma série de colunas pelo nome no fluxo. Pode passar um nome de fluxo opcional como segundo argumento. Se houver vários fósforos, o primeiro jogo é devolvido. Se não houver correspondência para uma coluna, toda a saída é um valor NU. O valor devolvido requer funções de conversão de tipo (toDate, toString, ...). Os nomes das colunas conhecidos na hora do design devem ser abordados apenas pelo seu nome. As entradas computadas não são suportadas, mas pode utilizar substituições de parâmetros.

  • toString(byNames(['parent', 'child']))
  • byNames(['parent']) ? string
  • toLong(byNames(['income']))
  • byNames(['income']) ? long
  • toBoolean(byNames(['foster']))
  • toLong(byNames($debtCols))
  • toString(byNames(['a Column']))
  • toString(byNames(['a Column'], 'DeriveStream'))
  • byNames(['orderItem']) ? (itemName as string, itemQty as integer)

byPath

byPath(<value1> : string, [<streamName> : string]) => any

Encontra um caminho hierárquico pelo nome no riacho. Pode passar um nome de fluxo opcional como segundo argumento. Se não for encontrado tal caminho, retorna nulo. Os nomes/caminhos das colunas conhecidos na hora do design devem ser abordados apenas pelo seu nome ou pelo seu caminho de notação de pontos. As entradas computadas não são suportadas, mas pode utilizar substituições de parâmetros.

  • byPath('grandpa.parent.child') => column

byPosition

byPosition(<position> : integer) => any

Seleciona um valor de coluna pela sua posição relativa(1) no fluxo. Se a posição estiver fora dos limites, devolve um valor NUDO. O valor devolvido tem de ser digitado por uma das funções de conversão do tipo (TO_DATE, TO_STRING ...) As entradas computadas não são suportadas, mas pode utilizar substituições de parâmetros.

  • toString(byPosition(1))
  • toDecimal(byPosition(2), 10, 2)
  • toBoolean(byName(4))
  • toString(byName($colName))
  • toString(byPosition(1234))

hasPath

hasPath(<value1> : string, [<streamName> : string]) => boolean

Verifica se existe um certo caminho hierárquico pelo nome no fluxo. Pode passar um nome de fluxo opcional como segundo argumento. Os nomes/caminhos das colunas conhecidos na hora do design devem ser abordados apenas pelo seu nome ou pelo seu caminho de notação de pontos. As entradas computadas não são suportadas, mas pode utilizar substituições de parâmetros.

  • hasPath('grandpa.parent.child') => boolean

hex

hex(<value1>: binary) => string

Devolve uma representação de corda hexadária de um valor binário * hex(toBinary([toByte(0x1f), toByte(0xad), toByte(0xbe)])) -> '1fadbe'


unhex

unhex(<value1>: string) => binary

Unhexes um valor binário da sua representação de cordas. Isto pode ser usado em conjunto com sha2, md5 para converter de corda para representação binária * unhex('1fadbe') -> toBinary([toByte(0x1f), toByte(0xad), toByte(0xbe)])

  • unhex(md5(5, 'gunchus', 8.2, 'bojjus', true, toDate('2010-4-4'))) -> toBinary([toByte(0x4c),toByte(0xe8),toByte(0xa8),toByte(0x80),toByte(0xbd),toByte(0x62),toByte(0x1a),toByte(0x1f),toByte(0xfa),toByte(0xd0),toByte(0xbc),toByte(0xa9),toByte(0x05),toByte(0xe1),toByte(0xbc),toByte(0x5a)])

Funções do Windows

As seguintes funções só estão disponíveis em transformações de janelas.


cumeDist

cumeDist() => integer

A função CumeDist calcula a posição de um valor relativo a todos os valores da partição. O resultado é o número de linhas anteriores ou iguais à linha atual na ordem da partição dividida pelo número total de linhas na divisória da janela. Quaisquer valores de empate na ordem avaliarão para a mesma posição.

  • cumeDist()

denseRank

denseRank() => integer

Calcula o grau de valor num grupo de valores especificados na ordem de uma janela por cláusula. O resultado é um mais o número de linhas anteriores ou iguais à linha atual na ordem da partição. Os valores não produzirão lacunas na sequência. Dense Rank funciona mesmo quando os dados não são classificados e procura mudanças de valores.

  • denseRank()

lag

lag(<value> : any, [<number of rows to look before> : number], [<default value> : any]) => any

Obtém o valor do primeiro parâmetro avaliado nas linhas n antes da linha atual. O segundo parâmetro é o número de linhas para olhar para trás e o valor padrão é 1. Se não houver tantas linhas, um valor de nulo é devolvido a menos que seja especificado um valor padrão.

  • lag(amount, 2)
  • lag(amount, 2000, 100)

lead

lead(<value> : any, [<number of rows to look after> : number], [<default value> : any]) => any

Obtém o valor do primeiro parâmetro avaliado nas linhas n após a linha atual. O segundo parâmetro é o número de linhas para olhar para a frente e o valor padrão é 1. Se não houver tantas linhas, um valor de nulo é devolvido a menos que seja especificado um valor padrão.

  • lead(amount, 2)
  • lead(amount, 2000, 100)

nTile

nTile([<value1> : integer]) => integer

A NTile função divide as linhas para cada divisória de janela em n baldes que variam de 1 a no máximo n . Os valores do balde diferirão no máximo 1. Se o número de linhas na partição não se dividir uniformemente no número de baldes, então os valores restantes são distribuídos um por balde, começando pelo primeiro balde. A NTile função é útil para o cálculo tertiles de, quartiles, deciles e outras estatísticas sumárias comuns. A função calcula duas variáveis durante a inicialização: O tamanho de um balde regular terá uma linha extra adicionada. Ambas as variáveis são baseadas no tamanho da partição atual. Durante o processo de cálculo, a função mantém o registo do número de linha atual, do número atual do balde e do número de linha em que o balde mudará (baldeSEtenha). Quando o número da linha atual atinge o limiar do balde, o valor do balde é aumentado por um e o limiar é aumentado pelo tamanho do balde (mais um extra se o balde atual for acolchoado).

  • nTile()
  • nTile(numOfBuckets)

rank

rank() => integer

Calcula o grau de valor num grupo de valores especificados na ordem de uma janela por cláusula. O resultado é um mais o número de linhas anteriores ou iguais à linha atual na ordem da partição. Os valores produzirão lacunas na sequência. O rank funciona mesmo quando os dados não são classificados e procura mudanças de valores.

  • rank()

rowNumber

rowNumber() => integer

Atribui uma numeração de linha sequencial para linhas numa janela a partir de 1.

  • rowNumber()

Passos seguintes

Aprenda a usar o Expression Builder.