Utilizzo delle espressioni di trasformazione dei dati nel flusso di dati di mapping

Articolo
10/20/2023

SI APPLICA A: Azure Data Factory Azure Synapse Analytics

Suggerimento

Provare Data Factory in Microsoft Fabric, una soluzione di analisi completa per le aziende. Microsoft Fabric copre tutti gli elementi, dallo spostamento dei dati all'analisi scientifica dei dati, all'analisi in tempo reale, alla business intelligence e alla creazione di report. Scopri come avviare gratuitamente una nuova versione di valutazione .

I flussi di dati sono disponibili sia in Azure Data Factory che in Azure Synapse Pipelines. Questo articolo si applica ai flussi di dati di mapping. Se non si ha esperienza con le trasformazioni, vedere l'articolo introduttivo Trasformare i dati usando un flusso di dati di mapping.

Gli articoli seguenti forniscono informazioni dettagliate sull'utilizzo di tutte le espressioni e funzioni supportate da Azure Data Factory e Azure Synapse Analytics nei flussi di dati di mapping. Per i riepiloghi di ogni tipo di funzione supportata, fare riferimento agli articoli seguenti:

Elenco alfabetico di tutte le funzioni

Di seguito è riportato un elenco alfabetico di tutte le funzioni disponibili nei flussi di dati di mapping.

Un

`abs`

abs(<value1> : number) => number

Valore assoluto di un numero.

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

`acos`

acos(<value1> : number) => double

Calcola un valore inverso coseno.

acos(1) -> 0.0

`add`

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

Aggiunge una coppia di stringhe o numeri. Aggiunge una data a un numero di giorni. Aggiunge una durata a un timestamp. Aggiunge una matrice di tipo simile a un'altra. Uguale all'operatore + .

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

Aggiunge giorni a una data o a un timestamp. Uguale all'operatore + per date.

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

`addMonths`

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

Aggiunge mesi a una data o a un timestamp. Facoltativamente, è possibile passare un fuso orario.

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

Operatore AND logico. Uguale a &&.

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

`approxDistinctCount`

approxDistinctCount(<value1> : any, [ <value2> : double ]) => long

Ottiene il conteggio aggregato approssimativo di valori distinti per una colonna. Il secondo parametro facoltativo consiste nel controllare l'errore di stima.

approxDistinctCount(ProductID, .05) => long

`array`

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

Crea una matrice di elementi. Tutti gli elementi devono essere dello stesso tipo. Se non viene specificato alcun elemento, il valore predefinito è una matrice di stringhe vuota. Uguale a un operatore di creazione [].

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

`ascii`

ascii(<Input> : string) => number

Restituisce il valore numerico del carattere di input. Se la stringa di input ha più di un carattere, viene restituito il valore numerico del primo carattere

ascii('A') -> 65
ascii('a') -> 97

`asin`

asin(<value1> : number) => double

Calcola un valore seno inverso.

asin(0) -> 0.0

`assertErrorMessages`

assertErrorMessages() => map

Restituisce una mappa di tutti i messaggi di errore per la riga con ID asserzione come chiave.

Esempi

assertErrorMessages() => ['assert1': 'This row failed on assert1.', 'assert2': 'This row failed on assert2.']. In this example, at(assertErrorMessages(), 'assert1') would return 'This row failed on assert1.'

`associate`

reassociate(<value1> : map, <value2> : binaryFunction) => map

Crea una mappa di chiavi/valori. Tutti i valori e chiavi devono essere dello stesso tipo. Se non viene specificato alcun elemento, per impostazione predefinita viene impostato un mapping di stringa al tipo stringa. Uguale a un [ -> ] operatore di creazione. Chiavi e valori devono alternarsi tra loro.

associate('fruit', 'apple', 'vegetable', 'carrot' )=> ['fruit' -> 'apple', 'vegetable' -> 'carrot']

`at`

at(<value1> : array/map, <value2> : integer/key type) => array

Trova l'elemento in corrispondenza di un indice di matrice. L'indice è basato su 1. L'indice out-of-bounds restituisce un valore Null. Trova un valore in una mappa in base a una chiave. Se la chiave non viene trovata, restituisce Null.

at(['apples', 'pears'], 1) => 'apples'
at(['fruit' -> 'apples', 'vegetable' -> 'carrot'], 'fruit') => 'apples'

`atan`

atan(<value1> : number) => double

Calcola un valore tangente inverso.

atan(0) -> 0.0

`atan2`

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

Restituisce l'angolo in radianti tra l'asse x positivo di un piano e il punto specificato dalle coordinate.

atan2(0, 0) -> 0.0

`avg`

avg(<value1> : number) => number

Ottiene la media dei valori di una colonna.

avg(sales)

`avgIf`

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

In base a un criterio, ottiene la media dei valori di una colonna.

avgIf(region == 'West', sales)

G

`between`

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

Controlla se il primo valore è compreso tra due altri valori in modo inclusivo. È possibile confrontare valori numerici, stringa e datetime

between(10, 5, 24)
true
between(currentDate(), currentDate() + 10, currentDate() + 20)
false

`bitwiseAnd`

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

Operatore And bit per bit tra i tipi integrali. Uguale all'operatore &

bitwiseAnd(0xf4, 0xef)
0xe4
(0xf4 & 0xef)
0xe4

`bitwiseOr`

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

Operatore Or bit per bit tra tipi integrali. Uguale a | Operatore

bitwiseOr(0xf4, 0xef)
0xff
(0xf4 | 0xef)
0xff

`bitwiseXor`

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

Operatore Or bit per bit tra tipi integrali. Uguale a | Operatore

bitwiseXor(0xf4, 0xef)
0x1b
(0xf4 ^ 0xef)
0x1b
(true ^ false)
true
(true ^ true)
false

`blake2b`

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

Calcola il digest Blake2 del set di colonne di tipi di dati primitivi variabili in base a una lunghezza di bit, che può essere costituito solo da multipli di 8 tra 8 e 512. Può essere usato per calcolare un'impronta digitale per una riga

blake2b(256, 'gunchus', 8.2, 'bojjus', true, toDate('2010-4-4'))
'c9521a5080d8da30dffb430c50ce253c345cc4c4effc315dab2162dac974711d'

`blake2bBinary`

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

Calcola il digest Blake2 del set di colonne di tipi di dati primitivi variabili in base a una lunghezza di bit, che può essere costituito solo da multipli di 8 tra 8 e 512. Può essere usato per calcolare un'impronta digitale per una riga

blake2bBinary(256, 'gunchus', 8.2, 'bojjus', true, toDate('2010-4-4'))
unHex('c9521a5080d8da30dffb430c50ce253c345cc4c4effc315dab2162dac974711d')

`byItem`

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

Trovare un elemento secondario all'interno di una struttura o di una matrice di struttura. Se sono presenti più corrispondenze, restituisce la prima corrispondenza. Se non viene trovata nessuna corrispondenza, restituisce un valore NULL. Il valore restituito deve essere convertito da una delle azioni di conversione del tipo(? date, ? stringa ...). I nomi di colonna noti in fase di progettazione devono essere risolti in base al nome. Gli input calcolati non sono supportati, ma è possibile usare le sostituzioni dei parametri

byItem( byName('customer'), 'orderItems') ? (itemName as string, itemQty as integer)
byItem( byItem( byName('customer'), 'orderItems'), 'itemName') ? string

`byName`

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

