Integrierte FunktionenBuilt-in functions

AggregatfunktionenAggregate functions

FunktionFunction BESCHREIBUNGDescription
Any (expr)any(expr) Gibt true zurück, wenn mindestens ein Wert von expr true ist.Returns true if at least one value of expr is true.
approx_count_distinct (expr [, relativesd])approx_count_distinct(expr[,relativeSD]) Gibt die geschätzte Kardinalität durch hyperloglog + + zurück.Returns the estimated cardinality by HyperLogLog++. relativeSD definiert den maximal zulässigen Schätzwert.relativeSD defines the maximum estimation error allowed.
approx_percentile (col, Prozentsatz [, Genauigkeit])approx_percentile(col,percentage[,accuracy]) Gibt den ungefähren Perzentilwert der numerischen Spalte col am angegebenen Prozentsatz zurück.Returns the approximate percentile value of numeric column col at the given percentage. Der Wert des Prozentsatzes muss zwischen 0,0 und 1,0 liegen.The value of percentage must be between 0.0 and 1.0. Der- accuracy Parameter (Standardwert: 10000) ist ein positives numerisches wahrsten, das die Näherungs Genauigkeit auf Kosten des Arbeitsspeichers steuert.The accuracy parameter (default: 10000) is a positive numeric literal which controls approximation accuracy at the cost of memory. Ein höherer Wert von accuracy ergibt eine bessere Genauigkeit, 1.0/accuracy ist der relative Fehler der Näherung.Higher value of accuracy yields better accuracy, 1.0/accuracy is the relative error of the approximation. Wenn percentage ein Array ist, muss jeder Wert des Prozentsatz-Arrays zwischen 0,0 und 1,0 liegen.When percentage is an array, each value of the percentage array must be between 0.0 and 1.0. In diesem Fall gibt das ungefähre Perzentil-Array der Spalte col am angegebenen Prozentsatz Array zurück.In this case, returns the approximate percentile array of column col at the given percentage array.
Durchschn. (expr)avg(expr) Gibt den Mittelwert zurück, der aus den Werten einer Gruppe berechnet wird.Returns the mean calculated from values of a group.
BIT_OR (expr)bit_or(expr) Gibt das bitweise OR von allen Eingabe Werten ungleich NULL oder NULL zurück, wenn keine.Returns the bitwise OR of all non-null input values, or null if none.
BIT_XOR (expr)bit_xor(expr) Gibt das bitweise XOR aller Eingabewerte ungleich NULL oder NULL zurück, wenn kein Wert ist.Returns the bitwise XOR of all non-null input values, or null if none.
bool_and (expr)bool_and(expr) Gibt true zurück, wenn alle Werte von expr true sind.Returns true if all values of expr are true.
bool_or (expr)bool_or(expr) Gibt true zurück, wenn mindestens ein Wert von expr true ist.Returns true if at least one value of expr is true.
collect_list (expr)collect_list(expr) Sammelt und gibt eine Liste von nicht eindeutigen Elementen zurück.Collects and returns a list of non-unique elements.
collect_set (expr)collect_set(expr) Sammelt und gibt einen Satz eindeutiger-Elemente zurück.Collects and returns a set of unique elements.
Corr (expr1, expr2)corr(expr1,expr2) Gibt den Pearson-Koeffizienten der Korrelation zwischen einem Satz von Zahlenpaaren zurück.Returns Pearson coefficient of correlation between a set of number pairs.
Anzahl (*)count(*) Gibt die Gesamtzahl der abgerufenen Zeilen zurück, einschließlich der Zeilen, die NULL enthalten.Returns the total number of retrieved rows, including rows containing null.
count (expr [, expr...])count(expr[,expr…]) Gibt die Anzahl der Zeilen zurück, für die der angegebene Ausdruck (n) nicht NULL ist.Returns the number of rows for which the supplied expression(s) are all non-null.
count (eindeutiger expr [, expr...])count(DISTINCT expr[,expr…]) Gibt die Anzahl der Zeilen zurück, für die der angegebene Ausdruck eindeutig und nicht NULL ist.Returns the number of rows for which the supplied expression(s) are unique and non-null.
count_if (expr)count_if(expr) Gibt die Anzahl der TRUE Werte für den Ausdruck zurück.Returns the number of TRUE values for the expression.
count_min_sketch (col, EPS, Vertrauen, Seed)count_min_sketch(col,eps,confidence,seed) Gibt eine count-min-Skizze für eine Spalte mit dem angegebenen ESP, dem Vertrauen und dem Ausgangswert zurück.Returns a count-min sketch of a column with the given esp, confidence and seed. Das Ergebnis ist ein Bytearray, das vor der Verwendung in einen deserialisiert werden kann CountMinSketch .The result is an array of bytes, which can be deserialized to a CountMinSketch before usage. Count-min Sketch ist eine probabilistische Datenstruktur, die für die Kardinalitätsschätzung mit einem unter linearen Raum verwendet wird.Count-min sketch is a probabilistic data structure used for cardinality estimation using sub-linear space.
COVAR_POP (expr1, expr2)covar_pop(expr1,expr2) Gibt die auffüllungs Kovarianz eines Satzes von Zahlenpaaren zurück.Returns the population covariance of a set of number pairs.
COVAR_SAMP (expr1, expr2)covar_samp(expr1,expr2) Gibt die Stichproben Kovarianz eines Satzes von Zahlenpaaren zurück.Returns the sample covariance of a set of number pairs.
Alle (expr)every(expr) Gibt true zurück, wenn alle Werte von expr true sind.Returns true if all values of expr are true.
First (expr [, isignorumull])first(expr[,isIgnoreNull]) Gibt den ersten Wert von expr für eine Gruppe von Zeilen zurück.Returns the first value of expr for a group of rows. Wenn isIgnoreNull true ist, gibt nur Werte zurück, die nicht NULL sind.If isIgnoreNull is true, returns only non-null values.
FIRST_VALUE (expr [, isignorumull])first_value(expr[,isIgnoreNull]) Gibt den ersten Wert von expr für eine Gruppe von Zeilen zurück.Returns the first value of expr for a group of rows. Wenn isIgnoreNull true ist, gibt nur Werte zurück, die nicht NULL sind.If isIgnoreNull is true, returns only non-null values.
kurum (expr)kurtosis(expr) Gibt den von den Werten einer Gruppe berechneten kurum-Wert zurück.Returns the kurtosis value calculated from values of a group.
Last (expr [, isignorumull])last(expr[,isIgnoreNull]) Gibt den letzten Wert von expr für eine Gruppe von Zeilen zurück.Returns the last value of expr for a group of rows. Wenn isIgnoreNull true ist, gibt nur Werte zurück, die nicht NULL sind.If isIgnoreNull is true, returns only non-null values.
LAST_VALUE (expr [, isignorumull])last_value(expr[,isIgnoreNull]) Gibt den letzten Wert von expr für eine Gruppe von Zeilen zurück.Returns the last value of expr for a group of rows. Wenn isIgnoreNull true ist, gibt nur Werte zurück, die nicht NULL sind.If isIgnoreNull is true, returns only non-null values.
Max (expr)max(expr) Gibt den maximalen Wert von zurück expr .Returns the maximum value of expr.
max_by (x, y)max_by(x,y) Gibt den Wert von zurück, der x dem maximalen Wert von zugeordnet ist y .Returns the value of x associated with the maximum value of y.
Mean (expr)mean(expr) Gibt den Mittelwert zurück, der aus den Werten einer Gruppe berechnet wird.Returns the mean calculated from values of a group.
min (expr)min(expr) Gibt den minimalen Wert von zurück expr .Returns the minimum value of expr.
min_by (x, y)min_by(x,y) Gibt den Wert von zurück, der x mit dem Minimalwert von verknüpft ist y .Returns the value of x associated with the minimum value of y.
Perzentil (col, Prozentsatz [, frequency])percentile(col,percentage[,frequency]) Gibt den genauen Perzentilwert der numerischen Spalte col am angegebenen Prozentsatz zurück.Returns the exact percentile value of numeric column col at the given percentage. Der Wert des Prozentsatzes muss zwischen 0,0 und 1,0 liegen.The value of percentage must be between 0.0 and 1.0. Der Wert von Frequency sollte ein positiver ganzzahliger Wert sein.The value of frequency should be positive integral.
Perzentil (col, Array (percentage1 [, percentage2]...) [, Häufigkeit])percentile(col,array(percentage1[,percentage2]…)[,frequency]) Gibt das genaue Perzentil-Wert Array der numerischen Spalte col an den angegebenen Prozentsätzen zurück.Returns the exact percentile value array of numeric column col at the given percentage(s). Jeder Wert des Prozentsatzes muss zwischen 0,0 und 1,0 liegen.Each value of the percentage array must be between 0.0 and 1.0. Der Wert von Frequency sollte ein positiver ganzzahliger Wert sein.The value of frequency should be positive integral.
percentile_approx (col, Prozentsatz [, Genauigkeit])percentile_approx(col,percentage[,accuracy]) Gibt den ungefähren Perzentilwert der numerischen Spalte col am angegebenen Prozentsatz zurück.Returns the approximate percentile value of numeric column col at the given percentage. Der Wert des Prozentsatzes muss zwischen 0,0 und 1,0 liegen.The value of percentage must be between 0.0 and 1.0. Der- accuracy Parameter (Standardwert: 10000) ist ein positives numerisches wahrsten, das die Näherungs Genauigkeit auf Kosten des Arbeitsspeichers steuert.The accuracy parameter (default: 10000) is a positive numeric literal which controls approximation accuracy at the cost of memory. Ein höherer Wert von accuracy ergibt eine bessere Genauigkeit, 1.0/accuracy ist der relative Fehler der Näherung.Higher value of accuracy yields better accuracy, 1.0/accuracy is the relative error of the approximation. Wenn percentage ein Array ist, muss jeder Wert des Prozentsatz-Arrays zwischen 0,0 und 1,0 liegen.When percentage is an array, each value of the percentage array must be between 0.0 and 1.0. In diesem Fall gibt das ungefähre Perzentil-Array der Spalte col am angegebenen Prozentsatz Array zurück.In this case, returns the approximate percentile array of column col at the given percentage array.
schrägkeit (expr)skewness(expr) Gibt den Wert der schrägkeit zurück, der aus den Werten einer Gruppe berechnet wird.Returns the skewness value calculated from values of a group.
einige (expr)some(expr) Gibt true zurück, wenn mindestens ein Wert von expr true ist.Returns true if at least one value of expr is true.
Std (expr)std(expr) Gibt die Stichproben Standardabweichung zurück, die aus Werten einer Gruppe berechnet wird.Returns the sample standard deviation calculated from values of a group.
StdDev (expr)stddev(expr) Gibt die Stichproben Standardabweichung zurück, die aus Werten einer Gruppe berechnet wird.Returns the sample standard deviation calculated from values of a group.
STDDEV_POP (expr)stddev_pop(expr) Gibt die Standardabweichung der Auffüllung zurück, die aus den Werten einer Gruppe berechnet wird.Returns the population standard deviation calculated from values of a group.
STDDEV_SAMP (expr)stddev_samp(expr) Gibt die Stichproben Standardabweichung zurück, die aus Werten einer Gruppe berechnet wird.Returns the sample standard deviation calculated from values of a group.
Sum (expr)sum(expr) Gibt die Summe zurück, die aus den Werten einer Gruppe berechnet wird.Returns the sum calculated from values of a group.
VAR_POP (expr)var_pop(expr) Gibt die auffüllungs Varianz aus den Werten einer Gruppe zurück.Returns the population variance calculated from values of a group.
VAR_SAMP (expr)var_samp(expr) Gibt die Beispiel Varianz zurück, die aus den Werten einer Gruppe berechnet wird.Returns the sample variance calculated from values of a group.
Varianz (expr)variance(expr) Gibt die Beispiel Varianz zurück, die aus den Werten einer Gruppe berechnet wird.Returns the sample variance calculated from values of a group.

