Yerleşik işlevler

Toplama işlevleri

İşlev Açıklama
Any (Expr) En az bir değeri true ise true döndürür expr .
approx_count_distinct (Expr [, relativeSD]) Hiperloglog + + tahmini kardinalitesini döndürür. relativeSD izin verilen maksimum tahmin hatasını tanımlar.
approx_percentile (sütun, yüzde [, doğruluk]) Verilen yüzdedeki sayısal sütunun yaklaşık yüzdebirlik değerini döndürür col . Yüzde değeri 0,0 ile 1,0 arasında olmalıdır. accuracyParametresi (varsayılan: 10000), belleğin maliyetinde yaklaşık doğruluğu denetleyen pozitif bir sayısal değişmez değerdir. Daha yüksek bir değer accuracy daha iyi doğruluk verir, 1.0/accuracy yaklaşık göreli hatadır. percentageBir dizi olduğunda, yüzde dizisinin her değeri 0,0 ile 1,0 arasında olmalıdır. Bu durumda, verilen yüzde dizisindeki sütunun yaklaşık yüzdebirlik dizisini döndürür col .
Ort (Expr) Bir grubun değerlerinden hesaplanan ortalama değeri döndürür.
bit_or (Expr) Null olmayan tüm giriş değerlerini veya None ise null bit düzeyinde veya null değerini döndürür.
bit_xor (Expr) Null olmayan tüm giriş değerlerinin bit düzeyinde XOR değeri veya None ise null değerini döndürür.
bool_and (Expr) Tüm değerleri true ise true döndürür expr .
bool_or (Expr) En az bir değeri true ise true döndürür expr .
collect_list (Expr) Benzersiz olmayan öğelerin bir listesini toplar ve döndürür.
collect_set (Expr) Benzersiz bir öğe kümesi toplar ve döndürür.
Corr (expr1, expr2) Bir sayı çiftleri kümesi arasındaki, Pearson katsayısını döndürür.
sayı (*) Null içeren satırlar da dahil olmak üzere alınan toplam satır sayısını döndürür.
sayı (Expr [, Expr...]) Sağlanan ifade (ler) in null olmayan satır sayısını döndürür.
sayı (farklı Expr [, Expr...]) Sağlanan ifade (ler) in benzersiz ve null olmayan satır sayısını döndürür.
count_if (Expr) TRUEİfade için değerlerin sayısını döndürür.
count_min_sketch (Col, EPS, güvenirlik, çekirdek) Verilen ESP, güvenirlik ve çekirdek içeren bir sütunun Count-min taslağını döndürür. Sonuç bir bayt dizisidir ve bu, bir önceki kullanım için seri hale eklenebilir CountMinSketch . Count-min taslağı, alt doğrusal alan kullanarak kardinalite tahmini için kullanılan bir dayalı veri yapısıdır.
covar_pop (expr1, expr2) Bir dizi sayı çiftinin popülasyon kovaryansını döndürür.
covar_samp (expr1, expr2) Bir sayı çiftleri kümesinin örnek kovaryansını döndürür.
her (Expr) Tüm değerleri true ise true döndürür expr .
First (Expr [, ısıgnorenull]) exprBir satır grubu için ilk değeri döndürür. isIgnoreNullTrue ise, yalnızca null olmayan değerler döndürür.
first_value (Expr [, ısıgnorenull]) exprBir satır grubu için ilk değeri döndürür. isIgnoreNullTrue ise, yalnızca null olmayan değerler döndürür.
basıklık (Expr) Bir grubun değerlerinden hesaplanan basıklık değerini döndürür.
Last (Expr [, ısıgnorenull]) exprBir satır grubu için son değeri döndürür. isIgnoreNullTrue ise, yalnızca null olmayan değerler döndürür.
last_value (Expr [, ısıgnorenull]) exprBir satır grubu için son değeri döndürür. isIgnoreNullTrue ise, yalnızca null olmayan değerler döndürür.
Max (Expr) En büyük değerini döndürür expr .
max_by (x, y) xEn büyük değeri ile ilişkili değerini döndürür y .
Ortalama (Expr) Bir grubun değerlerinden hesaplanan ortalama değeri döndürür.
Min (Expr) En küçük değerini döndürür expr .
min_by (x, y) xEn küçük değeri ile ilişkili değerini döndürür y .
yüzdebirlik (sütun, yüzde [, sıklık]) Belirtilen yüzdedeki sayısal sütunun tam yüzdebirlik değerini döndürür col . Yüzde değeri 0,0 ile 1,0 arasında olmalıdır. Sıklık değeri pozitif integral olmalıdır.
yüzdebirlik (Col, Array (percentage1 [, percentage2]...) [, sıklık]) Verilen yüzdede sayısal sütunun tam yüzdebirlik değer dizisini döndürür col . Yüzde dizisinin her değeri 0,0 ile 1,0 arasında olmalıdır. Sıklık değeri pozitif integral olmalıdır.
percentile_approx (sütun, yüzde [, doğruluk]) Verilen yüzdedeki sayısal sütunun yaklaşık yüzdebirlik değerini döndürür col . Yüzde değeri 0,0 ile 1,0 arasında olmalıdır. accuracyParametresi (varsayılan: 10000), belleğin maliyetinde yaklaşık doğruluğu denetleyen pozitif bir sayısal değişmez değerdir. Daha yüksek bir değer accuracy daha iyi doğruluk verir, 1.0/accuracy yaklaşık göreli hatadır. percentageBir dizi olduğunda, yüzde dizisinin her değeri 0,0 ile 1,0 arasında olmalıdır. Bu durumda, verilen yüzde dizisindeki sütunun yaklaşık yüzdebirlik dizisini döndürür col .
çarpıklık (Expr) Bir grubun değerlerinden hesaplanan çarpıklık değerini döndürür.
Some (Expr) En az bir değeri true ise true döndürür expr .
STD (Expr) Bir grubun değerlerinden hesaplanan örnek standart sapmasını döndürür.
stddev (Expr) Bir grubun değerlerinden hesaplanan örnek standart sapmasını döndürür.
stddev_pop (Expr) Bir grubun değerlerinden hesaplanan popülasyon standart sapmasını döndürür.
stddev_samp (Expr) Bir grubun değerlerinden hesaplanan örnek standart sapmasını döndürür.
Sum (Expr) Bir grubun değerlerinden hesaplanan toplamı döndürür.
var_pop (Expr) Bir grubun değerlerinden hesaplanan popülasyon varyansını döndürür.
var_samp (Expr) Bir grubun değerlerinden hesaplanan örnek varyansı döndürür.
Varyans (Expr) Bir grubun değerlerinden hesaplanan örnek varyansı döndürür.