Seleziona un valore di colonna nel flusso in base al nome. È possibile passare un nome di flusso facoltativo come secondo argomento. Se sono presenti più corrispondenze, restituisce la prima corrispondenza. Se non viene trovata nessuna corrispondenza, restituisce un valore NULL. Il valore restituito deve essere convertito da una delle funzioni di conversione del tipo (TO_DATE, TO_STRING ...). I nomi di colonna noti in fase di progettazione devono essere risolti in base al nome. Gli input calcolati non sono supportati, ma è possibile usare le sostituzioni dei parametri.

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

Selezionare una matrice di colonne nel flusso in base al nome. È possibile passare un nome di flusso facoltativo come secondo argomento. Se sono presenti più corrispondenze, restituisce la prima corrispondenza. Se non sono presenti corrispondenze per una colonna, l'intero output è un valore NULL. Il valore restituito richiede una funzione di conversione dei tipi (toDate, toString, ...). I nomi di colonna noti in fase di progettazione devono essere risolti in base al nome. Gli input calcolati non sono supportati, ma è possibile usare le sostituzioni dei parametri.

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)

`byOrigin`

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

Seleziona un valore di colonna in base al nome nel flusso di origine. Il secondo argomento è il nome del flusso di origine. Se sono presenti più corrispondenze, restituisce la prima corrispondenza. Se non viene trovata nessuna corrispondenza, restituisce un valore NULL. Il valore restituito deve essere convertito da una delle funzioni di conversione del tipo (TO_DATE, TO_STRING ...). I nomi di colonna noti in fase di progettazione devono essere risolti in base al nome. Gli input calcolati non sono supportati, ma è possibile usare le sostituzioni dei parametri.

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

`byOrigins`

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

Seleziona una matrice di colonne in base al nome nel flusso. Il secondo argomento è il flusso da cui ha avuto origine. Se sono presenti più corrispondenze, restituisce la prima corrispondenza. Se non viene trovata nessuna corrispondenza, restituisce un valore NULL. Il valore restituito deve essere convertito da una delle funzioni di conversione del tipo (TO_DATE, TO_STRING ...) I nomi di colonna noti in fase di progettazione devono essere risolti in base al nome. Gli input calcolati non sono supportati, ma è possibile usare le sostituzioni dei parametri.

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

`byPath`

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

Trova un percorso gerarchico in base al nome nel flusso. È possibile passare un nome di flusso facoltativo come secondo argomento. Se non viene trovato alcun percorso di questo tipo, restituisce null. I nomi e i percorsi delle colonne noti in fase di progettazione devono essere indirizzati solo con il nome o il percorso di notazione del punto. Gli input calcolati non sono supportati, ma è possibile usare le sostituzioni dei parametri.

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

`byPosition`

byPosition(<position> : integer) => any

Seleziona un valore di colonna in base alla relativa posizione (basata su 1) nel flusso. Se la posizione non è compresa nei limiti, restituisce un valore NULL. Il valore restituito deve essere convertito da una delle funzioni di conversione del tipo (TO_DATE, TO_STRING ...) Gli input calcolati non sono supportati, ma è possibile usare le sostituzioni dei parametri.

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

A

`case`

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

In base alle condizioni alternative, applica un valore o l'altro. Se il numero di input è pari, l'altro valore predefinito è NULL per l'ultima condizione.

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

Calcola la radice del cubo di un numero.

cbrt(8) -> 2.0

`ceil`

ceil(<value1> : number) => number

Restituisce il numero intero più piccolo non inferiore al numero.

ceil(-0.1) -> 0

`char`

char(<Input> : number) => string

Restituisce il carattere ascii rappresentato dal numero di input. Se number è maggiore di 256, il risultato è equivalente a char(number % 256)

char(65) -> 'A'
char(97) -> 'a'

`coalesce`

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

Restituisce il primo valore diverso da NULL da un set di input. Tutti gli input devono essere dello stesso tipo.

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

`collect`

collect(<value1> : any) => array

Raccoglie tutti i valori dell'espressione nel gruppo aggregato in una matrice. Durante questo processo è possibile raccogliere e trasformare le strutture in strutture alternative. Il numero di elementi sarà uguale al numero di righe nel gruppo e può contenere valori NULL. Il numero di elementi raccolti deve essere ridotto.

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

`collectUnique`

collectUnique(<value1> : any) => array

Raccoglie tutti i valori dell'espressione nel gruppo aggregato in una matrice univoca. Durante questo processo è possibile raccogliere e trasformare le strutture in strutture alternative. Il numero di elementi sarà uguale al numero di righe nel gruppo e può contenere valori NULL. Il numero di elementi raccolti deve essere ridotto.

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

`columnNames`

