Hologres:LAMBDA expressions and functions

LAMBDA [ (lambda_arg1, ..., lambda_argn) => expr ]

LAMBDA [ (x1, x2, x3) => x2 - x1 * x3 + array_min(arr_col) ]

FUNCTION_NAME(LAMBDA[func(x1 [, ..., xN])], source_arr1 [, ..., source_arrN]);

HG_ARRAY_MAP

Bir LAMBDA ifadesini bir veya daha fazla dizinin karşılık gelen öğelerine uygular ve sonuçlardan oluşan yeni bir dizi döndürür.

Sözdizimi

HG_ARRAY_MAP(LAMBDA[func(x1 [, ..., xN])], source_arr1 [, ..., source_arrN]);

Parametreler

Dönüş değeri

Öğe türü LAMBDA ifadesinin dönüş türüyle eşleşen bir dizi döndürür. Uzunluk ilk giriş dizisinin uzunluğuna eşittir. Giriş dizilerinden herhangi biri NULL ise NULL döndürür.

Örnekler

Aşağıdaki örneklerde bu örnek tablo kullanılır:

DROP TABLE IF EXISTS tbl1;
CREATE TABLE tbl1(id INT, arr_col1 INT[], arr_col2 INT[], col3 INT, col4 INT);
INSERT INTO tbl1 VALUES(1, ARRAY[1,2,3], ARRAY[11,12,13],1,2);
INSERT INTO tbl1 VALUES(2, ARRAY[21,22,23], ARRAY[31,32,33],10,20);

Her dizi öğesine bir sütun değeri ekleyin (sütun yakalama)

LAMBDA gövdesi yalnızca dizi öğelerini değil aynı satırdaki sütunlara da başvurabilir. Bu örnekte arr_col1 içindeki her öğeye col3 eklenir:

SELECT
    id,
    HG_ARRAY_MAP (LAMBDA[x => x + col3], arr_col1)
FROM
    tbl1
ORDER BY
    id;

Sonuç:

id | hg_array_map
----+--------------
  1 | {2,3,4}
  2 | {31,32,33}
(2 rows)

İki diziden öğeleri toplayın ve alt dizi toplamını dahil edin

Bu örnekte arr_col1 ve sabit dizi ARRAY[5,6,7] içindeki karşılık gelen öğeler toplanır ardından arr_col2 minimum değeri eklenir:

SELECT
    id,
    HG_ARRAY_MAP (LAMBDA[(x, y) => y + x + array_min (arr_col2)], arr_col1, ARRAY[5,6,7])
FROM
    tbl1
ORDER BY
    id;

Sonuç:

id | hg_array_map
----+--------------
  1 | {17,19,21}
  2 | {57,59,61}
(2 rows)

İç içe LAMBDA ifadesi kullanın

Bu örnekte HG_ARRAY_MAP başka bir HG_ARRAY_MAP içinde iç içe geçer. İlk olarak arr_col2 içindeki her öğeye col3 eklenir bu ara dizinin minimumu alınır ve ardından sonuç arr_col1 içindeki her öğeye eklenir:

SELECT
    id,
    HG_ARRAY_MAP (LAMBDA[x => x + array_min (HG_ARRAY_MAP (LAMBDA[a => a + col3], arr_col2))], arr_col1)
FROM
    tbl1
ORDER BY
    id;

Sonuç:

id | hg_array_map
----+--------------
  1 | {13,14,15}
  2 | {62,63,64}
(2 rows)

HG_ARRAY_FILL

Giriş dizilerini soldan sağa tarar. Her konumda LAMBDA ifadesi değerlendirilir: TRUE dönerse ilk giriş dizisinden gelen karşılık gelen öğe geçerli doldurma değeri olur ve bu değer bir sonraki TRUE sonucuna kadar sonraki her konuma yayılır. LAMBDA ilk konumda FALSE dönerse ilk öğe olduğu gibi korunur.

Sözdizimi

HG_ARRAY_FILL(LAMBDA[func(x1 [, ..., xN])], source_arr1 [, ..., source_arrN]);

Parametreler

Dönüş değeri

İlk giriş dizisiyle aynı veri türünde ve uzunlukta bir dizi döndürür. Giriş dizilerinden herhangi biri NULL ise NULL döndürür.

Örnekler

Aşağıdaki örneklerde bu örnek tablo kullanılır:

DROP TABLE IF EXISTS tbl2;
CREATE TABLE tbl2(id INT, arr_col1 INT[], arr_col2 INT[], col3 INT, col4 INT);
INSERT INTO tbl2 VALUES(1, ARRAY[1,2,3,4,5,6,7,8,9],ARRAY[1,0,0,1,0,0,0,1,0],1,2);
INSERT INTO tbl2 VALUES(2, ARRAY[10,12,13,14,15,16,17,18,19],ARRAY[1,0,0,1,0,0,0,1,0],1,2);

