Fonctions d'ordre supérieur 

-> opérateur, fonction lambda (params, expr) 

Allows describing a lambda function for passing to a higher-order function. The left side of the arrow has a formal parameter, which is any ID, or multiple formal parameters – any IDs in a tuple. The right side of the arrow has an expression that can use these formal parameters, as well as any table columns.

Exemple: x -> 2 * x, str -> str != Referer.

Les fonctions d'ordre supérieur ne peuvent accepter que les fonctions lambda comme argument fonctionnel.

Une fonction lambda qui accepte plusieurs arguments peuvent être passés à une fonction d'ordre supérieur. Dans ce cas, la fonction d'ordre supérieur est passé plusieurs tableaux de longueur identique que ces arguments correspondent.

Pour certaines fonctions, telles que arrayCount ou arraySum le premier argument (la fonction lambda) peut être omis. Dans ce cas, un mappage identique est supposé.

Une fonction lambda ne peut pas être omise pour les fonctions suivantes:

arrayMap(func, arr1, …) 

Renvoie un tableau obtenu à partir de l'application d'origine func fonction à chaque élément dans le arr tableau.

Exemple:

SELECT arrayMap(x -> (x + 2), [1, 2, 3]) as res;
┌─res─────┐
│ [3,4,5] │
└─────────┘

L'exemple suivant montre comment créer un n-uplet d'éléments de différents tableaux:

SELECT arrayMap((x, y) -> (x, y), [1, 2, 3], [4, 5, 6]) AS res
┌─res─────────────────┐
│ [(1,4),(2,5),(3,6)] │
└─────────────────────┘

Notez que le premier argument (fonction lambda) ne peut pas être omis dans le arrayMap fonction.

arrayFilter(func, arr1, …) 

Renvoie un tableau contenant uniquement les éléments arr1 pour ce qui func retourne autre chose que 0.

Exemple:

SELECT arrayFilter(x -> x LIKE '%World%', ['Hello', 'abc World']) AS res
┌─res───────────┐
│ ['abc World'] │
└───────────────┘
SELECT
    arrayFilter(
        (i, x) -> x LIKE '%World%',
        arrayEnumerate(arr),
        ['Hello', 'abc World'] AS arr)
    AS res
┌─res─┐
│ [2] │
└─────┘

Notez que le premier argument (fonction lambda) ne peut pas être omis dans le arrayFilter fonction.

arrayFill(func, arr1, …) 

Analyse par le biais de arr1 du premier élément au dernier élément et remplacer arr1[i] par arr1[i - 1] si func renvoie 0. Le premier élément de arr1 ne sera pas remplacé.

Exemple:

SELECT arrayFill(x -> not isNull(x), [1, null, 3, 11, 12, null, null, 5, 6, 14, null, null]) AS res
┌─res──────────────────────────────┐
│ [1,1,3,11,12,12,12,5,6,14,14,14] │
└──────────────────────────────────┘

Notez que le premier argument (fonction lambda) ne peut pas être omis dans le arrayFill fonction.

arrayReverseFill(func, arr1, …) 

Analyse par le biais de arr1 du dernier élément au premier élément et remplacer arr1[i] par arr1[i + 1] si func renvoie 0. Le dernier élément de arr1 ne sera pas remplacé.

Exemple:

SELECT arrayReverseFill(x -> not isNull(x), [1, null, 3, 11, 12, null, null, 5, 6, 14, null, null]) AS res
┌─res────────────────────────────────┐
│ [1,3,3,11,12,5,5,5,6,14,NULL,NULL] │
└────────────────────────────────────┘

Notez que le premier argument (fonction lambda) ne peut pas être omis dans le arrayReverseFill fonction.

arraySplit(func, arr1, …) 

Split arr1 en plusieurs tableaux. Lorsque func retourne autre chose que 0, la matrice sera de split sur le côté gauche de l'élément. Le tableau ne sera pas partagé avant le premier élément.

Exemple:

SELECT arraySplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res
┌─res─────────────┐
│ [[1,2,3],[4,5]] │
└─────────────────┘

Notez que le premier argument (fonction lambda) ne peut pas être omis dans le arraySplit fonction.