columnNames(<value1>columnNames( : string, i><value1> : boolean) = array> Ottiene i nomi di tutte le colonne di output per un flusso. È possibile passare un nome di flusso facoltativo come primo argomento. Il secondo argomento è facoltativo, con false come valore predefinito. Se si imposta il secondo argomento su true(), ADF restituirà solo le colonne che vengono deviate tramite deriva dello schema.



columnNames()
columnNames('DeriveStream')
columnNames('DeriveStream', true())
columnNames('', true())



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


Ottiene i valori di tutte le colonne di output per un flusso. È possibile passare un nome di flusso facoltativo come secondo argomento.

columns()
columns('DeriveStream')



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


Confronta due valori dello stesso tipo. Restituisce un numero intero negativo se value1 < value2, 0 se value1 == value2, valore positivo se value1 > value2.

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



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


Concatena un numero variabile di stringhe. Uguale all'operatore + con stringhe.

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



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


Concatena un numero variabile di stringhe con un separatore. Il primo parametro è il separatore.

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



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


Restituisce true se un elemento nella matrice fornita restituisce true nel predicato fornito. Contains prevede un riferimento a un elemento nella funzione predicato come #item.

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



cos
cos(<value1> : number) => double


Calcola un valore coseno.

cos(10) -> -0.8390715290764524



cosh
cosh(<value1> : number) => double


Calcola un coseno iperbolico di un valore.

cosh(0) -> 1.0



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


Ottiene il conteggio aggregato dei valori. Se si specificano le colonne facoltative, ignora i valori NULL nel conteggio.

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



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


Ottiene il conteggio aggregato di valori inclusi i valori Null.

countAll(custId)
countAll()



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


Ottiene il conteggio aggregato di valori distinti di un set di colonne.

countDistinct(custId, custName)



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


Ottiene il conteggio aggregato di valori distinti di un set di colonne, inclusi i valori Null.

countAllDistinct(custId, custName)



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


In base a un criterio, ottiene il conteggio aggregato dei valori. Se viene specificata la colonna facoltativa, ignora i valori NULL nel conteggio.

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



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


Ottiene la covarianza della popolazione tra due colonne.

covariancePopulation(sales, profit)



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


In base a un criterio, ottiene la covarianza della popolazione di due colonne.

covariancePopulationIf(region == 'West', sales)



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


Ottiene la covarianza di esempio di due colonne.

covarianceSample(sales, profit)



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


In base a un criterio, ottiene la covarianza di esempio di due colonne.

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



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


Calcola l'hash CRC32 del set di colonne di tipi di dati primitivi variabili in base a una lunghezza di bit, che può essere di solo valori 0(256), 224, 256, 384, 512. Può essere usato per calcolare un'impronta digitale per una riga.

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



cumeDist
cumeDist() => integer


La funzione CumeDist calcola la posizione di un valore rispetto a tutti i valori nella partizione. Il risultato è il numero di righe precedenti o uguali alla riga corrente nell'ordinamento della partizione diviso per il numero totale di righe nella partizione di finestra. Eventuali valori collegati nell'ordinamento vengono valutati nella stessa posizione.

cumeDist()



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


Ottiene la data corrente quando viene avviata l'esecuzione del processo. È possibile passare un fuso orario facoltativo nel formato 'GMT', 'PST', 'UTC', 'America/Cayman'. Il fuso orario locale del data center/area della data factory viene usato come predefinito. Per i formati disponibili, vedere la classe Java SimpleDateFormat . 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


Ottiene il timestamp corrente all'avvio dell'esecuzione del processo con fuso orario locale.

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



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


Ottiene il timestamp corrente come ora UTC. Se si vuole che l'ora corrente venga interpretata in un fuso orario diverso rispetto al fuso orario del cluster, è possibile passare un fuso orario facoltativo sotto forma di "GMT", "PST", "UTC", "America/Cayman". L'impostazione predefinita è il fuso orario corrente. Per i formati disponibili, vedere la classe Java SimpleDateFormat . https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html. Per convertire l'ora UTC in un fuso orario diverso, usare 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


D

dayOfMonth
dayOfMonth(<value1> : datetime) => integer


Ottiene il giorno del mese dato una data.

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



dayOfWeek
dayOfWeek(<value1> : datetime) => integer


Ottiene il giorno della settimana in base a una data specificata. 1 - Domenica, 2 - Lunedì ..., 7 - Sabato.

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



dayOfYear
dayOfYear(<value1> : datetime) => integer


Ottiene il giorno dell'anno in base a una data.

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



days
days(<value1> : integer) => long


Durata in millisecondi per il numero di giorni.

days(2) -> 172800000L



decode
decode(<Input> : any, <Charset> : string) => binary


Decodifica i dati di input codificati in una stringa in base al set di caratteri specificato. È possibile usare un secondo argomento (facoltativo) per specificare il set di caratteri da usare : 'US-ASCII', 'ISO-8859-1', 'UTF-8' (impostazione predefinita), 'UTF-16BE', 'UTF-16LE', 'UTF-16'

decode(array(toByte(97),toByte(98),toByte(99)), 'US-ASCII') -> abc



degrees
degrees(<value1> : number) => double


Converte i radianti in gradi.

degrees(3.141592653589793) -> 180



denseRank
denseRank() => integer


Calcola la classificazione di un valore in un gruppo di valori specificato nella clausola ORDER BY di una finestra. Come risultato si ha uno più il numero di righe precedenti o uguali alla riga corrente nell'ordinamento della partizione. I valori non produrranno spazi vuoti nella sequenza. Dense Rank funziona anche quando i dati non vengono ordinati e cercano modifiche nei valori.

denseRank()



distinct
distinct(<value1> : array) => array


Restituisce un set distinto di elementi di una matrice.

distinct([10, 20, 30, 10]) => [10, 20, 30]



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


Divide coppie di numeri. Uguale all'operatore / .

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



dropLeft
dropLeft(<value1> : string, <value2> : integer) => string


Rimuove il numero di caratteri a sinistra della stringa. Se l'eliminazione richiesta supera la lunghezza della stringa, viene restituita una stringa vuota.

dropLeft('bojjus', 2) => 'jjus'
dropLeft('cake', 10) => ''



dropRight
dropRight(<value1> : string, <value2> : integer) => string


Rimuove il numero di caratteri a destra della stringa. Se l'eliminazione richiesta supera la lunghezza della stringa, viene restituita una stringa vuota.

dropRight('bojjus', 2) => 'bojj'
dropRight('cake', 10) => ''


E

encode
encode(<Input> : string, <Charset> : string) => binary


Codifica i dati della stringa di input in file binari in base a un set di caratteri. È possibile usare un secondo argomento (facoltativo) per specificare il set di caratteri da usare : 'US-ASCII', 'ISO-8859-1', 'UTF-8' (impostazione predefinita), 'UTF-16BE', 'UTF-16LE', 'UTF-16'

encode('abc', 'US-ASCII') -> array(toByte(97),toByte(98),toByte(99))


Stringa di input: string, Charset: string) => binary 
endsWith
endsWith(<string> : string, <substring to check> : string) => boolean


Controlla se la stringa termina con la stringa specificata.

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



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


Operatore equals di confronto. Uguale all'operatore == .

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


Operatore equals di confronto senza distinzione tra maiuscole e minuscole. Uguale all'operatore <=> .

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



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


Esegue l'escape di una stringa in base a un formato. I valori letterali per il formato accettabile sono 'json', 'xml', 'ecmascript', 'html', 'java'.


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


Restituisce un set di differenze di una matrice da un'altra eliminazione di duplicati.

except([10, 20, 30], [20, 40]) => [10, 30]



expr
expr(<expr> : string) => any


Restituisce un'espressione da una stringa. Equivale a scrivere questa espressione in un formato non letterale. Può essere usato per passare i parametri come rappresentazioni di stringa.

expr('price * discount') => any


F

factorial
factorial(<value1> : number) => long


Calcola il fattoriale di un numero.

factorial(5) -> 120



false
false() => boolean


Restituisce sempre un valore false. Usare la funzione syntax(false()) se è presente una colonna denominata 'false'.

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



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


Filtra gli elementi dalla matrice che non soddisfano il predicato specificato. Il filtro prevede un riferimento a un elemento nella funzione predicato come #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


Trovare il primo elemento da una matrice che corrisponde alla condizione. Accetta una funzione di filtro in cui è possibile indirizzare l'elemento nella matrice come #item. Per le mappe annidate in modo approfondito, è possibile fare riferimento alla notazione #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') ] )



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


Ottiene il primo valore di un gruppo di colonne. Se il secondo parametro ignoreNulls viene omesso, si presuppone che sia false.

first(sales)
first(sales, false)



flatten
flatten(<array> : array, <value2> : array ..., <value2> : boolean) => array


Rende flat la matrice o le matrici in una singola matrice. Le matrici di elementi atomici vengono restituite invariate. L'ultimo argomento è facoltativo ed è impostato su false per rendere flat in modo ricorsivo più di un livello profondo.

flatten([['bojjus', 'girl'], ['gunchus', 'boy']]) => ['bojjus', 'girl', 'gunchus', 'boy']
flatten([[['bojjus', 'gunchus']]] , true) => ['bojjus', 'gunchus']



floor
floor(<value1> : number) => number


Restituisce il numero intero più grande non maggiore del numero.

floor(-0.1) -> -1



fromBase64
fromBase64(<value1> : string, <encoding type> : string) => string


Decodifica la stringa con codifica base64 specificata. Facoltativamente, è possibile passare il tipo di codifica.

fromBase64('Z3VuY2h1cw==') -> 'gunchus'
fromBase64('SGVsbG8gV29ybGQ=', 'Windows-1252') -> 'Hello World'



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


Converte il timestamp da UTC. È possibile fornire un fuso orario facoltativo nel formato "GMT", "PST", "UTC", "America/Cayman". L'impostazione predefinita è il fuso orario corrente. Per i formati disponibili, vedere la classe Java SimpleDateFormat . 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


G

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


Operatore greater di confronto. Uguale all'operatore > .

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


Operatore greater than o equal di confronto. Uguale all'operatore >= .

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



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


Restituisce il valore più grande dell'elenco di valori come input ignorando i valori NULL. Restituisce null se tutti gli input sono Null.

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')


H

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


