Gli assistenti Spark SQL forniscono funzioni Spark SQL integrate per estendere le funzionalità SQL.
Riferimento: Documentazione della funzione SQL Spark
Non tutte le funzioni della documentazione esterna sono supportate.
expr1 % expr2
: Restituisce il resto dopo expr1
/expr2
.
Esempi:
> SELECT 2 % 1.8;
0.2
> SELECT MOD(2, 1.8);
0.2
expr1 * expr2
: Restituisce expr1
*expr2
.
Esempio:
> SELECT 2 * 3;
6
expr1 + expr2
: Restituisce expr1
+expr2
.
Esempio:
> SELECT 1 + 2;
3
expr1 - expr2
: Restituisce expr1
-expr2
.
Esempio:
> SELECT 2 - 1;
1
expr1 / expr2
: Restituisce expr1
/expr2
. Esegue sempre la divisione in virgola mobile.
Esempi:
> SELECT 3 / 2;
1.5
> SELECT 2L / 2L;
1.0
abs(expr)
: Restituisce il valore assoluto del valore numerico.
Esempio:
> SELECT abs(-1);
1
acos(expr)
: Restituisce il coseno inverso (detto anche coseno di arco) di expr
, come se fosse calcolato da java.lang.Math.acos
.
Esempi:
> SELECT acos(1);
0.0
> SELECT acos(2);
NaN
approx_percentile(col, percentage [, accuracy])
: Restituisce il valore percentile approssimativo della colonna numerica col
alla percentuale specificata. Il valore della percentuale deve essere compreso tra 0,0 e 1,0. Il accuracy
parametro (predefinito: 10000) è un letterale numerico positivo che controlla la precisione di approssimazione al costo della memoria. Più alto è il valore dei accuracy
rendimenti più precisi, 1.0/accuracy
è l'errore relativo dell'approssimazione. Quando percentage
è un array, ogni valore dell'array di percentuali deve essere compreso tra 0,0 e 1,0. In questo caso, viene restituito l'array percentile approssimativo della colonna col
all'array di percentuali specificato.
Esempi:
> SELECT approx_percentile(10.0, array(0.5, 0.4, 0.1), 100);
[10.0,10.0,10.0]
> SELECT approx_percentile(10.0, 0.5, 100);
10.0
asin(expr)
: Restituisce il seno inverso (detto anche sinusoidale di arco), l'arco sinusoidale di expr
, come se fosse calcolato da java.lang.Math.asin
.
Esempi:
> SELECT asin(0);
0.0
> SELECT asin(2);
NaN
atan(expr)
: Restituisce la tangente inversa (nota anche come tangente ad arco) di expr
, come se calcolata da java.lang.Math.atan
Esempio:
> SELECT atan(0);
0.0
atan2(exprY, exprX)
: Restituisce l'angolo in radianti tra l'asse x positivo di un piano e il punto dato dalle coordinate (exprX
, exprY
), come se fosse calcolato da java.lang.Math.atan2
.
Argomenti:
exprY
: Coordinata sull'asseexprX
y: Coordinata sull'asse x
Esempio:
> SELECT atan2(0, 0);
0.0
avg(expr)
: Restituisce la media calcolata dai valori di un gruppo.
cardinality(expr)
: Restituisce la dimensione di un array o di una mappa. La funzione restituisce -1 se il relativo input è null e spark.sql.legacy.sizeOfNull
è impostato su true (predefinito). Se spark.sql.legacy.sizeOfNull
è impostata su false, la funzione restituisce null per l'input nullo.
Esempi:
> SELECT cardinality(array('b', 'd', 'c', 'a'));
4
> SELECT cardinality(map('a', 1, 'b', 2));
2
> SELECT cardinality(NULL);
-1
cbrt(expr)
: Restituisce la radice del cubo di expr
.
Esempio:
> Select cbrt(27.0);
3.0
ceil(expr)
: Restituisce il numero intero più piccolo non più piccolo di expr
.
Esempi:
> SELECT ceil(-0.1);
0
> SELECT ceil(5);
5
ceiling(expr)
: Restituisce il numero intero più piccolo non più piccolo di expr
.
Esempi:
> SELECT ceiling(-0.1);
0
> SELECT ceiling(5);
5
conv(num, from_base, to_base)
: Converti num
da from_base
a to_base
Esempi:
> SELECT conv('100', 2, 10);
4
> SELECT conv(-10, 16, -10);
-16
corr(expr1, expr2)
: Restituisce il coefficiente di correlazione Pearson tra un insieme di coppie di numeri.
cos(expr)
: Restituisce il coseno di expr
, come se fosse calcolato da java.lang.Math.cos
.
Esempio:
> SELECT cos(0);
1.0
cosh(expr)
: Restituisce il coseno iperbolico di expr
, come se fosse calcolato da java.lang.Math.cosh
.
Argomenti:
expr
: Angolo iperbolicoEsempio:
> SELECT cosh(0);
1.0
cot(expr)
: Restituisce la cotangente di expr
, come se fosse calcolata da 1/java.lang.Math.cot
.
Argomenti:
expr
: Angolo in radiantiEsempio:
> SELECT cot(1);
0.6420926159343306
dense_rank()
: Calcola il grado di un valore in un gruppo di valori. Il risultato è uno più il valore di classifica precedentemente assegnato. A differenza della funzione rank
, dense_rank
non crea spazi nella sequenza di classifica.
e()
: Restituisce il numero di Eulero, e.
Esempio:
> SELECT e();
2.718281828459045
exp(expr)
: Restituisce e alla potenza di expr
.
Esempio:
> SELECT exp(0);
1.0
expm1(expr)
: Restituisce exp(expr
) - 1.
Esempio:
> SELECT expm1(0);
0.0
factorial(expr)
: Restituisce il fattoriale di expr
. expr
è [0.20]. In caso contrario, null.
Esempio:
> SELECT factorial(5);
120
floor(expr)
: Restituisce il numero intero più grande non maggiore di expr
.
Esempi:
> SELECT floor(-0.1);
-1
> SELECT floor(5);
5
greatest(expr, ...)
: Restituisce il valore massimo di tutti i parametri, ignorando i valori null.
Esempio:
> SELECT greatest(10, 9, 2, 4, 3);
10
hypot(expr1, expr2)
: Restituisce sqrt(expr1
2 + expr2
2).
Esempio:
> SELECT hypot(3, 4);
5.0
kurtosis(expr)
: Restituisce il valore della curtosi calcolato in base ai valori di un gruppo.
least(expr, ...)
: Restituisce il valore minimo di tutti i parametri, ignorando i valori null.
Esempio:
> SELECT least(10, 9, 2, 4, 3);
2
levenshtein(str1, str2)
: Restituisce la distanza di Levenshtein tra le due stringhe specificate.
Esempi:
> SELECT levenshtein('kitten', 'sitting');
3
ln(expr)
: Restituisce il logaritmo naturale (base e) di expr
.
Esempio:
> SELECT ln(1);
0.0
log(base, expr)
: Restituisce il logaritmo di expr
con base
.
Esempio:
> SELECT log(10, 100);
2.0
log10(expr)
: Restituisce il logaritmo di expr
con base 10.
Esempio:
> SELECT log10(10);
1.0
log1p(expr)
: Restituisce log(1 + expr)
.
Esempio:
> SELECT log1p(0);
0.0
log2(expr)
: Restituisce il logaritmo di expr
con base 2.
Esempio:
> SELECT log2(2);
1.0
max(expr)
: Restituisce il valore massimo di expr
.
mean(expr)
: Restituisce la media calcolata dai valori di un gruppo.
min(expr)
: Restituisce il valore minimo di expr
.
monotonically_increasing_id()
: Restituisce numeri interi a 64 bit in aumento monotonico. L’ID generato è garantito in modo monotonico crescente e univoco, ma non consecutivo. L'implementazione corrente inserisce l'ID della partizione nei 31 bit superiori, mentre i 33 bit inferiori rappresentano il numero di record all'interno di ogni partizione. Il presupposto è che la cornice dati ha meno di 1 miliardo di partizioni, e ogni partizione ha meno di 8 miliardi di record. La funzione non è deterministica perché il risultato dipende dagli ID della partizione.
negative(expr)
: Restituisce il valore negativo di expr
.
Esempio:
> SELECT negative(1);
-1
percent_rank()
: Calcola la classificazione percentuale di un valore in un gruppo di valori.
percentile(col, percentage [, frequency])
: Restituisce il valore percentile esatto della colonna numerica col
alla percentuale specificata. Il valore di percentage
deve essere compreso tra 0,0 e 1,0. Il valore di frequency
dovrebbe essere integrale positivo.
percentile(col, array(percentage1 [, percentage2]...) [, frequency])
: Restituisce l'array di valori percentili esatti della colonna numerica col
in corrispondenza delle percentuali specificate. Ogni valore dell'array di percentuali deve essere compreso tra 0,0 e 1,0. Il valore di frequency
dovrebbe essere integrale positivo.
percentile_approx(col, percentage [, accuracy])
: Restituisce il valore percentile approssimativo della colonna numerica col
alla percentuale specificata. Il valore di percentage
deve essere compreso tra 0,0 e 1,0. Il accuracy
parametro (predefinito: 10000) è un letterale numerico positivo che controlla la precisione di approssimazione al costo della memoria. Più alto è il valore dei accuracy
rendimenti più precisi, 1.0/accuracy
è l'errore relativo dell'approssimazione. Quando percentage
è un array, ogni valore dell'array di percentuali deve essere compreso tra 0,0 e 1,0. In questo caso, restituisce l'array percentile approssimativo di colonna col
alla matrice percentuale specificata.
Esempi:
> SELECT percentile_approx(10.0, array(0.5, 0.4, 0.1), 100);
[10.0,10.0,10.0]
> SELECT percentile_approx(10.0, 0.5, 100);
10.0
pi()
: Restituisce pi.
Esempio:
> SELECT pi();
3.141592653589793
pmod(expr1, expr2)
: Restituisce il valore positivo di expr1
mod expr2
.
Esempi:
> SELECT pmod(10, 3);
1
> SELECT pmod(-10, 3);
2
positive(expr)
: Restituisce il valore positivo di expr
pow(expr1, expr2)
: Aumenta expr1
al potere di expr2
.
Esempio:
> SELECT pow(2, 3);
8.0
power(expr1, expr2)
: Aumenta expr1
al potere di expr2
.
Esempi:
> SELECT power(2, 3);
8.0
radians(expr)
: Converte i gradi in radianti.
Argomenti:
expr
: Angolo in gradiEsempio:
> SELECT radians(180);
3.141592653589793
rand([seed])
: Restituisce un valore casuale con valori distribuiti in modo indipendente e identico (i.i.d.) in modo uniforme in (0, 1).
Esempi:
> SELECT rand();
0.9629742951434543
> SELECT rand(0);
0.8446490682263027
> SELECT rand(null);
0.8446490682263027
Questa funzione non è deterministica in generale.
randn([seed])
: Restituisce un valore casuale con valori indipendenti e distribuiti in modo identico (i.i.d.) provenienti dalla distribuzione normale standard.
Esempi:
> SELECT randn();
-0.3254147983080288
> SELECT randn(0);
1.1164209726833079
> SELECT randn(null);
1.1164209726833079
Questa funzione non è deterministica in generale.
rint(expr)
: Restituisce il valore doppio più vicino in valore all'argomento ed è uguale a un numero intero matematico.
Esempi:
> SELECT rint(12.3456);
12.0
round(expr, d)
: Restituisce expr
arrotondato a d
posizioni decimali utilizzando la modalità di arrotondamento HALF_UP.
Esempio:
> SELECT round(2.5, 0);
3.0
sign(expr)
: Restituisce -1,0, 0,0 o 1,0 come expr
negativo, 0 o positivo.
Esempio:
> SELECT sign(40);
1.0
signum(expr)
: Restituisce -1,0, 0,0 o 1,0 come expr
negativo, 0 o positivo.
Esempio:
> SELECT signum(40);
1.0
sin(expr)
: Restituisce il seno di expr
, come se fosse calcolato da java.lang.Math.sin
.
Argomenti:
expr
: Angolo in radiantiEsempio:
> SELECT sin(0);
0.0
sinh(expr)
: Restituisce un seno iperbolico di expr
, come se fosse calcolato da java.lang.Math.sinh
.
Argomenti:
expr
: Angolo iperbolicoEsempio:
> SELECT sinh(0);
0.0
sqrt(expr)
: Restituisce la radice quadrata di expr
.
Esempio:
> SELECT sqrt(4);
2.0
stddev(expr)
: Restituisce la deviazione standard del campione calcolata dai valori di un gruppo.
sttdev_pop(expr)
: Restituisce la deviazione standard della popolazione calcolata dai valori di un gruppo.
stddev_samp(expr)
: Restituisce la deviazione standard del campione calcolata dai valori di un gruppo.
sum(expr)
: Restituisce la somma calcolata dai valori di un gruppo.
tan(expr)
: Restituisce la tangente di expr
, come se calcolata da java.lang.Math.tan
.
Argomenti:
expr
: Angolo in radiantiEsempio:
> SELECT tan(0);
0.0
tanh(expr)
: Restituisce la tangente iperbolica di expr
, come se fosse calcolata da java.lang.Math.tanh
.
Argomenti:
expr
: Angolo iperbolicoEsempio:
> SELECT tanh(0);
0.0
var_pop(expr)
: Restituisce la varianza della popolazione calcolata in base ai valori di un gruppo.
var_samp(expr)
: Restituisce la varianza del campione calcolata dai valori di un gruppo.
variance(expr)
: Restituisce la varianza del campione calcolata dai valori di un gruppo.
! expr
: Not logico.
expr1 < expr2
: Restituisce true se expr1
è minore di expr2
.
Argomenti:
expr1, expr2
: Le due espressioni devono essere dello stesso tipo oppure possono essere inserite in un tipo comune e devono essere un tipo che può essere ordinato. Ad esempio, il tipo di mappa non è ordinabile, quindi non è supportato. Per tipi complessi, ad esempio matrice/struttura, i tipi di dati dei campi devono essere ordinabili.Esempi:
> SELECT 1 < 2;
true
> SELECT 1.1 < '1';
false
> SELECT to_date('2009-07-30 04:17:52') < to_date('2009-07-30 04:17:52');
false
> SELECT to_date('2009-07-30 04:17:52') < to_date('2009-08-01 04:17:52');
true
> SELECT 1 < NULL;
NULL
expr1 <= expr2
: Restituisce true se expr1
è minore o uguale a expr2
.
Argomenti:
expr1, expr2
: Le due espressioni devono essere dello stesso tipo o possono essere collegate a un tipo comune e devono essere un tipo che può essere ordinato. Ad esempio, il tipo di mappa non è ordinabile, quindi non è supportato. Per tipi complessi come array/struttura, i tipi di dati dei campi devono essere ordinabili.Esempi:
> SELECT 2 <= 2;
true
> SELECT 1.0 <= '1';
true
> SELECT to_date('2009-07-30 04:17:52') <= to_date('2009-07-30 04:17:52');
true
> SELECT to_date('2009-07-30 04:17:52') <= to_date('2009-08-01 04:17:52');
true
> SELECT 1 <= NULL;
NULL
expr1 = expr2
: Restituisce true se expr1
è uguale a expr2
, oppure false in caso contrario.
Argomenti:
expr1, expr2
: Le due espressioni devono essere dello stesso tipo oppure possono essere inserite in un tipo comune e devono essere un tipo che può essere utilizzato per il confronto di uguaglianza. Il tipo di mappa non è supportato. Per tipi complessi, ad esempio matrice/struttura, i tipi di dati dei campi devono essere ordinabili.Esempi:
> SELECT 2 = 2;
true
> SELECT 1 = '1';
true
> SELECT true = NULL;
NULL
> SELECT NULL = NULL;
NULL
expr1 > expr2
: Restituisce true se expr1
è maggiore di expr2
.
Argomenti:
expr1, expr2
: Le due espressioni devono essere dello stesso tipo oppure possono essere inserite in un tipo comune e devono essere un tipo che può essere ordinato. Ad esempio, il tipo di mappa non è ordinabile, quindi non è supportato. Per tipi complessi, ad esempio matrice/struttura, i tipi di dati dei campi devono essere ordinabili.Esempi:
> SELECT 2 > 1;
true
> SELECT 2 > '1.1';
true
> SELECT to_date('2009-07-30 04:17:52') > to_date('2009-07-30 04:17:52');
false
> SELECT to_date('2009-07-30 04:17:52') > to_date('2009-08-01 04:17:52');
false
> SELECT 1 > NULL;
NULL
expr1 >= expr2
: Restituisce true se expr1
è maggiore o uguale a expr2
.
Argomenti:
expr1, expr2
: Le due espressioni devono essere dello stesso tipo oppure possono essere inserite in un tipo comune e devono essere un tipo che può essere ordinato. Ad esempio, il tipo di mappa non è ordinabile, quindi non è supportato. Per tipi complessi, ad esempio matrice/struttura, i tipi di dati dei campi devono essere ordinabili.Esempi:
> SELECT 2 >= 1;
true
> SELECT 2.0 >= '2.1';
false
> SELECT to_date('2009-07-30 04:17:52') >= to_date('2009-07-30 04:17:52');
true
> SELECT to_date('2009-07-30 04:17:52') >= to_date('2009-08-01 04:17:52');
false
> SELECT 1 >= NULL;
NULL
expr1 ^ expr2
: Restituisce il risultato di OR bit a bit esclusivo di expr1
e expr2
.
Esempio:
> SELECT 3 ^ 5;
2
expr1 and expr2
: AND logico.
arrays_overlap(a1, a2)
: Restituisce true se un1 contiene almeno un elemento non-null presente anche in a2. Se le matrici non hanno un elemento comune e non sono entrambe vuote e una di esse contiene un elemento null, viene restituito null. In caso contrario, viene restituito false.
Esempio:
> SELECT arrays_overlap(array(1, 2, 3), array(3, 4, 5));
true
Dal: 2.4.0
assert_true(expr)
: Genera un'eccezione se expr
non è vera.
Esempio:
> SELECT assert_true(0 < 1);
NULL
if(expr1, expr2, expr3)
: Se expr1
restituisce true, restituisce expr2
; altrimenti restituisce expr3
.
Esempio:
> SELECT if(1 < 2, 'a', 'b');
a
ifnull(expr1, expr2)
: Restituisce expr2
se expr1
è null o expr1
in caso contrario.
Esempio:
> SELECT ifnull(NULL, array('2'));
["2"]
expr1 in(expr2, expr3, ...)
: Restituisce true se expr
è uguale a qualsiasi valore valN.
Argomenti:
expr1, expr2, expr3, ...
: Gli argomenti devono essere dello stesso tipo.Esempi:
> SELECT 1 in(1, 2, 3);
true
> SELECT 1 in(2, 3, 4);
false
> SELECT named_struct('a', 1, 'b', 2) in(named_struct('a', 1, 'b', 1), named_struct('a', 1, 'b', 3));
false
> SELECT named_struct('a', 1, 'b', 2) in(named_struct('a', 1, 'b', 2), named_struct('a', 1, 'b', 3));
true
isnan(expr)
: Restituisce true se expr
è NaN o false in caso contrario.
Esempio:
> SELECT isnan(cast('NaN' as double));
true
isnotnull(expr)
: Restituisce true se non expr
è null o false in caso contrario.
Esempi:
> SELECT isnotnull(1);
true
isnull(expr)
: Restituisce true se expr
è null o false in caso contrario.
Esempio:
> SELECT isnull(1);
false
nanvl(expr1, expr2)
: Restituisce expr1
se non è NaN o expr2
in altro modo.
Esempio:
> SELECT nanvl(cast('NaN' as double), 123);
123.0
not expr
: Not logico.
expr1 or expr2
: OR logico.
xpath_boolean(xml, xpath)
: Restituisce true se l'espressione XPath restituisce true o se viene trovato un nodo corrispondente.
Esempio:
> SELECT xpath_boolean('<a><b>1</b></a>','a/b');
true
add_months(start_date, num_months)
: Restituisce la data num_months
successiva a start_date
.
Esempio:
> SELECT add_months('2016-08-31', 1);
2016-09-30
Dal: 1,5,0
date_add(start_date, num_days)
: Restituisce la data num_days
successiva a start_date
.
Esempio:
> SELECT date_add('2016-07-30', 1);
2016-07-31
Dal: 1,5,0
date_format(timestamp, fmt)
: Effettua la conversione timestamp
in un valore di stringa nel formato specificato dal formato data fmt
.
Esempio:
> SELECT date_format('2016-04-08', 'y');
2016
Dal: 1,5,0
date_sub(start_date, num_days)
: Restituisce la data num_days
precedente start_date
.
Esempio:
> SELECT date_sub('2016-07-30', 1);
2016-07-29
Dal: 1,5,0
date_trunc(fmt, ts)
: Restituisce le marche temporali troncate all'unità specificata dal modello di formato fmt
. fmt
Deve essere uno di ["ANNO", "AAAA", "AA", "MON", "MESE", "MM", "GIORNO", "GG", "ORA", "MINUTO", "SECONDO", "SETTIMANA", "TRIMESTRE"]
Esempi:
> SELECT date_trunc('YEAR', '2015-03-05T09:32:05.359');
2015-01-01 00:00:00
> SELECT date_trunc('MM', '2015-03-05T09:32:05.359');
2015-03-01 00:00:00
> SELECT date_trunc('DD', '2015-03-05T09:32:05.359');
2015-03-05 00:00:00
> SELECT date_trunc('HOUR', '2015-03-05T09:32:05.359');
2015-03-05 09:00:00
Dal: 2.3.0
datediff(endDate, startDate)
: Restituisce il numero di giorni da startDate
a endDate
.
Esempi:
> SELECT datediff('2009-07-31', '2009-07-30');
1
> SELECT datediff('2009-07-30', '2009-07-31');
-1
Dal: 1,5,0
day(date)
: Restituisce il giorno del mese della data/marca temporale.
Esempio:
> SELECT day('2009-07-30');
30
Dal: 1,5,0
dayofmonth(date)
: Restituisce il giorno del mese della data/marca temporale.
Esempio:
> SELECT dayofmonth('2009-07-30');
30
Dal: 1,5,0
dayofweek(date)
: Restituisce il giorno della settimana per data/marca temporale (1 = domenica, 2 = lunedì, …, 7 = sabato).
Esempio:
> SELECT dayofweek('2009-07-30');
5
Dal: 2.3.0
dayofyear(date)
: Restituisce il giorno dell’anno della data/marca temporale.
Esempio:
> SELECT dayofyear('2016-04-09');
100
Dal: 1,5,0
from_unixtime(unix_time, format)
: Restituisce unix_time
il valore specificato format
.
Esempio:
> SELECT from_unixtime(0, 'yyyy-MM-dd HH:mm:ss');
1970-01-01 00:00:00
Dal: 1,5,0
from_utc_timestamp(timestamp, timezone)
: Interpreta una marca temporale come '2017-07-14 02:40:00.0' come ora in UTC, e la riproduce come marca temporale nel fuso orario specificato. Ad esempio, 'GMT+1' restituirebbe '2017-07-14 03:40:00.0'.
Esempio:
> SELECT from_utc_timestamp('2016-08-31', 'Asia/Seoul');
2016-08-31 09:00:00
Dal: 1,5,0
hour(timestamp)
: Restituisce il componente ora della stringa/marca temporale.
Esempio:
> SELECT hour('2009-07-30 12:58:59');
12
Dal: 1,5,0
last_day(date):
Restituisce l'ultimo giorno del mese a cui la data appartiene.
Esempio:
> SELECT last_day('2009-01-12');
2009-01-31
Dal: 1,5,0
minute(timestamp)
: Restituisce il componente minuto della stringa/marca temporale.
Esempio:
> SELECT minute('2009-07-30 12:58:59');
58
Dal: 1,5,0
month(date)
Restituisce il componente del mese della data/marca temporale.
Esempio:
> SELECT month('2016-07-30');
7
Dal: 1,5,0
months_between(timestamp1, timestamp2[, roundOff])
: Se timestamp1
è successiva a timestamp2
, il risultato è positivo. Se timestamp1
e timestamp2
lo stesso giorno del mese, o se entrambi sono l'ultimo giorno del mese, l'ora del giorno verrà ignorata. In caso contrario, la differenza viene calcolata in base a 31 giorni al mese e arrotondata a 8 cifre a meno che roundOff=false
.
Esempi:
> SELECT months_between('1997-02-28 10:30:00', '1996-10-30');
3.94959677
> SELECT months_between('1997-02-28 10:30:00', '1996-10-30', false);
3.9495967741935485
Dal: 1,5,0
next_day(start_date, day_of_week)
: Restituisce la prima data successiva a quella indicata start_date
e denominata come indicato.
Esempio:
> SELECT next_day('2015-01-14', 'TU');
2015-01-20
Dal: 1,5,0
quarter(date)
: Restituisce il trimestre dell'anno per la data, compreso tra 1 e 4.
Esempio:
> SELECT quarter('2016-08-31');
3
Dal: 1,5,0
second(timestamp)
: Restituisce il secondo componente della stringa/marca temporale.
Esempio:
> SELECT second('2009-07-30 12:58:59');
59
Dal: 1,5,0
to_date(date_str[, fmt])
: Analizza l' date_str
espressione con l' fmt
espressione fino a una data. Restituisce null con input non valido. Per impostazione predefinita, segue le regole di inserimento a una data se l'oggetto fmt
viene omesso.
Esempi:
> SELECT to_date('2009-07-30 04:17:52');
2009-07-30
> SELECT to_date('2016-12-31', 'yyyy-MM-dd');
2016-12-31
Dal: 1,5,0
to_timestamp(timestamp[, fmt])
: Analizza l' timestamp
espressione con l' fmt
espressione su una marca temporale. Restituisce null con input non valido. Per impostazione predefinita, segue le regole di inserimento in una marca temporale se fmt
viene omessa.
Esempi:
> SELECT to_timestamp('2016-12-31 00:12:00');
2016-12-31 00:12:00
> SELECT to_timestamp('2016-12-31', 'yyyy-MM-dd');
2016-12-31 00:00:00
Dal: 2.2.0
to_unix_timestamp(expr[, pattern])
: Restituisce la marca temporale UNIX dell'ora specificata.
Esempio:
> SELECT to_unix_timestamp('2016-04-08', 'yyyy-MM-dd');
1460041200
Dal: 1.6.0
to_utc_timestamp(timestamp, timezone)
: Interpreta una marca temporale come '2017-07-14 02:40:00.0' come un'ora nel fuso orario specificato e la visualizza come marca temporale in UTC. Ad esempio, 'GMT+1' restituirebbe '2017-07-14 01:40:00.0'.
Esempio:
> SELECT to_utc_timestamp('2016-08-31', 'Asia/Seoul');
2016-08-30 15:00:00
Dal: 1,5,0
trunc(date, fmt)
: Restituisce la data con la parte temporale del giorno troncata all'unità specificata dal modello di formato fmt
. fmt
è uno di ["anno", "aaaa", "yy", "mon", "mese", "mm"]
Esempi:
> SELECT trunc('2009-02-12', 'MM');
2009-02-01
> SELECT trunc('2015-10-27', 'YEAR');
2015-01-01
Dal: 1,5,0
unix_timestamp([expr[, pattern]])
: Restituisce la marca temporale UNIX dell'ora corrente o specificata.
Esempi:
> SELECT unix_timestamp();
1476884637
> SELECT unix_timestamp('2016-04-08', 'yyyy-MM-dd');
1460041200
Dal: 1,5,0
weekday(date)
: Restituisce il giorno della settimana per data/marca temporale (0 = lunedì, 1 = martedì, …, 6 = domenica).
Esempio:
> SELECT weekday('2009-07-30');
3
Dal: 2.4.0
weekofyear(date)
: Restituisce la settimana dell'anno della data specificata. Una settimana inizia il lunedì e la settimana 1 è la prima settimana con >3 giorni.
Esempio:
> SELECT weekofyear('2008-02-20');
8
Dal: 1,5,0
CASE WHEN expr1 THEN expr2 [WHEN expr3 THEN expr4]* [ELSE expr5] END
: Quando expr1
= true, restituisce expr2
; else quando expr3
= true, restituisce expr4
; altrimenti restituisce expr5
.
Argomenti:
expr1
, expr3
: Le espressioni di condizione del ramo devono essere di tipo booleano.expr2
, expr4
, expr5
: Le espressioni del valore del ramo e dell'espressione del valore else devono essere dello stesso tipo o essere coerenti con un tipo comune.Esempi:
> SELECT CASE WHEN 1 > 0 THEN 1 WHEN 2 > 0 THEN 2.0 ELSE 1.2 END;
1
> SELECT CASE WHEN 1 < 0 THEN 1 WHEN 2 > 0 THEN 2.0 ELSE 1.2 END;
2
> SELECT CASE WHEN 1 < 0 THEN 1 WHEN 2 < 0 THEN 2.0 END;
NULL
year(date)
: Restituisce il componente dell’anno della marca data/ora.
Esempio:
> SELECT year('2016-07-30');
2016
Dal: 1,5,0
approx_count_distinct(expr[, relativeSD])
: Restituisce la cardinalità stimata da HyperLogLog++. relativeSD
definisce l'errore massimo di stima consentito.
array(expr, ...)
: Restituisce un array con gli elementi specificati.
Esempio:
> SELECT array(1, 2, 3);
[1,2,3]
array_contains(array, value)
: Restituisce true se la matrice contiene il valore.
Esempio:
> SELECT array_contains(array(1, 2, 3), 2);
true
array_distinct(array)
: Rimuove i valori duplicati dall'array.
Esempio:
> SELECT array_distinct(array(1, 2, 3, null, 3));
[1,2,3,null]
Dal: 2.4.0
array_except(array1, array2)
: Restituisce un array degli elementi in array1
ma non in array2
, senza duplicati.
Esempio:
> SELECT array_except(array(1, 2, 3), array(1, 3, 5));
[2]
Dal: 2.4.0
array_intersect(array1, array2)
: Restituisce un array degli elementi nell'intersezione di array1
e array2
, senza duplicati.
Esempio:
> SELECT array_intersect(array(1, 2, 3), array(1, 3, 5));
[1,3]
Dal: 2.4.0
array_join(array, delimiter[, nullReplacement])
: Concatena gli elementi dell'array specificato utilizzando il delimitatore e una stringa opzionale per sostituire i valori Null. Se non viene impostato alcun valore, nullReplacement
qualsiasi valore nullo viene filtrato.
Esempi:
> SELECT array_join(array('hello', 'world'), ' ');
hello world
> SELECT array_join(array('hello', null ,'world'), ' ');
hello world
> SELECT array_join(array('hello', null ,'world'), ' ', ',');
hello , world
Dal: 2.4.0
array_max(array)
: Restituisce il valore massimo nell'array. Gli elementi Null vengono ignorati.
Esempio:
> SELECT array_max(array(1, 20, null, 3));
20
Dal: 2.4.0
array_min(array)
: Restituisce il valore minimo nell'array. Gli elementi Null vengono ignorati.
Esempio:
> SELECT array_min(array(1, 20, null, 3));
1
Dal: 2.4.0
array_position(array, element)
: Restituisce l'indice (basato su 1) del primo elemento dell'array per il periodo di tempo.
Esempio:
> SELECT array_position(array(3, 2, 1), 1);
3
Dal: 2.4.0
array_remove(array, element)
: Rimuovete dall'array tutti gli elementi uguali all'elemento.
Esempio:
> SELECT array_remove(array(1, 2, 3, null, 3), 3);
[1,2,null]
Dal: 2.4.0
array_repeat(element, count)
: Restituisce l'array contenente le ore di conteggio degli elementi.
Esempio:
> SELECT array_repeat('123', 2);
["123","123"]
Dal: 2.4.0
array_sort(array)
: Ordina l'array di input in ordine crescente. Gli elementi dell'array di input devono essere ordinabili. Gli elementi Null vengono inseriti alla fine dell'array restituito.
Esempio:
> SELECT array_sort(array('b', 'd', null, 'c', 'a'));
["a","b","c","d",null]
Dal: 2.4.0
array_union(array1, array2)
: Restituisce un array degli elementi nell'unione di array1
e array2
, senza duplicati.
Esempio:
> SELECT array_union(array(1, 2, 3), array(1, 3, 5));
[1,2,3,5]
Dal: 2.4.0
arrays_zip(a1, a2, ...)
: Restituisce un array unito di strutture in cui la struttura N contiene tutti i valori N-th degli array di input.
Esempi:
> SELECT arrays_zip(array(1, 2, 3), array(2, 3, 4));
[{"0":1,"1":2},{"0":2,"1":3},{"0":3,"1":4}]
> SELECT arrays_zip(array(1, 2), array(2, 3), array(3, 4));
[{"0":1,"1":2,"2":3},{"0":2,"1":3,"2":4}]
Dal: 2.4.0
element_at(array, index)
: Restituisce l'elemento dell'array in corrispondenza dell'indice specificato (basato su 1). Se index < 0
, accede agli elementi dall'ultimo al primo. Restituisce NULL se l'indice supera la lunghezza dell'array.
element_at(map, key)
: Restituisce il valore per la chiave specificata, o NULL se la chiave non è contenuta nella mappa
Esempi:
> SELECT element_at(array(1, 2, 3), 2);
2
> SELECT element_at(map(1, 'a', 2, 'b'), 2);
b
Dal: 2.4.0
explode(expr)
: Separa gli elementi della matrice expr
in più righe o gli elementi della mappa expr
in più righe e colonne.
Esempi:
> SELECT explode(array(10, 20));
10
20
explode_outer(expr)
: Separa gli elementi della matrice expr
in più righe o gli elementi della mappa expr
in più righe e colonne.
Esempio:
> SELECT explode_outer(array(10, 20));
10
20
find_in_set(str, str_array)
: Restituisce l'indice (basato su 1) della stringa specificata (str
) nell'elenco delimitato da virgole (str_array
). Restituisce 0, se la stringa non è stata trovata o se la stringa specificata (str
) contiene una virgola.
Esempio:
> SELECT find_in_set('ab','abc,b,ab,c,def');
3
flatten(arrayOfArrays)
: Trasforma un array di array in un singolo array.
Esempio:
> SELECT flatten(array(array(1, 2), array(3, 4)));
[1,2,3,4]
Dal: 2.4.0
inline(expr)
: Consente di esplodere un array di strutture in una tabella.
Esempio:
> SELECT inline(array(struct(1, 'a'), struct(2, 'b')));
1 a
2 b
inline_outer(expr)
: Consente di esplodere un array di strutture in una tabella.
Esempio:
> SELECT inline_outer(array(struct(1, 'a'), struct(2, 'b')));
1 a
2 b
posexplode(expr)
: Separa gli elementi della matrice expr
in più righe con posizioni, o gli elementi della mappa expr
in più righe e colonne con posizioni.
Esempio:
> SELECT posexplode(array(10,20));
0 10
1 20
posexplode_outer(expr)
: Separa gli elementi della matrice expr
in più righe con posizioni, o gli elementi della mappa expr
in più righe e colonne con posizioni.
Esempio:
> SELECT posexplode_outer(array(10,20));
0 10
1 20
reverse(array)
: Restituisce una stringa inversa o un array con ordine inverso degli elementi.
Esempi:
> SELECT reverse('Spark SQL');
LQS krapS
> SELECT reverse(array(2, 1, 4, 3));
[3,4,1,2]
Dal: 1,5,0
La logica rse per gli array è disponibile dal 2.4.0.
shuffle(array)
: Restituisce una permutazione casuale dell'array specificato.
Esempi:
> SELECT shuffle(array(1, 20, 3, 5));
[3,1,5,20]
> SELECT shuffle(array(1, 20, null, 3));
[20,null,3,1]
Dal: 2.4.0
è non deterministica.
slice(x, start, length)
: L'array dei sottoinsiemi x inizia dall'inizio dell'indice (o inizia dalla fine se l'inizio è negativo) con la lunghezza specificata.
Esempi:
> SELECT slice(array(1, 2, 3, 4), 2, 2);
[2,3]
> SELECT slice(array(1, 2, 3, 4), -2, 2);
[3,4]
Dal: 2.4.0
sort_array(array[, ascendingOrder])
: Dispone l'array di input in ordine crescente o decrescente in base all'ordine naturale degli elementi dell'array. Gli elementi Null vengono inseriti all'inizio dell'array restituito in ordine crescente o alla fine dell'array restituito in ordine decrescente.
Esempi:
> SELECT sort_array(array('b', 'd', null, 'c', 'a'), true);
[null,"a","b","c","d"]
zip_with(left, right, func)
: Unisce i due array, a livello di elemento, in un singolo array utilizzando la funzione. Se una matrice è più corta, alla fine vengono aggiunti dei valori null che corrispondono alla lunghezza della matrice più lunga, prima di applicare la funzione.
Esempi:
> SELECT zip_with(array(1, 2, 3), array('a', 'b', 'c'), (x, y) -> (y, x));
[{"y":"a","x":1},{"y":"b","x":2},{"y":"c","x":3}]
> SELECT zip_with(array(1, 2), array(3, 4), (x, y) -> x + y);
[4,6]
> SELECT zip_with(array('a', 'b', 'c'), array('d', 'e', 'f'), (x, y) -> concat(x, y));
["ad","be","cf"]
Dal: 2.4.0
bigint(expr)
: Crea il valore expr
in base al tipo di dati di destinazione bigint
.
binary(expr)
: Crea il valore expr
in base al tipo di dati di destinazione binary
.
boolean(expr)
: Crea il valore expr
in base al tipo di dati di destinazione boolean
.
cast(expr AS type)
: Crea il valore expr
in base al tipo di dati di destinazione type
.
Esempio:
> SELECT cast('10' as int);
10
date(expr)
: Crea il valore expr
in base al tipo di dati di destinazione date
.
decimal(expr)
: Crea il valore expr
in base al tipo di dati di destinazione decimal
.
double(expr)
: Crea il valore expr
in base al tipo di dati di destinazione double
.
float(expr)
: Crea il valore expr
in base al tipo di dati di destinazione float
.
int(expr)
: Crea il valore expr
in base al tipo di dati di destinazione int
.
map(key0, value0, key1, value1, ...)
: Crea una mappa con le coppie chiave/valore specificate.
Esempio:
> SELECT map(1.0, '2', 3.0, '4');
{1.0:"2",3.0:"4"}
smallint(expr)
: Crea il valore expr
in base al tipo di dati di destinazione smallint
.
str_to_map(text[, pairDelim[, keyValueDelim]])
: Crea una mappa dopo la divisione del testo in coppie chiave/valore utilizzando i delimitatori. I delimitatori predefiniti sono ',' per pairDelim
e ':' per keyValueDelim
.
Esempi:
> SELECT str_to_map('a:1,b:2,c:3', ',', ':');
map("a":"1","b":"2","c":"3")
> SELECT str_to_map('a');
map("a":null)
string(expr)
: Crea il valore expr
in base al tipo di dati di destinazione string
.
struct(col1, col2, col3, ...)
: Crea una struttura con i valori dei campi specificati.
tinyint(expr)
: Crea il valore expr
in base al tipo di dati di destinazione tinyint
.
ascii(str)
: Restituisce il valore numerico del primo carattere di str
.
Esempi:
> SELECT ascii('222');
50
> SELECT ascii(2);
50
base64(bin)
: Converte l'argomento da un binario bin
a una stringa base 64.
Esempio:
> SELECT base64('Spark SQL');
U3BhcmsgU1FM
bin(expr)
: Restituisce la rappresentazione in formato stringa del valore lungo expr
rappresentato in binario.
Esempi:
> SELECT bin(13);
1101
> SELECT bin(-13);
1111111111111111111111111111111111111111111111111111111111110011
> SELECT bin(13.3);
1101
bit_length(expr)
: Restituisce la lunghezza in bit dei dati stringa o il numero di bit dei dati binari.
Esempio:
> SELECT bit_length('Spark SQL');
72
char(expr)
: Restituisce il carattere ASCII con l'equivalente binario del expr
. Se n è maggiore di 256, il risultato è equivalente a chr(n % 256)
.
Esempio:
> SELECT char(65);
A
char_length(expr)
: Restituisce la lunghezza del carattere dei dati stringa o il numero di byte di dati binari. La lunghezza dei dati stringa include gli spazi finali. La lunghezza dei dati binari include zeri binari.
Esempi:
> SELECT char_length('Spark SQL ');
10
> SELECT CHAR_LENGTH('Spark SQL ');
10
> SELECT CHARACTER_LENGTH('Spark SQL ');
10
character_length(expr)
: Restituisce la lunghezza del carattere dei dati stringa o il numero di byte di dati binari. La lunghezza dei dati stringa include gli spazi finali. La lunghezza dei dati binari include zeri binari.
Esempi:
> SELECT character_length('Spark SQL ');
10
> SELECT CHAR_LENGTH('Spark SQL ');
10
> SELECT CHARACTER_LENGTH('Spark SQL ');
10
chr(expr)
: Restituisce il carattere ASCII con l'equivalente binario di expr. Se n è maggiore di 256, il risultato è equivalente a chr(n % 256)
Esempio:
> SELECT chr(65);
A
degrees(expr)
: Converte i radianti in gradi.
Argomenti:
expr
: Angolo in radiantiEsempio:
> SELECT degrees(3.141592653589793);
180.0
format_number(expr1, expr2)
: Formatta il numero expr1
come '#,###,###.##', arrotondato a expr2
cifre decimali. Se expr2
è 0, il risultato non ha separatori decimali o parti frazionarie. expr2
accetta anche un formato specificato dall'utente. Questo è destinato a funzionare come MySQL FORMAT
.
Esempi:
> SELECT format_number(12332.123456, 4);
12,332.1235
> SELECT format_number(12332.123456, '##################.###');
12332.123
from_json(jsonStr, schema[, options])
: Restituisce un valore struct con il valore specificato jsonStr
e schema
.
Esempi:
> SELECT from_json('{"a":1, "b":0.8}', 'a INT, b DOUBLE');
{"a":1, "b":0.8}
> SELECT from_json('{"time":"26/08/2015"}', 'time Timestamp', map('timestampFormat', 'dd/MM/yyyy'));
{"time":"2015-08-26 00:00:00.0"}
Dal: 2.2.0
hash(expr1, expr2, ...)
: Restituisce un valore hash degli argomenti.
Esempio:
> SELECT hash('Spark', array(123), 2);
-1321691492
hex(expr)
: Effettua la conversione expr
in esadecimale.
Esempi:
> SELECT hex(17);
11
> SELECT hex('Spark SQL');
537061726B2053514C
initcap(str)
: Restituisce str
la prima lettera di ciascuna parola in caratteri maiuscoli. Tutte le altre lettere sono in lettere minuscole. Le parole sono delimitate da uno spazio vuoto.
Esempio:
> SELECT initcap('sPark sql');
Spark Sql
lcase(str)
: Restituisce str
con tutti i caratteri modificati in caratteri minuscoli.
Esempio:
> SELECT lcase('SparkSql');
sparksql
lower(str)
: Restituisce str
con tutti i caratteri modificati in caratteri minuscoli.
Esempio:
> SELECT lower('SparkSql');
sparksql
lpad(str, len, pad)
: Restituisce str
, con pad
aggiunta a sinistra a una lunghezza di len
. Se str
è più lungo di len
, il valore restituito è ridotto a len
caratteri.
Esempi:
> SELECT lpad('hi', 5, '??');
???hi
> SELECT lpad('hi', 1, '??');
h
map(key0, value0, key1, value1, ...)
: Crea una mappa con le coppie chiave/valore specificate.
Esempio:
> SELECT map(1.0, '2', 3.0, '4');
{1.0:"2",3.0:"4"}
map_from_arrays(keys, values)
: Crea una mappa con una coppia di array chiave/valore specificati. Gli elementi nelle chiavi non possono essere null.
Esempio:
> SELECT map_from_arrays(array(1.0, 3.0), array('2', '4'));
{1.0:"2",3.0:"4"}
Dal: 2.4.0
map_from_entries(arrayOfEntries)
: Restituisce una mappa creata dall'array specificato di voci.
Esempio:
> SELECT map_from_entries(array(struct(1, 'a'), struct(2, 'b')));
{1:"a",2:"b"}
Dal: 2.4.0
md5(expr)
: Restituisce un checksum MD5 a 128 bit come stringa esadecimale di expr
.
Esempio:
> SELECT md5('Spark');
8cde774d6f7333752ed72cacddb05126
rpad(str, len, pad)
: Restituisce str
, imbottito a destra con pad
una lunghezza di len
. Se str
è più lungo di len
, il valore restituito è ridotto a len
caratteri.
Esempi:
> SELECT rpad('hi', 5, '??');
hi???
> SELECT rpad('hi', 1, '??');
h
rtrim(str)
: Rimuove gli spazi vuoti finali da str
.
rtrim(trimStr, str)
: Rimuove dalla str
stringa finale la stringa che contiene i caratteri della stringa di rifilo.
Argomenti:
str
: Espressione stringatrimStr
: I caratteri stringa di rifilo da tagliare. Il valore predefinito è un singolo spazioEsempi:
> SELECT rtrim(' SparkSQL ');
SparkSQL
> SELECT rtrim('LQSa', 'SSparkSQLS');
SSpark
sha(expr)
: Restituisce un valore sha1
hash come stringa esadecimale dell'oggetto expr
.
Esempio:
> SELECT sha('Spark');
85f5955f4b27a9a4c2aab6ffe5d7189fc298b92c
sha1(expr)
: Restituisce un valore sha1
hash come stringa esadecimale dell'oggetto expr
.
Esempio:
> SELECT sha1('Spark');
85f5955f4b27a9a4c2aab6ffe5d7189fc298b92c
sha2(expr, bitLength)
: Restituisce un checksum della famiglia SHA-2 come stringa esadecimale di expr
. Sono supportati SHA-224, SHA-256, SHA-384 e SHA-512. La lunghezza del bit pari a 0 equivale a 256.
Esempio:
> SELECT sha2('Spark', 256);
529bc3b07127ecb7e53a4dcf1991d9152c24537d919178022b2c42657f79a26b
soundex(str)
: Restituisce il codice Soundex della stringa.
Esempio:
> SELECT soundex('Miller');
M460
stack(n, expr1, ..., exprk)
: Separa expr1
, …, exprk
in n
righe.
Esempio:
> SELECT stack(2, 1, 2, 3);
1 2
3 NULL
substr(str, pos[, len])
: Restituisce la sottostringa di str
che inizia da pos
ed è di lunghezza len
, oppure la sezione di matrice di byte che inizia da pos
ed è di lunghezza len
.
Esempi:
> SELECT substr('Spark SQL', 5);
k SQL
> SELECT substr('Spark SQL', -3);
SQL
> SELECT substr('Spark SQL', 5, 1);
k
substring(str, pos[, len])
: Restituisce la sottostringa di str
che inizia da pos
ed è di lunghezza len
, oppure la sezione di matrice di byte che inizia da pos
ed è di lunghezza len
.
Esempi:
> SELECT substring('Spark SQL', 5);
k SQL
> SELECT substring('Spark SQL', -3);
SQL
> SELECT substring('Spark SQL', 5, 1);
k
to_json(expr[, options])
: Restituisce una stringa JSON con un valore di struttura specificato.
Esempi:
> SELECT to_json(named_struct('a', 1, 'b', 2));
{"a":1,"b":2}
> SELECT to_json(named_struct('time', to_timestamp('2015-08-26', 'yyyy-MM-dd')), map('timestampFormat', 'dd/MM/yyyy'));
{"time":"26/08/2015"}
> SELECT to_json(array(named_struct('a', 1, 'b', 2)));
[{"a":1,"b":2}]
> SELECT to_json(map('a', named_struct('b', 1)));
{"a":{"b":1}}
> SELECT to_json(map(named_struct('a', 1),named_struct('b', 2)));
{"[1]":{"b":2}}
> SELECT to_json(map('a', 1));
{"a":1}
> SELECT to_json(array((map('a', 1))));
[{"a":1}]
Dal: 2.2.0
translate(input, from, to)
: Traduce la input
stringa sostituendo i caratteri presenti nella from
stringa con i caratteri corrispondenti nella to
stringa.
Esempio:
> SELECT translate('AaBbCc', 'abc', '123');
A1B2C3
trim(str)
: Rimuove gli spazi iniziali e finali da str
.
trim(BOTH trimStr FROM str)
: Rimuovere i trimStr
caratteri iniziali e finali da str
.
trim(LEADING trimStr FROM str)
: Rimuovere i trimStr
caratteri iniziali da str
.
trim(TRAILING trimStr FROM str)
: Rimuovere i trimStr
caratteri finali da str
.
Argomenti:
str
: Espressione stringatrimStr
: I caratteri stringa di rifilo da tagliare, il valore predefinito è un singolo spazioBOTH
, FROM
: Si tratta di parole chiave per specificare il taglio dei caratteri stringa da entrambe le estremità della stringaLEADING
, FROM
: Si tratta di parole chiave per specificare il taglio dei caratteri stringa dall'estremità sinistra della stringaTRAILING
, FROM
: Si tratta di parole chiave per specificare il taglio dei caratteri stringa dall'estremità destra della stringaEsempi:
> SELECT trim(' SparkSQL ');
SparkSQL
> SELECT trim('SL', 'SSparkSQLS');
parkSQ
> SELECT trim(BOTH 'SL' FROM 'SSparkSQLS');
parkSQ
> SELECT trim(LEADING 'SL' FROM 'SSparkSQLS');
parkSQLS
> SELECT trim(TRAILING 'SL' FROM 'SSparkSQLS');
SSparkSQ
ucase(str)
: Restituisce str
con tutti i caratteri modificati in caratteri maiuscoli.
Esempio:
> SELECT ucase('SparkSql');
SPARKSQL
unbase64(str)
: Converte l'argomento da una stringa base 64 str
in un binario.
Esempio:
> SELECT unbase64('U3BhcmsgU1FM');
Spark SQL
unhex(expr)
: Converte l'esadecimale expr
in binario.
Esempio:
> SELECT decode(unhex('537061726B2053514C'), 'UTF-8');
Spark SQL
upper(str)
: Restituisce str
con tutti i caratteri modificati in caratteri maiuscoli.
Esempio:
> SELECT upper('SparkSql');
SPARKSQL
uuid()
: Restituisce una stringa di identificatore universale univoco (UUID). Il valore viene restituito come stringa canonica UUID a 36 caratteri.
Esempio:
> SELECT uuid();
46707d92-02f4-4817-8116-a4c3b23e6266
La funzione non è deterministica.
coalesce(expr1, expr2, ...)
: Restituisce il primo argomento non-null, se esistente. In caso contrario, null.
Esempio:
> SELECT coalesce(NULL, 1, NULL);
1
collect_list(expr)
: Raccoglie e restituisce un elenco di elementi non univoci.
collect_set(expr)
: Raccoglie e restituisce un set di elementi univoci.
concat(col1, col2, ..., colN)
: Restituisce la concatenazione di col1, col2, …, colN.
Esempi:
> SELECT concat('Spark', 'SQL');
SparkSQL
> SELECT concat(array(1, 2, 3), array(4, 5), array(6));
[1,2,3,4,5,6]
concat
logica per gli array è disponibile dal 2.4.0.
concat_ws(sep, [str | array(str)]+)
: Restituisce la concatenazione delle stringhe separate da sep
.
Esempio:
> SELECT concat_ws(' ', 'Spark', 'SQL');
Spark SQL
count(*)
: Restituisce il numero totale di righe recuperate, incluse le righe contenenti null.
count(expr[, expr...])
: Restituisce il numero di righe per le quali le espressioni fornite sono tutte non-null.
count(DISTINCT expr[, expr...])
: Restituisce il numero di righe per le quali le espressioni fornite sono univoche e non-null.
crc32(expr)
: Restituisce un valore di controllo della ridondanza ciclica dell'elemento expr
bigint.
Esempio:
> SELECT crc32('Spark');
1557323817
decode(bin, charset)
: Decodifica il primo argomento utilizzando il secondo insieme di caratteri argomento.
Esempio:
> SELECT decode(encode('abc', 'utf-8'), 'utf-8');
abc
elt(n, input1, input2, ...)
: Restituisce il n
nono input, ad esempio, restituisce input2
se n
è 2.
Esempio:
> SELECT elt(1, 'scala', 'java');
scala
encode(str, charset)
: Codifica il primo argomento utilizzando il secondo insieme di caratteri argomento.
Esempio:
> SELECT encode('abc', 'utf-8');
abc
first(expr[, isIgnoreNull])
: Restituisce il primo valore di expr
per un gruppo di righe. Se isIgnoreNull
è true, restituisce solo valori non-null.
first_value(expr[, isIgnoreNull])
: Restituisce il primo valore di expr
per un gruppo di righe. Se isIgnoreNull
è true, restituisce solo valori non-null.
get_json_object(json_txt, path)
: Estrae un oggetto json da path
.
Esempio:
> SELECT get_json_object('{"a":"b"}', '$.a');
b
instr(str, substr)
: Restituisce l'indice (basato su 1) della prima occorrenza di substr
in str
.
Esempio:
> SELECT instr('SparkSQL', 'SQL');
6
json_tuple(jsonStr, p1, p2, ..., pn)
: Restituisce una tupla come la funzione get_json_object
, ma richiede più nomi. Tutti i parametri di input e i tipi di colonna di output sono stringhe.
Esempio:
> SELECT json_tuple('{"a":1, "b":2}', 'a', 'b');
1 2
lag(input[, offset[, default]])
: Restituisce il valore di input
nella offset
terza riga prima della riga corrente nella finestra. Il valore predefinito di offset
è 1 e il valore predefinito di default
è null. Se il valore di input
at the offset
th row è null, viene restituito null. Se non è presente una riga di offset (ad esempio, se l'offset è 1, la prima riga della finestra non ha una riga precedente) e default
viene restituita.
last(expr[, isIgnoreNull])
: Restituisce l'ultimo valore di expr
per un gruppo di righe. Se isIgnoreNull
è true, restituisce solo valori non-null.
last_value(expr[, isIgnoreNull])
: Restituisce l'ultimo valore di expr
per un gruppo di righe. Se isIgnoreNull
è true, restituisce solo valori non-null.
lead(input[, offset[, default]])
: Restituisce il valore di input
nella offset
terza riga dopo la riga corrente nella finestra. Il valore predefinito di offset
è 1 e il valore predefinito di default
è null. Se il valore di input
at the offset
th row è null, viene restituito null. Se non è presente una riga di offset (ad esempio, se l'offset è 1, l'ultima riga della finestra non ha alcuna riga successiva) e default
viene restituita.
left(str, len)
: Restituisce i caratteri più a sinistra len
(len
può essere di tipo stringa) della stringa str
. Se len
è minore o uguale a 0, il risultato è una stringa vuota.
Esempio:
> SELECT left('Spark SQL', 3);
Spa
length(expr)
: Restituisce la lunghezza del carattere dei dati stringa o il numero di byte di dati binari. La lunghezza dei dati stringa include gli spazi finali. La lunghezza dei dati binari include zeri binari.
Esempi:
> SELECT length('Spark SQL ');
10
> SELECT CHAR_LENGTH('Spark SQL ');
10
> SELECT CHARACTER_LENGTH('Spark SQL ');
10
locate(substr, str[, pos])
: Restituisce la posizione della prima occorrenza di substr
in str
dopo la posizione pos
. Il valore specificato pos
e restituito sono basati su 1.
Esempi:
> SELECT locate('bar', 'foobarbar');
4
> SELECT locate('bar', 'foobarbar', 5);
7
> SELECT POSITION('bar' IN 'foobarbar');
4
map_concat(map, ...)
: Restituisce l'unione di tutte le mappe specificate.
Esempio:
> SELECT map_concat(map(1, 'a', 2, 'b'), map(2, 'c', 3, 'd'));
{1:"a",2:"c",3:"d"}
Dal: 2.4.0
map_keys(map)
: Restituisce un array non ordinato contenente le chiavi della mappa.
Esempio:
> SELECT map_keys(map(1, 'a', 2, 'b'));
[1,2]
map_values(map)
: Restituisce un array non ordinato contenente i valori della mappa.
Esempio:
> SELECT map_values(map(1, 'a', 2, 'b'));
["a","b"]
ntile(n)
: Divide le righe per ogni partizione della finestra in n
bucket che vanno da 1 al massimo n
.
nullif(expr1, expr2)
: Restituisce null se expr1
è uguale a expr2
oppure expr1
altrimenti.
Esempio:
> SELECT nullif(2, 2);
NULL
nvl(expr1, expr2)
: Restituisce expr2
se expr1
è null o expr1
in caso contrario.
Esempio:
> SELECT nvl(NULL, array('2'));
["2"]
nvl2(expr1, expr2, expr3)
: Restituisce expr2
se expr1
non è null o expr3
in caso contrario.
Esempio:
> SELECT nvl2(NULL, 2, 1);
1
parse_url(url, partToExtract[, key])
: Estrae una parte da un URL.
Esempi:
> SELECT parse_url('http://spark.apache.org/path?query=1', 'HOST')
spark.apache.org
> SELECT parse_url('http://spark.apache.org/path?query=1', 'QUERY')
query=1
> SELECT parse_url('http://spark.apache.org/path?query=1', 'QUERY', 'query')
1
position(substr, str[, pos])
: Restituisce la posizione della prima occorrenza di substr
in str
dopo la posizione pos
. Il valore specificato pos
e restituito sono basati su 1.
Esempi:
> SELECT position('bar', 'foobarbar');
4
> SELECT position('bar', 'foobarbar', 5);
7
> SELECT POSITION('bar' IN 'foobarbar');
4
rank()
: Calcola il grado di un valore in un gruppo di valori. Il risultato è uno più il numero di righe precedenti o uguali alla riga corrente nell'ordine della partizione. I valori producono spazi vuoti nella sequenza.
regexp_extract(str, regexp[, idx])
: Estrae un gruppo che corrisponde a regexp
.
Esempio:
> SELECT regexp_extract('100-200', '(\\d+)-(\\d+)', 1);
100
regexp_replace(str, regexp, rep)
: Sostituisce tutte le sottostringhe di str
cui corrisponde regexp
a rep
.
Esempio:
> SELECT regexp_replace('100-200', '(\\d+)', 'num');
num-num
repeat(str, n)
: Restituisce la stringa che ripete il valore stringa specificato in ore.
Esempio:
> SELECT repeat('123', 2);
123123
replace(str, search[, replace])
: Sostituisce tutte le occorrenze di search
con replace
.
Argomenti:
str
: Espressione stringasearch
: Un'espressione stringa. Se non search
viene trovata in str
, str
viene restituita invariata.replace
: Un'espressione stringa. Se non replace
è specificata o è una stringa vuota, nulla sostituisce la stringa rimossa da str
.Esempio:
> SELECT replace('ABCabc', 'abc', 'DEF');
ABCDEF
row_number()
: Assegna un numero sequenziale univoco a ogni riga, a partire da una, in base all'ordine delle righe all'interno della partizione della finestra.
schema_of_json(json[, options])
: Restituisce lo schema nel formato DDL della stringa JSON.
Esempio:
> SELECT schema_of_json('[{"col":0}]');
array<struct<col:int>>
Dal: 2.4.0
sentences(str[, lang, country])
: Divide str
in un array di parole.
Esempio:
> SELECT sentences('Hi there! Good morning.');
[["Hi","there"],["Good","morning"]]
sequence(start, stop, step)
: Genera un array di elementi dall'inizio all'arresto (incluso), incrementando passo per passo. Il tipo degli elementi restituiti è uguale al tipo di espressioni di argomento.
I tipi supportati sono: byte, short, integer, long, date, timestamp.
Le espressioni start
e stop
devono essere risolte allo stesso tipo. Se start
e stop
le espressioni vengono risolte al tipo "data" o "timestamp", l' step
espressione deve essere risolta al tipo "intervallo"; in caso contrario, viene risolto nello stesso tipo delle espressioni start
e stop
.
Argomenti:
start
: Un'espressione. L'inizio dell'intervallo.stop
: Un'espressione. La fine dell'intervallo (incluso).step
: Un'espressione facoltativa. Il passo dell'intervallo. Per impostazione predefinita step
è '1' se start
è minore o uguale a stop
, altrimenti '-1'. Per le sequenze temporali è rispettivamente '1' giorno e '-1' giorno. Se start
è maggiore di stop
, il step
valore deve essere negativo e viceversa.Esempi:
> SELECT sequence(1, 5);
[1,2,3,4,5]
> SELECT sequence(5, 1);
[5,4,3,2,1]
> SELECT sequence(to_date('2018-01-01'), to_date('2018-03-01'), interval '1' month);
[2018-01-01,2018-02-01,2018-03-01]
Dal: 2.4.0
shiftleft(base, expr)
: Spostamento a sinistra bit a bit.
Esempio:
> SELECT shiftleft(2, 1);
4
shiftright(base, expr)
: Spostamento a destra bit a bit (con segno).
Esempio:
> SELECT shiftright(4, 1);
2
shiftrightunsigned(base, expr)
: Spostamento a destra bit a bit senza segno.
Esempio:
> SELECT shiftrightunsigned(4, 1);
2
size(expr)
: Restituisce la dimensione di un array o di una mappa. La funzione restituisce -1 se il relativo input è nullo e spark.sql.legacy.sizeOfNull
è impostato su true. Se spark.sql.legacy.sizeOfNull
è impostata su false, la funzione restituisce null per l'input nullo. Per impostazione predefinita, il spark.sql.legacy.sizeOfNull
parametro è impostato su true.
Esempi:
> SELECT size(array('b', 'd', 'c', 'a'));
4
> SELECT size(map('a', 1, 'b', 2));
2
> SELECT size(NULL);
-1
space(n)
: Restituisce una stringa costituita da n
spazi.
Esempio:
> SELECT concat(space(2), '1');
1
split(str, regex)
: Divide str
intorno alle occorrenze corrispondenti regex
.
Esempio:
> SELECT split('oneAtwoBthreeC', '[ABC]');
["one","two","three",""]
substring_index(str, delim, count)
: Restituisce la sottostringa da str
prima count
delle occorrenze del delimitatore delim
. Se count
è positivo, viene restituito tutto a sinistra del delimitatore finale (conteggio da sinistra). Se count
è negativo, viene restituito tutto a destra del delimitatore finale (contando da destra). La funzione substring_index
esegue una corrispondenza con distinzione tra maiuscole e minuscole durante la ricerca delim
.
Esempio:
> SELECT substring_index('www.apache.org', '.', 2);
www.apache
xpath(xml, xpath)
: Restituisce un array di stringhe di valori all'interno dei nodi del codice xml che corrispondono all'espressione XPath.
Esempio:
> SELECT xpath('<a><b>b1</b><b>b2</b><b>b3</b><c>c1</c><c>c2</c></a>','a/b/text()');
['b1','b2','b3']
xpath_double(xml, xpath)
: Restituisce un valore doppio, il valore zero se non viene trovata alcuna corrispondenza, NaN se viene trovata una corrispondenza ma il valore non è numerico.
Esempio:
> SELECT xpath_double('<a><b>1</b><b>2</b></a>', 'sum(a/b)');
3.0
xpath_float(xml, xpath)
: Restituisce un valore float, il valore zero se non viene trovata alcuna corrispondenza o NaN se viene trovata una corrispondenza ma il valore non è numerico.
Esempio:
> SELECT xpath_float('<a><b>1</b><b>2</b></a>', 'sum(a/b)');
3.0
xpath_int(xml, xpath)
: Restituisce un valore intero, oppure il valore zero se non viene trovata alcuna corrispondenza, oppure viene trovata una corrispondenza ma il valore non è numerico.
Esempio:
> SELECT xpath_int('<a><b>1</b><b>2</b></a>', 'sum(a/b)');
3
xpath_long(xml, xpath)
: Restituisce un valore intero lungo, oppure il valore zero se non viene trovata alcuna corrispondenza, oppure viene trovata una corrispondenza ma il valore non è numerico.
Esempio:
> SELECT xpath_long('<a><b>1</b><b>2</b></a>', 'sum(a/b)');
3
xpath_number(xml, xpath)
: Restituisce un valore doppio, il valore zero se non viene trovata alcuna corrispondenza, NaN se viene trovata una corrispondenza ma il valore non è numerico.
Esempio:
> SELECT xpath_number('<a><b>1</b><b>2</b></a>', 'sum(a/b)');
3.0
xpath_short(xml, xpath)
: Restituisce un valore intero breve, oppure il valore zero se non viene trovata alcuna corrispondenza, oppure viene trovata una corrispondenza ma il valore non è numerico.
Esempio:
> SELECT xpath_short('<a><b>1</b><b>2</b></a>', 'sum(a/b)');
3
xpath_string(xml, xpath)
: Restituisce il contenuto del testo del primo nodo xml che corrisponde all'espressione XPath.
Esempio:
> SELECT xpath_string('<a><b>b</b><c>cc</c></a>','a/c');
cc
current_database()
: Restituisce il database corrente.
Esempio:
> SELECT current_database();
default
current_date()
: Restituisce la data corrente all'inizio della valutazione della query.
Dal: 1,5,0
current_timestamp()
: Restituisce la marca temporale corrente all'inizio della valutazione della query.
Dal: 1,5,0
now()
: Restituisce la marca temporale corrente all'inizio della valutazione della query.
Dal: 1,5,0
transform(array, lambdaExpression): array
Trasformare gli elementi in un array utilizzando la funzione.
Se sono presenti due argomenti per la funzione lambda, il secondo argomento indica l'indice dell'elemento.
Esempio:
> SELECT transform(array(1, 2, 3), x -> x + 1);
[2,3,4]
> SELECT transform(array(1, 2, 3), (x, i) -> x + i);
[1,3,5]
exists(array, lambdaExpression returning Boolean): Boolean
Verificare se un predicato contiene uno o più elementi nell'array.
Esempio:
> SELECT exists(array(1, 2, 3), x -> x % 2 == 0);
true
filter(array, lambdaExpression returning Boolean): array
Filtrare l'array di input utilizzando il predicato specificato.
Esempio:
> SELECT filter(array(1, 2, 3), x -> x % 2 == 1);
[1,3]
aggregate(array, <initial accumulator value>, lambdaExpression to accumulate the value): array
Applicate un operatore binario a uno stato iniziale e a tutti gli elementi dell'array, e riducetelo a un singolo stato. Lo stato finale viene convertito nel risultato finale applicando una funzione di fine.
Esempio:
> SELECT aggregate(array(1, 2, 3), 0, (acc, x) -> acc + x);
6
> SELECT aggregate(array(1, 2, 3), 0, (acc, x) -> acc + x, acc -> acc * 10);
60