Utilizzo dell’espressione per la trasformazione dei dati nel flusso di dati per mapping

Articolo
10/01/2024

SI APPLICA A: Azure Data Factory Azure Synapse Analytics

Suggerimento

Provare Data Factory in Microsoft Fabric, una soluzione di analisi all-in-one per le aziende. Microsoft Fabric copre tutto, dallo spostamento dati al data science, all'analisi in tempo reale, alla business intelligence e alla creazione di report. Vedere le informazioni su come iniziare una nuova prova gratuita!

I flussi di dati sono disponibili nelle pipeline sia di Azure Data Factory che di Azure Synapse. Questo articolo si applica ai flussi di dati per mapping. Se non si ha esperienza con le trasformazioni, vedere l'articolo introduttivo Trasformare i dati con un flusso di dati per 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 per mapping. Per i riepiloghi relativi a 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 per mapping.

Un

`abs`

abs(<value1> : number) => number

Valore assoluto di un numero.

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

`acos`

acos(<value1> : number) => double

Calcola il valore della funzione inversa del coseno.

acos(1) -> 0.0

`add`

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

Aggiunge una coppia di stringhe o numeri. Aggiunge una data a molti 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 la data.

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 dei valori distinti per una colonna. Il secondo parametro facoltativo consente di 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 il valore della funzione inversa del seno.

asin(0) -> 0.0

`assertErrorMessages`

assertErrorMessages() => map

Restituisce una mappa di tutti i messaggi di errore per la riga con l’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. Tutte le chiavi e i valori devono essere dello stesso tipo. Se non viene specificato alcun elemento, per impostazione predefinita viene impostato un mapping del tipo da stringa a 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 dell’indice di matrice. L'indice è in base 1. L'indice fuori intervallo 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 il valore della tangente inversa.

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 altri due valori in modo inclusivo. È possibile confrontare valori numerici, di stringa e di data/ora

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

`bitwiseAnd`

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

Operatore bitwise AND bit a bit tra tipi integrali. Uguale all'operatore &

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

`bitwiseOr`

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

Operatore bitwise OR bit a bit tra tipi integrali. Uguale all'operatore |

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

`bitwiseXor`

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

Operatore bitwise OR bit a bit tra tipi integrali. Uguale all'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 di un set di colonne di diversi tipi di dati primitivi, data una lunghezza in bit che può corrispondere solo a valori multipli di 8 compresi 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 di un set di colonne di diversi tipi di dati primitivi, data una lunghezza in bit che può corrispondere solo a valori multipli di 8 compresi 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 in base al tipo secondo una delle funzioni di conversione del tipo (? date, ? string ...). Riportare solo i nomi di colonna noti in fase di progettazione in base al relativo nome. Gli input calcolati non sono supportati, ma è possibile usare le sostituzioni di parametro.

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 in base al tipo secondo una delle funzioni di conversione del tipo (TO_DATE, TO_STRING ...). Riportare solo i nomi di colonna noti in fase di progettazione in base al relativo nome. Gli input calcolati non sono supportati, ma è possibile usare le sostituzioni di parametro.

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 delle funzioni di conversione del tipo (toDate, toString ...). Riportare solo i nomi di colonna noti in fase di progettazione in base al relativo nome. Gli input calcolati non sono supportati, ma è possibile usare le sostituzioni di parametro.

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 nel flusso di origine in base al nome. Il secondo argomento corrisponde al 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 in base al tipo secondo una delle funzioni di conversione del tipo (TO_DATE, TO_STRING ...). Riportare solo i nomi di colonna noti in fase di progettazione in base al relativo nome. Gli input calcolati non sono supportati, ma è possibile usare le sostituzioni di parametro.

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

`byOrigins`

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

Seleziona una matrice di colonne nel flusso in base al nome. Il secondo argomento corrisponde al 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 in base al tipo secondo una delle funzioni di conversione del tipo (TO_DATE, TO_STRING ...). Riportare solo i nomi di colonna noti in fase di progettazione in base al relativo nome. Gli input calcolati non sono supportati, ma è possibile usare le sostituzioni di parametro.

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

`byPath`

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

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

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 nell'intervallo, restituisce un valore NULL. Il valore restituito deve essere convertito in base al tipo secondo una delle funzioni di conversione del tipo (TO_DATE, TO_STRING ...). Gli input calcolati non sono supportati, ma è possibile usare le sostituzioni di parametro.

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 è NULL per impostazione predefinita in base all'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 cubica di un numero.

cbrt(8) -> 2.0