Verifica la presenza di un valore di colonna nel flusso in base al nome. È possibile passare un nome di flusso facoltativo come secondo argomento. I nomi di colonna noti in fase di progettazione devono essere riportati solo in base al relativo nome. Gli input calcolati non sono supportati, ma è possibile usare le sostituzioni dei parametri.

hasColumn('parent')



hasError
hasError([<value1> : string]) => boolean


Controlla se l'asserzione con ID specificato è contrassegnata come errore.
Esempi

hasError('assert1')
hasError('assert2')



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


Controlla se un determinato percorso gerarchico esiste in base al nome nel flusso. È possibile passare un nome di flusso facoltativo come secondo argomento. I nomi e i percorsi delle colonne noti in fase di progettazione devono essere indirizzati solo con il nome o il percorso di notazione del punto. Gli input calcolati non sono supportati, ma è possibile usare le sostituzioni dei parametri.

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



hex
hex(<value1>: binary) => string


Restituisce una rappresentazione di stringa esadecimale di un valore binario

hex(toBinary([toByte(0x1f), toByte(0xad), toByte(0xbe)])) -> '1fadbe'



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


Ottiene il valore dell'ora di un timestamp. È possibile passare un fuso orario facoltativo nel formato 'GMT', 'PST', 'UTC', 'America/Cayman'. Per impostazione predefinita viene usato il fuso orario locale. Per i formati disponibili, vedere la classe Java SimpleDateFormat . 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


Durata in millisecondi per il numero di ore.

hours(2) -> 7200000L


I

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


In base alla condizione specifica, applica un valore o l'altro. Se l'altro non è specificato, viene considerato NULL. Entrambi i valori devono essere compatibili (numeric, string...).

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


Dato due o più input, restituisce il primo elemento non Null. Questa funzione equivale a coalesce.

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



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


Controlla se un elemento si trova nella matrice.

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



initCap
initCap(<value1> : string) => string


Converte la prima lettera di ogni parola in lettere maiuscole. Le parole vengono identificate come separate da spazi vuoti.

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



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


Trova la posizione (in base 1) della sottostringa all'interno di una stringa. Se non viene trovato, viene restituito 0.

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



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


Restituisce un set di intersezioni di elementi distinti da 2 matrici.

intersect([10, 20, 30], [20, 40]) => [20]



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


Controlla se in questo bitset è impostata una posizione di bit

isBitSet(toBitSet([10, 32, 98]), 10) => true



isBoolean
isBoolean(<value1>: string) => boolean


Controlla se il valore stringa è un valore booleano in base alle regole di toBoolean()

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



isByte
isByte(<value1> : string) => boolean


Controlla se il valore stringa è un valore di byte dato un formato facoltativo in base alle regole di toByte()

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



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


Controlla se la stringa della data di input è una data usando un formato di data di input facoltativo. Per i formati disponibili, vedere SimpleDateFormat di Java. Se il formato della data di input viene omesso, il formato predefinito è yyyy-[M]M-[d]d. I formati accettati sono [ 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



isDecimal
isDecimal (<value1> : string) => boolean


Controlla se il valore stringa è un valore decimale in base a un formato facoltativo in base alle regole di toDecimal()

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



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


Controlla se la riga è contrassegnata per l'eliminazione. Per le trasformazioni che accettano più di un flusso di input è possibile fornire l'indice del flusso (in base 1). L'indice del flusso deve essere 1 o 2 e il valore predefinito è 1.

isDelete()
isDelete(1)



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


Trova se una colonna o un set di colonne è distinta. Non conta null come valore distinto

isDistinct(custId, custName) => boolean



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


Controlla se il valore stringa è un valore doppio in base alle regole di toDouble()

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



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


Controlla se la riga è contrassegnata come errore. Per le trasformazioni che accettano più di un flusso di input è possibile fornire l'indice del flusso (in base 1). L'indice del flusso deve essere 1 o 2 e il valore predefinito è 1.

isError()
isError(1)



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


Controlla se il valore stringa è un valore float dato un formato facoltativo in base alle regole di toFloat()

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



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


Controlla se la riga è contrassegnata per essere ignorata. Per le trasformazioni che accettano più di un flusso di input è possibile fornire l'indice del flusso (in base 1). L'indice del flusso deve essere 1 o 2 e il valore predefinito è 1.

isIgnore()
isIgnore(1)



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


Controlla se la riga è contrassegnata per l'inserimento. Per le trasformazioni che accettano più di un flusso di input è possibile fornire l'indice del flusso (in base 1). L'indice del flusso deve essere 1 o 2 e il valore predefinito è 1.

isInsert()
isInsert(1)



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


Controlla se il valore stringa è un valore intero dato un formato facoltativo in base alle regole di toInteger()

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



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


Controlla se il valore stringa è un valore long dato un formato facoltativo in base alle regole di toLong()

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



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


Controlla se per la riga viene trovata una corrispondenza. Per le trasformazioni che accettano più di un flusso di input è possibile fornire l'indice del flusso (in base 1). L'indice del flusso deve essere 1 o 2 e il valore predefinito è 1.

isMatch()
isMatch(1)



isNan
isNan (<value1> : integral) => boolean


Controllare se questo non è un numero.

isNan(10.2) => false



isNull
isNull(<value1> : any) => boolean


Controlla se il valore è NULL.

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



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


Controlla se il valore stringa è un valore breve dato un formato facoltativo in base alle regole di toShort()

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



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


Controlla se la stringa di data di input è un timestamp usando un formato timestamp di input facoltativo. Per i formati disponibili, vedere SimpleDateFormat di Java. Se il timestamp viene omesso, viene usato il modello yyyy-[M]M-[d]d hh:mm:ss[.f...] predefinito. È possibile passare un fuso orario facoltativo nel formato 'GMT', 'PST', 'UTC', 'America/Cayman'. Timestamp supporta fino a millisecondi di accuratezza con valore 999 Fare riferimento a SimpleDateFormat di Java per i formati disponibili.

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



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


Controlla se la riga è contrassegnata per l'aggiornamento. Per le trasformazioni che accettano più di un flusso di input è possibile fornire l'indice del flusso (in base 1). L'indice del flusso deve essere 1 o 2 e il valore predefinito è 1.

isUpdate()
isUpdate(1)



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


Controlla se la riga è contrassegnata per l'inserimento. Per le trasformazioni che accettano più di un flusso di input è possibile fornire l'indice del flusso (in base 1). L'indice del flusso deve essere 1 o 2 e il valore predefinito è 1.

isUpsert()
isUpsert(1)


J

jaroWinkler
jaroWinkler(<value1> : string, <value2> : string) => double


Ottiene la distanza jaroWinkler tra due stringhe.

jaroWinkler('frog', 'frog') => 1.0


K

keyValues
keyValues(<value1> : array, <value2> : array) => map


Crea una mappa di chiavi/valori. Il primo parametro è una matrice di chiavi e la seconda è la matrice di valori. Entrambe le matrici devono avere una lunghezza uguale.

keyValues(['bojjus', 'appa'], ['gunchus', 'ammi']) => ['bojjus' -> 'gunchus', 'appa' -> 'ammi']



kurtosis
kurtosis(<value1> : number) => double


Ottiene la curtosi di una colonna.

kurtosis(sales)



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


In base a un criterio, ottiene la curtosi di una colonna.

kurtosisIf(region == 'West', sales)


L

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


Ottiene il valore del primo parametro valutato in n righe prima della riga corrente. Il secondo parametro è il numero di righe da controllare e il valore predefinito è 1. Se non vengono restituite tutte le righe, viene restituito un valore Null a meno che non venga specificato un valore predefinito.

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



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


Ottiene l'ultimo valore di un gruppo di colonne. Se il secondo parametro ignoreNulls viene omesso, si presuppone che sia false.

last(sales)
last(sales, false)



lastDayOfMonth
lastDayOfMonth(<value1> : datetime) => date


Ottiene l'ultima data del mese in base a una data.

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



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


Ottiene il valore del primo parametro valutato in n righe dopo la riga corrente. Il secondo parametro è il numero di righe da controllare e il valore predefinito è 1. Se non vengono restituite tutte le righe, viene restituito un valore Null a meno che non venga specificato un valore predefinito.

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



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


Operatore lesser than o equal di confronto. Uguale all'operatore <= .

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


Estrae una sottostringa iniziale in corrispondenza dell'indice 1 con il numero di caratteri specificato. Uguale a SUBSTRING(str, 1, n).

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



length
length(<value1> : string) => integer


Restituisce la lunghezza della stringa.

length('dumbo') -> 5



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


Operatore less di confronto. Uguale all'operatore < .

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


Operatore lesser than o equal di confronto. Uguale all'operatore <= .

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



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


Ottiene la distanza levenshtein tra due stringhe.

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



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


Il modello è una stringa con corrispondenza letterale. Le eccezioni sono i seguenti simboli speciali: _ corrisponde a qualsiasi carattere nell'input (simile a . nelle posix espressioni regolari) % corrisponde a zero o più caratteri nell'input (simile a .* nelle posix espressioni regolari).
Il carattere di escape è ". Se un carattere di escape precede un simbolo speciale o un altro carattere di escape, per il carattere successivo viene stabilita una corrispondenza letterale. Non è valido eseguire l'escape di qualsiasi altro carattere.

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



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


Trova la posizione (in base 1) della sottostringa all'interno di una stringa a partire da una determinata posizione. Se la posizione viene omessa, viene considerata dall'inizio della stringa. Se non viene trovato, viene restituito 0.

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



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


Calcola il valore del logaritmo. È possibile specificare una base facoltativa; in caso contrario, è possibile specificare un numero eulero.

log(100, 10) -> 2



log10
log10(<value1> : number) => double


Calcola il valore del log in base a 10 base.

log10(100) -> 2



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


Cerca la prima riga dal sink memorizzato nella cache usando le chiavi specificate che corrispondono alle chiavi del sink memorizzato nella cache.

cacheSink#lookup(movieId)



lower
lower(<value1> : string) => string


Lettere minuscole di una stringa.

lower('GunChus') -> 'gunchus'



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


Riempie a sinistra la stringa in base al riempimento specificato fino a raggiungere una determinata lunghezza. Se la stringa è uguale o maggiore della lunghezza, viene tagliata fino alla lunghezza.

lpad('dumbo', 10, '-') -> '-----dumbo'
lpad('dumbo', 4, '-') -> 'dumb'



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


Rimuove i caratteri iniziali dal lato sinistro di una stringa. Se il secondo parametro non è specificato, rimuove lo spazio vuoto. Altrimenti taglia qualsiasi carattere specificato nel secondo parametro.

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


M

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


Esegue il mapping di ogni elemento della matrice a un nuovo elemento usando l'espressione fornita. Map prevede un riferimento a un elemento nella funzione di espressione come #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']