Örnekler

-- 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|
+-----------------------------+

Pencere işlevleri

İşlev Açıklama
cume_dist () Bölümdeki tüm değerlere göre bir değerin konumunu hesaplar.
dense_rank () Bir değer grubundaki bir değerin derecesini hesaplar. Sonuç, daha önce atanmış olan bir sıra değeridir. İşlev derecelendirmesinden farklı olarak dense_rank, derecelendirme dizisinde boşluk üretmeyecektir.
gecikme (giriş [, öteleme [, varsayılan]]) input offset Penceredeki geçerli satırdan önceki her satırdaki değerini döndürür. Varsayılan değeri offset 1 ' dir ve varsayılan değeri default null olur. input offset On satırındaki değeri null ise null döndürülür. Böyle bir fark satırı yoksa (örn., fark 1 olduğunda, pencerenin ilk satırı önceki satıra sahip değilse) default döndürülür.
lider (giriş [, konum [, varsayılan]]) input offset Penceredeki geçerli satırdan sonraki her satırdaki değerini döndürür. Varsayılan değeri offset 1 ' dir ve varsayılan değeri default null olur. input offset On satırındaki değeri null ise null döndürülür. Böyle bir fark satırı yoksa (örn., fark 1 olduğunda, pencerenin son satırı sonraki satıra sahip değildir), default döndürülür.
ntile (n) Her pencere bölümü için satırları, n 1 ile en çok arasında olacak demetlere böler n .
percent_rank () Bir değer grubundaki bir değerin yüzde sıralamasını hesaplar.
Rank () Bir değer grubundaki bir değerin derecesini hesaplar. Sonuç, Bölüm sıralamasına göre geçerli satırdan önceki veya eşit olan satır sayısıdır. Değerler dizide boşluk oluşturur.
row_number() Pencere bölümü içindeki satırların sıralamasına göre her satıra benzersiz, sıralı bir sayı atar.