arrayReverseSplit(func, arr1, …) 

Split arr1 en plusieurs tableaux. Lorsque func retourne autre chose que 0, la matrice sera de split sur le côté droit de l'élément. Le tableau ne sera pas divisé après le dernier élément.

Exemple:

SELECT arrayReverseSplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res
┌─res───────────────┐
│ [[1],[2,3,4],[5]] │
└───────────────────┘

Notez que le premier argument (fonction lambda) ne peut pas être omis dans le arraySplit fonction.

arrayCount([func,] arr1, …) 

Renvoie le nombre d'éléments dans l'arr tableau pour lequel func renvoie autre chose que 0. Si ‘func’ n'est pas spécifié, il renvoie le nombre d'éléments non nuls dans le tableau.

arrayExists([func,] arr1, …) 

Renvoie 1 s'il existe au moins un élément ‘arr’ pour ce qui ‘func’ retourne autre chose que 0. Sinon, il renvoie 0.

arrayAll([func,] arr1, …) 

Renvoie 1 si ‘func’ retourne autre chose que 0 pour tous les éléments de ‘arr’. Sinon, il renvoie 0.

arraySum([func,] arr1, …) 

Renvoie la somme de la ‘func’ valeur. Si la fonction est omise, elle retourne la somme des éléments du tableau.

arrayFirst(func, arr1, …) 

Renvoie le premier élément du ‘arr1’ tableau pour lequel ‘func’ retourne autre chose que 0.

Notez que le premier argument (fonction lambda) ne peut pas être omis dans le arrayFirst fonction.

arrayFirstIndex(func, arr1, …) 

Renvoie l'index du premier élément de la ‘arr1’ tableau pour lequel ‘func’ retourne autre chose que 0.

Notez que le premier argument (fonction lambda) ne peut pas être omis dans le arrayFirstIndex fonction.

arrayCumSum([func,] arr1, …) 

Retourne un tableau des sommes partielles d'éléments dans le tableau source (une somme). Si l' func la fonction est spécifiée, les valeurs des éléments du tableau sont convertis par cette fonction avant l'addition.

Exemple:

SELECT arrayCumSum([1, 1, 1, 1]) AS res
┌─res──────────┐
│ [1, 2, 3, 4] │
└──────────────┘

arrayCumSumNonNegative (arr) 

Même que arrayCumSum, renvoie un tableau des sommes partielles d'éléments dans le tableau source (une somme). Différent arrayCumSum, lorsque la valeur renvoyée contient une valeur inférieure à zéro, la valeur est remplacée par zéro et le calcul ultérieur est effectué avec des paramètres zéro. Exemple:

SELECT arrayCumSumNonNegative([1, 1, -4, 1]) AS res
┌─res───────┐
│ [1,2,0,1] │
└───────────┘

arraySort([func,] arr1, …) 

Renvoie un tableau à la suite du tri des éléments de arr1 dans l'ordre croissant. Si l' func la fonction est spécifiée, l'ordre de classement est déterminé par le résultat de la fonction func appliquée aux éléments du tableau (tableaux)

Le Transformation schwartzienne est utilisé pour améliorer l'efficacité du tri.

Exemple:

SELECT arraySort((x, y) -> y, ['hello', 'world'], [2, 1]);
┌─res────────────────┐
│ ['world', 'hello'] │
└────────────────────┘

Pour plus d'informations sur la arraySort la méthode, voir l' Fonctions pour travailler avec des tableaux section.

arrayReverseSort([func,] arr1, …) 

Renvoie un tableau à la suite du tri des éléments de arr1 dans l'ordre décroissant. Si l' func la fonction est spécifiée, l'ordre de classement est déterminé par le résultat de la fonction func appliquée aux éléments du tableau (tableaux).

Exemple:

SELECT arrayReverseSort((x, y) -> y, ['hello', 'world'], [2, 1]) as res;
┌─res───────────────┐
│ ['hello','world'] │
└───────────────────┘

Pour plus d'informations sur la arrayReverseSort la méthode, voir l' Fonctions pour travailler avec des tableaux section.

Article Original

Rating: 3.1 - 8 votes

Was this content helpful?
★★★☆☆