BeispieleExamples

-- any
SELECT any(col) FROM VALUES (true), (false), (false) AS tab(col);
+--------+
|any(col)|
+--------+
|    true|
+--------+

SELECT any(col) FROM VALUES (NULL), (true), (false) AS tab(col);
+--------+
|any(col)|
+--------+
|    true|
+--------+

SELECT any(col) FROM VALUES (false), (false), (NULL) AS tab(col);
+--------+
|any(col)|
+--------+
|   false|
+--------+

-- approx_count_distinct
SELECT approx_count_distinct(col1) FROM VALUES (1), (1), (2), (2), (3) tab(col1);
+---------------------------+
|approx_count_distinct(col1)|
+---------------------------+
|                          3|
+---------------------------+

-- approx_percentile
SELECT approx_percentile(10.0, array(0.5, 0.4, 0.1), 100);
+--------------------------------------------------+
|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);
+-------------------------------------------------+
|approx_percentile(10.0, CAST(0.5 AS DOUBLE), 100)|
+-------------------------------------------------+
|                                             10.0|
+-------------------------------------------------+

-- avg
SELECT avg(col) FROM VALUES (1), (2), (3) AS tab(col);
+--------+
|avg(col)|
+--------+
|     2.0|
+--------+

SELECT avg(col) FROM VALUES (1), (2), (NULL) AS tab(col);
+--------+
|avg(col)|
+--------+
|     1.5|
+--------+

-- bit_or
SELECT bit_or(col) FROM VALUES (3), (5) AS tab(col);
+-----------+
|bit_or(col)|
+-----------+
|          7|
+-----------+

-- bit_xor
SELECT bit_xor(col) FROM VALUES (3), (5) AS tab(col);
+------------+
|bit_xor(col)|
+------------+
|           6|
+------------+

-- bool_and
SELECT bool_and(col) FROM VALUES (true), (true), (true) AS tab(col);
+-------------+
|bool_and(col)|
+-------------+
|         true|
+-------------+

SELECT bool_and(col) FROM VALUES (NULL), (true), (true) AS tab(col);
+-------------+
|bool_and(col)|
+-------------+
|         true|
+-------------+

SELECT bool_and(col) FROM VALUES (true), (false), (true) AS tab(col);
+-------------+
|bool_and(col)|
+-------------+
|        false|
+-------------+

-- bool_or
SELECT bool_or(col) FROM VALUES (true), (false), (false) AS tab(col);
+------------+
|bool_or(col)|
+------------+
|        true|
+------------+

SELECT bool_or(col) FROM VALUES (NULL), (true), (false) AS tab(col);
+------------+
|bool_or(col)|
+------------+
|        true|
+------------+

SELECT bool_or(col) FROM VALUES (false), (false), (NULL) AS tab(col);
+------------+
|bool_or(col)|
+------------+
|       false|
+------------+

-- collect_list
SELECT collect_list(col) FROM VALUES (1), (2), (1) AS tab(col);
+-----------------+
|collect_list(col)|
+-----------------+
|        [1, 2, 1]|
+-----------------+

-- collect_set
SELECT collect_set(col) FROM VALUES (1), (2), (1) AS tab(col);
+----------------+
|collect_set(col)|
+----------------+
|          [1, 2]|
+----------------+

-- corr
SELECT corr(c1, c2) FROM VALUES (3, 2), (3, 3), (6, 4) as tab(c1, c2);
+--------------------------------------------+
|corr(CAST(c1 AS DOUBLE), CAST(c2 AS DOUBLE))|
+--------------------------------------------+
|                          0.8660254037844387|
+--------------------------------------------+

-- count
SELECT count(*) FROM VALUES (NULL), (5), (5), (20) AS tab(col);
+--------+
|count(1)|
+--------+
|       4|
+--------+

SELECT count(col) FROM VALUES (NULL), (5), (5), (20) AS tab(col);
+----------+
|count(col)|
+----------+
|         3|
+----------+

SELECT count(DISTINCT col) FROM VALUES (NULL), (5), (5), (10) AS tab(col);
+-------------------+
|count(DISTINCT col)|
+-------------------+
|                  2|
+-------------------+

-- count_if
SELECT count_if(col % 2 = 0) FROM VALUES (NULL), (0), (1), (2), (3) AS tab(col);
+-------------------------+
|count_if(((col % 2) = 0))|
+-------------------------+
|                        2|
+-------------------------+

SELECT count_if(col IS NULL) FROM VALUES (NULL), (0), (1), (2), (3) AS tab(col);
+-----------------------+
|count_if((col IS NULL))|
+-----------------------+
|                      1|
+-----------------------+

-- covar_pop
SELECT covar_pop(c1, c2) FROM VALUES (1,1), (2,2), (3,3) AS tab(c1, c2);
+-------------------------------------------------+
|covar_pop(CAST(c1 AS DOUBLE), CAST(c2 AS DOUBLE))|
+-------------------------------------------------+
|                               0.6666666666666666|
+-------------------------------------------------+

-- covar_samp
SELECT covar_samp(c1, c2) FROM VALUES (1,1), (2,2), (3,3) AS tab(c1, c2);
+--------------------------------------------------+
|covar_samp(CAST(c1 AS DOUBLE), CAST(c2 AS DOUBLE))|
+--------------------------------------------------+
|                                               1.0|
+--------------------------------------------------+

-- every
SELECT every(col) FROM VALUES (true), (true), (true) AS tab(col);
+----------+
|every(col)|
+----------+
|      true|
+----------+

SELECT every(col) FROM VALUES (NULL), (true), (true) AS tab(col);
+----------+
|every(col)|
+----------+
|      true|
+----------+

SELECT every(col) FROM VALUES (true), (false), (true) AS tab(col);
+----------+
|every(col)|
+----------+
|     false|
+----------+

-- first
SELECT first(col) FROM VALUES (10), (5), (20) AS tab(col);
+-----------------+
|first(col, false)|
+-----------------+
|               10|
+-----------------+

SELECT first(col) FROM VALUES (NULL), (5), (20) AS tab(col);
+-----------------+
|first(col, false)|
+-----------------+
|             null|
+-----------------+