arr_col2 öğesi 0'dan büyük olduğunda ileri doldurma yapın

arr_col2 > 0 koşulunun TRUE olarak değerlendirildiği konumlarda karşılık gelen arr_col1 öğesi doldurma değeri haline gelir ve bir sonraki TRUE değerine kadar sonraki her konuma yayılır:

SELECT
    id,
    HG_ARRAY_FILL (LAMBDA[(x, y) => y > 0], arr_col1, arr_col2)
FROM
    tbl2
ORDER BY
    id;

Sonuç:

id |        hg_array_fill
----+------------------------------
  1 | {1,1,1,4,4,4,4,8,8}
  2 | {10,10,10,14,14,14,14,18,18}
(2 rows)

arr_col2 öğesi 0'a eşit veya küçük olduğunda ileri doldurma yapın

Koşul tersine çevrilir: arr_col2 <= 0 koşulunun TRUE olarak değerlendirildiği konumlar. arr_col2 ilk öğesi 1 olduğundan (<= 0 değildir) LAMBDA 1. konumda FALSE döndürür ve ilk öğe olduğu gibi korunur:

SELECT
    id,
    HG_ARRAY_FILL (LAMBDA[(x, y) => y <= 0], arr_col1, arr_col2)
FROM
    tbl2
ORDER BY
    id;

Sonuç:

id |        hg_array_fill
----+------------------------------
  1 | {1,2,3,3,5,6,7,7,9}
  2 | {10,12,13,13,15,16,17,17,19}
(2 rows)

HG_ARRAY_FILTER

Giriş dizilerinin karşılık gelen öğelerine bir LAMBDA ifadesi uygulayarak Boolean dizisi oluşturur ardından yalnızca Boolean değeri TRUE olan ilk dizinin öğelerini korur.

Sözdizimi

HG_ARRAY_FILTER(LAMBDA[func(x1 [, ..., xN])], source_arr1 [, ..., source_arrN]);

Parametreler

Dönüş değeri

İlk giriş dizisiyle aynı veri türünde yalnızca LAMBDA'nın TRUE döndürdüğü öğeleri içeren bir dizi döndürür. Giriş dizilerinden herhangi biri NULL ise NULL döndürür.

Örnekler

Aşağıdaki örneklerde bu örnek tablo kullanılır:

DROP TABLE IF EXISTS tbl3;
CREATE TABLE tbl3(id INT, arr_col1 INT[], arr_col2 INT[], col3 INT, col4 INT);
INSERT INTO tbl3 VALUES(1, ARRAY[0,2,3,4,5,6,7,0,9], ARRAY[1,0,0,1,0,0,0,1,18],1,2);
INSERT INTO tbl3 VALUES(2, NULL, ARRAY[31,32,33,34,35,36,37,38,39],10,20);
INSERT INTO tbl3 VALUES(3, ARRAY[0,2,3,4,5,6,7,0,9], ARRAY[11,12,13,14,15,16,17,18,19],NULL,2);

Karşılık gelen arr_col2 öğesi 0'dan büyük olan öğeleri koruyun

SELECT
    id,
    HG_ARRAY_FILTER (LAMBDA[(x, y) => y > 0], arr_col1, arr_col2)
FROM
    tbl3
ORDER BY
    id;

Sonuç:

id |   hg_array_filter
----+---------------------
  1 | {0,4,0,9}
  2 |
  3 | {0,2,3,4,5,6,7,0,9}
(3 rows)

id=2 için arr_col1 NULL olduğundan sonuç NULL döner. id=3 için arr_col2 içindeki tüm öğeler 0'dan büyüktür bu nedenle arr_col1 içindeki tüm öğeler korunur.

Sütun başvuruları içeren bileşik koşulu kullanarak filtreleme yapın

Bu örnekte aşağıdaki koşullardan herhangi biri doğruysa öğeler korunur: arr_col1 içindeki öğe 0'dır col3 NULL'dur veya arr_col1[i] + arr_col2[i] + col3 + col4 toplamı 20'yi aşar. Sorgu HG_ARRAY_MAP örneklerinde kullanılan tbl1 tablosunu kullanır:

SELECT
    id,
    HG_ARRAY_FILTER (
        LAMBDA[(x, y) =>
            (x = 0)
            OR (col3 IS NULL)
            OR (x + y + col3 + col4 > 20)]
        , arr_col1, arr_col2)
FROM
    tbl1
ORDER BY
    id;

Sonuç:

id |   hg_array_filter
----+---------------------
  1 | {}
  2 | {21,22,23}
(2 rows)

HG_ARRAY_SORT