mapAssociation
mapAssociation(<value1> : map, <value2> : binaryFunction) => array


Trasforma una mappa associando le chiavi ai nuovi valori. Restituisce una matrice. Accetta una funzione di mapping in cui è possibile indirizzare l'elemento come #key e il valore corrente come #value.

mapAssociation(['bojjus' -> 'gunchus', 'appa' -> 'ammi'], @(key = #key, value = #value)) => [@(key = 'bojjus', value = 'gunchus'), @(key = 'appa', value = 'ammi')]



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


Esegue il mapping condizionale di una matrice a un'altra matrice di lunghezza uguale o inferiore. I valori possono essere di qualsiasi tipo di dati, inclusi structTypes. Accetta una funzione di mapping in cui è possibile indirizzare l'elemento nella matrice come #item e l'indice corrente come #index. Per le mappe annidate in modo approfondito, è possibile fare riferimento alle mappe padre usando la #item_[n](#item_1, #index_1...) notazione .

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


Esegue il mapping di ogni elemento della matrice a un nuovo elemento usando l'espressione fornita. Map prevede un riferimento a un elemento nella funzione di espressione come #item e un riferimento all'indice dell'elemento come #index.

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



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


Esegue un ciclo da 1 a lunghezza per creare una matrice di tale lunghezza. Accetta una funzione di mapping in cui è possibile indirizzare l'indice nella matrice come #index. Per le mappe annidate in modo approfondito, è possibile fare riferimento alla notazione #index_n(#index_1, #index_2...) padre.

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



max
max(<value1> : any) => any


Ottiene il valore massimo di una colonna.

max(sales)



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


In base a un criterio, ottiene il valore massimo di una colonna.

maxIf(region == 'West', sales)



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


Calcola il digest MD5 del set di colonne di tipi di dati primitivi variabili e restituisce una stringa esadecimale di 32 caratteri. Può essere usato per calcolare un'impronta digitale per una riga.

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



mean
mean(<value1> : number) => number


Ottiene la media dei valori di una colonna. Uguale a AVG.

mean(sales)



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


In base a un criterio, ottiene la media dei valori di una colonna. Uguale a avgIf.

meanIf(region == 'West', sales)



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


Ottiene il valore dei millisecondi di una data. È possibile passare un fuso orario facoltativo nel formato 'GMT', 'PST', 'UTC', 'America/Cayman'. Per impostazione predefinita viene usato il fuso orario locale. Per i formati disponibili, vedere la classe Java SimpleDateFormat . 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


Durata in millisecondi per il numero di millisecondi.

milliseconds(2) -> 2L



min
min(<value1> : any) => any


Ottiene il valore minimo di una colonna.

min(sales)



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


In base a un criterio, ottiene il valore minimo di una colonna.

minIf(region == 'West', sales)



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


Sottrae numeri. Sottrarre il numero di giorni da una data. Sottrarre la durata da un timestamp. Sottrarre due timestamp per ottenere la differenza in millisecondi. Uguale all'operatore - .

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


Ottiene il valore dei minuti di un timestamp. È possibile passare un fuso orario facoltativo nel formato 'GMT', 'PST', 'UTC', 'America/Cayman'. Per impostazione predefinita viene usato il fuso orario locale. Per i formati disponibili, vedere la classe Java SimpleDateFormat . 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


Durata in millisecondi per il numero di minuti.

minutes(2) -> 120000L



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


Cerca tutte le righe corrispondenti dal sink memorizzato nella cache usando le chiavi specificate che corrispondono alle chiavi del sink memorizzato nella cache.

cacheSink#mlookup(movieId)



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


Calcola il modulo di coppie di numeri. Uguale all'operatore %.

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



month
month(<value1> : datetime) => integer


Ottiene il valore del mese di una data o di un timestamp.

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



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


Ottiene il numero di mesi tra due date. È possibile arrotondare il calcolo. È possibile passare un fuso orario facoltativo nel formato 'GMT', 'PST', 'UTC', 'America/Cayman'. Per impostazione predefinita viene usato il fuso orario locale. Per i formati disponibili, vedere la classe Java SimpleDateFormat . 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


Moltiplica coppie di numeri. Uguale all'operatore * .

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


N

negate
negate(<value1> : number) => number


Nega un numero. Trasforma numeri positivi in negativi e viceversa.

negate(13) -> -13



nextSequence
nextSequence() => long


Restituisce la sequenza univoca successiva. Il numero è consecutivo solo all'interno di una partizione ed è preceduto dal partitionId.

nextSequence() == 12313112 -> false



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


Normalizza il valore stringa in modo da separare i caratteri Unicode accentati.

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



not
not(<value1> : boolean) => boolean


Operatore di negazione logico.

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



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


Operatore not equals di confronto. Uguale all'operatore != .

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



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


La NTile funzione divide le righe per ogni partizione di finestra in n bucket compresi tra 1 e al massimo n. I valori dei bucket si differenzieranno per un massimo di 1. Se il numero di righe nella partizione non viene diviso uniformemente nel numero di bucket, i valori rimanenti vengono distribuiti uno per bucket, a partire dal primo bucket. La NTile funzione è utile per il calcolo di tertiles, quartili, decili e altre statistiche di riepilogo comuni. La funzione calcola due variabili durante l'inizializzazione: le dimensioni di un bucket regolare avranno una riga aggiuntiva aggiunta. Entrambe le variabili si basano sulle dimensioni della partizione corrente. Durante il processo di calcolo, la funzione tiene traccia del numero di righe corrente, del numero di bucket corrente e del numero di righe in corrispondenza del quale il bucket cambierà (bucketThreshold). Quando il numero di righe corrente raggiunge la soglia del bucket, il valore del bucket viene incrementato di uno e la soglia viene aumentata in base alla dimensione del bucket (più un valore aggiuntivo, in caso di riempimento del bucket corrente).

nTile()
nTile(numOfBuckets)



null
null() => null


Restituisce un valore NULL. Usare la funzione syntax(null()) se è presente una colonna denominata 'null'. Qualsiasi operazione utilizzata comporterà un valore NULL.

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


O

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


Operatore OR logico. Uguale a ||.

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



originColumns
originColumns(<streamName> : string) => any


Ottiene tutte le colonne di output per un flusso di origine in cui sono state create colonne. Deve essere racchiuso in un'altra funzione.

array(toString(originColumns('source1')))



output
output() => any


Restituisce la prima riga dei risultati del sink della cache

cacheSink#output()



outputs
output() => any


Restituisce l'intero set di righe di output dei risultati del sink della cache

cacheSink#outputs()


P

partitionId
partitionId() => integer


Restituisce l'ID della partizione corrente in cui si trova la riga di input.

partitionId()



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


Calcola il modulo positivo di coppie di numeri.

pmod(-20, 8) -> 4



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


Alza un numero alla potenza di un altro.

power(10, 2) -> 100


R

radians
radians(<value1> : number) => double


Converte i gradi in radianti

radians(180) => 3.141592653589793



random
random(<value1> : integral) => long


Restituisce un numero casuale dato un valore di inizializzazione facoltativo all'interno di una partizione. Il valore di inizializzazione deve essere un valore fisso e viene usato con partitionId per produrre valori casuali

random(1) == 1 -> false



rank
rank() => integer


Calcola la classificazione di un valore in un gruppo di valori specificato nella clausola ORDER BY di una finestra. Come risultato si ha uno più il numero di righe precedenti o uguali alla riga corrente nell'ordinamento della partizione. I valori produrranno spazi nella sequenza. Rank funziona anche quando i dati non sono ordinati e cercano modifiche nei valori.

rank()



reassociate
reassociate(<value1> : map, <value2> : binaryFunction) => map


Trasforma una mappa associando le chiavi ai nuovi valori. Accetta una funzione di mapping in cui è possibile indirizzare l'elemento come #key e il valore corrente come #value.

reassociate(['fruit' -> 'apple', 'vegetable' -> 'tomato'], substring(#key, 1, 1) + substring(#value, 1, 1)) => ['fruit' -> 'fa', 'vegetable' -> 'vt']



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


Accumula gli elementi in una matrice. Reduce prevede un riferimento a un enumeratore e un elemento nella prima funzione di espressione come #acc e #item e prevede che il valore risultante venga usato come #result nella seconda funzione di espressione.

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



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


Estrae una sottostringa corrispondente per un modello di espressione regolare specificato. L'ultimo parametro identifica il gruppo di corrispondenza e, se omesso, viene usato il valore predefinito 1. Usare <regex>(virgolette indietro) per trovare una corrispondenza con una stringa senza escape. L'indice 0 restituisce tutte le corrispondenze. Senza gruppi di corrispondenze, l'indice 1 e superiore non restituirà alcun risultato.

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 la stringa corrisponde al modello di espressione regolare specificato. Usare <regex>(virgolette indietro) per trovare una corrispondenza con una stringa senza escape.

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


Sostituire tutte le occorrenze di un criterio regex con un'altra sottostringa nella stringa specificata Usare <regex>(virgolette indietro) per trovare una corrispondenza con una stringa senza escape.

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 una stringa in base a un delimitatore in base all'espressione regolare e restituisce una matrice di stringhe.

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


Sostituisce tutte le occorrenze di una sottostringa con un'altra sottostringa nella stringa specificata. Se l'ultimo parametro viene omesso, per impostazione predefinita è una stringa vuota.

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



reverse
reverse(<value1> : string) => string


Inverte una stringa.

reverse('gunchus') -> 'suhcnug'



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


Estrae una sottostringa finale con il numero di caratteri specificato. Uguale a SUBSTRING(str, LENGTH(str) - n, n).

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



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


Verifica se la stringa corrisponde al modello di espressione regolare specificato.

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



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


Arrotonda un numero in base a una scala e a una modalità di arrotondamento facoltative. Se la scala viene omessa, il valore predefinito è 0. Se la modalità viene omessa, per impostazione predefinita viene ROUND_HALF_UP(5). I valori per l'arrotondamento includono

ROUND_UP - Modalità di arrotondamento per arrotondare da zero.
ROUND_DOWN - Modalità di arrotondamento per arrotondare verso zero.
ROUND_CEILING - Modalità di arrotondamento per arrotondare verso l'infinito positivo. [Uguale a ROUND_UP se l'input è positivo. Se negativo, si comporta come ROUND_DOWN. Ad esempio = -1.1 sarebbe -1.0 con ROUND_CEILING e -2 con ROUND_UP]
ROUND_FLOOR - Modalità di arrotondamento per arrotondare verso l'infinito negativo. [Uguale a ROUND_DOWN se l'input è positivo. Se negativo, si comporta come ROUND_UP]
ROUND_HALF_UP - Modalità di arrotondamento verso il "vicino più vicino" a meno che entrambi i vicini non siano equidistenti, nel qual caso ROUND_UP. [Più comune + impostazione predefinita per Il flusso di dati].
ROUND_HALF_DOWN - Modalità di arrotondamento verso il "vicino più vicino" a meno che entrambi i vicini non siano equidistenti, nel qual caso ROUND_DOWN.
ROUND_HALF_EVEN - Modalità di arrotondamento per arrotondare verso il "vicino più vicino" a meno che entrambi i vicini non siano equidistenti, nel qual caso, arrotondare verso il vicino pari.
ROUND_UNNECESSARY - Modalità arrotondamento per affermare che l'operazione di arrotondamento ha un risultato esatto, pertanto non è necessario arrotondamento.


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



rowNumber
rowNumber() => integer


Assegna un numero di righe sequenziale per le righe in una finestra a partire da 1.

rowNumber()


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


Riempie a destra la stringa in base al riempimento specificato fino a raggiungere una determinata lunghezza. Se la stringa è uguale o maggiore della lunghezza, viene tagliata fino alla lunghezza.

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



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


Destra taglia una stringa di caratteri finali. Se il secondo parametro non è specificato, rimuove lo spazio vuoto. Altrimenti taglia qualsiasi carattere specificato nel secondo parametro.

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


S

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


Ottiene il valore dei secondi di una data. È possibile passare un fuso orario facoltativo nel formato 'GMT', 'PST', 'UTC', 'America/Cayman'. Per impostazione predefinita viene usato il fuso orario locale. Per i formati disponibili, vedere la classe Java SimpleDateFormat . 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


Durata in millisecondi per il numero di secondi.

seconds(2) -> 2000L



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


Imposta le posizioni dei bit in questo bitset

setBitSet(toBitSet([10, 32]), [98]) => [4294968320L, 17179869184L]



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


Calcola il digest SHA-1 del set di colonne di tipi di dati primitivi variabili e restituisce una stringa esadecimale di 40 caratteri. Può essere usato per calcolare un'impronta digitale per una riga.

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



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


Calcola il digest SHA-2 di un set di colonne di diversi tipi di dati primitivi, data una lunghezza in bit che può avere solo i valori 0(256), 224, 256, 384 e 512. Può essere usato per calcolare un'impronta digitale per una riga.

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



sin
sin(<value1> : number) => double


Calcola un valore seno.

sin(2) -> 0.9092974268256817



sinh
sinh(<value1> : number) => double


Calcola un valore seno iperbolico.

sinh(0) -> 0.0



size
size(<value1> : any) => integer


Trova le dimensioni di una matrice o di un tipo di mappa

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



skewness
skewness(<value1> : number) => double


Ottiene l'asimmetria di una colonna.

skewness(sales)



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


In base a un criterio, ottiene l'asimmetria di una colonna.

skewnessIf(region == 'West', sales)



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


Estrae un subset di una matrice da una posizione. La posizione è in base 1. Se la lunghezza viene omessa, l'impostazione predefinita è la fine della stringa.

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


Ordina la matrice usando la funzione di predicato fornita. Sort prevede un riferimento a due elementi consecutivi nella funzione di espressione come #item1 e #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']



soundex
soundex(<value1> : string) => string


Ottiene il soundex codice per la stringa.

soundex('genius') -> 'G520'



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


Divide una stringa in base a un delimitatore e restituisce una matrice di stringhe.

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


Calcola la radice quadrata di un numero.

sqrt(9) -> 3



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


Controlla se la stringa inizia con la stringa specificata.

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



stddev
stddev(<value1> : number) => double


Ottiene la deviazione standard di una colonna.

stdDev(sales)



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


In base a un criterio, ottiene la deviazione standard di una colonna.

stddevIf(region == 'West', sales)



stddevPopulation
stddevPopulation(<value1> : number) => double


Ottiene la deviazione standard della popolazione di una colonna.

stddevPopulation(sales)



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


In base a un criterio, ottiene la deviazione standard della popolazione di una colonna.

stddevPopulationIf(region == 'West', sales)



stddevSample
stddevSample(<value1> : number) => double


Ottiene la deviazione standard del campione di una colonna.

stddevSample(sales)



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


In base a un criterio, ottiene la deviazione standard del campione di una colonna.

stddevSampleIf(region == 'West', sales)



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


Sottrae i giorni da una data o un timestamp. Uguale all'operatore - per date.

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



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


Sottrae mesi da una data o da un timestamp.

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


Estrae una sottostringa di una determinata lunghezza da una posizione. La posizione è in base 1. Se la lunghezza viene omessa, l'impostazione predefinita è la fine della stringa.

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) -> ''



substringIndex
substringIndex(<string to subset><delimiter>substringIndex( : string, : string, <count of delimiter occurences> : integral]) = string>


Estrae la sottostringa prima count delle occorrenze del delimitatore. Se count è positivo, viene restituito tutto a sinistra del delimitatore finale (conteggio dalla sinistra). Se count è negativo, viene restituito tutto a destra del delimitatore finale (conteggio dalla destra).


substringIndex('111-222-333', '-', 1) -> '111'
substringIndex('111-222-333', '-', 2) -> '111-222'
substringIndex('111-222-333', '-', -1) -> '333'
substringIndex('111-222-333', '-', -2) -> '222-333'



sum
sum(<value1> : number) => number


Ottiene la somma aggregata di una colonna numerica.

sum(col)



sumDistinct
sumDistinct(<value1> : number) => number


Ottiene la somma aggregata di valori distinti di una colonna numerica.

sumDistinct(col)



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


In base a criteri, ottiene la somma aggregata di una colonna numerica. La condizione può essere basata su qualsiasi colonna.

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



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


In base a criteri, ottiene la somma aggregata di una colonna numerica. La condizione può essere basata su qualsiasi colonna.

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


T

tan
tan(<value1> : number) => double


Calcola un valore tangente.

tan(0) -> 0.0



tanh
tanh(<value1> : number) => double


Calcola un valore tangente iperbolico.

tanh(0) -> 0.0



toBase64
toBase64(<value1> : string, <encoding type> : string]) => string