SELECT first(col, true) FROM VALUES (NULL), (5), (20) AS tab(col);
+----------------+
|first(col, true)|
+----------------+
|               5|
+----------------+

-- first_value
SELECT first_value(col) FROM VALUES (10), (5), (20) AS tab(col);
+-----------------------+
|first_value(col, false)|
+-----------------------+
|                     10|
+-----------------------+

SELECT first_value(col) FROM VALUES (NULL), (5), (20) AS tab(col);
+-----------------------+
|first_value(col, false)|
+-----------------------+
|                   null|
+-----------------------+

SELECT first_value(col, true) FROM VALUES (NULL), (5), (20) AS tab(col);
+----------------------+
|first_value(col, true)|
+----------------------+
|                     5|
+----------------------+

-- kurtosis
SELECT kurtosis(col) FROM VALUES (-10), (-20), (100), (1000) AS tab(col);
+-----------------------------+
|kurtosis(CAST(col AS DOUBLE))|
+-----------------------------+
|          -0.7014368047529618|
+-----------------------------+

SELECT kurtosis(col) FROM VALUES (1), (10), (100), (10), (1) as tab(col);
+-----------------------------+
|kurtosis(CAST(col AS DOUBLE))|
+-----------------------------+
|          0.19432323191698986|
+-----------------------------+

-- last
SELECT last(col) FROM VALUES (10), (5), (20) AS tab(col);
+----------------+
|last(col, false)|
+----------------+
|              20|
+----------------+

SELECT last(col) FROM VALUES (10), (5), (NULL) AS tab(col);
+----------------+
|last(col, false)|
+----------------+
|            null|
+----------------+

SELECT last(col, true) FROM VALUES (10), (5), (NULL) AS tab(col);
+---------------+
|last(col, true)|
+---------------+
|              5|
+---------------+

-- last_value
SELECT last_value(col) FROM VALUES (10), (5), (20) AS tab(col);
+----------------------+
|last_value(col, false)|
+----------------------+
|                    20|
+----------------------+

SELECT last_value(col) FROM VALUES (10), (5), (NULL) AS tab(col);
+----------------------+
|last_value(col, false)|
+----------------------+
|                  null|
+----------------------+

SELECT last_value(col, true) FROM VALUES (10), (5), (NULL) AS tab(col);
+---------------------+
|last_value(col, true)|
+---------------------+
|                    5|
+---------------------+

-- max
SELECT max(col) FROM VALUES (10), (50), (20) AS tab(col);
+--------+
|max(col)|
+--------+
|      50|
+--------+

-- max_by
SELECT max_by(x, y) FROM VALUES (('a', 10)), (('b', 50)), (('c', 20)) AS tab(x, y);
+------------+
|max_by(x, y)|
+------------+
|           b|
+------------+

-- mean
SELECT mean(col) FROM VALUES (1), (2), (3) AS tab(col);
+---------+
|mean(col)|
+---------+
|      2.0|
+---------+

SELECT mean(col) FROM VALUES (1), (2), (NULL) AS tab(col);
+---------+
|mean(col)|
+---------+
|      1.5|
+---------+

-- min
SELECT min(col) FROM VALUES (10), (-1), (20) AS tab(col);
+--------+
|min(col)|
+--------+
|      -1|
+--------+

-- min_by
SELECT min_by(x, y) FROM VALUES (('a', 10)), (('b', 50)), (('c', 20)) AS tab(x, y);
+------------+
|min_by(x, y)|
+------------+
|           a|
+------------+

-- percentile
SELECT percentile(col, 0.3) FROM VALUES (0), (10) AS tab(col);
+---------------------------------------+
|percentile(col, CAST(0.3 AS DOUBLE), 1)|
+---------------------------------------+
|                                    3.0|
+---------------------------------------+

SELECT percentile(col, array(0.25, 0.75)) FROM VALUES (0), (10) AS tab(col);
+-------------------------------------+
|percentile(col, array(0.25, 0.75), 1)|
+-------------------------------------+
|                           [2.5, 7.5]|
+-------------------------------------+

-- percentile_approx
SELECT percentile_approx(10.0, array(0.5, 0.4, 0.1), 100);
+--------------------------------------------------+
|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);
+-------------------------------------------------+
|percentile_approx(10.0, CAST(0.5 AS DOUBLE), 100)|
+-------------------------------------------------+
|                                             10.0|
+-------------------------------------------------+

-- skewness
SELECT skewness(col) FROM VALUES (-10), (-20), (100), (1000) AS tab(col);
+-----------------------------+
|skewness(CAST(col AS DOUBLE))|
+-----------------------------+
|           1.1135657469022013|
+-----------------------------+

SELECT skewness(col) FROM VALUES (-1000), (-100), (10), (20) AS tab(col);
+-----------------------------+
|skewness(CAST(col AS DOUBLE))|
+-----------------------------+
|          -1.1135657469022011|
+-----------------------------+

-- some
SELECT some(col) FROM VALUES (true), (false), (false) AS tab(col);
+---------+
|some(col)|
+---------+
|     true|
+---------+

SELECT some(col) FROM VALUES (NULL), (true), (false) AS tab(col);
+---------+
|some(col)|
+---------+
|     true|
+---------+

SELECT some(col) FROM VALUES (false), (false), (NULL) AS tab(col);
+---------+
|some(col)|
+---------+
|    false|
+---------+

-- std
SELECT std(col) FROM VALUES (1), (2), (3) AS tab(col);
+------------------------+
|std(CAST(col AS DOUBLE))|
+------------------------+
|                     1.0|
+------------------------+

-- stddev
SELECT stddev(col) FROM VALUES (1), (2), (3) AS tab(col);
+---------------------------+
|stddev(CAST(col AS DOUBLE))|
+---------------------------+
|                        1.0|
+---------------------------+

-- stddev_pop
SELECT stddev_pop(col) FROM VALUES (1), (2), (3) AS tab(col);
+-------------------------------+
|stddev_pop(CAST(col AS DOUBLE))|
+-------------------------------+
|              0.816496580927726|
+-------------------------------+

-- stddev_samp
SELECT stddev_samp(col) FROM VALUES (1), (2), (3) AS tab(col);
+--------------------------------+
|stddev_samp(CAST(col AS DOUBLE))|
+--------------------------------+
|                             1.0|
+--------------------------------+

-- sum
SELECT sum(col) FROM VALUES (5), (10), (15) AS tab(col);
+--------+
|sum(col)|
+--------+
|      30|
+--------+

SELECT sum(col) FROM VALUES (NULL), (10), (15) AS tab(col);
+--------+
|sum(col)|
+--------+
|      25|
+--------+

SELECT sum(col) FROM VALUES (NULL), (NULL) AS tab(col);
+--------+
|sum(col)|
+--------+
|    null|
+--------+

-- var_pop
SELECT var_pop(col) FROM VALUES (1), (2), (3) AS tab(col);
+----------------------------+
|var_pop(CAST(col AS DOUBLE))|
+----------------------------+
|          0.6666666666666666|
+----------------------------+

-- var_samp
SELECT var_samp(col) FROM VALUES (1), (2), (3) AS tab(col);
+-----------------------------+
|var_samp(CAST(col AS DOUBLE))|
+-----------------------------+
|                          1.0|
+-----------------------------+

-- variance
SELECT variance(col) FROM VALUES (1), (2), (3) AS tab(col);
+-----------------------------+
|variance(CAST(col AS DOUBLE))|
+-----------------------------+
|                          1.0|
+-----------------------------+

FensterfunktionenWindow functions