`ceil`

ceil(<value1> : number) => number

Restituisce l’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 il numero è maggiore di 256, il risultato è equivalente a char (numero % 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 è uguale al numero di righe nel gruppo e può contenere valori NULL. Il numero di elementi raccolti deve essere limitato.

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 unità. Durante questo processo è possibile raccogliere e trasformare le strutture in strutture alternative. Il numero di elementi è uguale al numero di righe nel gruppo e può contenere valori NULL. Il numero di elementi raccolti deve essere limitato.

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

`columnNames`

columnNames(<value1>columnNames( : stringa, i><value1> : booleano) => matrice Ottiene i nomi di tutte le colonne di output per un flusso. È possibile passare un nome di flusso facoltativo come primo argomento. Anche il secondo argomento è facoltativo, con false come valore predefinito. Se si imposta il secondo argomento su true(), Data Factory restituisce solo le etichette di colonna che vengono spostate tramite spostamento 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 intero negativo se value1 < value2, 0 se value1 == value2, un 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 le 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 il valore del coseno.

cos(10) -> -0.8390715290764524



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


Calcola il coseno iperbolico di un valore.

cosh(0) -> 1.0



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


Ottiene il conteggio aggregato dei valori. Se vengono specificate una o più 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 dei valori, inclusi i valori Null.

countAll(custId)
countAll()



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


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

countDistinct(custId, custName)



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


Ottiene il conteggio aggregato dei 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 campionaria di due colonne.

covarianceSample(sales, profit)



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


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

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



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


Calcola l'hash CRC32 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.

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. Tutti i valori di parità nell'ordinamento restituiscono la 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'. Per impostazione predefinita, viene usato il fuso orario locale del data center/area della data factory. 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 quando viene avviata l'esecuzione del processo con il 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 da quello del cluster, è 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. 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 in base a una data specificata.

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 specificata.

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 producono spazi nella sequenza. Dense Rank può essere eseguita anche quando i dati non sono ordinati e cerca eventuali variazioni dei valori.

denseRank()



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


Restituisce un set di elementi distinti da 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 lo stesso numero di caratteri dalla parte 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 lo stesso numero di caratteri dalla parte 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))



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 accettabili sono ''json'', ''xml'', ''ecmascript'', ''html'' e ''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 forma non letterale. Può essere usato per passare i parametri come rappresentazioni di stringa.

expr('price * discount') => tutti


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 dalla matrice gli elementi 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 di una matrice che soddisfa la condizione. Richiede una funzione di filtro in cui è possibile indirizzare l'elemento nella matrice come #item. Per le mappe annidate in modo approfondito, è possibile fare riferimento alle mappe dell’elemento padre usando la 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, Data Factory presuppone false.

first(sales)
first(sales, false)



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


Appiattisce la matrice o le matrici in una singola matrice. Le matrici di elementi atomici vengono restituite invariate. L'ultimo argomento è facoltativo e, per impostazione predefinita, impostato su false, in modo da appiattire ricorsivamente più di un livello di profondità.

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



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


Restituisce l'intero più grande non superiore al numero.

floor(-0.1) -> -1



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


Decodifica la stringa codificata in 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. Riportare solo i nomi di colonna noti in fase di progettazione in base al relativo nome. Gli input calcolati non sono supportati, ma è possibile usare le sostituzioni di parametro.

hasColumn('parent')



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


Controlla se l'asset con l'ID specificato è contrassegnato 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 o i percorsi delle colonne noti in fase di progettazione devono essere riportati solo in base al relativo nome o percorso di notazione col punto. Gli input calcolati non sono supportati, ma è possibile usare le sostituzioni di parametro.

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, il valore viene considerato NULL. Entrambi i valori devono essere compatibili (valore numerico, stringa...).

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


Dati due o più input, restituisce il primo elemento non NULL. Questa funzione equivale a unire.

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


Verifica la presenza di un elemento 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 in base agli 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 trovata, restituisce 0.

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



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


Restituisce un set di intersezione di elementi distinti da due matrici.

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



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


Controlla se in questo set di bit è impostata una posizione di bit

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



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


Controlla se il valore di 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 di stringa è un valore 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. Fare riferimento a SimpleDateFormat di Java per i formati disponibili. 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 di stringa è un valore decimale dato 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 è distinto. Non conta Null come valore distinto

isDistinct(custId, custName) => boolean



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