Codifica la stringa specificata in base64. Facoltativamente, è possibile passare il tipo di codifica

toBase64('bojjus') -> 'Ym9qanVz'
toBase64('± 25000, € 5.000,- |', 'Windows-1252') -> 'sSAyNTAwMCwggCA1LjAwMCwtIHw='



toBinary
toBinary(<value1> : any) => binary


Converte qualsiasi valore numerico/data/timestamp/stringa in rappresentazione binaria.

toBinary(3) -> [0x11]



toBoolean
toBoolean(<value1> : string) => boolean


Converte un valore di ('t', 'true', 'y', 'yes', '1') in true e ('f', 'false', 'n', 'no', '0') in false e NULL per qualsiasi altro valore.

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



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


Converte qualsiasi valore numerico o stringa in un valore di byte. Per la conversione è possibile usare un formato decimale Java facoltativo.

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



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


Converte la stringa della data di input in date usando un formato di data di input facoltativo. Per i formati disponibili, vedere la classe Java SimpleDateFormat . Se il formato della data di input viene omesso, il formato predefinito è aaaa-[M]M-[d]d. I formati accettati sono :[ yyyy, yyyy-[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 un valore numerico o stringa in un valore decimale. Se la precisione e la scala non vengono specificate, per impostazione predefinita viene impostato su (10,2). Per la conversione è possibile usare un formato decimale Java facoltativo. Formato delle impostazioni locali facoltativo sotto forma di linguaggio BCP47 come 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 un valore numerico o stringa in un valore double. Per la conversione è possibile usare un formato decimale Java facoltativo. Formato delle impostazioni locali facoltativo sotto forma di linguaggio BCP47 come 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 un valore numerico o stringa in un valore float. Per la conversione è possibile usare un formato decimale Java facoltativo. Tronca qualsiasi doppio.

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 un valore numerico o stringa in un valore integer. Per la conversione è possibile usare un formato decimale Java facoltativo. Tronca qualsiasi long, float, double.

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



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


Converte un valore numerico o stringa in un valore long. Per la conversione è possibile usare un formato decimale Java facoltativo. Tronca qualsiasi float, double.

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



topN
topN(<column/expression> : any, <count> : long, <n> : integer) => array


Ottiene i primi N valori per questa colonna in base all'argomento count.

topN(custId, count, 5)
topN(productId, num_sales, 10)



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


Converte un valore numerico o stringa in un valore short. Per la conversione è possibile usare un formato decimale Java facoltativo. Tronca qualsiasi integer, long, float, double.

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



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


Converte un tipo di dati primitivo in una stringa. Per numeri e date è possibile specificare un formato. Se non è specificato, viene selezionato il valore predefinito del sistema. Per i numeri viene usato il formato decimale Java. Per tutti i formati di data possibili, vedere Java SimpleDateFormat; il formato predefinito è aaaa-MM-gg. Per data o timestamp è possibile specificare le impostazioni locali facoltativamente.

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'
toString(toDate('12/31/18', 'MM/dd/yy', 'es-ES'), 'MM/dd/yy', 'de-DE')



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


Converte una stringa in un timestamp in base a un formato di timestamp facoltativo. Se il timestamp viene omesso, viene usato il modello predefinito aaaa-[M]M-[d]d hh:mm:ss[.f...]. È possibile passare un fuso orario facoltativo nel formato 'GMT', 'PST', 'UTC', 'America/Cayman'. Timestamp supporta fino a millisecondi di accuratezza con valore 999. Per i formati disponibili, vedere la classe Java SimpleDateFormat . 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 il timestamp in UTC. È possibile passare un fuso orario facoltativo nel formato 'GMT', 'PST', 'UTC', 'America/Cayman'. L'impostazione predefinita è il fuso orario corrente. Per i formati disponibili, vedere la classe Java SimpleDateFormat . 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


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


Sostituisce un set di caratteri con un altro set di caratteri nella stringa. I caratteri hanno una sostituzione da 1 a 1.

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



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


Rimuove i caratteri iniziali e finali di una stringa. Se il secondo parametro non è specificato, rimuove lo spazio vuoto. Altrimenti taglia qualsiasi carattere specificato nel secondo parametro.

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



true
true() => boolean


Restituisce sempre un valore true. Usare la funzione syntax(true()) se è presente una colonna denominata 'true'.

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



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


Trova corrispondenze tra tipi di colonne. Può essere usato solo nelle espressioni pattern.number corrisponde a short, integer, long, double, float o decimal, integral match short, integer, long, fractional match double, float, decimal e datetime corrisponde al tipo date o timestamp.

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


U

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


Annulla l'escape di una stringa in base a un formato. I valori letterali per il formato accettabile sono 'json', 'xml', 'ecmascript', 'html', 'java'.

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



unfold
unfold (<value1>: array) => any


Apre una matrice in un set di righe e ripete i valori per le colonne rimanenti in ogni riga.

unfold(addresses) => any
unfold( @(name = salesPerson, sales = salesAmount) ) => any



unhex
unhex(<value1>: string) => binary


Annulla l'hash di un valore binario dalla relativa rappresentazione di stringa. Può essere usato con sha2, md5 per eseguire la conversione da stringa a rappresentazione binaria

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)])


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