FunktionFunction BESCHREIBUNGDescription
CUME_DIST ()cume_dist() Berechnet die Position eines Werts relativ zu allen Werten in der Partition.Computes the position of a value relative to all values in the partition.
DENSE_RANK ()dense_rank() Berechnet den Rang eines Werts in einer Gruppe von Werten.Computes the rank of a value in a group of values. Das Ergebnis ist 1 plus der zuvor zugewiesene Rangwert.The result is one plus the previously assigned rank value. Im Gegensatz zum Funktions Rang ergeben DENSE_RANK keine Lücken in der Rangfolge.Unlike the function rank, dense_rank will not produce gaps in the ranking sequence.
lag (input [, Offset [, Default]])lag(input[,offset[,default]]) Gibt den Wert von input in der offset Zeilen Zeile vor der aktuellen Zeile im Fenster zurück.Returns the value of input at the offsetth row before the current row in the window. Der Standardwert von offset ist 1, und der Standardwert von default ist NULL.The default value of offset is 1 and the default value of default is null. Wenn der Wert von input in der offset th-Zeile NULL ist, wird NULL zurückgegeben.If the value of input at the offsetth row is null, null is returned. Wenn keine solche Offset Zeile vorhanden ist (z. b. wenn der Offset 1 ist, enthält die erste Zeile des Fensters keine vorherige Zeile), default wird zurückgegeben.If there is no such offset row (e.g., when the offset is 1, the first row of the window does not have any previous row), default is returned.
Lead (Eingabe [, Offset [, Standard]])lead(input[,offset[,default]]) Gibt den Wert von input in der offset Zeilen Zeile nach der aktuellen Zeile im Fenster zurück.Returns the value of input at the offsetth row after the current row in the window. Der Standardwert von offset ist 1, und der Standardwert von default ist NULL.The default value of offset is 1 and the default value of default is null. Wenn der Wert von input in der offset th-Zeile NULL ist, wird NULL zurückgegeben.If the value of input at the offsetth row is null, null is returned. Wenn keine solche Offset Zeile vorhanden ist (z. b. wenn der Offset 1 ist, enthält die letzte Zeile des Fensters keine nachfolgende Zeile), default wird zurückgegeben.If there is no such an offset row (e.g., when the offset is 1, the last row of the window does not have any subsequent row), default is returned.
nkachel (n)ntile(n) Dividiert die Zeilen für jede Fenster Partition in ein bucketbereich n von 1 bis höchstens n .Divides the rows for each window partition into n buckets ranging from 1 to at most n.
PERCENT_RANK ()percent_rank() Berechnet den Prozentsatz eines Werts in einer Gruppe von Werten.Computes the percentage ranking of a value in a group of values.
Rang ()rank() Berechnet den Rang eines Werts in einer Gruppe von Werten.Computes the rank of a value in a group of values. Das Ergebnis ist 1 plus der Anzahl von Zeilen vor der aktuellen Zeile oder gleich dieser in der Reihenfolge der Partition.The result is one plus the number of rows preceding or equal to the current row in the ordering of the partition. Die Werte erzeugen Lücken in der Folge.The values will produce gaps in the sequence.
row_number()row_number() Weist jeder Zeile eine eindeutige, sequenzielle Zahl zu, beginnend mit 1, gemäß der Reihenfolge der Zeilen in der Fenster Partition.Assigns a unique, sequential number to each row, starting with one, according to the ordering of rows within the window partition.

ArrayfunktionenArray functions

FunktionFunction BESCHREIBUNGDescription
array_contains (Array, Wert)array_contains(array,value) Gibt "true" zurück, wenn das Array den Wert enthält.Returns true if the array contains the value.
array_distinct (Array)array_distinct(array) Entfernt doppelte Werte aus dem Array.Removes duplicate values from the array.
array_except (array1, array2)array_except(array1,array2) Gibt ein Array der Elemente in array1, jedoch nicht in array2 ohne Duplikate zurück.Returns an array of the elements in array1 but not in array2, without duplicates.
array_intersect (array1, array2)array_intersect(array1,array2) Gibt ein Array der Elemente in der Schnittmenge von array1 und array2 ohne Duplikate zurück.Returns an array of the elements in the intersection of array1 and array2, without duplicates.
array_join (Array, Trennzeichen [, nullreplace])array_join(array,delimiter[,nullReplacement]) Verkettet die Elemente des angegebenen Arrays mithilfe des Trenn Zeichens und einer optionalen Zeichenfolge zum Ersetzen von Nullen.Concatenates the elements of the given array using the delimiter and an optional string to replace nulls. Wenn kein Wert für nullreplace festgelegt ist, wird ein beliebiger NULL-Wert gefiltert.If no value is set for nullReplacement, any null value is filtered.
array_max (Array)array_max(array) Gibt den maximalen Wert im Array zurück.Returns the maximum value in the array. NULL-Elemente werden übersprungen.NULL elements are skipped.
array_min (Array)array_min(array) Gibt den minimalen Wert im Array zurück.Returns the minimum value in the array. NULL-Elemente werden übersprungen.NULL elements are skipped.
array_position (Array, Element)array_position(array,element) Gibt den (1-basierten) Index des ersten Elements des Arrays als Long-Wert zurück.Returns the (1-based) index of the first element of the array as long.
array_remove (Array, Element)array_remove(array,element) Entfernt alle Elemente, die dem-Element gleich sind, aus dem Array.Removes all elements that equal to element from array.
array_repeat (Element, Anzahl)array_repeat(element,count) Gibt das Array zurück, das die Anzahl der Elemente enthält.Returns the array containing element count times.
array_union (array1, array2)array_union(array1,array2) Gibt ein Array der Elemente in der Union von array1 und array2 ohne Duplikate zurück.Returns an array of the elements in the union of array1 and array2, without duplicates.
arrays_overlap (a1, a2)arrays_overlap(a1,a2) Gibt true zurück, wenn a1 mindestens ein nicht-NULL-Element enthält, das auch in a2 vorhanden ist.Returns true if a1 contains at least a non-null element present also in a2. Wenn die Arrays kein gemeinsames Element aufweisen und beide nicht leer sind und beide ein NULL-Element enthalten, wird NULL zurückgegeben, andernfalls false.If the arrays have no common element and they are both non-empty and either of them contains a null element null is returned, false otherwise.
arrays_zip (a1, a2,...)arrays_zip(a1,a2,…) Gibt ein zusammen geführtes Array von Strukturen zurück, in dem die n-te Struktur alle n-ten Werte von Eingabe Arrays enthält.Returns a merged array of structs in which the N-th struct contains all N-th values of input arrays.
Concat (Col1, col2,..., Coln)concat(col1,col2,…,colN) Gibt die Verkettung von Col1, col2,..., Coln zurück.Returns the concatenation of col1, col2, …, colN.
Flatten (arrayofarrays)flatten(arrayOfArrays) Transformiert ein Array von Arrays in ein einzelnes Array.Transforms an array of arrays into a single array.
umkehren (Array)reverse(array) Gibt eine umgekehrte Zeichenfolge oder ein Array mit umgekehrter Reihenfolge von Elementen zurück.Returns a reversed string or an array with reverse order of elements.
Sequenz (starten, Ende, Schritt)sequence(start,stop,step) Generiert ein Array von Elementen von Anfang bis Ende (inklusiv), inkrementiert nach Schritt.Generates an array of elements from start to stop (inclusive), incrementing by step. Der Typ der zurückgegebenen Elemente ist mit dem Typ der Argument Ausdrücke identisch.The type of the returned elements is the same as the type of argument expressions. Folgende Typen werden unterstützt: Byte, Short, Integer, Long, Date, timestamp.Supported types are: byte, short, integer, long, date, timestamp. Die Ausdrücke zum Starten und abbrechen müssen in denselben Typ aufgelöst werden.The start and stop expressions must resolve to the same type. Wenn die Ausdrücke zum Starten und Abbrechen in den Typ ' date ' oder ' timestamp ' aufgelöst werden, muss der Schritt Ausdruck in den ' Interval '-Typ aufgelöst werden, andernfalls in denselben Typ wie die Start-und die-Beendigung-Ausdrücke.If start and stop expressions resolve to the ‘date’ or ‘timestamp’ type then the step expression must resolve to the ‘interval’ type, otherwise to the same type as the start and stop expressions.
shuffle (Array)shuffle(array) Gibt eine zufällige permutations für das angegebene Array zurück.Returns a random permutation of the given array.
Slice (x, Start, Länge)slice(x,start,length) Teilmengen des Arrays x beginnend mit dem Index Start (Array Indizes beginnen bei 1 oder beginnend am Ende, wenn der Start negativ ist) mit der angegebenen Länge.Subsets array x starting from index start (array indices start at 1, or starting from the end if start is negative) with the specified length.
sort_array (Array [, AscendingOrder])sort_array(array[,ascendingOrder]) Sortiert das Eingabe Array in aufsteigender oder absteigender Reihenfolge entsprechend der natürlichen Reihenfolge der Array Elemente.Sorts the input array in ascending or descending order according to the natural ordering of the array elements. NULL-Elemente werden am Anfang des zurückgegebenen Arrays in aufsteigender Reihenfolge oder am Ende des zurückgegebenen Arrays in absteigender Reihenfolge platziert.Null elements will be placed at the beginning of the returned array in ascending order or at the end of the returned array in descending order.

BeispieleExamples

-- array_contains
SELECT array_contains(array(1, 2, 3), 2);
+---------------------------------+
|array_contains(array(1, 2, 3), 2)|
+---------------------------------+
|                             true|
+---------------------------------+

-- array_distinct
SELECT array_distinct(array(1, 2, 3, null, 3));
+----------------------------------------------------+
|array_distinct(array(1, 2, 3, CAST(NULL AS INT), 3))|
+----------------------------------------------------+
|                                          [1, 2, 3,]|
+----------------------------------------------------+

-- array_except
SELECT array_except(array(1, 2, 3), array(1, 3, 5));
+--------------------------------------------+
|array_except(array(1, 2, 3), array(1, 3, 5))|
+--------------------------------------------+
|                                         [2]|
+--------------------------------------------+

-- array_intersect
SELECT array_intersect(array(1, 2, 3), array(1, 3, 5));
+-----------------------------------------------+
|array_intersect(array(1, 2, 3), array(1, 3, 5))|
+-----------------------------------------------+
|                                         [1, 3]|
+-----------------------------------------------+

-- array_join
SELECT array_join(array('hello', 'world'), ' ');
+----------------------------------+
|array_join(array(hello, world),  )|
+----------------------------------+
|                       hello world|
+----------------------------------+

SELECT array_join(array('hello', null ,'world'), ' ');
+--------------------------------------------------------+
|array_join(array(hello, CAST(NULL AS STRING), world),  )|
+--------------------------------------------------------+
|                                             hello world|
+--------------------------------------------------------+