Controlla se il valore di stringa è un valore double dato un formato facoltativo 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 di 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 di stringa è un valore integer 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 di 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 di stringa è un valore short 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 della data di input è un timestamp usando un formato di timestamp di input facoltativo. Fare riferimento a SimpleDateFormat di Java per i formati disponibili. Se il timestamp viene omesso, viene usato il modello predefinito yyyy-[M]M-[d]d hh:mm:ss[.f...]. È possibile passare un fuso orario facoltativo nel formato 'GMT', 'PST', 'UTC', 'America/Cayman'. Il timestamp supporta un'accuratezza fino al millisecondo con un valore pari a 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 il secondo è la matrice di valori. Entrambe le matrici devono avere la stessa lunghezza.

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 il numero di righe è limitato, viene restituito un valore Null, a meno che non sia 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'ultimo giorno del mese in base a una data specificata.

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 il numero di righe è limitato, viene restituito un valore Null, a meno che non sia 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 di 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 simboli speciali seguenti: _ corrisponde a un carattere qualsiasi nell'input (simile a. nelle espressioni regolari posix) % corrisponde a zero o più caratteri nell'input (simile a .* nelle espressioni regolari posix).
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 è possibile aggiungere caratteri di escape a 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, è considerata dall'inizio della stringa. Se non trovata, restituisce 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 se viene usato un numero di Eulero.

log(100, 10) -> 2



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


Calcola il valore del logaritmo in base 10.

log10(100) -> 2



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


Cerca la prima riga del sink memorizzato nella cache usando le chiavi specificate che corrispondono a quelle di tale sink.

cacheSink#lookup(movieId)



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


Applica il formato minuscolo a tutti i caratteri 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 superiore alla lunghezza, viene troncata 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. In caso contrario, rimuove 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. Il mapping prevede un riferimento a un elemento nella funzione dell'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 di una matrice a un'altra matrice di lunghezza uguale o inferiore in modo condizionale. I valori possono provenire da qualsiasi tipo di dato, inclusi gli 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 dell’elemento padre usando la notazione #item_[n](#item_1, #index_1...).

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. Il mapping prevede un riferimento a un elemento nella funzione dell'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 alla 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 alle mappe dell’elemento padre usando la notazione #index_n(#index_1, #index_2...).

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 di un set di colonne di diversi tipi di dati primitivi e restituisce una stringa esadecimale a 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 all'operatore AVG.

mean(sales)



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


In base a un criterio, ottiene la media dei valori di una colonna. Uguale all'operatore avglf.

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 del sink memorizzato nella cache usando le chiavi specificate che corrispondono a quelle di tale sink.

cacheSink#mlookup(movieId)



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


Calcola il modulo di coppie di numeri. Uguale all'operatore 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 i 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 da partitionId.

nextSequence() == 12313112 -> false



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


Normalizza il valore della stringa per 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 funzione NTile divide le righe per ogni partizione di finestra in bucket n compresi tra 1 e un valore massimo di n. I valori dei bucket si differenzieranno per un massimo di 1. Se il numero di righe nella partizione non può essere diviso equamente in base al numero di bucket, i valori rimanenti vengono distribuiti uno per bucket, a partire dal primo bucket. La funzione NTile è particolarmente 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, a cui verrà aggiunta una riga in più. 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 usata restituirà 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. Ugual 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 le colonne. Deve essere racchiusa 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 di 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


Eleva 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. La funzione rank può essere eseguita anche quando i dati non sono ordinati e cerca eventuali variazioni dei 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. La funzione di riduzione prevede un riferimento a un accumulatore e un elemento nella prima funzione di espressione come #acc e #item e prevede che il valore risultante sia #result da usare nella seconda funzione dell'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> (apice inverso) per trovare una corrispondenza con una stringa senza caratteri di 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> (apice inverso) per trovare una corrispondenza con una stringa senza caratteri di 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


Sostituisce tutte le occorrenze di un modello di espressione regolare con un'altra sottostringa nella stringa specificata. Usare <regex> (apice inverso) per trovare una corrispondenza con una stringa senza caratteri di 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


Suddivide una stringa in base a un delimitatore basato su un'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, il valore predefinito è 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 all'operatore 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, viene usato il valore predefinito 0. Se la modalità di arrotondamento viene omessa, viene usato il valore predefinito ROUND_HALF_UP(5). I valori per l'arrotondamento includono