Giriş dizilerine bir LAMBDA ifadesi uygulayarak sıralama anahtarı dizisi türetir ardından ilk giriş dizisini bu anahtarlara göre artan düzende sıralayarak döndürür.

Sözdizimi

HG_ARRAY_SORT(LAMBDA[func(x1 [, ..., xN])], source_arr1 [, ..., source_arrN]);

Parametreler

Dönüş değeri

İlk giriş dizisiyle aynı veri türünde ve uzunlukta hesaplanan sıralama anahtarlarına göre artan düzende sıralanmış bir dizi döndürür. Giriş dizilerinden herhangi biri NULL ise NULL döndürür.

Örnekler

Başka bir sütundaki değerlere göre sabit bir diziyi sıralayın

DROP TABLE IF EXISTS tbl4;
CREATE TABLE tbl4(id INT, arr_col1 INT[]);
INSERT INTO tbl4 VALUES(1, ARRAY[3,1,2]);
INSERT INTO tbl4 VALUES(2, ARRAY[2,3,1]);
INSERT INTO tbl4 VALUES(3, ARRAY[1,2,3]);
INSERT INTO tbl4 VALUES(4, NULL);

SELECT
    id,
    HG_ARRAY_SORT (LAMBDA[(x,y) => y], ARRAY[4,5,6], arr_col1)
FROM
    tbl4
ORDER BY
    id;

Sabit dizi ARRAY[4,5,6] arr_col1 değerlerinin artan sırasına göre yeniden düzenlenir. Sonuç:

id | hg_array_sort
----+---------------
  1 | {5,6,4}
  2 | {6,4,5}
  3 | {4,5,6}
  4 |
(4 rows)

NULL işlemesi ile birlikte tamsayı sıralama anahtarı dizisine göre metin dizisini sıralayın

DROP TABLE IF EXISTS tbl5;
CREATE TABLE tbl5(id INT, arr_col1 TEXT[], arr_col2 INT[]);
INSERT INTO tbl5 VALUES(1, ARRAY['1','2','3','4','5'], ARRAY[1,2,3,4,5]);
INSERT INTO tbl5 VALUES(2, ARRAY['1','2','3','4','5'], NULL);
INSERT INTO tbl5 VALUES(3, ARRAY['1','2','3','4','5'], ARRAY[21, 22, 20, 24, 25]);
INSERT INTO tbl5 VALUES(4, ARRAY['1','2','3','4','5'], ARRAY[21, 24, 22, 25, 23]);
INSERT INTO tbl5 VALUES(5, ARRAY['1','2','3','4','5'], ARRAY[21, 22, NULL, 24, 25]);

SELECT
    id,
    HG_ARRAY_SORT (LAMBDA[(x, y) => y], arr_col1, arr_col2)
FROM
    tbl5
ORDER BY
    id;

Sonuç:

id | hg_array_sort
----+---------------
  1 | {1,2,3,4,5}
  2 |
  3 | {3,1,2,4,5}
  4 | {1,3,5,2,4}
  5 | {3,1,2,4,5}
(5 rows)

id=2 için arr_col2 NULL olduğundan işlev NULL döndürür.

HG_ARRAY_FIRST_INDEX

Giriş dizilerine bir LAMBDA ifadesi uygulayarak Boolean dizisi oluşturur ve ilk TRUE öğesinin 1 tabanlı indeksini döndürür. Hiçbir öğe TRUE değilse 0 döndürür.

Sözdizimi

HG_ARRAY_FIRST_INDEX(LAMBDA[func(x1 [, ..., xN])], source_arr1 [, ..., source_arrN]);

Parametreler

Dönüş değeri

LAMBDA'nın TRUE döndürdüğü ilk öğenin 1 tabanlı indeksini döndürür. Hiçbir öğe TRUE değilse 0 döndürür. Giriş dizilerinden herhangi biri NULL ise NULL döndürür.

Örnek

arr_col1 içindeki 3'e eşit veya büyük olan ilk öğenin indeksini bulun:

DROP TABLE IF EXISTS tbl6;
CREATE TABLE tbl6(id INT, arr_col1 INT[]);
INSERT INTO tbl6 VALUES(1, ARRAY[1,2,3,4,5]);
INSERT INTO tbl6 VALUES(2, NULL);

SELECT
    id,
    HG_ARRAY_FIRST_INDEX (LAMBDA[x => x >= 3], arr_col1)
FROM
    tbl6
ORDER BY
    id;

Sonuç:

id | hg_array_first_index
----+----------------------
  1 |          3
  2 |
(2 rows)

id=1 için >= 3 olan ilk öğe 3. indekste yer alır (değer 3). id=2 için arr_col1 NULL olduğundan işlev NULL döndürür.