Restituisce un set di unioni di elementi distinti da 2 matrici.

union([10, 20, 30], [20, 40]) => [10, 20, 30, 40]



upper
upper(<value1> : string) => string


Maiuscole di una stringa.

upper('bojjus') -> 'BOJJUS'



uuid
uuid() => string


Restituisce l'UUID generato.

uuid()


V

variance
variance(<value1> : number) => double


Ottiene la varianza di una colonna.

variance(sales)



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


In base a un criterio, ottiene la varianza di una colonna.

varianceIf(region == 'West', sales)



variancePopulation
variancePopulation(<value1> : number) => double


Ottiene la varianza della popolazione di una colonna.

variancePopulation(sales)



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


In base a un criterio, ottiene la varianza della popolazione di una colonna.

variancePopulationIf(region == 'West', sales)



varianceSample
varianceSample(<value1> : number) => double


Ottiene la varianza non distorta di una colonna.

varianceSample(sales)



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


In base a un criterio, ottiene la varianza non distorta di una colonna.

varianceSampleIf(region == 'West', sales)


Me

weekOfYear
weekOfYear(<value1> : datetime) => integer


Ottiene la settimana dell'anno in base a una data.

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



weeks
weeks(<value1> : integer) => long


Durata in millisecondi per il numero di settimane.