ROUND_UP: modalità di arrotondamento per allontanarsi da zero.
ROUND_DOWN: modalità di arrotondamento per avvicinarsi allo zero.
ROUND_CEILING: modalità di arrotondamento per avvicinarsi all'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 avvicinarsi all'infinito negativo. [Uguale a ROUND_DOWN se l'input è positivo. Se negativo, si comporta come ROUND_UP]
ROUND_HALF_UP: modalità di arrotondamento per avvicinarsi al "vicino più prossimo", a meno che entrambi i vicini non siano equidistanti. In tal caso, si tratta della modalità ROUND_UP. [Più comune + impostazione predefinita per il flusso di dati].
ROUND_HALF_DOWN: modalità di arrotondamento per avvicinarsi al "vicino più prossimo", a meno che entrambi i vicini non siano equidistanti. In tal caso, si tratta della modalità ROUND_DOWN.
ROUND_HALF_EVEN: modalità di arrotondamento per avvicinarsi al "vicino più prossimo", a meno che entrambi i vicini non siano equidistanti. In tal caso, arrotondare al vicino pari.
ROUND_UNNECESSARY: modalità di arrotondamento per affermare che l'operazione di arrotondamento genera un risultato esatto. Pertanto, non è necessario alcun arrotondamento.


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



rowNumber
rowNumber() => integer


Assegna una numerazione sequenziale alle 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 superiore alla lunghezza, viene troncata in base a tale lunghezza.

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



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


Rimuove i caratteri finali dal lato destro di una stringa. Se il secondo parametro non è specificato, rimuove lo spazio vuoto. In caso contrario, rimuove 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 di bit in questo set di bit

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



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


Calcola il digest SHA-1 di un set di colonne di diversi tipi di dati primitivi e restituisce una stringa esadecimale a 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 il valore del seno.

sin(2) -> 0.9092974268256817



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


Calcola il valore del 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’indice di asimmetria di una colonna.

skewness(sales)



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


In base a un criterio, ottiene l'indice di 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, per impostazione predefinita viene estratta la parte finale 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 dell'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 codice soundex per la stringa.

soundex('genius') -> 'G520'



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


Suddivide 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 campionaria di una colonna.

stddevSample(sales)



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


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

stddevSampleIf(region == 'West', sales)



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


Sottrae mesi da una data o da un timestamp. Uguale all'operatore - per la data.

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, per impostazione predefinita viene estratta la parte finale 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(<da stringa a sottoinsieme><delimitatore>substringIndex( : stringa,  : stringa, <conteggio delle occorrenze del delimitatore> : integrale]) => stringa


Estrae la sottostringa prima del count delle occorrenze del delimitatore. Se count è positivo, viene restituito tutto ciò che si trova a sinistra del delimitatore finale (conteggio da sinistra). Se count è negativo, viene restituito tutto ciò che si trova a destra del delimitatore finale (conteggio da 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 il valore della tangente.

tan(0) -> 0.0



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


Calcola il valore della tangente iperbolica.

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 numeri/dati/timestamp/stringa in una rappresentazione binaria.

toBinary(3) -> [0x11]



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


Converte un valore ("t", "true", "y", "yes", "1") in true e un valore ("f", "false", "n", "no", "0") in false e in 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 un valore numerico o stringa in un valore 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 vengono impostate su (10,2). Per la conversione è possibile usare un formato decimale Java facoltativo. Un formato facoltativo per le impostazioni locali sotto forma di linguaggio BCP47, ad esempio 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. Un formato facoltativo per le impostazioni locali sotto forma di linguaggio BCP47, ad esempio 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 valore double.

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 valore 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 valore float, double.

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



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


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

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 valore 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. Fare riferimento a SimpleDateFormat di Java per tutti i formati di data disponibili. 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-[g]g hh:mm:ss[.f...]. È possibile passare un fuso orario facoltativo nel formato 'GMT', 'PST', 'UTC', 'America/Cayman'. Il timestamp supporta un livello di accuratezza fino al millisecondo con un valore pari a 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'. Per impostazione predefinita viene usato 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. Viene eseguita 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. In caso contrario, rimuove 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 del criterio. Number trova corrispondenze con short, integer, long, double, float o decimal; integral trova corrispondenze con short, integer o long; fractional trova corrispondenze con double, float o decimal; datetime trova corrispondenze con il 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 accettabili sono ''json'', ''xml'', ''ecmascript'', ''html'' e ''java''.

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



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


Espande 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


Scompone un valore binario nella sua 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


Applica il formato maiuscolo a tutti i caratteri 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 imparziale di una colonna.

varianceSample(sales)



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


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

varianceSampleIf(region == 'West', sales)


W

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


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

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 dell’espressione per la trasformazione dei dati nel flusso di dati per 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`