SELECT array_join(array('hello', null ,'world'), ' ', ',');
+-----------------------------------------------------------+
|array_join(array(hello, CAST(NULL AS STRING), world),  , ,)|
+-----------------------------------------------------------+
|                                              hello , world|
+-----------------------------------------------------------+

-- array_max
SELECT array_max(array(1, 20, null, 3));
+---------------------------------------------+
|array_max(array(1, 20, CAST(NULL AS INT), 3))|
+---------------------------------------------+
|                                           20|
+---------------------------------------------+

-- array_min
SELECT array_min(array(1, 20, null, 3));
+---------------------------------------------+
|array_min(array(1, 20, CAST(NULL AS INT), 3))|
+---------------------------------------------+
|                                            1|
+---------------------------------------------+

-- array_position
SELECT array_position(array(3, 2, 1), 1);
+---------------------------------+
|array_position(array(3, 2, 1), 1)|
+---------------------------------+
|                                3|
+---------------------------------+

-- array_remove
SELECT array_remove(array(1, 2, 3, null, 3), 3);
+-----------------------------------------------------+
|array_remove(array(1, 2, 3, CAST(NULL AS INT), 3), 3)|
+-----------------------------------------------------+
|                                              [1, 2,]|
+-----------------------------------------------------+

-- array_repeat
SELECT array_repeat('123', 2);
+--------------------+
|array_repeat(123, 2)|
+--------------------+
|          [123, 123]|
+--------------------+

-- array_union
SELECT array_union(array(1, 2, 3), array(1, 3, 5));
+-------------------------------------------+
|array_union(array(1, 2, 3), array(1, 3, 5))|
+-------------------------------------------+
|                               [1, 2, 3, 5]|
+-------------------------------------------+

-- arrays_overlap
SELECT arrays_overlap(array(1, 2, 3), array(3, 4, 5));
+----------------------------------------------+
|arrays_overlap(array(1, 2, 3), array(3, 4, 5))|
+----------------------------------------------+
|                                          true|
+----------------------------------------------+