Dizi işlevleri

İşlev Açıklama
array_contains (dizi, değer) Dizi değeri içeriyorsa true döndürür.
array_distinct (dizi) Yinelenen değerleri diziden kaldırır.
array_except (dizi1, dizi2) Yinelemeler olmadan, dizi1 içinde olmayan ancak dizi2 içindeki öğelerin bir dizisini döndürür.
array_intersect (dizi1, dizi2) Yineleme olmadan dizi1 ve dizi2 kesişimindeki öğelerin bir dizisini döndürür.
array_join (dizi, sınırlayıcı [, Nulldeğiştirme]) Belirtilen dizinin öğelerini sınırlayıcı ve null değerleri değiştirmek için isteğe bağlı bir dize ile birleştirir. Nulldeðiþtirme için hiçbir değer ayarlanmamışsa, hiçbir null değer filtrelenir.
array_max (dizi) Dizideki en büyük değeri döndürür. NULL öğeler atlandı.
array_min (dizi) Dizideki en küçük değeri döndürür. NULL öğeler atlandı.
array_position (dizi, öğe) Dizinin ilk öğesinin (1 tabanlı) dizinini Long olarak döndürür.
array_remove (dizi, öğe) Diziden öğeye eşit olan tüm öğeleri kaldırır.
array_repeat (öğe, sayı) Öğe sayısı sürelerini içeren diziyi döndürür.
array_union (dizi1, dizi2) Yineleme olmadan dizi1 ve dizi2 birleşimdeki öğelerin dizisini döndürür.
arrays_overlap (a1, a2) A1, a2 içinde de en az null olmayan bir öğe içeriyorsa true döndürür. Diziler ortak bir öğeye sahip değilse ve ikisi de boş olmayan ve ikisi de null bir öğesi içeriyorsa null değeri döndürülür, aksi takdirde false olur.
arrays_zip (a1, a2,...) N-th yapısının, giriş dizilerinin tüm N-th değerlerini içerdiği, bir birleştirilmiş yapı dizisini döndürür.
Concat (Sütun1, Col2,..., colN) Sütun1, Col2,..., colN birleşimini döndürür.
Düzleştir (arrayOfArrays) Dizi dizisini tek bir diziye dönüştürür.
ters (dizi) Ters bir dize veya öğelerin ters sırasını içeren bir dizi döndürür.
sıra (Başlat, durdur, adım) Başlangıçtan itibaren (dahil), adımla artan bir dizi öğe oluşturur. Döndürülen öğelerin türü, bağımsız değişken ifadelerinin türüyle aynıdır. Desteklenen türler şunlardır: bayt, kısa, tamsayı, uzun, tarih, zaman damgası. Start ve stop ifadeleri aynı tür olarak çözümlenmelidir. Başlatma ve durdurma ifadeleri ' Date ' veya ' timestamp ' türüne çözümlense, adım ifadesinin ' Interval ' türüne çözümlenmesi gerekir, aksi takdirde Start ve stop deyimleriyle aynı tür.
karışık (dizi) Verilen dizinin rastgele bir permütasyoni döndürür.
dilim (x, başlangıç, uzunluk) Dizin başlangıcından başlayan alt kümeler dizisi x (dizi dizinleri 1 ' den başlar veya başlangıç negatifse uçtan uca) belirtilen uzunluğa sahip olur.
sort_array (dizi [, ascendingOrder]) Giriş dizisini, dizi öğelerinin doğal sıralamasına göre artan veya azalan düzende sıralar. Null öğeler, döndürülen dizinin başına artan düzende veya döndürülen dizinin sonunda azalan sırada yerleştirilir.

Örnekler

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

Eşleme işlevleri

İşlev Açıklama
map_concat (eşleme,...) Verilen tüm haritaların birleşimini döndürür.
map_entries (eşleme) Verilen haritadaki tüm girdilerin sırasız dizisini döndürür.
map_from_entries (arrayOfEntries) Verilen girdi dizisinden oluşturulan eşlemeyi döndürür.
map_keys (eşleme) Haritanın anahtarlarını içeren bir sırasız dizi döndürür.
map_values (eşleme) Haritanın değerlerini içeren bir sırasız dizi döndürür.

Örnekler

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

Tarih ve zaman damgası işlevleri

Tarih ve zaman damgası biçimleri hakkında bilgi için bkz. TarihSaat desenleri.

İşlev Açıklama
add_months (start_date, num_months) Sonraki tarihi döndürür num_months start_date .
current_date () Sorgu değerlendirmesinin başlangıcında geçerli tarihi döndürür.
current_timestamp () Sorgu değerlendirmesinin başlangıcında geçerli zaman damgasını döndürür.
date_add (start_date, num_days) Sonraki tarihi döndürür num_days start_date .
date_format (timestamp, fmt) timestampTarih biçimiyle belirtilen biçimdeki dize değerine dönüştürür fmt .
date_part (alan, kaynak) Tarih/zaman damgası veya Aralık kaynağının bir parçasını ayıklar.
date_sub (start_date, num_days) Önceki tarihi döndürür num_days start_date .
date_trunc (fmt, TS) tsBiçim modeli tarafından belirtilen birime kesilen zaman damgasını döndürür fmt .
DateDiff (endDate, startDate) İçin gün sayısını döndürür startDate endDate .
DayOfWeek (Tarih) Tarih/zaman damgası için haftanın gününü döndürür (1 = Pazar, 2 = Pazartesi,..., 7 = Cumartesi).
DayOfYear (Tarih) Tarih/zaman damgasının yılın gününü döndürür.
from_unixtime (unix_time, biçim) unix_timeBelirtilen ' i döndürür format .
from_utc_timestamp (zaman damgası, saat dilimi) ' 2017-07-14 02:40:00.0 ' gibi bir zaman damgası verildiğinde, UTC olarak bir zaman olarak yorumlar ve bu saati verilen saat diliminde zaman damgası olarak işler. Örneğin, ' GMT + 1 ', ' 2017-07-14 03:40:00.0 ' olarak yield.
Saat (zaman damgası) Dizenin/zaman damgasının saat bileşenini döndürür.
last_day (Tarih) Tarihin ait olduğu ayın son gününü döndürür.
make_date (yıl, ay, gün) Yıl, ay ve gün alanlarından Tarih oluştur
make_timestamp (yıl, ay, gün, saat, dak, SEC [, TimeZone]) Yıl, ay, gün, saat, min, SEC ve TimeZone alanlarından zaman damgası oluşturun.
dakika (zaman damgası) Dizenin/zaman damgasının dakika bileşenini döndürür.
ay (Tarih) Tarih/zaman damgasının ay bileşenini döndürür.
months_between (timestamp1, timestamp2 [, roundOff]) timestamp1Daha sonra ise timestamp2 , sonuç pozitif olur. , timestamp1 Ve timestamp2 ayın günüyle veya her ikisinin de ayın son günü varsa, günün saati yok sayılır. Aksi takdirde, fark aylık 31 güne dayanarak hesaplanır ve roundOff = false olmadığı takdirde 8 basamağa yuvarlanır.
next_day (start_date, day_of_week) Belirtildiği gibi, daha sonra ve adlandırılmış ilk tarihi döndürür start_date .
now() Sorgu değerlendirmesinin başlangıcında geçerli zaman damgasını döndürür.
Çeyrek (Tarih) 1 ile 4 aralığında tarih için yılın çeyreği döndürür.
saniye (zaman damgası) Dizenin/zaman damgasının ikinci bileşenini döndürür.
to_date (date_str [, FMT]) İfadeyi date_str fmt bir tarih olacak şekilde ayrıştırır. Geçersiz girişle null değerini döndürür. Varsayılan olarak, atlanırsa kural bir tarihe fmt ayarlanır
to_timestamp (timestamp_str [, FMT]) İfadeyi timestamp_str fmt bir zaman damgasıyla ayrıştırır. Geçersiz girişle null değerini döndürür. Varsayılan olarak, atlanırsa kural bir zaman damgasına fmt ayarlanır.
to_unix_timestamp (timeExp [, biçim]) Verilen sürenin UNIX zaman damgasını döndürür.
to_utc_timestamp (zaman damgası, saat dilimi) ' 2017-07-14 02:40:00.0 ' gibi bir zaman damgası verildiğinde, belirli bir saat diliminde bir zaman olarak yorumladığı ve bu saati UTC olarak bir zaman damgası olarak işleyen. Örneğin, ' GMT + 1 ', ' 2017-07-14 01:40:00.0 ' olarak yield
TRUNC (datefmt) dateGünün zaman kısmı, biçim modeli tarafından belirtilen birime kesilerek döndürülür fmt .
unix_timestamp ([timeExp [biçim]]) Geçerli veya belirtilen saatin UNIX zaman damgasını döndürür.
hafta içi (Tarih) Tarih/zaman damgası için haftanın gününü döndürür (0 = Pazartesi, 1 = Salı,..., 6 = Pazar).
WeekOfYear (Tarih) Verilen tarihin yılın haftasını döndürür. Haftanın Pazartesi günü başlaması kabul edilir ve 1. hafta 3 güne >sahip ilk haftadır.
yıl (Tarih) Tarih/zaman damgasının yıl bileşenini döndürür.
pencere (timeColumn, windowDuration, Slaytsüresi, startTime) Sütunları belirten bir zaman damgası verilen bir veya daha fazla zaman penceresi içine satır ekleyin.

Örnekler

-- 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|
+------------------------------+

Bir akışa işaret eden bir görünüme () bir sorgu uygulayın readings_streaming . Sorgu, her 2 dakikada bir ortalama ve akış içindeki alanın sayısını toplar reading_1 device_type .

SELECT window.start, device_type,
  AVG(reading_1) AS reading_1,
  COUNT(reading_1) AS count_reading_1
FROM readings_streaming
GROUP BY
  window(reading_time, '2 minutes'),
  device_type
ORDER BY
  window DESC,
  device_type ASC

JSON işlevleri

İşlev Açıklama
from_json (jsonStr, şema [, Seçenekler]) Verilen ve ile bir struct değeri döndürür jsonStr schema .
get_json_object (json_txt, yol) İçinden bir JSON nesnesi ayıklar path .
json_tuple (jsonStr, P1, P2,..., PN) İşlev gibi bir tanımlama grubu döndürür get_json_object , ancak birden çok ad alır. Tüm giriş parametreleri ve çıkış sütunu türleri dizedir.
schema_of_json (JSON [, Seçenekler]) JSON dizesinin DDL biçimindeki şemayı döndürür.
to_json (Expr [, Options]) Verilen struct değeri olan bir JSON dizesi döndürür.

Örnekler

-- 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}]|
+-------------------------+