weeks(2) -> 1209600000L


X

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


Operatore XOR logico. Uguale all'operatore ^ .

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


Y

year
year(<value1> : datetime) => integer


Ottiene il valore dell'anno di una data.

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

Contenuto correlato

Elenco di tutte le funzioni di aggregazione.
Elenco di tutte le funzioni di matrice.
Elenco di tutte le funzioni di ricerca memorizzate nella cache.
Elenco di tutte le funzioni di conversione.
Elenco di tutte le funzioni di data e ora.
Elenco di tutte le funzioni di espressione.
Elenco di tutte le funzioni della mappa.
Elenco di tutte le metafunzioni.
Elenco di tutte le funzioni finestra.
Informazioni su come usare il Generatore di espressioni.

Condividi tramite

Utilizzo delle espressioni di trasformazione dei dati nel flusso di dati di mapping

Elenco alfabetico di tutte le funzioni

Un

abs

acos

add

addDays

addMonths

and

approxDistinctCount

array

ascii

asin

assertErrorMessages

associate

at

atan

atan2

avg

avgIf

G

between

bitwiseAnd

bitwiseOr

bitwiseXor

blake2b

blake2bBinary

byItem

byName

byNames

byOrigin

byOrigins

byPath

byPosition

A

case

cbrt

ceil

char

coalesce

collect

collectUnique

columnNames

columns

compare

concat

concatWS

contains

cos

cosh

count

countAll

countDistinct

countAllDistinct

countIf

covariancePopulation

covariancePopulationIf

covarianceSample

covarianceSampleIf

crc32

cumeDist

currentDate

currentTimestamp

currentUTC

D

dayOfMonth

dayOfWeek

dayOfYear

days

decode

degrees

denseRank

distinct

divide

dropLeft

dropRight

E

encode

endsWith

`abs`

`acos`

`add`

`addDays`

`addMonths`

`and`

`approxDistinctCount`

`array`

`ascii`

`asin`

`assertErrorMessages`

`associate`

`at`

`atan`

`atan2`

`avg`

`avgIf`

`between`

`bitwiseAnd`

`bitwiseOr`

`bitwiseXor`

`blake2b`

`blake2bBinary`

`byItem`

`byName`

`byNames`

`byOrigin`

`byOrigins`

`byPath`

`byPosition`

`case`

`cbrt`

`ceil`

`char`

`coalesce`

`collect`

`collectUnique`

`columnNames`

`columns`

`compare`

`concat`

`concatWS`

`contains`

`cos`

`cosh`

`count`

`countAll`

`countDistinct`

`countAllDistinct`

`countIf`

`covariancePopulation`

`covariancePopulationIf`

`covarianceSample`

`covarianceSampleIf`

`crc32`

`cumeDist`

`currentDate`

`currentTimestamp`

`currentUTC`

`dayOfMonth`

`dayOfWeek`

`dayOfYear`

`days`

`decode`

`degrees`

`denseRank`

`distinct`

`divide`

`dropLeft`

`dropRight`

`encode`

`endsWith`

`equals`

`equalsIgnoreCase`

`escape`

`except`

`expr`

`factorial`

`false`

`filter`