-- arrays_zip
SELECT arrays_zip(array(1, 2, 3), array(2, 3, 4));
+------------------------------------------+
|arrays_zip(array(1, 2, 3), array(2, 3, 4))|
+------------------------------------------+
|                      [[1, 2], [2, 3], ...|
+------------------------------------------+

SELECT arrays_zip(array(1, 2), array(2, 3), array(3, 4));
+-------------------------------------------------+
|arrays_zip(array(1, 2), array(2, 3), array(3, 4))|
+-------------------------------------------------+
|                             [[1, 2, 3], [2, 3...|
+-------------------------------------------------+

-- concat
SELECT concat('Spark', 'SQL');
+------------------+
|concat(Spark, SQL)|
+------------------+
|          SparkSQL|
+------------------+

SELECT concat(array(1, 2, 3), array(4, 5), array(6));
+---------------------------------------------+
|concat(array(1, 2, 3), array(4, 5), array(6))|
+---------------------------------------------+
|                           [1, 2, 3, 4, 5, 6]|
+---------------------------------------------+

-- flatten
SELECT flatten(array(array(1, 2), array(3, 4)));
+----------------------------------------+
|flatten(array(array(1, 2), array(3, 4)))|
+----------------------------------------+
|                            [1, 2, 3, 4]|
+----------------------------------------+

-- reverse
SELECT reverse('Spark SQL');
+------------------+
|reverse(Spark SQL)|
+------------------+
|         LQS krapS|
+------------------+

SELECT reverse(array(2, 1, 4, 3));
+--------------------------+
|reverse(array(2, 1, 4, 3))|
+--------------------------+
|              [3, 4, 1, 2]|
+--------------------------+

-- sequence
SELECT sequence(1, 5);
+---------------+
| sequence(1, 5)|
+---------------+
|[1, 2, 3, 4, 5]|
+---------------+

SELECT sequence(5, 1);
+---------------+
| sequence(5, 1)|
+---------------+
|[5, 4, 3, 2, 1]|
+---------------+

SELECT sequence(to_date('2018-01-01'), to_date('2018-03-01'), interval 1 month);
+---------------------------------------------------------------------------+
|sequence(to_date('2018-01-01'), to_date('2018-03-01'), INTERVAL '1 months')|
+---------------------------------------------------------------------------+
|                                                       [2018-01-01, 2018...|
+---------------------------------------------------------------------------+

-- shuffle
SELECT shuffle(array(1, 20, 3, 5));
+---------------------------+
|shuffle(array(1, 20, 3, 5))|
+---------------------------+
|              [5, 20, 3, 1]|
+---------------------------+

SELECT shuffle(array(1, 20, null, 3));
+-------------------------------------------+
|shuffle(array(1, 20, CAST(NULL AS INT), 3))|
+-------------------------------------------+
|                                [20, 3,, 1]|
+-------------------------------------------+

-- slice
SELECT slice(array(1, 2, 3, 4), 2, 2);
+------------------------------+
|slice(array(1, 2, 3, 4), 2, 2)|
+------------------------------+
|                        [2, 3]|
+------------------------------+

SELECT slice(array(1, 2, 3, 4), -2, 2);
+-------------------------------+
|slice(array(1, 2, 3, 4), -2, 2)|
+-------------------------------+
|                         [3, 4]|
+-------------------------------+

-- sort_array
SELECT sort_array(array('b', 'd', null, 'c', 'a'), true);
+---------------------------------------------------------+
|sort_array(array(b, d, CAST(NULL AS STRING), c, a), true)|
+---------------------------------------------------------+
|                                           [, a, b, c, d]|
+---------------------------------------------------------+

Map-FunktionenMap functions

FunktionFunction BESCHREIBUNGDescription
map_concat (map,...)map_concat(map,…) Gibt die Vereinigung aller angegebenen Zuordnungen zurück.Returns the union of all the given maps.
map_entries (Map)map_entries(map) Gibt ein ungeordneter Array aller Einträge in der angegebenen Karte zurück.Returns an unordered array of all entries in the given map.
map_from_entries (ArrayOf Entries)map_from_entries(arrayOfEntries) Gibt eine Zuordnung zurück, die aus dem angegebenen Array von Einträgen erstellt wurde.Returns a map created from the given array of entries.
map_keys (Map)map_keys(map) Gibt ein ungeordneter Array zurück, das die Schlüssel der Karte enthält.Returns an unordered array containing the keys of the map.
map_values (Map)map_values(map) Gibt ein ungeordneter Array zurück, das die Werte der Karte enthält.Returns an unordered array containing the values of the map.

BeispieleExamples

-- map_concat
SELECT map_concat(map(1, 'a', 2, 'b'), map(3, 'c'));
+--------------------------------------+
|map_concat(map(1, a, 2, b), map(3, c))|
+--------------------------------------+
|                  [1 -> a, 2 -> b, ...|
+--------------------------------------+

-- map_entries
SELECT map_entries(map(1, 'a', 2, 'b'));
+----------------------------+
|map_entries(map(1, a, 2, b))|
+----------------------------+
|            [[1, a], [2, b]]|
+----------------------------+

-- map_from_entries
SELECT map_from_entries(array(struct(1, 'a'), struct(2, 'b')));
+---------------------------------------------------+
|map_from_entries(array(struct(1, a), struct(2, b)))|
+---------------------------------------------------+
|                                   [1 -> a, 2 -> b]|
+---------------------------------------------------+

-- map_keys
SELECT map_keys(map(1, 'a', 2, 'b'));
+-------------------------+
|map_keys(map(1, a, 2, b))|
+-------------------------+
|                   [1, 2]|
+-------------------------+

-- map_values
SELECT map_values(map(1, 'a', 2, 'b'));
+---------------------------+
|map_values(map(1, a, 2, b))|
+---------------------------+
|                     [a, b]|
+---------------------------+

Datums-und Zeitstempel FunktionenDate and timestamp functions

Informationen zu Datums-und Zeitstempel Formaten finden Sie unter DateTime Patterns.For information on date and timestamp formats, see Datetime patterns.

FunktionFunction BESCHREIBUNGDescription
add_months (start_date, num_months)add_months(start_date,num_months) Gibt das Datum zurück, das num_months nach liegt start_date .Returns the date that is num_months after start_date.
CURRENT_DATE ()current_date() Gibt das aktuelle Datum zu Beginn der Abfrage Auswertung zurück.Returns the current date at the start of query evaluation.
CURRENT_TIMESTAMP ()current_timestamp() Gibt den aktuellen Zeitstempel zu Beginn der Abfrage Auswertung zurück.Returns the current timestamp at the start of query evaluation.
DATE_ADD (start_date, NUM_DAYS)date_add(start_date,num_days) Gibt das Datum zurück, das num_days nach liegt start_date .Returns the date that is num_days after start_date.
date_format (Timestamp, f MT)date_format(timestamp,fmt) Konvertiert timestamp in einen Wert der Zeichenfolge in dem Format, das durch das Datumsformat angegeben wird fmt .Converts timestamp to a value of string in the format specified by the date format fmt.
date_part (Feld, Quelle)date_part(field,source) Extrahiert einen Teil der Date/Timestamp-oder Interval-Quelle.Extracts a part of the date/timestamp or interval source.
DATE_SUB (start_date, NUM_DAYS)date_sub(start_date,num_days) Gibt das Datum zurück, das num_days vor liegt start_date .Returns the date that is num_days before start_date.
date_trunc ("f", "TS")date_trunc(fmt,ts) Gibt den Zeitstempel-Wert zurück ts , der auf die durch das Format Modell angegebene Einheit gekürzt wird fmt .Returns timestamp ts truncated to the unit specified by the format model fmt.
DateDiff (EndDate, StartDate)datediff(endDate,startDate) Gibt die Anzahl der Tage von startDate bis zurück endDate .Returns the number of days from startDate to endDate.
dayof Week (Datum)dayofweek(date) Gibt den Wochentag für Datum/Zeitstempel zurück (1 = Sonntag, 2 = Montag,..., 7 = Samstag).Returns the day of the week for date/timestamp (1 = Sunday, 2 = Monday, …, 7 = Saturday).
dayosyear (Datum)dayofyear(date) Gibt den Tag des Jahres des Datums-/Uhrzeitstempels zurück.Returns the day of year of the date/timestamp.
FROM_UNIXTIME (unix_time, Format)from_unixtime(unix_time,format) Gibt unix_time in der angegebenen zurück format .Returns unix_time in the specified format.
from_utc_timestamp (Timestamp, TimeZone)from_utc_timestamp(timestamp,timezone) Wenn ein Zeitstempel wie "2017-07-14 02:40:00.0" angegeben ist, interpretiert ihn als Zeit in UTC und rendert diesen Zeitpunkt als Zeitstempel in der angegebenen Zeitzone.Given a timestamp like ‘2017-07-14 02:40:00.0’, interprets it as a time in UTC, and renders that time as a timestamp in the given time zone. "GMT + 1" würde beispielsweise "2017-07-14 03:40:00.0" ergeben.For example, ‘GMT+1’ would yield ‘2017-07-14 03:40:00.0’.
Hour (Timestamp)hour(timestamp) Gibt die Stunden Komponente der Zeichenfolge bzw. des Zeitstempels zurück.Returns the hour component of the string/timestamp.
last_day (Datum)last_day(date) Gibt den letzten Tag des Monats zurück, zu dem das Datum gehört.Returns the last day of the month which the date belongs to.
make_date (Jahr, Monat, Tag)make_date(year,month,day) Erstellungsdatum aus den Feldern Jahr, Monat und TagCreate date from year, month and day fields
make_timestamp (Jahr, Monat, Tag, Stunde, min, Sek. [, Zeitzone])make_timestamp(year,month,day,hour,min,sec[,timezone]) Erstellen Sie einen Zeitstempel aus den Feldern Jahr, Monat, Tag, Stunde, min, SEC und Zeitzone.Create timestamp from year, month, day, hour, min, sec and timezone fields.
Minute (Timestamp)minute(timestamp) Gibt die Minuten Komponente der Zeichenfolge bzw. des Zeitstempels zurück.Returns the minute component of the string/timestamp.
Monat (Datum)month(date) Gibt die Monats Komponente des Datums-/Uhrzeitstempels zurück.Returns the month component of the date/timestamp.
MONTHS_BETWEEN (timestamp1, timestamp2 [, roundoff])months_between(timestamp1,timestamp2[,roundOff]) Wenn timestamp1 später als ist timestamp2 , ist das Ergebnis positiv.If timestamp1 is later than timestamp2, then the result is positive. Wenn timestamp1 und timestamp2 am selben Tag des Monats liegen oder beide den letzten Tag des Monats sind, wird die Tageszeit ignoriert.If timestamp1 and timestamp2 are on the same day of month, or both are the last day of month, time of day will be ignored. Andernfalls wird der Unterschied basierend auf 31 Tagen pro Monat berechnet und auf 8 Ziffern gerundet, es sei denn, roundoff = false.Otherwise, the difference is calculated based on 31 days per month, and rounded to 8 digits unless roundOff=false.
next_day (start_date, day_of_week)next_day(start_date,day_of_week) Gibt das erste Datum zurück, das nach dem start_date angegebenen liegt und den Namen hat.Returns the first date which is later than start_date and named as indicated.
now()now() Gibt den aktuellen Zeitstempel zu Beginn der Abfrage Auswertung zurück.Returns the current timestamp at the start of query evaluation.
Quartal (Datum)quarter(date) Gibt das Quartal des Jahres für date im Bereich von 1 bis 4 zurück.Returns the quarter of the year for date, in the range 1 to 4.
Second (Timestamp)second(timestamp) Gibt die zweite Komponente der Zeichenfolge bzw. des Zeitstempels zurück.Returns the second component of the string/timestamp.
TO_DATE (date_str [, f])to_date(date_str[,fmt]) Analysiert den date_str Ausdruck mit dem fmt Ausdruck bis zu einem Datum.Parses the date_str expression with the fmt expression to a date. Gibt NULL zurück, wenn die Eingabe ungültig ist.Returns null with invalid input. Standardmäßig folgt die Umwandlung von Regeln in ein Datum, wenn fmt ausgelassen wird.By default, it follows casting rules to a date if the fmt is omitted
to_timestamp (timestamp_str [, f])to_timestamp(timestamp_str[,fmt]) Analysiert den timestamp_str Ausdruck mit dem fmt Ausdruck zu einem Zeitstempel.Parses the timestamp_str expression with the fmt expression to a timestamp. Gibt NULL zurück, wenn die Eingabe ungültig ist.Returns null with invalid input. Standardmäßig folgt die Umwandlung von Regeln in einen Zeitstempel, wenn fmt ausgelassen wird.By default, it follows casting rules to a timestamp if the fmt is omitted.
to_unix_timestamp (timeexp [, Format])to_unix_timestamp(timeExp[,format]) Gibt den UNIX-Zeitstempel des angegebenen Zeitraums zurück.Returns the UNIX timestamp of the given time.
to_utc_timestamp (Timestamp, TimeZone)to_utc_timestamp(timestamp,timezone) Interpretiert einen Zeitstempel wie z. b. "2017-07-14 02:40:00.0" als Zeit in der angegebenen Zeitzone und rendert diese Uhrzeit als Zeitstempel in UTC.Given a timestamp like ‘2017-07-14 02:40:00.0’, interprets it as a time in the given time zone, and renders that time as a timestamp in UTC. "GMT + 1" würde beispielsweise "2017-07-14 01:40:00.0" ergeben.For example, ‘GMT+1’ would yield ‘2017-07-14 01:40:00.0’
trunc (datefmt)trunc(datefmt) Gibt date mit dem Zeitteil des Tages zurück, der auf die durch das Format Modell angegebene Einheit gekürzt wird fmt .Returns date with the time portion of the day truncated to the unit specified by the format model fmt.
UNIX_TIMESTAMP ([timeexp [Format]])unix_timestamp([timeExp[format]]) Gibt den UNIX-Zeitstempel der aktuellen oder der angegebenen Uhrzeit zurück.Returns the UNIX timestamp of current or specified time.
Wochentag (Datum)weekday(date) Gibt den Wochentag für Datum/Zeitstempel zurück (0 = Montag, 1 = Dienstag,..., 6 = Sonntag).Returns the day of the week for date/timestamp (0 = Monday, 1 = Tuesday, …, 6 = Sunday).
weekosyear (Datum)weekofyear(date) Gibt die Woche des Jahres des angegebenen Datums zurück.Returns the week of the year of the given date. Eine Woche gilt als Start an Montag, und Woche 1 ist die erste Woche mit >3 Tagen.A week is considered to start on a Monday and week 1 is the first week with >3 days.
Jahr (Datum)year(date) Gibt die Jahres Komponente des Datums-/Uhrzeitstempels zurück.Returns the year component of the date/timestamp.

BeispieleExamples

-- add_months
SELECT add_months('2016-08-31', 1);
+---------------------------------------+
|add_months(CAST(2016-08-31 AS DATE), 1)|
+---------------------------------------+
|                             2016-09-30|
+---------------------------------------+

-- current_date
SELECT current_date();
+--------------+
|current_date()|
+--------------+
|    2020-06-06|
+--------------+

SELECT current_date;
+--------------+
|current_date()|
+--------------+
|    2020-06-06|
+--------------+

-- current_timestamp
SELECT current_timestamp();
+--------------------+
| current_timestamp()|
+--------------------+
|2020-06-06 14:00:...|
+--------------------+

SELECT current_timestamp;
+--------------------+
| current_timestamp()|
+--------------------+
|2020-06-06 14:00:...|
+--------------------+

-- date_add
SELECT date_add('2016-07-30', 1);
+-------------------------------------+
|date_add(CAST(2016-07-30 AS DATE), 1)|
+-------------------------------------+
|                           2016-07-31|
+-------------------------------------+

-- date_format
SELECT date_format('2016-04-08', 'y');
+---------------------------------------------+
|date_format(CAST(2016-04-08 AS TIMESTAMP), y)|
+---------------------------------------------+
|                                         2016|
+---------------------------------------------+

-- date_part
SELECT date_part('YEAR', TIMESTAMP '2019-08-12 01:00:00.123456');
+---------------------------------------------------------+
|date_part('YEAR', TIMESTAMP '2019-08-12 01:00:00.123456')|
+---------------------------------------------------------+
|                                                     2019|
+---------------------------------------------------------+

SELECT date_part('week', timestamp'2019-08-12 01:00:00.123456');
+---------------------------------------------------------+
|date_part('week', TIMESTAMP '2019-08-12 01:00:00.123456')|
+---------------------------------------------------------+
|                                                       33|
+---------------------------------------------------------+

SELECT date_part('doy', DATE'2019-08-12');
+-----------------------------------+
|date_part('doy', DATE '2019-08-12')|
+-----------------------------------+
|                                224|
+-----------------------------------+

SELECT date_part('SECONDS', timestamp'2019-10-01 00:00:01.000001');
+------------------------------------------------------------+
|date_part('SECONDS', TIMESTAMP '2019-10-01 00:00:01.000001')|
+------------------------------------------------------------+
|                                                    1.000001|
+------------------------------------------------------------+

SELECT date_part('days', interval 1 year 10 months 5 days);
+------------------------------------------------------+
|date_part('days', INTERVAL '1 years 10 months 5 days')|
+------------------------------------------------------+
|                                                     5|
+------------------------------------------------------+

SELECT date_part('seconds', interval 5 hours 30 seconds 1 milliseconds 1 microseconds);
+----------------------------------------------------------+
|date_part('seconds', INTERVAL '5 hours 30.001001 seconds')|
+----------------------------------------------------------+
|                                                 30.001001|
+----------------------------------------------------------+

-- date_sub
SELECT date_sub('2016-07-30', 1);
+-------------------------------------+
|date_sub(CAST(2016-07-30 AS DATE), 1)|
+-------------------------------------+
|                           2016-07-29|
+-------------------------------------+

-- date_trunc
SELECT date_trunc('YEAR', '2015-03-05T09:32:05.359');
+------------------------------------------------------------+
|date_trunc(YEAR, CAST(2015-03-05T09:32:05.359 AS TIMESTAMP))|
+------------------------------------------------------------+
|                                         2015-01-01 00:00:00|
+------------------------------------------------------------+

SELECT date_trunc('MM', '2015-03-05T09:32:05.359');
+----------------------------------------------------------+
|date_trunc(MM, CAST(2015-03-05T09:32:05.359 AS TIMESTAMP))|
+----------------------------------------------------------+
|                                       2015-03-01 00:00:00|
+----------------------------------------------------------+

SELECT date_trunc('DD', '2015-03-05T09:32:05.359');
+----------------------------------------------------------+
|date_trunc(DD, CAST(2015-03-05T09:32:05.359 AS TIMESTAMP))|
+----------------------------------------------------------+
|                                       2015-03-05 00:00:00|
+----------------------------------------------------------+

SELECT date_trunc('HOUR', '2015-03-05T09:32:05.359');
+------------------------------------------------------------+
|date_trunc(HOUR, CAST(2015-03-05T09:32:05.359 AS TIMESTAMP))|
+------------------------------------------------------------+
|                                         2015-03-05 09:00:00|
+------------------------------------------------------------+

SELECT date_trunc('MILLISECOND', '2015-03-05T09:32:05.123456');
+----------------------------------------------------------------------+
|date_trunc(MILLISECOND, CAST(2015-03-05T09:32:05.123456 AS TIMESTAMP))|
+----------------------------------------------------------------------+
|                                                  2015-03-05 09:32:...|
+----------------------------------------------------------------------+

-- datediff
SELECT datediff('2009-07-31', '2009-07-30');
+------------------------------------------------------------+
|datediff(CAST(2009-07-31 AS DATE), CAST(2009-07-30 AS DATE))|
+------------------------------------------------------------+
|                                                           1|
+------------------------------------------------------------+

SELECT datediff('2009-07-30', '2009-07-31');
+------------------------------------------------------------+
|datediff(CAST(2009-07-30 AS DATE), CAST(2009-07-31 AS DATE))|
+------------------------------------------------------------+
|                                                          -1|
+------------------------------------------------------------+

-- dayofweek
SELECT dayofweek('2009-07-30');
+-----------------------------------+
|dayofweek(CAST(2009-07-30 AS DATE))|
+-----------------------------------+
|                                  5|
+-----------------------------------+

-- dayofyear
SELECT dayofyear('2016-04-09');
+-----------------------------------+
|dayofyear(CAST(2016-04-09 AS DATE))|
+-----------------------------------+
|                                100|
+-----------------------------------+

-- from_unixtime
SELECT from_unixtime(0, 'yyyy-MM-dd HH:mm:ss');
+-----------------------------------------------------+
|from_unixtime(CAST(0 AS BIGINT), yyyy-MM-dd HH:mm:ss)|
+-----------------------------------------------------+
|                                  1970-01-01 00:00:00|
+-----------------------------------------------------+

-- from_utc_timestamp
SELECT from_utc_timestamp('2016-08-31', 'Asia/Seoul');
+-------------------------------------------------------------+
|from_utc_timestamp(CAST(2016-08-31 AS TIMESTAMP), Asia/Seoul)|
+-------------------------------------------------------------+
|                                          2016-08-31 09:00:00|
+-------------------------------------------------------------+

-- hour
SELECT hour('2009-07-30 12:58:59');
+--------------------------------------------+
|hour(CAST(2009-07-30 12:58:59 AS TIMESTAMP))|
+--------------------------------------------+
|                                          12|
+--------------------------------------------+

-- last_day
SELECT last_day('2009-01-12');
+----------------------------------+
|last_day(CAST(2009-01-12 AS DATE))|
+----------------------------------+
|                        2009-01-31|
+----------------------------------+

-- make_date
SELECT make_date(2013, 7, 15);
+----------------------+
|make_date(2013, 7, 15)|
+----------------------+
|            2013-07-15|
+----------------------+

SELECT make_date(2019, 13, 1);
+----------------------+
|make_date(2019, 13, 1)|
+----------------------+
|                  null|
+----------------------+

SELECT make_date(2019, 7, NULL);
+-------------------------------------+
|make_date(2019, 7, CAST(NULL AS INT))|
+-------------------------------------+
|                                 null|
+-------------------------------------+

SELECT make_date(2019, 2, 30);
+----------------------+
|make_date(2019, 2, 30)|
+----------------------+
|                  null|
+----------------------+

-- make_timestamp
SELECT make_timestamp(2014, 12, 28, 6, 30, 45.887);
+-----------------------------------------------------------------+
|make_timestamp(2014, 12, 28, 6, 30, CAST(45.887 AS DECIMAL(8,6)))|
+-----------------------------------------------------------------+
|                                             2014-12-28 06:30:...|
+-----------------------------------------------------------------+

SELECT make_timestamp(2014, 12, 28, 6, 30, 45.887, 'CET');
+----------------------------------------------------------------------+
|make_timestamp(2014, 12, 28, 6, 30, CAST(45.887 AS DECIMAL(8,6)), CET)|
+----------------------------------------------------------------------+
|                                                  2014-12-28 05:30:...|
+----------------------------------------------------------------------+

SELECT make_timestamp(2019, 6, 30, 23, 59, 60);
+-------------------------------------------------------------+
|make_timestamp(2019, 6, 30, 23, 59, CAST(60 AS DECIMAL(8,6)))|
+-------------------------------------------------------------+
|                                          2019-07-01 00:00:00|
+-------------------------------------------------------------+

SELECT make_timestamp(2019, 13, 1, 10, 11, 12, 'PST');
+------------------------------------------------------------------+
|make_timestamp(2019, 13, 1, 10, 11, CAST(12 AS DECIMAL(8,6)), PST)|
+------------------------------------------------------------------+
|                                                              null|
+------------------------------------------------------------------+

SELECT make_timestamp(null, 7, 22, 15, 30, 0);
+-------------------------------------------------------------------------+
|make_timestamp(CAST(NULL AS INT), 7, 22, 15, 30, CAST(0 AS DECIMAL(8,6)))|
+-------------------------------------------------------------------------+
|                                                                     null|
+-------------------------------------------------------------------------+

-- minute
SELECT minute('2009-07-30 12:58:59');
+----------------------------------------------+
|minute(CAST(2009-07-30 12:58:59 AS TIMESTAMP))|
+----------------------------------------------+
|                                            58|
+----------------------------------------------+

-- month
SELECT month('2016-07-30');
+-------------------------------+
|month(CAST(2016-07-30 AS DATE))|
+-------------------------------+
|                              7|
+-------------------------------+

-- months_between
SELECT months_between('1997-02-28 10:30:00', '1996-10-30');
+-------------------------------------------------------------------------------------------+
|months_between(CAST(1997-02-28 10:30:00 AS TIMESTAMP), CAST(1996-10-30 AS TIMESTAMP), true)|
+-------------------------------------------------------------------------------------------+
|                                                                                 3.94959677|
+-------------------------------------------------------------------------------------------+

SELECT months_between('1997-02-28 10:30:00', '1996-10-30', false);
+--------------------------------------------------------------------------------------------+
|months_between(CAST(1997-02-28 10:30:00 AS TIMESTAMP), CAST(1996-10-30 AS TIMESTAMP), false)|
+--------------------------------------------------------------------------------------------+
|                                                                          3.9495967741935485|
+--------------------------------------------------------------------------------------------+

-- next_day
SELECT next_day('2015-01-14', 'TU');
+--------------------------------------+
|next_day(CAST(2015-01-14 AS DATE), TU)|
+--------------------------------------+
|                            2015-01-20|
+--------------------------------------+

-- now
SELECT now();
+--------------------+
|               now()|
+--------------------+
|2020-06-06 14:00:...|
+--------------------+

-- quarter
SELECT quarter('2016-08-31');
+---------------------------------+
|quarter(CAST(2016-08-31 AS DATE))|
+---------------------------------+
|                                3|
+---------------------------------+

-- second
SELECT second('2009-07-30 12:58:59');
+----------------------------------------------+
|second(CAST(2009-07-30 12:58:59 AS TIMESTAMP))|
+----------------------------------------------+
|                                            59|
+----------------------------------------------+

-- to_date
SELECT to_date('2009-07-30 04:17:52');
+------------------------------+
|to_date('2009-07-30 04:17:52')|
+------------------------------+
|                    2009-07-30|
+------------------------------+

SELECT to_date('2016-12-31', 'yyyy-MM-dd');
+-----------------------------------+
|to_date('2016-12-31', 'yyyy-MM-dd')|
+-----------------------------------+
|                         2016-12-31|
+-----------------------------------+

-- to_timestamp
SELECT to_timestamp('2016-12-31 00:12:00');
+-----------------------------------+
|to_timestamp('2016-12-31 00:12:00')|
+-----------------------------------+
|                2016-12-31 00:12:00|
+-----------------------------------+

SELECT to_timestamp('2016-12-31', 'yyyy-MM-dd');
+----------------------------------------+
|to_timestamp('2016-12-31', 'yyyy-MM-dd')|
+----------------------------------------+
|                     2016-12-31 00:00:00|
+----------------------------------------+

-- to_unix_timestamp
SELECT to_unix_timestamp('2016-04-08', 'yyyy-MM-dd');
+-----------------------------------------+
|to_unix_timestamp(2016-04-08, yyyy-MM-dd)|
+-----------------------------------------+
|                               1460073600|
+-----------------------------------------+

-- to_utc_timestamp
SELECT to_utc_timestamp('2016-08-31', 'Asia/Seoul');
+-----------------------------------------------------------+
|to_utc_timestamp(CAST(2016-08-31 AS TIMESTAMP), Asia/Seoul)|
+-----------------------------------------------------------+
|                                        2016-08-30 15:00:00|
+-----------------------------------------------------------+

-- trunc
SELECT trunc('2019-08-04', 'week');
+-------------------------------------+
|trunc(CAST(2019-08-04 AS DATE), week)|
+-------------------------------------+
|                           2019-07-29|
+-------------------------------------+

SELECT trunc('2019-08-04', 'quarter');
+----------------------------------------+
|trunc(CAST(2019-08-04 AS DATE), quarter)|
+----------------------------------------+
|                              2019-07-01|
+----------------------------------------+

SELECT trunc('2009-02-12', 'MM');
+-----------------------------------+
|trunc(CAST(2009-02-12 AS DATE), MM)|
+-----------------------------------+
|                         2009-02-01|
+-----------------------------------+

SELECT trunc('2015-10-27', 'YEAR');
+-------------------------------------+
|trunc(CAST(2015-10-27 AS DATE), YEAR)|
+-------------------------------------+
|                           2015-01-01|
+-------------------------------------+

-- unix_timestamp
SELECT unix_timestamp();
+--------------------------------------------------------+
|unix_timestamp(current_timestamp(), yyyy-MM-dd HH:mm:ss)|
+--------------------------------------------------------+
|                                              1591452047|
+--------------------------------------------------------+

SELECT unix_timestamp('2016-04-08', 'yyyy-MM-dd');
+--------------------------------------+
|unix_timestamp(2016-04-08, yyyy-MM-dd)|
+--------------------------------------+
|                            1460073600|
+--------------------------------------+

-- weekday
SELECT weekday('2009-07-30');
+---------------------------------+
|weekday(CAST(2009-07-30 AS DATE))|
+---------------------------------+
|                                3|
+---------------------------------+

-- weekofyear
SELECT weekofyear('2008-02-20');
+------------------------------------+
|weekofyear(CAST(2008-02-20 AS DATE))|
+------------------------------------+
|                                   8|
+------------------------------------+

-- year
SELECT year('2016-07-30');
+------------------------------+
|year(CAST(2016-07-30 AS DATE))|
+------------------------------+
|                          2016|
+------------------------------+

JSON-FunktionenJSON functions

FunktionFunction BESCHREIBUNGDescription
from_json (jsonstr, Schema [, Optionen])from_json(jsonStr, schema[, options]) Gibt einen Strukturwert mit dem angegebenen und dem angegebenen zurück jsonStr schema .Returns a struct value with the given jsonStr and schema.
get_json_object (json_txt, Pfad)get_json_object(json_txt, path) Extrahiert ein JSON-Objekt aus path .Extracts a json object from path.
json_tuple (jsonstr, P1, P2,..., PN)json_tuple(jsonStr, p1, p2, …, pn) Gibt ein Tupel wie die-Funktion zurück get_json_object , es werden jedoch mehrere Namen benötigt.Returns a tuple like the function get_json_object, but it takes multiple names. Alle Eingabeparameter und Ausgabespalten Typen sind Zeichen folgen.All the input parameters and output column types are string.
schema_of_json (JSON [, Optionen])schema_of_json(json[, options]) Gibt das Schema im DDL-Format der JSON-Zeichenfolge zurück.Returns schema in the DDL format of JSON string.
to_json (expr [, Optionen])to_json(expr[, options]) Gibt eine JSON-Zeichenfolge mit einem angegebenen Struktur Wert zurück.Returns a JSON string with a given struct value.

BeispieleExamples

-- from_json
SELECT from_json('{"a":1, "b":0.8}', 'a INT, b DOUBLE');
+---------------------------+
|from_json({"a":1, "b":0.8})|
+---------------------------+
|                   [1, 0.8]|
+---------------------------+

SELECT from_json('{"time":"26/08/2015"}', 'time Timestamp', map('timestampFormat', 'dd/MM/yyyy'));
+--------------------------------+
|from_json({"time":"26/08/2015"})|
+--------------------------------+
|            [2015-08-26 00:00...|
+--------------------------------+

-- get_json_object
SELECT get_json_object('{"a":"b"}', '$.a');
+-------------------------------+
|get_json_object({"a":"b"}, $.a)|
+-------------------------------+
|                              b|
+-------------------------------+

-- json_tuple
SELECT json_tuple('{"a":1, "b":2}', 'a', 'b');
+---+---+
| c0| c1|
+---+---+
|  1|  2|
+---+---+

-- schema_of_json
SELECT schema_of_json('[{"col":0}]');
+---------------------------+
|schema_of_json([{"col":0}])|
+---------------------------+
|       array<struct<col:...|
+---------------------------+

SELECT schema_of_json('[{"col":01}]', map('allowNumericLeadingZeros', 'true'));
+----------------------------+
|schema_of_json([{"col":01}])|
+----------------------------+
|        array<struct<col:...|
+----------------------------+

-- to_json
SELECT to_json(named_struct('a', 1, 'b', 2));
+---------------------------------+
|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'));
+---------------------------------------------------------------------+
|to_json(named_struct(time, to_timestamp('2015-08-26', 'yyyy-MM-dd')))|
+---------------------------------------------------------------------+
|                                                 {"time":"26/08/20...|
+---------------------------------------------------------------------+

SELECT to_json(array(named_struct('a', 1, 'b', 2)));
+----------------------------------------+
|to_json(array(named_struct(a, 1, b, 2)))|
+----------------------------------------+
|                         [{"a":1,"b":2}]|
+----------------------------------------+

SELECT to_json(map('a', named_struct('b', 1)));
+-----------------------------------+
|to_json(map(a, named_struct(b, 1)))|
+-----------------------------------+
|                      {"a":{"b":1}}|
+-----------------------------------+

SELECT to_json(map(named_struct('a', 1),named_struct('b', 2)));
+----------------------------------------------------+
|to_json(map(named_struct(a, 1), named_struct(b, 2)))|
+----------------------------------------------------+
|                                     {"[1]":{"b":2}}|
+----------------------------------------------------+

SELECT to_json(map('a', 1));
+------------------+
|to_json(map(a, 1))|
+------------------+
|           {"a":1}|
+------------------+

SELECT to_json(array((map('a', 1))));
+-------------------------+
|to_json(array(map(a, 1)))|
+-------------------------+
|                [{"a":1}]|
+-------------------------+