Fonctions Array - ClickHouse Documentation

array

Introduit dans : v1.1.0 Crée un tableau à partir des arguments de la fonction. Les arguments doivent être des constantes et avoir des types partageant un supertype commun. Au moins un argument doit être fourni, sinon le type de tableau à créer n’est pas clair. Cela signifie que vous ne pouvez pas utiliser cette fonction pour créer un tableau vide. Pour cela, utilisez la fonction emptyArray*. Utilisez l’opérateur [ ] pour obtenir le même résultat. Syntaxe

array(x1 [, x2, ..., xN])

Arguments

x1 — Valeur constante de n’importe quel type T. Si seul cet argument est fourni, le tableau sera de type T. - [, x2, ..., xN] — N valeurs constantes supplémentaires ayant un supertype commun avec x1

Valeur renvoyée Renvoie un tableau, où ‘T’ est le plus petit type commun parmi les arguments passés. Array(T) Exemples Utilisation valide

Query

SELECT array(toInt32(1), toUInt16(2), toInt8(3)) AS a, toTypeName(a)

Response

┌─a───────┬─toTypeName(a)─┐
│ [1,2,3] │ Array(Int32)  │
└─────────┴───────────────┘

Utilisation incorrecte

Query

SELECT array(toInt32(5), toDateTime('1998-06-16'), toInt8(5)) AS a, toTypeName(a)

Response

Received exception from server (version 25.4.3):
Code: 386. DB::Exception: Received from localhost:9000. DB::Exception:
There is no supertype for types Int32, DateTime, Int8 ...

arrayAUCPR

Introduit dans : v20.4.0 Calcule l’aire sous la courbe précision-rappel (PR). Une courbe précision-rappel est obtenue en représentant la précision sur l’axe des y et le rappel sur l’axe des x pour tous les seuils. La valeur obtenue est comprise entre 0 et 1, une valeur plus élevée indiquant de meilleures performances du modèle. La PR AUC est particulièrement utile pour les jeux de données déséquilibrés, car elle offre dans ce cas une comparaison des performances plus claire que la ROC AUC. Pour plus de détails, veuillez consulter ici, ici et ici. Syntaxe

arrayAUCPR(scores, labels[, partial_offsets])

Alias : arrayPRAUC Arguments

cores — Scores fournis par le modèle de prédiction. Array((U)Int*) or Array(Float*)
labels — Étiquettes des échantillons, généralement 1 pour un échantillon positif et 0 pour un échantillon négatif. Array((U)Int*) or Array(Enum)
partial_offsets —
Facultatif. Un Array(T) de trois entiers non négatifs permettant de calculer une aire partielle sous la courbe PR (équivalente à une bande verticale de l’espace PR) au lieu de l’AUC complète. Cette option est utile pour le calcul distribué de l’AUC PR. Le tableau doit contenir les éléments suivants [higher_partitions_tp, higher_partitions_fp, total_positives].
- higher_partitions_tp : Le nombre d’étiquettes positives dans les partitions ayant les scores les plus élevés.
- higher_partitions_fp : Le nombre d’étiquettes négatives dans les partitions ayant les scores les plus élevés.
- total_positives : Le nombre total d’échantillons positifs dans l’ensemble du jeu de données.

Lorsque arr_partial_offsets est utilisé, arr_scores et arr_labels ne doivent représenter qu’une partition de l’ensemble du jeu de données, contenant un intervalle de scores. Le jeu de données doit être divisé en partitions contiguës, où chaque partition contient le sous-ensemble de données dont les scores se situent dans une plage spécifique. Par exemple :

Une partition peut contenir tous les scores dans l’intervalle [0, 0.5).
Une autre partition peut contenir les scores dans l’intervalle [0.5, 1.0].

Valeur renvoyée Renvoie l’aire sous la courbe précision-rappel (PR). Float64 Exemples Exemple d’utilisation

Query

SELECT arrayAUCPR([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);

Response

┌─arrayAUCPR([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1])─┐
│                              0.8333333333333333 │
└─────────────────────────────────────────────────┘

arrayAll

Introduit dans : v1.1.0 Renvoie 1 si la fonction lambda func(x [, y1, y2, ... yN]) renvoie true pour tous les éléments. Sinon, renvoie 0. Syntaxe

arrayAll(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

Arguments

func(x[, y1, ..., yN]) — Une fonction lambda qui s’applique aux éléments du tableau source (x) et des tableaux de condition (y). Fonction lambda
source_arr — Le tableau source à traiter. Array(T)
cond1_arr, ... — Facultatif. N tableaux de condition fournissant des arguments supplémentaires à la fonction lambda. Array(T)

Valeur renvoyée Renvoie 1 si la fonction lambda renvoie true pour tous les éléments, 0 sinon UInt8 Exemples Tous les éléments correspondent

Query

SELECT arrayAll(x, y -> x=y, [1, 2, 3], [1, 2, 3])

Response

Certains éléments ne correspondent pas

Query

SELECT arrayAll(x, y -> x=y, [1, 2, 3], [1, 1, 1])

Response

arrayAutocorrelation

Introduite dans : v26.4.0 Calcule l’autocorrélation d’un tableau. Si max_lag est fourni, calcule la corrélation uniquement pour les décalages de l’intervalle [0, max_lag). Si max_lag n’est pas fourni, calcule la corrélation pour tous les décalages possibles. Syntaxe

arrayAutocorrelation(arr, [max_lag])

Arguments

arr — Tableau de nombres. Array(T)
max_lag — Facultatif. Nombre maximal de retards à calculer. Doit être un entier non négatif. Integer

Valeur renvoyée Renvoie un tableau de Float64. Renvoie NaN si la variance est égale à 0. Array(Float64) Exemples Linéaire

Query

SELECT arrayAutocorrelation([1, 2, 3, 4, 5]);

Response

[1, 0.4, -0.1, -0.4, -0.4]

Symétrique

Query

SELECT arrayAutocorrelation([10, 20, 10]);

Response

[1, -0.6666666666666669, 0.16666666666666674]

Constante

Query

SELECT arrayAutocorrelation([5, 5, 5]);

Response

[nan, nan, nan]

Limité

Query

SELECT arrayAutocorrelation([1, 2, 3, 4, 5], 2);

Response

[1, 0.4]

arrayAvg

Introduit dans : v21.1.0 Renvoie la moyenne des éléments du tableau source. Si une fonction lambda func est spécifiée, renvoie la moyenne des éléments obtenus par la fonction lambda. Syntaxe

arrayAvg([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])

Arguments

func(x[, y1, ..., yN]) — Facultatif. Une fonction lambda qui s’applique aux éléments du tableau source (x) et aux tableaux de conditions (y). Fonction lambda
source_arr — Le tableau source à traiter. Array(T)
[, cond1_arr, ... , condN_arr] — Facultatif. N tableaux de conditions fournissant des arguments supplémentaires à la fonction lambda. Array(T)

Valeur renvoyée Renvoie la moyenne des éléments du tableau source, ou la moyenne des éléments résultant de la fonction lambda si elle est fournie. Float64 Exemples Exemple de base

Query

SELECT arrayAvg([1, 2, 3, 4]);

Response

2.5

Utilisation avec une fonction lambda

Query

SELECT arrayAvg(x, y -> x*y, [2, 3], [2, 3]) AS res;

Response

6.5

arrayBottomK

Introduit dans : v26.6.0 Renvoie un tableau des K plus petits éléments du tableau d’entrée, triés par ordre croissant. Si une fonction lambda f est spécifiée, les éléments sont comparés selon le résultat de f appliqué à chaque élément. Si f accepte plusieurs arguments, des tableaux supplémentaires sont transmis à arrayBottomK ; leurs éléments correspondent aux arguments de f. Les valeurs NULL sont ignorées et n’apparaissent pas dans le résultat. La taille du résultat est au plus K et peut être inférieure lorsque le tableau d’entrée contient moins de K éléments non nuls. Le type d’élément du résultat est la version non nullable du type d’élément d’entrée. arrayBottomK est une fonction d’ordre supérieur. Voir aussi :

arrayTopK, qui renvoie à la place les K plus grands éléments.
arrayPartialSort, qui produit les mêmes K éléments aux positions [1..K], mais conserve également les éléments restants dans un ordre non spécifié et n’ignore pas les valeurs nulles.

Syntaxe

arrayBottomK([f,] K, arr [, arr1, ... ,arrN])

Arguments

f(arr[, arr1, ... ,arrN]) — Facultatif. Une fonction lambda permettant de calculer la clé de tri de chaque élément. fonction lambda
K — Le nombre de plus petits éléments à renvoyer. (U)Int8/16/32/64
arr — Un tableau. Array(T)
arr1, ... ,arrN — N tableaux supplémentaires, si f accepte plusieurs arguments. Array(T)

Valeur renvoyée Renvoie jusqu’à K éléments de arr ayant les plus petites valeurs (ou les plus petits résultats de la fonction lambda), triés par ordre croissant. Les valeurs NULL sont ignorées. Le tableau renvoyé a pour type d’élément T, même lorsque l’entrée est de type Nullable(T). Exemples simple_int

Query

SELECT arrayBottomK(3, [1, 5, 2, 7, 3])

Response

[1,2,3]

skip_nulls

Query

SELECT arrayBottomK(3, [1, NULL, 5, 2, NULL, 7])

Response

[1,2,5]

fewer_than_k

Query

SELECT arrayBottomK(5, [1, NULL, 2])

Response

[1,2]

lambda_simple

Query

SELECT arrayBottomK((x) -> -x, 2, [5, 9, 1, 3])

Response

[9,5]

lambda_multi

Query

SELECT arrayBottomK((x, y) -> y, 2, ['a', 'b', 'c'], [3, 1, 2])

Response

['b','c']

arrayCompact

Introduit dans : v20.1.0 Supprime les doublons consécutifs d’un tableau, y compris les valeurs null. L’ordre des valeurs dans le tableau résultant est déterminé par leur ordre dans le tableau source. Syntaxe

arrayCompact(arr)

Arguments

arr — Un tableau dont les doublons doivent être supprimés. Array(T)

Valeur renvoyée Renvoie un tableau sans doublons Array(T) Exemples Exemple d’utilisation

Query

SELECT arrayCompact([1, 1, nan, nan, 2, 3, 3, 3]);

Response

[1,nan,2,3]

arrayConcat

Introduit dans : v1.1.0 Combine les tableaux fournis en argument. Syntaxe

arrayConcat(arr1 [, arr2, ... , arrN])

Arguments

arr1 [, arr2, ... , arrN] — N tableaux à concaténer. Array(T)

Valeur renvoyée Renvoie un tableau unique obtenu à partir des tableaux fournis en arguments. Array(T) Exemples Exemple d’utilisation

Query

SELECT arrayConcat([1, 2], [3, 4], [5, 6]) AS res

Response

[1, 2, 3, 4, 5, 6]

arrayCount

Introduite dans : v1.1.0 Renvoie le nombre d’éléments pour lesquels func(arr1[i], ..., arrN[i]) renvoie true. Si func n’est pas spécifiée, arrayCount renvoie le nombre d’éléments non nuls du tableau. arrayCount est une fonction d’ordre supérieur. Syntaxe

arrayCount([func, ] arr1, ...)

Arguments

func — Facultatif. Fonction à appliquer à chaque élément du ou des tableaux. fonction lambda
arr1, ..., arrN — N tableaux. Array(T)

Valeur renvoyée Renvoie le nombre d’éléments pour lesquels func renvoie true. Sinon, renvoie le nombre d’éléments non nuls du tableau. UInt32 Exemples Exemple d’utilisation

Query

SELECT arrayCount(x -> (x % 2), groupArray(number)) FROM numbers(10)

Response

arrayCumSum

Introduit dans : v1.1.0 Renvoie un tableau des sommes partielles (cumulatives) des éléments du tableau source. Si une fonction lambda est spécifiée, la somme est calculée en appliquant la fonction lambda aux éléments du tableau à chaque position. Syntaxe

arrayCumSum([func,] arr1[, arr2, ... , arrN])

Arguments

func — Facultatif. Fonction lambda à appliquer aux éléments du tableau à chaque position. fonction lambda
arr1 — Le tableau source de valeurs numériques. Array(T)
[arr2, ..., arrN] — Facultatif. Tableaux supplémentaires de même taille, passés comme arguments à la fonction lambda si elle est spécifiée. Array(T)

Valeur renvoyée Renvoie un tableau des sommes partielles des éléments du tableau source. Le type du résultat correspond au type numérique du tableau d’entrée. Array(T) Exemples Utilisation de base

Query

SELECT arrayCumSum([1, 1, 1, 1]) AS res

Response

[1, 2, 3, 4]

Avec une fonction lambda

Query

SELECT arrayCumSum(x -> x * 2, [1, 2, 3]) AS res

Response

[2, 6, 12]

arrayCumSumNonNegative

Introduit dans : v18.12.0 Renvoie un tableau des sommes partielles cumulées des éléments du tableau source, toute somme cumulée négative étant remplacée par zéro. Si une fonction lambda est spécifiée, la somme est calculée en appliquant la lambda aux éléments du tableau à chaque position. Syntaxe

arrayCumSumNonNegative([func,] arr1[, arr2, ... , arrN])

Arguments

func — Facultatif. Une fonction lambda à appliquer aux éléments du tableau à chaque position. fonction lambda
arr1 — Le tableau source de valeurs numériques. Array(T)
[arr2, ..., arrN] — Facultatif. Des tableaux supplémentaires de même taille, passés comme arguments à la fonction lambda si elle est spécifiée. Array(T)

Valeur renvoyée Renvoie un tableau des sommes partielles des éléments du tableau source, où toute somme cumulée négative est remplacée par zéro. Le type du résultat correspond au type numérique du tableau d’entrée. Array(T) Exemples Utilisation de base

Query

SELECT arrayCumSumNonNegative([1, 1, -4, 1]) AS res

Response

[1, 2, 0, 1]

Avec une fonction lambda

Query

SELECT arrayCumSumNonNegative(x -> x * 2, [1, -2, 3]) AS res

Response

[2, 0, 6]

arrayDifference

Introduit dans : v1.1.0 Calcule un tableau contenant les différences entre les éléments adjacents d’un tableau. Le premier élément du tableau de résultat sera 0, le deuxième arr[1] - arr[0], le troisième arr[2] - arr[1], etc. Le type des éléments du tableau de résultat est déterminé par les règles d’inférence de type pour la soustraction (par ex. UInt8 - UInt8 = Int16). Syntaxe

arrayDifference(arr)

Arguments

arr — Tableau pour lequel calculer les différences entre des éléments consécutifs. Array(T)

Valeur renvoyée Renvoie un tableau contenant les différences entre les éléments consécutifs du tableau UInt* Exemples Exemple d’utilisation

Query

SELECT arrayDifference([1, 2, 3, 4]);

Response

[0,1,1,1]

Exemple de dépassement de capacité dû au type de résultat Int64

Query

SELECT arrayDifference([0, 10000000000000000000]);

Response

┌─arrayDifference([0, 10000000000000000000])─┐
│ [0,-8446744073709551616]                   │
└────────────────────────────────────────────┘

arrayDistinct

Introduit dans : v1.1.0 Renvoie un tableau contenant uniquement les éléments distincts d’un tableau. Syntaxe

arrayDistinct(arr)

Arguments

arr — Tableau à partir duquel extraire les éléments distincts. Array(T)

Valeur renvoyée Renvoie un tableau contenant les éléments distincts Array(T) Exemples Exemple d’utilisation

Query

SELECT arrayDistinct([1, 2, 2, 3, 1]);

Response

[1,2,3]

arrayDotProduct

Introduit dans : v23.5.0 Renvoie le produit scalaire de deux tableaux.

Les deux vecteurs doivent être de même taille. Les Array et les Tuple peuvent également contenir des éléments de types différents.

Syntaxe

arrayDotProduct(v1, v2)

Arguments

v1 — Premier vecteur. Array((U)Int* | Float* | Decimal) ou Tuple((U)Int* | Float* | Decimal)
v2 — Deuxième vecteur. Array((U)Int* | Float* | Decimal) ou Tuple((U)Int* | Float* | Decimal)

Valeur de retour Le produit scalaire des deux vecteurs.

Le type de retour dépend du type des arguments. Si des Array ou des Tuple contiennent des types d’éléments mixtes, le type du résultat est le supertype.

(U)Int* ou Float* ou Decimal Exemples Exemple avec Array

Query

SELECT arrayDotProduct([1, 2, 3], [4, 5, 6]) AS res, toTypeName(res);

Response

32    UInt16

Exemple de Tuple

Query

SELECT dotProduct((1::UInt16, 2::UInt8, 3::Float32),(4::Int16, 5::Float32, 6::UInt8)) AS res, toTypeName(res);

Response

32    Float64

arrayElement

Introduit dans : v1.1.0 Récupère l’élément du tableau fourni à l’indice n, où n peut être de n’importe quel type entier. Si l’indice est en dehors des limites du tableau, la fonction renvoie une valeur par défaut (0 pour les nombres, une chaîne vide pour les chaînes de caractères, etc.), sauf pour les arguments correspondant à un tableau non constant et à un indice constant égal à 0. Dans ce cas, l’erreur Array indices are 1-based est renvoyée.

Les tableaux dans ClickHouse sont indexés à partir de 1.

Les indices négatifs sont pris en charge. Dans ce cas, l’élément correspondant est sélectionné en comptant depuis la fin. Par exemple, arr[-1] est le dernier élément du tableau. L’opérateur [n] fournit la même fonctionnalité. Syntaxe

arrayElement(arr, n)

Arguments

arr — Le tableau à parcourir. Array(T). - n — Position de l’élément à récupérer. (U)Int*.

Valeur renvoyée Renvoie un tableau unique combiné à partir des arguments de tableau fournis Array(T) Exemples Exemple d’utilisation

Query

SELECT arrayElement(arr, 2) FROM (SELECT [1, 2, 3] AS arr)

Response

Indices négatifs

Query

SELECT arrayElement(arr, -1) FROM (SELECT [1, 2, 3] AS arr)

Response

Utiliser la notation [n]

Query

SELECT arr[2] FROM (SELECT [1, 2, 3] AS arr)

Response

Indice hors limites du tableau

Query

SELECT arrayElement(arr, 4) FROM (SELECT [1, 2, 3] AS arr)

Response

arrayElementOrNull

Introduit dans : v1.1.0 Renvoie l’élément du tableau fourni à l’indice n, où n peut être de n’importe quel type entier. Si l’indice est hors des limites du tableau, NULL est renvoyé au lieu d’une valeur par défaut.

Les tableaux dans ClickHouse sont indexés à partir de 1.

arrayElementOrNull(arrays)

Arguments

arrays — Nombre arbitraire d’arguments de type tableau. Array

Valeur renvoyée Renvoie un seul tableau combiné à partir des arguments de tableau fournis. Array(T) Exemples Exemple d’utilisation

Query

SELECT arrayElementOrNull(arr, 2) FROM (SELECT [1, 2, 3] AS arr)

Response

Indices négatifs

Query

SELECT arrayElementOrNull(arr, -1) FROM (SELECT [1, 2, 3] AS arr)

Response

Indice hors limites du tableau

Query

SELECT arrayElementOrNull(arr, 4) FROM (SELECT [1, 2, 3] AS arr)

Response

NULL

arrayEnumerate

Introduit dans : v1.1.0 Renvoie le tableau [1, 2, 3, ..., length (arr)] Cette fonction est généralement utilisée avec la clause ARRAY JOIN. Elle permet de ne compter quelque chose qu’une seule fois pour chaque tableau après l’application de ARRAY JOIN. Cette fonction peut également être utilisée dans des fonctions d’ordre supérieur. Par exemple, vous pouvez l’utiliser pour obtenir les indices des éléments d’un tableau qui correspondent à une condition. Syntaxe

arrayEnumerate(arr)

Arguments

arr — Le tableau à énumérer. Array

Valeur renvoyée Renvoie le tableau [1, 2, 3, ..., length (arr)]. Array(UInt32) Exemples Exemple de base avec ARRAY JOIN

Query

CREATE TABLE test
(
    `id` UInt8,
    `tag` Array(String),
    `version` Array(String)
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO test VALUES (1, ['release-stable', 'dev', 'security'], ['2.4.0', '2.6.0-alpha', '2.4.0-sec1']);

SELECT
    id,
    tag,
    version,
    seq
FROM test
ARRAY JOIN
    tag,
    version,
    arrayEnumerate(tag) AS seq

Response

┌─id─┬─tag────────────┬─version─────┬─seq─┐
│  1 │ release-stable │ 2.4.0       │   1 │
│  1 │ dev            │ 2.6.0-alpha │   2 │
│  1 │ security       │ 2.4.0-sec1  │   3 │
└────┴────────────────┴─────────────┴─────┘

arrayEnumerateDense

Introduit dans : v18.12.0 Renvoie un tableau de même taille que le tableau source, indiquant la première occurrence de chaque élément dans le tableau source. Syntaxe

arrayEnumerateDense(arr)

Arguments

arr — Le tableau à énumérer. Array(T)

Valeur renvoyée Renvoie un tableau de même taille que arr, indiquant la position de la première occurrence de chaque élément dans le tableau source Array(T) Exemples Exemple d’utilisation

Query

SELECT arrayEnumerateDense([10, 20, 10, 30])

Response

[1,2,1,3]

arrayEnumerateDenseRanked

Introduite dans : v20.1.0 Renvoie un tableau de la même taille que le tableau source, indiquant où chaque élément apparaît pour la première fois dans le tableau source. Cette fonction permet d’énumérer un tableau multidimensionnel en précisant jusqu’à quelle profondeur parcourir le tableau. Syntaxe

arrayEnumerateDenseRanked(clear_depth, arr, max_array_depth)

Arguments

clear_depth — Énumère séparément les éléments au niveau spécifié. Doit être inférieur ou égal à max_arr_depth. UInt*
arr — Tableau à N dimensions à énumérer. Array(T)
max_array_depth — Profondeur effective maximale. Doit être inférieure ou égale à la profondeur de arr. UInt*

Valeur renvoyée Renvoie un tableau indiquant où chaque élément apparaît pour la première fois dans le tableau source Array Exemples Utilisation de base

Query

-- With clear_depth=1 and max_array_depth=1, the result is identical to what arrayEnumerateDense would give.

SELECT arrayEnumerateDenseRanked(1,[10, 20, 10, 30],1);

Response

[1,2,1,3]

Utilisation avec un tableau multidimensionnel

Query

-- In this example, arrayEnumerateDenseRanked is used to obtain an array indicating, for each element of the
-- multidimensional array, what its position is among elements of the same value.
-- For the first row of the passed array, [10, 10, 30, 20], the corresponding first row of the result is [1, 1, 2, 3],
-- indicating that 10 is the first number encountered in position 1 and 2, 30 the second number encountered in position 3
-- and 20 is the third number encountered in position 4.
-- For the second row, [40, 50, 10, 30], the corresponding second row of the result is [4,5,1,2], indicating that 40
-- and 50 are the fourth and fifth numbers encountered in position 1 and 2 of that row, that another 10
-- (the first encountered number) is in position 3 and 30 (the second number encountered) is in the last position.

SELECT arrayEnumerateDenseRanked(1,[[10,10,30,20],[40,50,10,30]],2);

Response

[[1,1,2,3],[4,5,1,2]]

Exemple avec clear_depth augmenté

Query

-- Changing clear_depth=2 results in the enumeration occurring separately for each row anew.

SELECT arrayEnumerateDenseRanked(2,[[10,10,30,20],[40,50,10,30]],2);

Response

[[1, 1, 2, 3], [1, 2, 3, 4]]

arrayEnumerateUniq

Introduit dans : v1.1.0 Renvoie un tableau de même taille que le tableau source, où chaque élément indique sa position parmi les éléments de même valeur. Cette fonction est utile lors de l’utilisation de ARRAY JOIN et de l’agrégation des éléments du tableau. La fonction peut prendre plusieurs tableaux de même taille comme arguments. Dans ce cas, l’unicité est évaluée sur les tuples d’éléments occupant les mêmes positions dans tous les tableaux. Syntaxe

arrayEnumerateUniq(arr1[, arr2, ... , arrN])

Arguments

arr1 — Premier tableau à traiter. Array(T)
arr2, ... — Facultatif. Tableaux supplémentaires de même taille pour garantir l’unicité des tuples. Array(UInt32)

Valeur renvoyée Renvoie un tableau dans lequel chaque élément indique sa position parmi les éléments ayant la même valeur ou le même tuple. Array(T) Exemples Utilisation de base

Query

SELECT arrayEnumerateUniq([10, 20, 10, 30]);

Response

[1, 1, 2, 1]

Plusieurs arrays

Query

SELECT arrayEnumerateUniq([1, 1, 1, 2, 2, 2], [1, 1, 2, 1, 1, 2]);

Response

[1,2,1,1,2,1]

Agrégation avec ARRAY JOIN

Query

-- Each goal ID has a calculation of the number of conversions (each element in the Goals nested data structure is a goal that was reached, which we refer to as a conversion)
-- and the number of sessions. Without ARRAY JOIN, we would have counted the number of sessions as sum(Sign). But in this particular case,
-- the rows were multiplied by the nested Goals structure, so in order to count each session one time after this, we apply a condition to the
-- value of the arrayEnumerateUniq(Goals.ID) function.

SELECT
    Goals.ID AS GoalID,
    sum(Sign) AS Reaches,
    sumIf(Sign, num = 1) AS Visits
FROM test.visits
ARRAY JOIN
    Goals,
    arrayEnumerateUniq(Goals.ID) AS num
WHERE CounterID = 160656
GROUP BY GoalID
ORDER BY Reaches DESC
LIMIT 10

Response

┌──GoalID─┬─Reaches─┬─Visits─┐
│   53225 │    3214 │   1097 │
│ 2825062 │    3188 │   1097 │
│   56600 │    2803 │    488 │
│ 1989037 │    2401 │    365 │
│ 2830064 │    2396 │    910 │
│ 1113562 │    2372 │    373 │
│ 3270895 │    2262 │    812 │
│ 1084657 │    2262 │    345 │
│   56599 │    2260 │    799 │
│ 3271094 │    2256 │    812 │
└─────────┴─────────┴────────┘

arrayEnumerateUniqRanked

Introduit dans : v20.1.0 Renvoie un tableau (ou un tableau multidimensionnel) ayant les mêmes dimensions que le tableau source, en indiquant pour chaque élément sa position parmi les éléments ayant la même valeur. Cette fonction permet d’énumérer un tableau multidimensionnel en précisant jusqu’à quel niveau de profondeur l’examiner. Syntaxe

arrayEnumerateUniqRanked(clear_depth, arr, max_array_depth)

Arguments

clear_depth — Énumère séparément les éléments au niveau spécifié. Entier positif inférieur ou égal à max_arr_depth. UInt*
arr — Tableau à N dimensions à énumérer. Array(T)
max_array_depth — Profondeur effective maximale. Entier positif inférieur ou égal à la profondeur de arr. UInt*

Valeur renvoyée Renvoie un tableau à N dimensions de même taille que arr, dans lequel chaque élément indique sa position par rapport aux autres éléments de même valeur. Array(T) Exemples Exemple 1

Query

-- With clear_depth=1 and max_array_depth=1, the result of arrayEnumerateUniqRanked
-- is identical to that which arrayEnumerateUniq would give for the same array.

SELECT arrayEnumerateUniqRanked(1, [1, 2, 1], 1);

Response

[1, 1, 2]

Exemple 2

Query

-- with clear_depth=1 and max_array_depth=1, the result of arrayEnumerateUniqRanked
-- is identical to that which arrayEnumerateUniqwould give for the same array.

SELECT arrayEnumerateUniqRanked(1, [[1, 2, 3], [2, 2, 1], [3]], 2);", "[[1, 1, 1], [2, 3, 2], [2]]

Response

[1, 1, 2]

Exemple 3

Query

-- In this example, arrayEnumerateUniqRanked is used to obtain an array indicating,
-- for each element of the multidimensional array, what its position is among elements
-- of the same value. For the first row of the passed array, [1, 2, 3], the corresponding
-- result is [1, 1, 1], indicating that this is the first time 1, 2 and 3 are encountered.
-- For the second row of the provided array, [2, 2, 1], the corresponding result is [2, 3, 3],
-- indicating that 2 is encountered for a second and third time, and 1 is encountered
-- for the second time. Likewise, for the third row of the provided array [3] the
-- corresponding result is [2] indicating that 3 is encountered for the second time.

SELECT arrayEnumerateUniqRanked(1, [[1, 2, 3], [2, 2, 1], [3]], 2);

Response

[[1, 1, 1], [2, 3, 2], [2]]

Exemple 4

Query

-- Changing clear_depth=2, results in elements being enumerated separately for each row.
SELECT arrayEnumerateUniqRanked(2,[[1, 2, 3],[2, 2, 1],[3]], 2);

Response

[[1, 1, 1], [1, 2, 1], [1]]

arrayExcept

Introduit dans : v25.9.0 Renvoie un tableau contenant les éléments de source qui ne figurent pas dans except, tout en préservant l’ordre d’origine. Cette fonction effectue une opération de différence ensembliste entre deux tableaux. Pour chaque élément de source, elle vérifie s’il existe dans except (à l’aide d’une comparaison exacte). Si ce n’est pas le cas, l’élément est inclus dans le résultat. L’opération conserve les propriétés suivantes :

L’ordre des éléments de source est préservé
Les doublons de source sont conservés s’ils n’existent pas dans except
NULL est traité comme une valeur distincte

Syntaxe

arrayExcept(source, except)

Arguments

source — Le tableau source contenant les éléments à filtrer. Array(T)
except — Le tableau contenant les éléments à exclure du résultat. Array(T)

Valeur renvoyée Renvoie un tableau du même type que le tableau d’entrée, contenant les éléments de source qui ne figurent pas dans except. Array(T) Exemples basic

Query

SELECT arrayExcept([1, 2, 3, 2, 4], [3, 5])

Response

[1, 2, 2, 4]

with_nulls1

Query

SELECT arrayExcept([1, NULL, 2, NULL], [2])

Response

[1, NULL, NULL]

with_nulls2

Query

SELECT arrayExcept([1, NULL, 2, NULL], [NULL, 2, NULL])

Response

[1]

chaînes

Query

SELECT arrayExcept(['apple', 'banana', 'cherry'], ['banana', 'date'])

Response

['apple', 'cherry']

arrayExists

Introduit dans : v1.1.0 Renvoie 1 s’il existe au moins un élément dans le tableau source pour lequel func(x[, y1, y2, ... yN]) renvoie true. Sinon, renvoie 0. Syntaxe

arrayExists(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

Arguments

func(x[, y1, ..., yN]) — Une fonction lambda qui s’applique aux éléments du tableau source (x) et des tableaux de condition (y). Fonction lambda
source_arr — Le tableau source à traiter. Array(T)
[, cond1_arr, ... , condN_arr] — Facultatif. N tableaux de condition fournissant des arguments supplémentaires à la fonction lambda. Array(T)

Valeur renvoyée Renvoie 1 si la fonction lambda renvoie true pour au moins un élément, sinon 0 UInt8 Exemples Exemple d’utilisation

Query

SELECT arrayExists(x, y -> x=y, [1, 2, 3], [0, 0, 0])

Response

arrayFill

Introduit dans : v20.1.0 La fonction arrayFill traite séquentiellement un tableau source du premier élément au dernier, en évaluant une condition lambda à chaque position à l’aide d’éléments du tableau source et des tableaux de condition. Lorsque la fonction lambda renvoie false à la position i, la fonction remplace cet élément par l’élément à la position i-1 dans l’état actuel du tableau. Le premier élément est toujours conservé, quelle que soit la condition. Syntaxe

arrayFill(func(x [, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

Arguments

func(x [, y1, ..., yN]) — Une fonction lambda func(x [, y1, y2, ... yN]) → F(x [, y1, y2, ... yN]) qui s’applique aux éléments du tableau source (x) et des tableaux de condition (y). fonction lambda
source_arr — Le tableau source à traiter. fonction lambda
[, cond1_arr, ... , condN_arr] — Facultatif. N tableaux de condition fournissant des arguments supplémentaires à la fonction lambda. Array(T)

Valeur renvoyée Renvoie un tableau Array(T) Exemples Exemple avec un seul tableau

Query

SELECT arrayFill(x -> not isNull(x), [1, null, 2, null]) AS res

Response

[1, 1, 2, 2]

Exemple avec deux tableaux

Query

SELECT arrayFill(x, y, z -> x > y AND x < z, [5, 3, 6, 2], [4, 7, 1, 3], [10, 2, 8, 5]) AS res

Response

[5, 5, 6, 6]

arrayFilter

Introduit dans : v1.1.0 Renvoie un tableau contenant uniquement les éléments du tableau source pour lesquels une fonction lambda renvoie true. Syntaxe

arrayFilter(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])]

Arguments

func(x[, y1, ..., yN]) — Une fonction lambda qui s’applique aux éléments du tableau source (x) et des tableaux de condition (y). fonction lambda
source_arr — Le tableau source à traiter. Array(T)
[, cond1_arr, ... , condN_arr] — Facultatif. N tableaux de condition fournissant des arguments supplémentaires à la fonction lambda. Array(T)

Valeur renvoyée Renvoie un sous-ensemble du tableau source Array(T) Exemples Exemple 1

Query

SELECT arrayFilter(x -> x LIKE '%World%', ['Hello', 'abc World']) AS res

Response

['abc World']

Exemple 2

Query

SELECT
    arrayFilter(
        (i, x) -> x LIKE '%World%',
        arrayEnumerate(arr),
        ['Hello', 'abc World'] AS arr)
    AS res

Response

[2]

arrayFirst

Introduit dans : v1.1.0 Renvoie le premier élément du tableau source pour lequel func(x[, y1, y2, ... yN]) renvoie true ; sinon, une valeur par défaut. Syntaxe

arrayFirst(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

Arguments

func(x[, y1, ..., yN]) — Une fonction lambda qui opère sur les éléments du tableau source (x) et des tableaux de condition (y). Fonction lambda. - source_arr — Le tableau source à traiter. Array(T). - [, cond1_arr, ... , condN_arr] — Facultatif. N tableaux de condition fournissant des arguments supplémentaires à la fonction lambda. Array(T).

Valeur renvoyée Renvoie le premier élément du tableau source pour lequel λ vaut true ; sinon, renvoie la valeur par défaut de T. Exemples Exemple d’utilisation

Query

SELECT arrayFirst(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])

Response

Aucune correspondance

Query

SELECT arrayFirst(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)

Response

0 UInt8

arrayFirstIndex

Introduit dans : v1.1.0 Renvoie l’indice du premier élément du tableau d’entrée pour lequel func(x[, y1, y2, ... yN]) renvoie vrai, sinon renvoie ‘0’. Syntaxe

arrayFirstIndex(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

Arguments

func(x[, y1, ..., yN]) — Une fonction lambda qui s’applique aux éléments du tableau source (x) et aux tableaux de condition (y). Fonction lambda. - source_arr — Le tableau source à traiter. Array(T). - [, cond1_arr, ... , condN_arr] — Facultatif. N tableaux de condition fournissant des arguments supplémentaires à la fonction lambda. Array(T).

Valeur renvoyée Renvoie l’indice du premier élément du tableau source pour lequel func est vrai ; sinon, renvoie 0 UInt32 Exemples Exemple d’utilisation

Query

SELECT arrayFirstIndex(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])

Response

Aucune correspondance

Query

SELECT arrayFirstIndex(x, y -> x=y, ['a', 'b', 'c'], ['d', 'e', 'f'])

Response

arrayFirstOrNull

Introduit dans : v1.1.0 Renvoie le premier élément du tableau source pour lequel func(x[, y1, y2, ... yN]) renvoie true ; sinon, renvoie NULL. Syntaxe

arrayFirstOrNull(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

Arguments

func(x[, y1, ..., yN]) — Une fonction lambda qui agit sur les éléments du tableau source (x) et des tableaux de condition (y). Fonction lambda
source_arr — Le tableau source à traiter. Array(T)
[, cond1_arr, ... , condN_arr] — Facultatif. N tableaux de condition fournissant des arguments supplémentaires à la fonction lambda. Array(T)

Valeur renvoyée Renvoie le premier élément du tableau source pour lequel func est vrai ; sinon, renvoie NULL. Exemples Exemple d’utilisation

Query

SELECT arrayFirstOrNull(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])

Response

Aucun résultat

Query

SELECT arrayFirstOrNull(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)

Response

NULL Nullable(UInt8)

arrayFlatten

Introduit dans : v20.1.0 Convertit un tableau de tableaux en un tableau à plat. Fonction :

S’applique à des tableaux imbriqués, quelle que soit leur profondeur.
Ne modifie pas les tableaux déjà plats.

Le tableau aplati contient tous les éléments de tous les tableaux sources. Syntaxe

arrayFlatten(arr)

Alias : flatten Arguments

arr — Un tableau multidimensionnel. Array(Array(T))

Valeur renvoyée Renvoie un tableau aplati Array(T) à partir du tableau multidimensionnel. Exemples Exemple d’utilisation

Query

SELECT arrayFlatten([[[1]], [[2], [3]]]);

Response

[1, 2, 3]

arrayFold

Introduit dans : v23.10.0 Applique une fonction lambda à un ou plusieurs tableaux de même taille et accumule le résultat dans un accumulateur. Syntaxe

arrayFold(λ(acc, x1 [, x2, x3, ... xN]), arr1 [, arr2, arr3, ... arrN], acc)

Arguments

λ(x, x1 [, x2, x3, ... xN]) — Une fonction lambda λ(acc, x1 [, x2, x3, ... xN]) → F(acc, x1 [, x2, x3, ... xN]) où F est une opération appliquée à acc et aux valeurs des tableaux de x, le résultat étant réutilisé comme nouvelle valeur de acc. Lambda function
arr1 [, arr2, arr3, ... arrN] — N tableaux sur lesquels effectuer l’opération. Array(T)
acc — Valeur accumulée du même type que le type de retour de la fonction lambda.

Valeur renvoyée Renvoie la valeur finale de acc. Exemples Exemple d’utilisation

Query

SELECT arrayFold(acc,x -> acc + x*2, [1, 2, 3, 4], 3::Int64) AS res;

Response

Suite de Fibonacci

Query

SELECT arrayFold(acc, x -> (acc.2, acc.2 + acc.1),range(number),(1::Int64, 0::Int64)).1 AS fibonacci FROM numbers(1,10);

Response

┌─fibonacci─┐
│         0 │
│         1 │
│         1 │
│         2 │
│         3 │
│         5 │
│         8 │
│        13 │
│        21 │
│        34 │
└───────────┘

Exemple avec plusieurs tableaux

Query

SELECT arrayFold(
(acc, x, y) -> acc + (x * y),
[1, 2, 3, 4],
[10, 20, 30, 40],
0::Int64
) AS res;

Response

arrayIntersect

Introduite dans : v1.1.0 Prend plusieurs tableaux et renvoie un tableau contenant les éléments présents dans tous les tableaux source. Le résultat ne contient que des valeurs uniques. Syntaxe

arrayIntersect(arr, arr1, ..., arrN)

Arguments

arrN — N tableaux à partir desquels former le nouveau tableau. Array(T).

Valeur renvoyée Renvoie un tableau contenant les éléments distincts présents dans les N tableaux Array(T) Exemples Exemple d’utilisation

Query

SELECT
arrayIntersect([1, 2], [1, 3], [2, 3]) AS empty_intersection,
arrayIntersect([1, 2], [1, 3], [1, 4]) AS non_empty_intersection

Response

┌─empty_intersection─┬─non_empty_intersection─┐
│ []                 │ [1]                    │
└────────────────────┴────────────────────────┘

arrayJaccardIndex

Introduit dans : v23.7.0 Renvoie l’indice de Jaccard de deux tableaux. Syntaxe

arrayJaccardIndex(arr_x, arr_y)

Arguments

arr_x — Premier tableau. Array(T)
arr_y — Deuxième tableau. Array(T)

Valeur renvoyée Renvoie l’indice de Jaccard entre arr_x et arr_y Float64 Exemples Exemple d’utilisation

Query

SELECT arrayJaccardIndex([1, 2], [2, 3]) AS res

Response

0.3333333333333333

arrayJoin

Introduit dans : v1.1.0 La fonction arrayJoin prend une ligne contenant un tableau et la déplie en générant plusieurs lignes — une pour chaque élément du tableau. Cela contraste avec les fonctions régulières de ClickHouse, qui associent des valeurs d’entrée à des valeurs de sortie dans la même ligne, et avec les fonctions d’agrégation, qui prennent un groupe de lignes et les “compressent” ou les “réduisent” en une seule ligne de synthèse (ou en une seule valeur dans une ligne de synthèse si elles sont utilisées avec GROUP BY). Toutes les valeurs des colonnes sont simplement copiées, à l’exception de celles de la colonne à laquelle cette fonction est appliquée ; celles-ci sont remplacées par la valeur correspondante du tableau. Syntaxe

arrayJoin(arr)

Alias : unnest Arguments

arr — Un tableau à déplier. Array(T)

Valeur renvoyée Renvoie un ensemble de lignes obtenues en dépliant arr. Exemples Utilisation de base

Query

SELECT arrayJoin([1, 2, 3] AS src) AS dst, 'Hello', src

Response

┌─dst─┬─\'Hello\'─┬─src─────┐
│   1 │ Hello     │ [1,2,3] │
│   2 │ Hello     │ [1,2,3] │
│   3 │ Hello     │ [1,2,3] │
└─────┴───────────┴─────────┘

arrayJoin affecte toutes les clauses de la requête

Query

-- The arrayJoin function affects all sections of the query, including the WHERE section. Notice the result 2, even though the subquery returned 1 row.

SELECT sum(1) AS impressions
FROM
(
    SELECT ['Istanbul', 'Berlin', 'Bobruisk'] AS cities
)
WHERE arrayJoin(cities) IN ['Istanbul', 'Berlin'];

Response

┌─impressions─┐
│           2 │
└─────────────┘

Utiliser plusieurs fonctions arrayJoin

Query

- A query can use multiple arrayJoin functions. In this case, the transformation is performed multiple times and the rows are multiplied.

SELECT
    sum(1) AS impressions,
    arrayJoin(cities) AS city,
    arrayJoin(browsers) AS browser
FROM
(
    SELECT
        ['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
        ['Firefox', 'Chrome', 'Chrome'] AS browsers
)
GROUP BY
    2,
    3

Response

┌─impressions─┬─city─────┬─browser─┐
│           2 │ Istanbul │ Chrome  │
│           1 │ Istanbul │ Firefox │
│           2 │ Berlin   │ Chrome  │
│           1 │ Berlin   │ Firefox │
│           2 │ Bobruisk │ Chrome  │
│           1 │ Bobruisk │ Firefox │
└─────────────┴──────────┴─────────┘

Résultats inattendus liés aux optimisations

Query

-- Using multiple arrayJoin with the same expression may not produce the expected result due to optimizations.
-- For these cases, consider modifying the repeated array expression with extra operations that do not affect join result.
- e.g. arrayJoin(arraySort(arr)), arrayJoin(arrayConcat(arr, []))

SELECT
    arrayJoin(dice) as first_throw,
    /* arrayJoin(dice) as second_throw */ -- is technically correct, but will annihilate result set
    arrayJoin(arrayConcat(dice, [])) as second_throw -- intentionally changed expression to force re-evaluation
FROM (
    SELECT [1, 2, 3, 4, 5, 6] as dice
);

Response

┌─first_throw─┬─second_throw─┐
│           1 │            1 │
│           1 │            2 │
│           1 │            3 │
│           1 │            4 │
│           1 │            5 │
│           1 │            6 │
│           2 │            1 │
│           2 │            2 │
│           2 │            3 │
│           2 │            4 │
│           2 │            5 │
│           2 │            6 │
│           3 │            1 │
│           3 │            2 │
│           3 │            3 │
│           3 │            4 │
│           3 │            5 │
│           3 │            6 │
│           4 │            1 │
│           4 │            2 │
│           4 │            3 │
│           4 │            4 │
│           4 │            5 │
│           4 │            6 │
│           5 │            1 │
│           5 │            2 │
│           5 │            3 │
│           5 │            4 │
│           5 │            5 │
│           5 │            6 │
│           6 │            1 │
│           6 │            2 │
│           6 │            3 │
│           6 │            4 │
│           6 │            5 │
│           6 │            6 │
└─────────────┴──────────────┘

Utilisation de la syntaxe ARRAY JOIN

Query

-- Note the ARRAY JOIN syntax in the `SELECT` query below, which provides broader possibilities.
-- ARRAY JOIN allows you to convert multiple arrays with the same number of elements at a time.

SELECT
    sum(1) AS impressions,
    city,
    browser
FROM
(
    SELECT
        ['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
        ['Firefox', 'Chrome', 'Chrome'] AS browsers
)
ARRAY JOIN
    cities AS city,
    browsers AS browser
GROUP BY
    2,
    3

Response

┌─impressions─┬─city─────┬─browser─┐
│           1 │ Istanbul │ Firefox │
│           1 │ Berlin   │ Chrome  │
│           1 │ Bobruisk │ Chrome  │
└─────────────┴──────────┴─────────┘

Utiliser Tuple

Query

-- You can also use Tuple

SELECT
    sum(1) AS impressions,
    (arrayJoin(arrayZip(cities, browsers)) AS t).1 AS city,
    t.2 AS browser
FROM
(
    SELECT
        ['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
        ['Firefox', 'Chrome', 'Chrome'] AS browsers
)
GROUP BY
    2,
    3

Response

┌─impressions─┬─city─────┬─browser─┐
│           1 │ Istanbul │ Firefox │
│           1 │ Berlin   │ Chrome  │
│           1 │ Bobruisk │ Chrome  │
└─────────────┴──────────┴─────────┘

arrayLast

Introduit dans : v1.1.0 Renvoie le dernier élément du tableau source pour lequel une fonction lambda func(x [, y1, y2, ... yN]) renvoie true, sinon une valeur par défaut est renvoyée. Syntaxe

arrayLast(func(x[, y1, ..., yN]), source[, cond1, ... , condN_arr])

Arguments

func(x[, y1, ..., yN]) — Une fonction lambda qui s’applique aux éléments du tableau source (x) et des tableaux de condition (y). Fonction lambda. - source — Le tableau source à traiter. Array(T). - [, cond1, ... , condN] — Facultatif. N tableaux de condition fournissant des arguments supplémentaires à la fonction lambda. Array(T).

Valeur renvoyée Renvoie le dernier élément du tableau source pour lequel func vaut true, sinon renvoie la valeur par défaut de T. Exemples Exemple d’utilisation

Query

SELECT arrayLast(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c'])

Response

Aucune correspondance

Query

SELECT arrayFirst(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)

Response

0 UInt8

arrayLastIndex

Introduit dans : v1.1.0 Renvoie l’indice du dernier élément du tableau source pour lequel func(x[, y1, y2, ... yN]) renvoie true ; sinon, renvoie ‘0’. Syntaxe

arrayLastIndex(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

Arguments

func(x[, y1, ..., yN]) — Une fonction lambda qui s’applique aux éléments du tableau source (x) et aux tableaux de condition (y). fonction lambda
source_arr — Le tableau source à traiter. Array(T)
[, cond1_arr, ... , condN_arr] — Facultatif. N tableaux de condition fournissant des arguments supplémentaires à la fonction lambda. Array(T)

Valeur renvoyée Renvoie l’indice du dernier élément du tableau source pour lequel func est true, sinon renvoie 0 UInt32 Exemples Exemple d’utilisation

Query

SELECT arrayLastIndex(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c']);

Response

Aucune correspondance

Query

SELECT arrayLastIndex(x, y -> x=y, ['a', 'b', 'c'], ['d', 'e', 'f']);

Response

arrayLastOrNull

Introduit dans : v1.1.0 Renvoie le dernier élément du tableau source pour lequel une fonction lambda func(x [, y1, y2, ... yN]) renvoie true ; sinon, renvoie NULL. Syntaxe

arrayLastOrNull(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

Arguments

func(x [, y1, ..., yN]) — Une fonction lambda qui agit sur les éléments du tableau source (x) et des tableaux de condition (y). Fonction lambda. - source_arr — Le tableau source à traiter. Array(T). - [, cond1_arr, ... , condN_arr] — Facultatif. N tableaux de condition fournissant des arguments supplémentaires à la fonction lambda. Array(T).

Valeur renvoyée Retourne le dernier élément du tableau source pour lequel λ n’est pas true, sinon retourne NULL. Exemples Exemple d’utilisation

Query

SELECT arrayLastOrNull(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c'])

Response

Aucune correspondance

Query

SELECT arrayLastOrNull(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)

Response

NULL Nullable(UInt8)

arrayLevenshteinDistance

Introduit dans : v25.4.0 Calcule la distance de Levenshtein entre deux tableaux. Syntaxe

arrayLevenshteinDistance(from, to)

Arguments

from — Le premier tableau. Array(T). - to — Le deuxième tableau. Array(T).

Valeur renvoyée Distance de Levenshtein entre le premier tableau et le deuxième. Float64 Exemples Exemple d’utilisation

Query

SELECT arrayLevenshteinDistance([1, 2, 4], [1, 2, 3])

Response

arrayLevenshteinDistanceWeighted

Introduit dans : v25.4.0 Calcule la distance de Levenshtein entre deux tableaux avec des pondérations personnalisées pour chaque élément. Le nombre d’éléments du tableau et celui de ses pondérations doivent correspondre. Syntaxe

arrayLevenshteinDistanceWeighted(from, to, from_weights, to_weights)

Arguments

from — premier tableau. Array(T). - to — deuxième tableau. Array(T). - from_weights — poids du premier tableau. Array((U)Int*|Float*)
to_weights — poids du deuxième tableau. Array((U)Int*|Float*)

Valeur renvoyée Distance de Levenshtein entre le premier et le deuxième tableaux, avec des poids personnalisés pour chaque élément Float64 Exemples Exemple d’utilisation

Query

SELECT arrayLevenshteinDistanceWeighted(['A', 'B', 'C'], ['A', 'K', 'L'], [1.0, 2, 3], [3.0, 4, 5])

Response

arrayMap

Introduit dans : v1.1.0 Renvoie un tableau obtenu à partir des tableaux d’origine en appliquant une fonction lambda à chaque élément. Syntaxe

arrayMap(func, arr)

Arguments

func — Une fonction lambda qui s’applique aux éléments du tableau source (x) et des tableaux de condition (y). Fonction lambda
arr — N tableaux à traiter. Array(T)

Valeur renvoyée Renvoie un tableau contenant les résultats de la fonction lambda Array(T) Exemples Exemple d’utilisation

Query

SELECT arrayMap(x -> (x + 2), [1, 2, 3]) as res;

Response

[3, 4, 5]

Création d’un tuple d’éléments à partir de plusieurs tableaux

Query

SELECT arrayMap((x, y) -> (x, y), [1, 2, 3], [4, 5, 6]) AS res

Response

[(1, 4),(2, 5),(3, 6)]

arrayMax

Introduit dans : v21.1.0 Renvoie l’élément maximal du tableau source. Si une fonction lambda func est spécifiée, renvoie l’élément maximal des résultats de la fonction lambda. Syntaxe

arrayMax([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])

Arguments

func(x[, y1, ..., yN]) — Facultatif. Une fonction lambda qui s’applique aux éléments du tableau source (x) et des tableaux de condition (y). Fonction lambda
source_arr — Le tableau source à traiter. Array(T)
[, cond1_arr, ... , condN_arr] — Facultatif. N tableaux de condition fournissant des arguments supplémentaires à la fonction lambda. Array(T)

Valeur renvoyée Renvoie l’élément maximal du tableau source, ou l’élément maximal des résultats de la fonction lambda si elle est fournie. Exemples Exemple simple

Query

SELECT arrayMax([5, 3, 2, 7]);

Response

Utilisation d’une fonction lambda

Query

SELECT arrayMax(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);

Response

arrayMin

Introduit dans : v21.1.0 Renvoie le plus petit élément du tableau source. Si une fonction lambda func est spécifiée, renvoie le plus petit élément parmi les résultats de la fonction lambda. Syntaxe

arrayMin([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])

Arguments

func(x[, y1, ..., yN]) — Facultatif. Fonction lambda s’appliquant aux éléments du tableau source (x) et des tableaux de conditions (y). fonction lambda
source_arr — Tableau source à traiter. Array(T)
cond1_arr, ... — Facultatif. N tableaux de conditions fournissant des arguments supplémentaires à la fonction lambda. Array(T)

Valeur renvoyée Renvoie l’élément minimal du tableau source, ou l’élément minimal des résultats de la fonction lambda si elle est fournie. Exemples Exemple simple

Query

SELECT arrayMin([5, 3, 2, 7]);

Response

Utilisation avec une fonction lambda

Query

SELECT arrayMin(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);

Response

arrayNormalizedGini

Introduit dans : v25.1.0 Calcule le coefficient de Gini normalisé. Syntaxe

arrayNormalizedGini(predicted, label)

Arguments

predicted — La valeur prédite. Array(T)
label — La valeur réelle. Array(T)

Valeur renvoyée Un tuple contenant les coefficients de Gini des valeurs prédites, le coefficient de Gini des valeurs normalisées et le coefficient de Gini normalisé (= le rapport entre les deux premiers coefficients de Gini) Tuple(Float64, Float64, Float64) Exemples Exemple d’utilisation

Query

SELECT arrayNormalizedGini([0.9, 0.3, 0.8, 0.7],[6, 1, 0, 2]);

Response

(0.18055555555555558, 0.2638888888888889, 0.6842105263157896)

arrayPartialReverseSort

Introduit dans : v23.2.0 Cette fonction est identique à arrayReverseSort, mais avec un argument limit supplémentaire permettant un tri partiel.

Pour conserver uniquement les éléments triés, utilisez arrayResize.

Syntaxe

arrayPartialReverseSort([f,] limit, arr [, arr1, ... ,arrN])

Arguments

f(arr[, arr1, ... ,arrN]) — La fonction lambda à appliquer aux éléments du tableau x. Fonction lambda
limit — Valeur d’indice jusqu’à laquelle le tri s’effectue. (U)Int*
arr — Tableau à trier. Array(T)
arr1, ... ,arrN — N tableaux supplémentaires, dans le cas où f accepte plusieurs arguments. Array(T)

Valeur renvoyée Renvoie un tableau de même taille que le tableau d’origine, dans lequel les éléments de l’intervalle [1..limit] sont triés par ordre décroissant. Les éléments restants (limit..N] sont dans un ordre non spécifié. Exemples simple_int

Query

SELECT arrayPartialReverseSort(2, [5, 9, 1, 3])

Response

[9, 5, 1, 3]

simple_string

Query

SELECT arrayPartialReverseSort(2, ['expenses','lasso','embolism','gladly'])

Response

['lasso','gladly','expenses','embolism']

retain_sorted

Query

SELECT arrayResize(arrayPartialReverseSort(2, [5, 9, 1, 3]), 2)

Response

[9, 5]

lambda_simple

Query

SELECT arrayPartialReverseSort((x) -> -x, 2, [5, 9, 1, 3])

Response

[1, 3, 5, 9]

lambda_complex

Query

SELECT arrayPartialReverseSort((x, y) -> -y, 1, [0, 1, 2], [1, 2, 3]) as res

Response

[0, 1, 2]

arrayPartialShuffle

Introduit dans : v23.2.0 Renvoie un tableau de la même taille que le tableau d’origine, dans lequel les éléments de l’intervalle [1..limit] forment un sous-ensemble aléatoire du tableau d’origine. Les éléments restants (limit..n] doivent contenir les éléments qui ne figurent pas dans l’intervalle [1..limit], dans un ordre indéfini. La valeur de limit doit être comprise dans l’intervalle [1..n]. Les valeurs en dehors de cet intervalle reviennent à effectuer un arrayShuffle complet :

Cette fonction ne matérialisera pas les constantes.La valeur de limit doit être comprise dans l’intervalle [1..N]. Les valeurs en dehors de cet intervalle reviennent à effectuer un arrayShuffle complet.

Syntaxe

arrayPartialShuffle(arr [, limit[, seed]])

Arguments

arr — Le tableau à mélanger. Array(T)
seed — Facultatif. La graine utilisée pour la génération de nombres aléatoires. Si elle n’est pas fournie, une graine aléatoire est utilisée. (U)Int*
limit — Facultatif. Le nombre d’échanges d’éléments à limiter, dans l’intervalle [1..N]. (U)Int*

Valeur renvoyée Tableau dont les éléments sont partiellement mélangés. Array(T) Exemples no_limit1

Query

SELECT arrayPartialShuffle([1, 2, 3, 4], 0)

Response

[2, 4, 3, 1]

no_limit2

Query

SELECT arrayPartialShuffle([1, 2, 3, 4])

Response

[4, 1, 3, 2]

random_seed

Query

SELECT arrayPartialShuffle([1, 2, 3, 4], 2)

Response

[3, 4, 1, 2]

explicit_seed

Query

SELECT arrayPartialShuffle([1, 2, 3, 4], 2, 41)

Response

[3, 2, 1, 4]

matérialiser

Query

SELECT arrayPartialShuffle(materialize([1, 2, 3, 4]), 2, 42), arrayPartialShuffle([1, 2, 3], 2, 42) FROM numbers(10)

Response

┌─arrayPartial⋯4]), 2, 42)─┬─arrayPartial⋯ 3], 2, 42)─┐
│ [3,2,1,4]                │ [3,2,1]                  │
│ [3,2,1,4]                │ [3,2,1]                  │
│ [4,3,2,1]                │ [3,2,1]                  │
│ [1,4,3,2]                │ [3,2,1]                  │
│ [3,4,1,2]                │ [3,2,1]                  │
│ [1,2,3,4]                │ [3,2,1]                  │
│ [1,4,3,2]                │ [3,2,1]                  │
│ [1,4,3,2]                │ [3,2,1]                  │
│ [3,1,2,4]                │ [3,2,1]                  │
│ [1,3,2,4]                │ [3,2,1]                  │
└──────────────────────────┴──────────────────────────┘

arrayPartialSort

Introduit dans : v23.2.0 Cette fonction est identique à arraySort, mais avec un argument limit supplémentaire qui permet un tri partiel.

Pour conserver uniquement les éléments triés, utilisez arrayResize.

Syntaxe

arrayPartialSort([f,] limit, arr [, arr1, ... ,arrN])

Arguments

f(arr[, arr1, ... ,arrN]) — La fonction lambda à appliquer aux éléments du tableau x. fonction lambda
limit — Valeur d’index jusqu’à laquelle le tri est effectué. (U)Int*
arr — Tableau à trier. Array(T)
arr1, ... ,arrN — N tableaux supplémentaires, lorsque f accepte plusieurs arguments. Array(T)

Valeur renvoyée Renvoie un tableau de la même taille que le tableau d’origine, dans lequel les éléments de l’intervalle [1..limit] sont triés par ordre croissant. Les éléments restants (limit..N] sont dans un ordre indéterminé. Exemples simple_int

Query

SELECT arrayPartialSort(2, [5, 9, 1, 3])

Response

[1, 3, 5, 9]

simple_string

Query

SELECT arrayPartialSort(2, ['expenses', 'lasso', 'embolism', 'gladly'])

Response

['embolism', 'expenses', 'gladly', 'lasso']

retain_sorted

Query

SELECT arrayResize(arrayPartialSort(2, [5, 9, 1, 3]), 2)

Response

[1, 3]

lambda_simple

Query

SELECT arrayPartialSort((x) -> -x, 2, [5, 9, 1, 3])

Response

[9, 5, 1, 3]

lambda_complex

Query

SELECT arrayPartialSort((x, y) -> -y, 1, [0, 1, 2], [1, 2, 3]) as res

Response

[2, 1, 0]

arrayPopBack

Introduit dans : v1.1.0 Supprime le dernier élément du tableau. Syntaxe

arrayPopBack(arr)

Arguments

arr — Le tableau dont il faut supprimer le dernier élément. Array(T)

Valeur renvoyée Renvoie un tableau identique à arr, mais sans son dernier élément Array(T) Exemples Exemple d’utilisation

Query

SELECT arrayPopBack([1, 2, 3]) AS res;

Response

[1, 2]

arrayPopFront

Introduit dans : v1.1.0 Supprime le premier élément du tableau. Syntaxe

arrayPopFront(arr)

Arguments

arr — Le tableau dont le premier élément doit être supprimé. Array(T)

Valeur renvoyée Renvoie un tableau identique à arr, mais sans son premier élément Array(T) Exemples Exemple d’utilisation

Query

SELECT arrayPopFront([1, 2, 3]) AS res;

Response

[2, 3]

arrayProduct

Introduit dans : v21.1.0 Renvoie le produit des éléments du tableau source. Si une fonction lambda func est spécifiée, renvoie le produit des éléments renvoyés par la fonction lambda. Syntaxe

arrayProduct([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])

Arguments

func(x[, y1, ..., yN]) — Facultatif. Une fonction lambda qui s’applique aux éléments du tableau source (x) et des tableaux de conditions (y). fonction lambda
source_arr — Le tableau source à traiter. Array(T)
[, cond1_arr, ... , condN_arr] — Facultatif. N tableaux de conditions fournissant des arguments supplémentaires à la fonction lambda. Array(T)

Valeur renvoyée Renvoie le produit des éléments du tableau source, ou le produit des résultats de la fonction lambda si elle est fournie. Float64 Exemples Exemple de base

Query

SELECT arrayProduct([1, 2, 3, 4]);

Response

Utilisation avec une fonction lambda

Query

SELECT arrayProduct(x, y -> x+y, [2, 2], [2, 2]) AS res;

Response

arrayPushBack

Introduit dans : v1.1.0 Ajoute un élément à la fin du tableau. Syntaxe

arrayPushBack(arr, x)

Arguments

arr — Le tableau à la fin duquel ajouter la valeur x. Array(T)
x —
Valeur unique à ajouter à la fin du tableau. Array(T).

Seuls des nombres peuvent être ajoutés à un tableau de nombres, et seules des chaînes peuvent être ajoutées à un tableau de chaînes.
Lors de l’ajout de nombres, ClickHouse définit automatiquement le type de x en fonction du type de données du tableau.
Peut être NULL. La fonction ajoute un élément NULL à un tableau, et le type des éléments du tableau est converti en Nullable.

Pour plus d’informations sur les types de données dans ClickHouse, consultez Types de données.

Valeur renvoyée Renvoie un tableau identique à arr, mais avec une valeur x supplémentaire à la fin du tableau Array(T) Exemples Exemple d’utilisation

Query

SELECT arrayPushBack(['a'], 'b') AS res;

Response

['a','b']

arrayPushFront

Introduite dans : v1.1.0 Ajoute un élément au début du tableau. Syntaxe

arrayPushFront(arr, x)

Arguments

arr — Tableau auquel ajouter la valeur x à la fin. Array(T). - x —
Valeur unique à ajouter au début du tableau. Array(T).

Seuls des nombres peuvent être ajoutés à un tableau de nombres, et seules des chaînes peuvent être ajoutées à un tableau de chaînes.
Lors de l’ajout de nombres, ClickHouse définit automatiquement le type de x en fonction du type de données du tableau.
Peut être NULL. La fonction ajoute un élément NULL au tableau, et le type des éléments du tableau devient Nullable.

Pour plus d’informations sur les types de données dans ClickHouse, consultez Types de données.

Valeur renvoyée Renvoie un tableau identique à arr, mais avec une valeur supplémentaire x au début du tableau Array(T) Exemples Exemple d’utilisation

Query

SELECT arrayPushFront(['b'], 'a') AS res;

Response

['a','b']

arrayROCAUC

Introduit dans : v20.4.0 Calcule l’aire sous la courbe ROC (receiver operating characteristic). Une courbe ROC est obtenue en traçant le taux de vrais positifs (True Positive Rate, TPR) sur l’axe des ordonnées et le taux de faux positifs (False Positive Rate, FPR) sur l’axe des abscisses pour tous les seuils. La valeur obtenue varie de zéro à un, une valeur plus élevée indiquant de meilleures performances du modèle. La ROC AUC (également appelée simplement AUC) est un concept d’apprentissage automatique. Pour plus de détails, veuillez consulter ici, ici et ici. Syntaxe

arrayROCAUC(scores, labels[, scale[, partial_offsets]])

Alias : arrayAUC Arguments

scores — Scores produits par le modèle de prédiction. Array((U)Int*) ou Array(Float*)
labels — Étiquettes des échantillons, généralement 1 pour un échantillon positif et 0 pour un échantillon négatif. Array((U)Int*) ou Enum
scale — Facultatif. Indique s’il faut renvoyer l’aire normalisée. Si false, renvoie à la place l’aire sous la courbe TP (true positives) x FP (false positives). Valeur par défaut : true. Bool
partial_offsets —
Tableau de quatre entiers non négatifs permettant de calculer une aire partielle sous la courbe ROC (équivalente à une bande verticale de l’espace ROC) au lieu de l’AUC complète. Cette option est utile pour le calcul distribué de la ROC AUC. Le tableau doit contenir les éléments suivants [higher_partitions_tp, higher_partitions_fp, total_positives, total_negatives]. Array d’entiers non négatifs. Facultatif.
- higher_partitions_tp : Le nombre d’étiquettes positives dans les partitions aux scores les plus élevés.
- higher_partitions_fp : Le nombre d’étiquettes négatives dans les partitions aux scores les plus élevés.
- total_positives : Le nombre total d’échantillons positifs dans l’ensemble du jeu de données.
- total_negatives : Le nombre total d’échantillons négatifs dans l’ensemble du jeu de données.

Lorsque arr_partial_offsets est utilisé, arr_scores et arr_labels ne doivent représenter qu’une partition de l’ensemble du jeu de données, contenant un intervalle de scores. Le jeu de données doit être divisé en partitions contiguës, chaque partition contenant le sous-ensemble de données dont les scores se situent dans une plage spécifique. Par exemple :

Une partition peut contenir tous les scores dans la plage [0, 0.5).
Une autre partition peut contenir les scores dans la plage [0.5, 1.0].

Valeur renvoyée Renvoie l’aire sous la courbe ROC (receiver operating characteristic). Float64 Exemples Exemple d’utilisation

Query

SELECT arrayROCAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);

Response

0.75

arrayRandomSample

Introduit dans : v23.10.0 Renvoie un sous-ensemble de samples éléments choisis aléatoirement dans un tableau en entrée. Si samples dépasse la taille du tableau en entrée, la taille de l’échantillon est limitée à celle du tableau ; autrement dit, tous les éléments du tableau sont renvoyés, mais leur ordre n’est pas garanti. La fonction peut traiter à la fois des tableaux plats et des tableaux imbriqués. Syntaxe

arrayRandomSample(arr, samples)

Arguments

arr — Le tableau d’entrée ou le tableau multidimensionnel à partir duquel prélever des éléments. Array(T)
samples — Le nombre d’éléments à inclure dans l’échantillon aléatoire. (U)Int*

Valeur renvoyée Un tableau contenant un échantillon aléatoire d’éléments du tableau d’entrée Array(T) Exemples Exemple d’utilisation

Query

SELECT arrayRandomSample(['apple', 'banana', 'cherry', 'date'], 2) as res;

Response

['cherry','apple']

Utiliser un tableau multidimensionnel

Query

SELECT arrayRandomSample([[1, 2], [3, 4], [5, 6]], 2) as res;

Response

[[3,4],[5,6]]

arrayReduce

Introduit dans : v1.1.0 Applique une fonction d’agrégation aux éléments d’un tableau et renvoie le résultat. Le nom de la fonction d’agrégation est passé sous forme de chaîne entre apostrophes : 'max', 'sum'. Lors de l’utilisation de fonctions d’agrégation paramétriques, le paramètre est indiqué entre parenthèses après le nom de la fonction : 'uniqUpTo(6)'. Syntaxe

arrayReduce(agg_f, arr1[, arr2, ... , arrN])

Arguments

agg_f — Nom d’une fonction d’agrégation, qui doit être une constante. String
arr1[, arr2, ... , arrN] — N tableaux correspondant aux arguments de agg_f. Array(T)

Valeur renvoyée Renvoie le résultat de la fonction d’agrégation Exemples Exemple d’utilisation

Query

SELECT arrayReduce('max', [1, 2, 3]);

Response

┌─arrayReduce('max', [1, 2, 3])─┐
│                             3 │
└───────────────────────────────┘

Exemple de fonction d’agrégation avec plusieurs arguments

Query

--If an aggregate function takes multiple arguments, then this function must be applied to multiple arrays of the same size.

SELECT arrayReduce('maxIf', [3, 5], [1, 0]);

Response

┌─arrayReduce('maxIf', [3, 5], [1, 0])─┐
│                                    3 │
└──────────────────────────────────────┘

Exemple avec une fonction d’agrégation paramétrique

Query

SELECT arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);

Response

┌─arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])─┐
│                                                           4 │
└─────────────────────────────────────────────────────────────┘

arrayReduceInRanges

Introduit dans : v20.4.0 Applique une fonction d’agrégation aux éléments du tableau dans les intervalles indiqués et renvoie un tableau contenant le résultat correspondant à chaque intervalle. La fonction renvoie le même résultat que plusieurs arrayReduce(agg_func, arraySlice(arr1, index, length), ...). Syntaxe

arrayReduceInRanges(agg_f, ranges, arr1[, arr2, ... ,arrN])

Arguments

agg_f — Nom de la fonction d’agrégation à utiliser. String
ranges — La plage sur laquelle effectuer l’agrégation. Un tableau de tuples (i, r) contenant l’indice i à partir duquel commencer et la plage r sur laquelle effectuer l’agrégation. Array(T) ou Tuple(T)
arr1[, arr2, ... ,arrN] — N tableaux passés comme arguments à la fonction d’agrégation. Array(T)

Valeur renvoyée Renvoie un tableau contenant les résultats de la fonction d’agrégation sur les plages spécifiées Array(T) Exemples Exemple d’utilisation

Query

SELECT arrayReduceInRanges(
    'sum',
    [(1, 5), (2, 3), (3, 4), (4, 4)],
    [1000000, 200000, 30000, 4000, 500, 60, 7]
) AS res

Response

┌─res─────────────────────────┐
│ [1234500,234000,34560,4567] │
└─────────────────────────────┘

arrayRemove

Introduit dans : v25.11.0 Supprime d’un tableau tous les éléments égaux à une valeur donnée. Les valeurs NULL sont considérées comme égales. Syntaxe

arrayRemove(arr, elem)

Alias : array_remove Arguments

arr — Array(T) - elem — T

Valeur renvoyée Renvoie un sous-ensemble du tableau source Array(T) Exemples Exemple 1

Query

SELECT arrayRemove([1, 2, 2, 3], 2)

Response

[1, 3]

Exemple 2

Query

SELECT arrayRemove(['a', NULL, 'b', NULL], NULL)

Response

['a', 'b']

arrayResize

Introduit dans : v1.1.0 Modifie la longueur du tableau. Syntaxe

arrayResize(arr, size[, extender])

Arguments

arr — Tableau à redimensionner. Array(T)
size — -La nouvelle longueur du tableau. Si size est inférieur à la taille d’origine du tableau, le tableau est tronqué à droite. Si size est supérieur à la taille initiale du tableau, le tableau est étendu à droite avec des valeurs extender ou les valeurs par défaut du type de données des éléments du tableau.
extender — Valeur à utiliser pour étendre le tableau. Peut être NULL.

Valeur renvoyée Un tableau de longueur size. Array(T) Exemples Exemple 1

Query

SELECT arrayResize([1], 3);

Response

[1,0,0]

Exemple 2

Query

SELECT arrayResize([1], 3, NULL);

Response

[1,NULL,NULL]

arrayReverse

Introduit dans : v1.1.0 Inverse l’ordre des éléments du tableau donné.

La fonction reverse(arr) remplit la même fonction, mais elle s’applique aussi à d’autres types de données en plus des Arrays.

Syntaxe

arrayReverse(arr)

Arguments

arr — Le tableau à inverser. Array(T)

Valeur renvoyée Renvoie un tableau de même taille que le tableau d’origine, contenant les éléments dans l’ordre inverse Array(T) Exemples Exemple d’utilisation

Query

SELECT arrayReverse([1, 2, 3])

Response

[3,2,1]

arrayReverseFill

Introduit dans : v20.1.0 La fonction arrayReverseFill traite séquentiellement un tableau source du dernier élément au premier, en évaluant une condition lambda à chaque position à l’aide d’éléments du tableau source et des tableaux de condition. Lorsque la condition renvoie false à la position i, la fonction remplace cet élément par l’élément à la position i+1 dans l’état actuel du tableau. Le dernier élément est toujours conservé, quelle que soit la condition. Syntaxe

arrayReverseFill(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

Arguments

func(x[, y1, ..., yN]) — Une fonction lambda qui s’applique aux éléments du tableau source (x) et des tableaux de conditions (y). Fonction lambda
source_arr — Le tableau source à traiter. Array(T)
[, cond1_arr, ... , condN_arr] — Facultatif. N tableaux de conditions fournissant des arguments supplémentaires à la fonction lambda. Array(T)

Valeur renvoyée Renvoie un tableau dont les éléments du tableau source sont remplacés par les résultats de la fonction lambda. Array(T) Exemples Exemple avec un seul tableau

Query

SELECT arrayReverseFill(x -> not isNull(x), [1, null, 2, null]) AS res

Response

[1, 2, 2, NULL]

Exemple avec deux tableaux

Query

SELECT arrayReverseFill(x, y, z -> x > y AND x < z, [5, 3, 6, 2], [4, 7, 1, 3], [10, 2, 8, 5]) AS res;

Response

[5, 6, 6, 2]

arrayReverseSort

Introduit dans : v1.1.0 Trie les éléments d’un tableau par ordre décroissant. Si une fonction f est spécifiée, le tableau fourni est trié en fonction du résultat de l’application de cette fonction aux éléments du tableau, puis le tableau trié est inversé. Si f accepte plusieurs arguments, la fonction arrayReverseSort reçoit plusieurs tableaux auxquels correspondront les arguments de func. Si le tableau à trier contient -Inf, NULL, NaN ou Inf, ces valeurs seront triées dans l’ordre suivant :

-Inf
Inf
NaN
NULL

arrayReverseSort est une fonction d’ordre supérieur. Syntaxe

arrayReverseSort([f,] arr [, arr1, ... ,arrN])

Arguments

f(y1[, y2 ... yN]) — La fonction lambda à appliquer aux éléments du tableau x. - arr — Un tableau à trier. Array(T) - arr1, ..., arrN — Facultatif. N tableaux supplémentaires, lorsque f accepte plusieurs arguments.

Valeur renvoyée Renvoie le tableau x trié par ordre décroissant si aucune fonction lambda n’est fournie ; sinon, renvoie un tableau trié selon la logique de la fonction lambda fournie, puis inversé. Array(T). Exemples Exemple 1

Query

SELECT arrayReverseSort((x, y) -> y, [4, 3, 5], ['a', 'b', 'c']) AS res;

Response

[5,3,4]

Exemple 2

Query

SELECT arrayReverseSort((x, y) -> -y, [4, 3, 5], [1, 2, 3]) AS res;

Response

[4,3,5]

arrayReverseSplit

Introduit dans : v20.1.0 Divise un tableau source en plusieurs tableaux. Lorsque func(x[, y1, ..., yN]) renvoie une valeur différente de zéro, le tableau est scindé à droite de l’élément. Le tableau n’est pas scindé après le dernier élément. Syntaxe

arrayReverseSplit(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

Arguments

func(x[, y1, ..., yN]) — Une fonction lambda qui s’applique aux éléments du tableau source (x) et des tableaux de condition (y). Fonction lambda
source_arr — Le tableau source à traiter. Fonction lambda
[, cond1_arr, ... , condN_arr] — Facultatif. N tableaux de condition fournissant des arguments supplémentaires à la fonction lambda. Array(T)

Valeur renvoyée Renvoie un tableau de tableaux. Array(Array(T)) Exemples Exemple d’utilisation

Query

SELECT arrayReverseSplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res

Response

[[1], [2, 3, 4], [5]]

arrayRotateLeft

Introduit dans : v23.8.0 Effectue une rotation d’un tableau vers la gauche du nombre d’éléments spécifié. Les valeurs négatives de n sont traitées comme une rotation vers la droite d’un nombre d’éléments égal à la valeur absolue de la rotation. Syntaxe

arrayRotateLeft(arr, n)

Arguments

arr — Le tableau dont les éléments doivent être décalés par rotation.Array(T). - n — Nombre d’éléments à décaler par rotation. (U)Int8/16/32/64.

Valeur renvoyée Un tableau décalé par rotation vers la gauche du nombre d’éléments spécifié Array(T) Exemples Exemple d’utilisation

Query

SELECT arrayRotateLeft([1,2,3,4,5,6], 2) as res;

Response

[3,4,5,6,1,2]

Valeur négative de n

Query

SELECT arrayRotateLeft([1,2,3,4,5,6], -2) as res;

Response

[5,6,1,2,3,4]

arrayRotateRight

Introduit dans : v23.8.0 Effectue une rotation du tableau vers la droite du nombre d’éléments spécifié. Les valeurs négatives de n correspondent à une rotation vers la gauche d’un nombre de positions égal à la valeur absolue de n. Syntaxe

arrayRotateRight(arr, n)

Arguments

arr — Le tableau dont les éléments doivent être décalés par rotation.Array(T). - n — Nombre d’éléments à décaler par rotation. (U)Int8/16/32/64.

Valeur renvoyée Un tableau décalé par rotation vers la droite du nombre d’éléments spécifié Array(T) Exemples Exemple d’utilisation

Query

SELECT arrayRotateRight([1,2,3,4,5,6], 2) as res;

Response

[5,6,1,2,3,4]

Valeur négative de n

Query

SELECT arrayRotateRight([1,2,3,4,5,6], -2) as res;

Response

[3,4,5,6,1,2]

arrayShiftLeft

Introduit dans : v23.8.0 Décale un tableau vers la gauche du nombre d’éléments indiqué. Les nouveaux éléments sont remplis avec l’argument fourni ou avec la valeur par défaut du type d’élément du tableau. Si le nombre d’éléments est négatif, le tableau est décalé vers la droite. Syntaxe

arrayShiftLeft(arr, n[, default])

Arguments

arr — Le tableau dont les éléments sont à décaler.Array(T). - n — Nombre d’éléments à décaler.(U)Int8/16/32/64. - default — Facultatif. Valeur par défaut des nouveaux éléments.

Valeur renvoyée Un tableau décalé vers la gauche du nombre d’éléments spécifié Array(T) Exemples Exemple d’utilisation

Query

SELECT arrayShiftLeft([1,2,3,4,5,6], 2) as res;

Response

[3,4,5,6,0,0]

Valeur négative de n

Query

SELECT arrayShiftLeft([1,2,3,4,5,6], -2) as res;

Response

[0,0,1,2,3,4]

Utiliser une valeur par défaut

Query

SELECT arrayShiftLeft([1,2,3,4,5,6], 2, 42) as res;

Response

[3,4,5,6,42,42]

arrayShiftRight

Introduit dans : v23.8.0 Décale un tableau vers la droite du nombre d’éléments spécifié. Les nouveaux éléments sont remplis par l’argument fourni ou par la valeur par défaut du type des éléments du tableau. Si le nombre d’éléments est négatif, le tableau est décalé vers la gauche. Syntaxe

arrayShiftRight(arr, n[, default])

Arguments

arr — Le tableau dont les éléments doivent être décalés. Array(T)
n — Nombre d’éléments à décaler. (U)Int8/16/32/64
default — Facultatif. Valeur par défaut des nouveaux éléments.

Valeur renvoyée Un tableau décalé vers la droite du nombre d’éléments spécifié Array(T) Exemples Exemple d’utilisation

Query

SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], 2) as res;

Response

[0, 0, 1, 2, 3, 4]

Valeur négative de n

Query

SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], -2) as res;

Response

[3, 4, 5, 6, 0, 0]

Utilisation d’une valeur par défaut

Query

SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], 2, 42) as res;

Response

[42, 42, 1, 2, 3, 4]

arrayShingles

Introduit dans : v24.1.0 Génère un tableau de shingles (semblables aux ngrams pour les chaînes), c’est-à-dire des sous-tableaux consécutifs de longueur spécifiée à partir du tableau d’entrée. Syntaxe

arrayShingles(arr, l)

Arguments

arr — Tableau à partir duquel générer un tableau de shingles. Array(T)
l — La longueur de chaque shingle. (U)Int*

Valeur renvoyée Un tableau contenant les shingles générés Array(T) Exemples Exemple d’utilisation

Query

SELECT arrayShingles([1, 2, 3, 4], 3) as res;

Response

[[1, 2, 3], [2, 3, 4]]

arrayShuffle

Introduite dans : v23.2.0 Renvoie un tableau de même taille que le tableau d’origine, contenant les éléments dans un ordre aléatoire. Les éléments sont réordonnés de sorte que chaque permutation possible a la même probabilité d’apparaître.

Cette fonction ne matérialise pas les constantes.

Syntaxe

arrayShuffle(arr [, seed])

Arguments

arr — Le tableau à mélanger. Array(T)
seed (optional) — Facultatif. Graine utilisée pour la génération de nombres aléatoires. Si elle n’est pas fournie, une graine aléatoire est utilisée. (U)Int*

Valeur renvoyée Tableau dont les éléments sont mélangés Array(T) Exemples Exemple sans graine (résultats non déterministes)

Query

SELECT arrayShuffle([1, 2, 3, 4]);

Response

[1,4,2,3]

Exemple sans seed (résultats stables)

Query

SELECT arrayShuffle([1, 2, 3, 4], 41);

Response

[3,2,1,4]

arraySimilarity

Introduit dans : v25.4.0 Calcule la similarité entre deux tableaux, de 0 à 1, sur la base de la distance de Levenshtein pondérée. Syntaxe

arraySimilarity(from, to, from_weights, to_weights)

Arguments

from — premier tableau Array(T)
to — second tableau Array(T)
from_weights — pondérations du premier tableau. Array((U)Int*|Float*)
to_weights — pondérations du second tableau. Array((U)Int*|Float*)

Valeur renvoyée Renvoie le degré de similarité entre 0 et 1 des deux tableaux, calculé à partir de la distance de Levenshtein pondérée Float64 Exemples Exemple d’utilisation

Query

SELECT arraySimilarity(['A', 'B', 'C'], ['A', 'K', 'L'], [1.0, 2, 3], [3.0, 4, 5]);

Response

0.2222222222222222

arraySlice

Introduit dans : v1.1.0 Renvoie une portion du tableau, en incluant les éléments NULL. Syntaxe

arraySlice(arr, offset [, length])

Arguments

arr — Tableau à découper. Array(T)
offset — Décalage à partir du bord du tableau. Une valeur positive indique un décalage à gauche, et une valeur négative un retrait à droite. La numérotation des éléments du tableau commence à 1. (U)Int*
length — Longueur de la tranche demandée. Si vous spécifiez une valeur négative, la fonction renvoie une tranche ouverte [offset, array_length - length]. Si vous omettez cette valeur, la fonction renvoie la tranche [offset, the_end_of_array]. (U)Int*

Valeur renvoyée Renvoie une tranche du tableau contenant length éléments à partir de l’offset spécifié Array(T) Exemples Exemple d’utilisation

Query

SELECT arraySlice([1, 2, NULL, 4, 5], 2, 3) AS res;

Response

[2, NULL, 4]

arraySort

Introduit dans : v1.1.0 Trie les éléments du tableau fourni dans l’ordre croissant. Si une fonction lambda f est spécifiée, l’ordre de tri est déterminé par le résultat de la fonction lambda appliquée à chaque élément du tableau. Si la fonction lambda accepte plusieurs arguments, la fonction arraySort reçoit plusieurs tableaux, auxquels correspondent les arguments de f. Si le tableau à trier contient -Inf, NULL, NaN ou Inf, ces valeurs seront triées dans l’ordre suivant :

-Inf
Inf
NaN
NULL

arraySort est une fonction d’ordre supérieur. Syntaxe

arraySort([f,] arr [, arr1, ... ,arrN])

Arguments

f(y1[, y2 ... yN]) — La fonction lambda à appliquer aux éléments du tableau x. - arr — Un tableau à trier. Array(T) - arr1, ..., arrN — Facultatif. N tableaux supplémentaires, lorsque f accepte plusieurs arguments.

Valeur renvoyée Renvoie le tableau arr trié par ordre croissant si aucune fonction lambda n’est fournie ; sinon, renvoie un tableau trié selon la logique de la fonction lambda fournie. Array(T). Exemples Exemple 1

Query

SELECT arraySort([1, 3, 3, 0]);

Response

[0,1,3,3]

Exemple 2

Query

SELECT arraySort(['hello', 'world', '!']);

Response

['!','hello','world']

Exemple 3

Query

SELECT arraySort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]);

Response

[-inf,-4,1,2,3,inf,nan,nan,NULL,NULL]

arraySplit

Introduit dans : v20.1.0 Scinde un tableau source en plusieurs tableaux. Lorsque func(x [, y1, ..., yN]) renvoie une valeur différente de zéro, le tableau est scindé juste avant l’élément. Le tableau n’est pas scindé avant le premier élément. Syntaxe

arraySplit(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

Arguments

func(x[, y1, ..., yN]) — Une fonction lambda qui s’applique aux éléments du tableau source (x) et des tableaux de conditions (y).Fonction lambda. - source_arr — Le tableau source à scinder Array(T). - [, cond1_arr, ... , condN_arr] — Facultatif. N tableaux de conditions fournissant des arguments supplémentaires à la fonction lambda. Array(T).

Valeur renvoyée Renvoie un tableau de tableaux Array(Array(T)) Exemples Exemple d’utilisation

Query

SELECT arraySplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res

Response

[[1, 2, 3], [4, 5]]

arraySum

Introduit dans : v21.1.0 Renvoie la somme des éléments du tableau source. Si une fonction lambda func est spécifiée, renvoie la somme des éléments issus des résultats de cette fonction lambda. Syntaxe

arraySum([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])

Arguments

func(x[, y1, ..., yN]) — Facultatif. Une fonction lambda qui s’applique aux éléments du tableau source (x) et des tableaux de condition (y). Fonction lambda
source_arr — Le tableau source à traiter. Array(T)
, cond1_arr, ... , condN_arr] — Facultatif. N tableaux de condition fournissant des arguments supplémentaires à la fonction lambda. Array(T)

Valeur renvoyée Retourne la somme des éléments du tableau source, ou la somme des éléments résultant de la fonction lambda si elle est fournie. Exemples Exemple simple

Query

SELECT arraySum([1, 2, 3, 4]);

Response

Utilisation avec une fonction lambda

Query

SELECT arraySum(x, y -> x+y, [1, 1, 1, 1], [1, 1, 1, 1]);

Response

arraySymmetricDifference

Introduite dans : v25.4.0 Accepte plusieurs tableaux et renvoie un tableau contenant les éléments qui ne sont pas présents dans tous les tableaux source. Le résultat ne contient que des valeurs uniques.

La différence symétrique de plus de deux ensembles est définie mathématiquement comme l’ensemble de tous les éléments d’entrée présents dans un nombre impair d’ensembles d’entrée. En revanche, la fonction arraySymmetricDifference renvoie simplement l’ensemble des éléments d’entrée qui ne sont pas présents dans tous les ensembles d’entrée.

Syntaxe

arraySymmetricDifference(arr1, arr2, ... , arrN)

Arguments

arrN — N tableaux à partir desquels le nouveau tableau est créé. Array(T).

Valeur renvoyée Renvoie un tableau contenant des éléments distincts qui ne sont pas présents dans tous les tableaux sources Array(T) Exemples Exemple d’utilisation

Query

SELECT
arraySymmetricDifference([1, 2], [1, 2], [1, 2]) AS empty_symmetric_difference,
arraySymmetricDifference([1, 2], [1, 2], [1, 3]) AS non_empty_symmetric_difference;

Response

┌─empty_symmetric_difference─┬─non_empty_symmetric_difference─┐
│ []                         │ [3,2]                          │
└────────────────────────────┴────────────────────────────────┘

arrayTopK

Introduit dans : v26.6.0 Renvoie un tableau des K plus grands éléments du tableau d’entrée, triés par ordre décroissant. Si une fonction lambda f est spécifiée, les éléments sont comparés en fonction du résultat de f appliqué à chaque élément. Si f accepte plusieurs arguments, des tableaux supplémentaires sont transmis à arrayTopK et leurs éléments correspondent aux arguments de f. Les valeurs NULL sont ignorées et n’apparaissent pas dans le résultat. La taille du résultat est au plus de K et peut être inférieure si le tableau d’entrée contient moins de K éléments non NULL. Le type d’élément du résultat est la version non nullable du type d’élément d’entrée. arrayTopK est une fonction d’ordre supérieur. Voir aussi arrayBottomK, qui renvoie à la place les K plus petits éléments. Syntaxe

arrayTopK([f,] K, arr [, arr1, ... ,arrN])

Arguments

f(arr[, arr1, ... ,arrN]) — Facultatif. Une fonction lambda qui calcule la clé de tri de chaque élément. fonction lambda
K — Le nombre des plus grands éléments à renvoyer. (U)Int8/16/32/64
arr — Un tableau. Array(T)
arr1, ... ,arrN — N tableaux supplémentaires, si f accepte plusieurs arguments. Array(T)

Valeur renvoyée Renvoie jusqu’à K éléments de arr ayant les valeurs les plus élevées (ou les résultats les plus élevés de la fonction lambda), triés par ordre décroissant. Les valeurs NULL sont ignorées. Le tableau renvoyé a pour type d’élément T, même lorsque l’entrée est de type Nullable(T). Exemples simple_int

Query

SELECT arrayTopK(3, [1, 5, 2, 7, 3])

Response

[7,5,3]

skip_nulls

Query

SELECT arrayTopK(3, [1, NULL, 5, 2, NULL, 7])

Response

[7,5,2]

fewer_than_k

Query

SELECT arrayTopK(5, [1, NULL, 2])

Response

[2,1]

lambda_simple

Query

SELECT arrayTopK((x) -> -x, 2, [5, 9, 1, 3])

Response

[1,3]

lambda_multi

Query

SELECT arrayTopK((x, y) -> y, 2, ['a', 'b', 'c'], [3, 1, 2])

Response

['a','c']

arrayTranspose

Introduit dans : v26.4.0 Transpose un tableau bidimensionnel. Tous les tableaux imbriqués doivent avoir la même longueur. Syntaxe

arrayTranspose(arr)

Arguments

arr — Un tableau bidimensionnel à transposer. Tous les sous-tableaux doivent avoir la même longueur. Array(Array(T))

Valeur renvoyée Un tableau bidimensionnel transposé dans lequel l’élément [i][j] du résultat est égal à l’élément [j][i] du tableau d’entrée. Array(Array(T)) Exemples Matrice carrée

Query

SELECT arrayTranspose([[1, 2], [3, 4]])

Response

[[1, 3], [2, 4]]

Matrice non carrée

Query

SELECT arrayTranspose([[1, 2, 3], [4, 5, 6]])

Response

[[1, 4], [2, 5], [3, 6]]

Éléments de type String

Query

SELECT arrayTranspose([['a', 'b'], ['c', 'd']])

Response

[['a', 'c'], ['b', 'd']]

arrayUnion

Introduit dans : v24.10.0 Prend plusieurs tableaux et renvoie un tableau contenant tous les éléments présents dans au moins l’un des tableaux sources. Le résultat ne contient que des valeurs uniques. Syntaxe

arrayUnion(arr1, arr2, ..., arrN)

Arguments

arrN — N tableaux à partir desquels créer le nouveau tableau. Array(T)

Valeur renvoyée Renvoie un tableau contenant les éléments distincts des tableaux source Array(T) Exemples Exemple d’utilisation

Query

SELECT
arrayUnion([-2, 1], [10, 1], [-2], []) as num_example,
arrayUnion(['hi'], [], ['hello', 'hi']) as str_example,
arrayUnion([1, 3, NULL], [2, 3, NULL]) as null_example

Response

┌─num_example─┬─str_example────┬─null_example─┐
│ [10,-2,1]   │ ['hello','hi'] │ [3,2,1,NULL] │
└─────────────┴────────────────┴──────────────┘

arrayUniq

Introduit dans : v1.1.0 Avec un seul argument, compte le nombre d’éléments distincts dans le tableau. Avec plusieurs arguments, compte le nombre de tuples distincts constitués d’éléments aux positions correspondantes dans plusieurs tableaux. Par exemple, SELECT arrayUniq([1,2], [3,4], [5,6]) formera les tuples suivants :

Position 1 : (1,3,5)
Position 2 : (2,4,6)

Il comptera ensuite le nombre de tuples uniques. Dans ce cas, 2. Tous les tableaux fournis doivent avoir la même longueur.

Si vous souhaitez obtenir une liste des éléments uniques d’un tableau, vous pouvez utiliser arrayReduce('groupUniqArray', arr).

Syntaxe

arrayUniq(arr1[, arr2, ..., arrN])

Arguments

arr1 — Tableau dont il faut compter le nombre d’éléments uniques. Array(T)
[, arr2, ..., arrN] — Facultatif. Tableaux supplémentaires utilisés pour compter le nombre de tuples uniques constitués des éléments aux positions correspondantes dans plusieurs tableaux. Array(T)

Valeur renvoyée Pour un seul argument, renvoie le nombre d’éléments uniques. Pour plusieurs arguments, renvoie le nombre de tuples uniques formés à partir des éléments aux positions correspondantes dans les tableaux. UInt32 Exemples Un seul argument

Query

SELECT arrayUniq([1, 1, 2, 2])

Response

Plusieurs arguments

Query

SELECT arrayUniq([1, 2, 3, 1], [4, 5, 6, 4])

Response

arrayWithConstant

Introduit dans : v20.1.0 Crée un tableau de longueur length, rempli de la constante x. Syntaxe

arrayWithConstant(N, x)

Arguments

length — Nombre d’éléments du tableau. (U)Int*
x — Valeur des N éléments du tableau, de n’importe quel type.

Valeur renvoyée Renvoie un Array contenant N éléments ayant pour valeur x. Array(T) Exemples Exemple d’utilisation

Query

SELECT arrayWithConstant(3, 1)

Response

[1, 1, 1]

arrayZip

Introduit dans : v20.1.0 Combine plusieurs tableaux en un seul. Le tableau obtenu contient, dans l’ordre indiqué des arguments, les éléments correspondants des tableaux sources, regroupés en tuples. Syntaxe

arrayZip(arr1, arr2, ... , arrN)

Arguments

arr1, arr2, ... , arrN — N tableaux à combiner en un seul tableau. Array(T)

Valeur renvoyée Renvoie un tableau dont les éléments des tableaux sources sont regroupés en tuples. Les types de données du tuple sont les mêmes que ceux des tableaux d’entrée, et dans le même ordre que celui dans lequel les tableaux sont transmis Array(T) Exemples Exemple d’utilisation

Query

SELECT arrayZip(['a', 'b', 'c'], [5, 2, 1]);

Response

[('a', 5), ('b', 2), ('c', 1)]

arrayZipUnaligned

Introduit dans : v20.1.0 Combine plusieurs tableaux en un seul, en autorisant des tableaux non alignés (de longueurs différentes). Le tableau obtenu contient les éléments correspondants des tableaux sources, regroupés en tuples dans l’ordre des arguments indiqués. Syntaxe

arrayZipUnaligned(arr1, arr2, ..., arrN)

Arguments

arr1, arr2, ..., arrN — N tableaux à combiner en un seul tableau. Array(T)

Valeur renvoyée Renvoie un tableau contenant des éléments des tableaux source regroupés en tuples. Les types de données du tuple sont identiques à ceux des tableaux d’entrée et dans le même ordre que celui dans lequel les tableaux sont transmis. Array(T) ou Tuple(T1, T2, ...) Exemples Exemple d’utilisation

Query

SELECT arrayZipUnaligned(['a'], [1, 2, 3]);

Response

[('a', 1),(NULL, 2),(NULL, 3)]

countEqual

Introduit dans : v1.1.0 Renvoie le nombre d’éléments du tableau dont la valeur est égale à x. Équivalent à arrayCount(elem -> elem = x, arr). Les éléments NULL sont traités comme des valeurs distinctes. Syntaxe

countEqual(arr, x)

Arguments

arr — Tableau dans lequel effectuer la recherche. Array(T)
x — Valeur à compter dans le tableau. N’importe quel type.

Valeur renvoyée Renvoie le nombre d’éléments du tableau égaux à x UInt64 Exemples Exemple d’utilisation

Query

SELECT countEqual([1, 2, NULL, NULL], NULL)

Response

empty

Introduit dans : v1.1.0 Vérifie si le tableau d’entrée est vide. Un tableau est considéré comme vide s’il ne contient aucun élément.

Peut être optimisée en activant le paramètre optimize_functions_to_subcolumns. Avec optimize_functions_to_subcolumns = 1, la fonction lit uniquement la subcolumn size0 au lieu de lire et de traiter toute la array column. La query SELECT empty(arr) FROM TABLE; est transformée en SELECT arr.size0 = 0 FROM TABLE;.

La fonction fonctionne également avec les Strings ou les UUIDs. Syntaxe

empty(arr)

Arguments

arr — Tableau en entrée. Array(T)

Valeur renvoyée Renvoie 1 pour un tableau vide ou 0 pour un tableau non vide UInt8 Exemples Exemple d’utilisation

Query

SELECT empty([]);

Response

emptyArrayDate

Introduit dans : v1.1.0 Renvoie un Array de Date vide Syntaxe

emptyArrayDate()

Arguments

Aucun.

Valeur renvoyée Un tableau Date vide. Array(T) Exemples Exemple d’utilisation

Query

SELECT emptyArrayDate

Response

[]

emptyArrayDateTime

Introduit dans : v1.1.0 Renvoie un tableau DateTime vide Syntaxe

emptyArrayDateTime()

Arguments

Aucun.

Valeur retournée Un tableau DateTime vide. Array(T) Exemples Exemple d’utilisation

Query

SELECT emptyArrayDateTime

Response

[]

emptyArrayFloat32

Introduit dans : v1.1.0 Renvoie un tableau vide de Float32 Syntaxe

emptyArrayFloat32()

Arguments

Aucun.

Valeur renvoyée Un tableau vide de Float32. Array(T) Exemples Exemple d’utilisation

Query

SELECT emptyArrayFloat32

Response

[]

emptyArrayFloat64

Introduit dans : v1.1.0 Renvoie un tableau(Float64) vide Syntaxe

emptyArrayFloat64()

Arguments

Aucun.

Valeur renvoyée Un tableau Float64 vide. Array(T) Exemples Exemple d’utilisation

Query

SELECT emptyArrayFloat64

Response

[]

emptyArrayInt16

Introduit dans : v1.1.0 Renvoie un tableau Int16 vide Syntaxe

emptyArrayInt16()

Arguments

Aucun.

Valeur renvoyée Un tableau vide de type Int16. Array(T) Exemples Exemple d’utilisation

Query

SELECT emptyArrayInt16

Response

[]

emptyArrayInt32

Introduit dans : v1.1.0 Renvoie un tableau Int32 vide Syntaxe

emptyArrayInt32()

Arguments

Aucun.

Valeur renvoyée Un tableau Int32 vide. Array(T) Exemples Exemple d’utilisation

Query

SELECT emptyArrayInt32

Response

[]

emptyArrayInt64

Introduit dans : v1.1.0 Renvoie un tableau Int64 vide Syntaxe

emptyArrayInt64()

Arguments

Aucun.

Valeur renvoyée Un tableau Int64 vide. Array(T) Exemples Exemple d’utilisation

Query

SELECT emptyArrayInt64

Response

[]

emptyArrayInt8

Disponible à partir de : v1.1.0 Renvoie un tableau vide de type Int8 Syntaxe

emptyArrayInt8()

Arguments

Aucun.

Valeur renvoyée Un tableau Int8 vide. Array(T) Exemples Exemple d’utilisation

Query

SELECT emptyArrayInt8

Response

[]

emptyArrayString

Introduit dans : v1.1.0 Renvoie un tableau vide de String Syntaxe

emptyArrayString()

Arguments

Aucun.

Valeur renvoyée Un tableau vide de String. Array(T) Exemples Exemple d’utilisation

Query

SELECT emptyArrayString

Response

[]

emptyArrayToSingle

Introduit dans : v1.1.0 Accepte un tableau vide et renvoie un tableau d’un seul élément correspondant à la valeur par défaut. Syntaxe

emptyArrayToSingle(arr)

Arguments

arr — Un tableau vide. Array(T)

Valeur renvoyée Un tableau contenant une seule valeur du type par défaut du tableau. Array(T) Exemples Exemple simple

Query

CREATE TABLE test (
  a Array(Int32),
  b Array(String),
  c Array(DateTime)
)
ENGINE = MergeTree
ORDER BY tuple();

INSERT INTO test VALUES ([], [], []);

SELECT emptyArrayToSingle(a), emptyArrayToSingle(b), emptyArrayToSingle(c) FROM test;

Response

┌─emptyArrayToSingle(a)─┬─emptyArrayToSingle(b)─┬─emptyArrayToSingle(c)───┐
│ [0]                   │ ['']                  │ ['1970-01-01 01:00:00'] │
└───────────────────────┴───────────────────────┴─────────────────────────┘

emptyArrayUInt16

Introduit dans : v1.1.0 Renvoie un tableau UInt16 vide Syntaxe

emptyArrayUInt16()

Arguments

Aucun.

Valeur retournée Un tableau UInt16 vide. Array(T) Exemples Exemple d’utilisation

Query

SELECT emptyArrayUInt16

Response

[]

emptyArrayUInt32

Introduit dans : v1.1.0 Renvoie un tableau vide de UInt32 Syntaxe

emptyArrayUInt32()

Arguments

Aucun.

Valeur renvoyée Un tableau UInt32 vide. Array(T) Exemples Exemple d’utilisation

Query

SELECT emptyArrayUInt32

Response

[]

emptyArrayUInt64

Introduit dans : v1.1.0 Renvoie un tableau UInt64 vide Syntaxe

emptyArrayUInt64()

Arguments

Aucun.

Valeur de retour Un tableau UInt64 vide. Array(T) Exemples Exemple d’utilisation

Query

SELECT emptyArrayUInt64

Response

[]

emptyArrayUInt8

Introduit dans : v1.1.0 Renvoie un tableau UInt8 vide Syntaxe

emptyArrayUInt8()

Arguments

Aucun.

Valeur de retour Un tableau UInt8 vide. Array(T) Exemples Exemple d’utilisation

Query

SELECT emptyArrayUInt8

Response

[]

has

Introduit dans : v1.1.0 Indique si le tableau contient l’élément spécifié, si la map contient la clé spécifiée ou si l’objet JSON contient le chemin spécifié. Pour JSON, les chemins imbriqués sont pris en charge avec la notation par points (par ex., ‘a.b.c’). Lorsque le premier argument est un tableau constant et que le deuxième argument est une colonne ou une expression, has(constant_array, column) se comporte comme column IN (constant_array) et peut utiliser la clé primaire ainsi que les index de saut de données pour l’optimisation. Par exemple, has([1, 10, 100], id) peut exploiter l’index de clé primaire si id fait partie de la PRIMARY KEY. Cette optimisation s’applique également lorsque la colonne est enveloppée dans des fonctions monotones (par ex., has([...], toDate(ts))). Syntaxe

has(haystack, needle)

Arguments

haystack — Le tableau source, la map ou le JSON. Array ou Map ou JSON
needle — La valeur à rechercher (élément du tableau, clé de la map ou chaîne de chemin dans le JSON).

Valeur renvoyée Renvoie 1 si haystack contient le needle spécifié, sinon 0. UInt8 Exemples Utilisation de base de tableau

Query

SELECT has([1, 2, 3], 2)

Response

tableau introuvable

Query

SELECT has([1, 2, 3], 4)

Response

Utilisation de base du type Map

Query

SELECT has(map('a', 1, 'b', 2), 'b')

Response

Chemin JSON

Query

SELECT has('{"a": {"b": 1}}'::JSON, 'a.b')

Response

hasAll

Introduit dans : v1.1.0 Vérifie si un tableau est un sous-ensemble d’un autre.

Un tableau vide est un sous-ensemble de tout tableau.
Null est traité comme une valeur.
L’ordre des valeurs dans les deux tableaux n’a pas d’importance.

Syntaxe

hasAll(set, subset)

Arguments

set — tableau de n’importe quel type contenant un ensemble d’éléments. Array(T)
subset — tableau de n’importe quel type partageant un supertype commun avec set et contenant des éléments dont il faut vérifier qu’ils constituent un sous-ensemble de set. Array(T)

Valeur renvoyée

1, si set contient tous les éléments de subset.
0, sinon.

Lève une exception NO_COMMON_TYPE si les éléments de set et de subset ne partagent pas de supertype commun. Exemples Tableaux vides

Query

SELECT hasAll([], [])

Response

Tableaux contenant des valeurs NULL

Query

SELECT hasAll([1, Null], [Null])

Response

Tableaux contenant des valeurs d’un type différent

Query

SELECT hasAll([1.0, 2, 3, 4], [1, 3])

Response

Tableaux contenant des valeurs de type String

Query

SELECT hasAll(['a', 'b'], ['a'])

Response

Tableaux sans type en commun

Query

SELECT hasAll([1], ['a'])

Response

Raises a NO_COMMON_TYPE exception

Tableau de tableaux

Query

SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [3, 5]])

Response

hasAny

Introduit dans : v1.1.0 Vérifie si deux tableaux ont des éléments en commun.

Null est traité comme une valeur.
L’ordre des valeurs dans les deux tableaux n’a pas d’importance.

Syntaxe

hasAny(arr_x, arr_y)

Arguments

arr_x — tableau de n’importe quel type contenant un ensemble d’éléments. Array(T)
arr_y — tableau de n’importe quel type partageant un supertype commun avec le tableau arr_x. Array(T)

Valeur renvoyée

1, si arr_x et arr_y ont au moins un élément en commun.
0, sinon.

Lève une exception NO_COMMON_TYPE si l’un des éléments des deux tableaux ne partage pas de supertype commun. Exemples Un tableau est vide

Query

SELECT hasAny([1], [])

Response

Tableaux avec des valeurs NULL

Query

SELECT hasAny([Null], [Null, 1])

Response

Tableaux contenant des valeurs d’un autre type

Query

SELECT hasAny([-128, 1., 512], [1])

Response

Tableaux sans type commun

Query

SELECT hasAny([[1, 2], [3, 4]], ['a', 'c'])

Response

Raises a `NO_COMMON_TYPE` exception

Tableau de tableaux

Query

SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [1, 2]])

Response

hasSubstr

Introduit dans : v20.6.0 Vérifie si tous les éléments de array2 apparaissent dans array1 dans exactement le même ordre. La fonction renvoie donc 1 si, et seulement si, array1 = préfixe + array2 + suffixe. Autrement dit, la fonction vérifie si tous les éléments de array2 sont présents dans array1, comme le fait la fonction hasAll. En outre, elle vérifie que les éléments apparaissent dans le même ordre dans array1 et array2.

La fonction renverra 1 si array2 est vide.
NULL est traité comme une valeur. Autrement dit, hasSubstr([1, 2, NULL, 3, 4], [2,3]) renverra 0. En revanche, hasSubstr([1, 2, NULL, 3, 4], [2,NULL,3]) renverra 1
L’ordre des valeurs dans les deux tableaux est important.

Lève une exception NO_COMMON_TYPE si certains éléments des deux tableaux n’ont pas de supertype commun. Syntaxe

hasSubstr(arr1, arr2)

Arguments

arr1 — tableau de n’importe quel type contenant un ensemble d’éléments. Array(T)
arr2 — tableau de n’importe quel type contenant un ensemble d’éléments. Array(T)

Valeur renvoyée Renvoie 1 si le tableau arr1 contient le tableau arr2. Sinon, renvoie 0. UInt8 Exemples Les deux tableaux sont vides

Query

SELECT hasSubstr([], [])

Response

Tableaux contenant des valeurs NULL

Query

SELECT hasSubstr([1, Null], [Null])

Response

Tableaux contenant des valeurs de type différent

Query

SELECT hasSubstr([1.0, 2, 3, 4], [1, 3])

Response

Tableaux contenant des chaînes de caractères

Query

SELECT hasSubstr(['a', 'b'], ['a'])

Response

Tableaux dont l’ordre est valide

Query

SELECT hasSubstr(['a', 'b' , 'c'], ['a', 'b'])

Response

Tableaux avec un ordre incorrect

Query

SELECT hasSubstr(['a', 'b' , 'c'], ['a', 'c'])

Response

tableau de tableaux

Query

SELECT hasSubstr([[1, 2], [3, 4], [5, 6]], [[1, 2], [3, 4]])

Response

Tableaux sans type en commun

Query

SELECT hasSubstr([1, 2, NULL, 3, 4], ['a'])

Response

Raises a `NO_COMMON_TYPE` exception

indexOf

Introduit dans : v1.1.0 Renvoie l’indice du premier élément de valeur ‘x’ (à partir de 1) s’il se trouve dans le tableau. Si le tableau ne contient pas la valeur recherchée, la fonction renvoie 0. Les éléments définis sur NULL sont traités comme des valeurs normales. Syntaxe

indexOf(arr, x)

Arguments

arr — Tableau dans lequel rechercher x. Array(T)
x — Valeur du premier élément correspondant dans arr dont l’indice doit être renvoyé. UInt64

Valeur renvoyée Renvoie l’indice (numéroté à partir de 1) du premier x dans arr s’il existe. Sinon, renvoie 0. UInt64 Exemples Exemple de base

Query

SELECT indexOf([5, 4, 1, 3], 3)

Response

Tableau contenant des valeurs NULL

Query

SELECT indexOf([1, 3, NULL, NULL], NULL)

Response

indexOfAssumeSorted

Introduit dans : v24.12.0 Renvoie l’indice du premier élément de valeur ‘x’ (à partir de 1) s’il se trouve dans le tableau. Si le tableau ne contient pas la valeur recherchée, la fonction renvoie 0.

Contrairement à la fonction indexOf, cette fonction suppose que le tableau est trié par ordre croissant. Si le tableau n’est pas trié, les résultats sont indéfinis.

Syntaxe

indexOfAssumeSorted(arr, x)

Arguments

arr — Un tableau trié dans lequel effectuer la recherche. Array(T)
x — Valeur du premier élément correspondant dans arr trié dont l’indice doit être renvoyé. UInt64

Valeur renvoyée Renvoie l’indice (numéroté à partir de 1) du premier x dans arr s’il existe. Sinon, renvoie 0. UInt64 Exemples Exemple simple

Query

SELECT indexOfAssumeSorted([1, 3, 3, 3, 4, 4, 5], 4)

Response

kql_array_sort_asc

Introduit dans : v23.10.0 Trie un ou plusieurs tableaux par ordre croissant. Le premier tableau est trié, puis les tableaux suivants sont réordonnés pour correspondre à l’ordre de tri du premier tableau. Les valeurs NULL sont placées à la fin. Il s’agit d’une fonction de compatibilité KQL (Kusto Query Language). Syntaxe

kql_array_sort_asc(array1[, array2, ..., nulls_last])

Arguments

array1 — Le tableau à trier. Array(T)
array2 — Facultatif. Tableaux supplémentaires à réordonner selon l’ordre de tri de array1. Array(T)
nulls_last — Facultatif. Booléen indiquant si les valeurs nulles doivent apparaître en dernier. La valeur par défaut est true. UInt8

Valeur renvoyée Renvoie un tuple de tableaux triés par ordre croissant. Tuple(Array, ...) Exemples Utilisation de base

Query

SELECT kql_array_sort_asc([3, 1, 2])

Response

([1, 2, 3])

kql_array_sort_desc

Introduit dans : v23.10.0 Trie un ou plusieurs tableaux par ordre décroissant. Le premier tableau est trié, et les tableaux suivants sont réorganisés selon l’ordre trié du premier tableau. Les valeurs NULL sont placées à la fin. Il s’agit d’une fonction de compatibilité KQL (Kusto Query Language). Syntaxe

kql_array_sort_desc(array1[, array2, ..., nulls_last])

Arguments

array1 — Le tableau à trier. Array(T)
array2 — Tableaux supplémentaires facultatifs à réordonner selon l’ordre de tri de array1. Array(T)
nulls_last — Booléen facultatif indiquant si les valeurs NULL doivent apparaître en dernier. La valeur par défaut est true. UInt8

Valeur renvoyée Renvoie un tuple de tableaux triés par ordre décroissant. Tuple(Array, ...) Exemples Utilisation de base

Query

SELECT kql_array_sort_desc([3, 1, 2])

Response

([3, 2, 1])

length

Introduit dans : v1.1.0 Calcule la longueur d’une chaîne ou d’un tableau.

Pour les arguments String ou FixedString : calcule le nombre d’octets de la chaîne.
Pour les arguments Array : calcule le nombre d’éléments du tableau.
Si elle est appliquée à un argument FixedString, la fonction est une expression constante.

Veuillez noter que le nombre d’octets d’une chaîne n’est pas le même que le nombre de points de code Unicode (“code points”), ni que le nombre de “grappes de graphèmes” Unicode (ce que nous appelons habituellement des “caractères”), ni que la largeur d’affichage de la chaîne. Les octets NULL ASCII sont autorisés dans les chaînes et seront également comptés. Syntaxe

length(x)

Alias : CARDINALITY, OCTET_LENGTH Arguments

x — Valeur pour laquelle calculer le nombre d’octets (pour String/FixedString) ou d’éléments (pour Array). String ou FixedString ou Array(T)

Valeur renvoyée Renvoie le nombre d’octets de la String/FixedString x / le nombre d’éléments du tableau x UInt64 Exemples Exemple de chaîne

Query

SELECT length('Hello, world!')

Response

Exemple : Array

Query

SELECT length(['Hello', 'world'])

Response

exemple de constexpr

Query

WITH 'hello' || toString(number) AS str
SELECT str,
isConstant(length(str)) AS str_length_is_constant,
isConstant(length(str::FixedString(6))) AS fixed_str_length_is_constant
FROM numbers(3)

Response

┌─str────┬─str_length_is_constant─┬─fixed_str_length_is_constant─┐
│ hello0 │                      0 │                            1 │
│ hello1 │                      0 │                            1 │
│ hello2 │                      0 │                            1 │
└────────┴────────────────────────┴──────────────────────────────┘

exemple Unicode

Query

SELECT 'ёлка' AS str1, length(str1), lengthUTF8(str1), normalizeUTF8NFKD(str1) AS str2, length(str2), lengthUTF8(str2)

Response

┌─str1─┬─length(str1)─┬─lengthUTF8(str1)─┬─str2─┬─length(str2)─┬─lengthUTF8(str2)─┐
│ ёлка │            8 │                4 │ ёлка │           10 │                5 │
└──────┴──────────────┴──────────────────┴──────┴──────────────┴──────────────────┘

ascii_vs_utf8 exemple

Query

SELECT 'ábc' AS str, length(str), lengthUTF8(str)

Response

┌─str─┬─length(str)──┬─lengthUTF8(str)─┐
│ ábc │            4 │               3 │
└─────┴──────────────┴─────────────────┘

notEmpty

Introduit dans : v1.1.0 Vérifie si le tableau en entrée n’est pas vide. Un tableau est considéré comme non vide s’il contient au moins un élément.

Cette fonction peut être optimisée en activant le paramètre optimize_functions_to_subcolumns. Avec optimize_functions_to_subcolumns = 1, la fonction lit uniquement la sous-colonne size0, au lieu de lire et traiter toute la colonne de tableau. La requête SELECT notEmpty(arr) FROM table est transformée en SELECT arr.size0 != 0 FROM TABLE.

La fonction fonctionne également avec les chaînes de caractères et les UUIDs. Syntaxe

notEmpty(arr)

Arguments

arr — Tableau en entrée. Array(T)

Valeur renvoyée Renvoie 1 pour un tableau non vide ou 0 pour un tableau vide UInt8 Exemples Exemple d’utilisation

Query

SELECT notEmpty([1,2]);

Response

range

Introduit dans : v1.1.0 Renvoie un tableau de nombres de start à end - 1, par pas de step. Les types pris en charge sont :

UInt8/16/32/64
Int8/16/32/64]
Tous les arguments start, end, step doivent être de l’un des types pris en charge ci-dessus. Les éléments du tableau renvoyé seront d’un supertype des arguments.
Une exception est levée si la fonction renvoie un tableau dont la longueur totale dépasse le nombre d’éléments spécifié par le paramètre function_range_max_elements_in_block.
Renvoie NULL si l’un des arguments est de type Nullable(nothing). Une exception est levée si l’un des arguments a la valeur NULL (type Nullable(T)).

Syntaxe

range([start, ] end [, step])

Arguments

start — Facultatif. Le premier élément du tableau. Obligatoire si step est utilisé. Valeur par défaut : 0. - end — Obligatoire. Le nombre jusqu’auquel le tableau est construit. - step — Facultatif. Détermine le pas entre chaque élément du tableau. Valeur par défaut : 1.

Valeur renvoyée Tableau de nombres allant de start à end - 1, avec un pas de step. Array(T) Exemples Exemple d’utilisation

Query

SELECT range(5), range(1, 5), range(1, 5, 2), range(-1, 5, 2);

Response

┌─range(5)────┬─range(1, 5)─┬─range(1, 5, 2)─┬─range(-1, 5, 2)─┐
│ [0,1,2,3,4] │ [1,2,3,4]   │ [1,3]          │ [-1,1,3]        │
└─────────────┴─────────────┴────────────────┴─────────────────┘

replicate

Introduit dans : v1.1.0 Crée un tableau contenant une seule valeur. Syntaxe

replicate(x, arr)

Arguments

x — La valeur avec laquelle remplir le tableau résultant. Any
arr — Un tableau. Array(T)

Valeur renvoyée Renvoie un tableau de même longueur que arr, rempli avec la valeur x. Array(T) Exemples Exemple d’utilisation

Query

SELECT replicate(1, ['a', 'b', 'c']);

Response

┌─replicate(1, ['a', 'b', 'c'])───┐
│ [1, 1, 1]                       │
└─────────────────────────────────┘

reverse

Introduit dans : v1.1.0 Inverse l’ordre des éléments du tableau d’entrée ou des caractères de la chaîne d’entrée. Syntaxe

reverse(arr | str)

Arguments

arr | str — Le tableau source ou la chaîne. Array(T) ou String

Valeur renvoyée Renvoie un tableau ou une chaîne dont l’ordre des éléments ou des caractères est inversé. Exemples Tableau inversé

Query

SELECT reverse([1, 2, 3, 4]);

Response

[4, 3, 2, 1]

Inverser une chaîne de caractères

Query

SELECT reverse('abcd');

Response

'dcba'

Fonctions de distance

Toutes les fonctions prises en charge sont décrites dans la documentation sur les fonctions de distance.

​array

​arrayAUCPR

​arrayAll

​arrayAutocorrelation

​arrayAvg

​arrayBottomK

​arrayCompact

​arrayConcat

​arrayCount

​arrayCumSum

​arrayCumSumNonNegative

​arrayDifference

​arrayDistinct

​arrayDotProduct

​arrayElement

​arrayElementOrNull

​arrayEnumerate

​arrayEnumerateDense

​arrayEnumerateDenseRanked

​arrayEnumerateUniq

​arrayEnumerateUniqRanked

​arrayExcept

​arrayExists

​arrayFill

​arrayFilter

​arrayFirst

​arrayFirstIndex

​arrayFirstOrNull

​arrayFlatten

​arrayFold

​arrayIntersect

​arrayJaccardIndex

​arrayJoin

​arrayLast

​arrayLastIndex

​arrayLastOrNull

​arrayLevenshteinDistance

​arrayLevenshteinDistanceWeighted

​arrayMap

​arrayMax

​arrayMin

​arrayNormalizedGini

​arrayPartialReverseSort

​arrayPartialShuffle

​arrayPartialSort

​arrayPopBack

​arrayPopFront

​arrayProduct

​arrayPushBack

​arrayPushFront

​arrayROCAUC

​arrayRandomSample

​arrayReduce

​arrayReduceInRanges

​arrayRemove

​arrayResize

​arrayReverse

​arrayReverseFill

​arrayReverseSort

​arrayReverseSplit

​arrayRotateLeft

​arrayRotateRight

​arrayShiftLeft

​arrayShiftRight

​arrayShingles

​arrayShuffle

​arraySimilarity

​arraySlice

​arraySort

​arraySplit

​arraySum

​arraySymmetricDifference

​arrayTopK

​arrayTranspose

​arrayUnion

​arrayUniq

​arrayWithConstant

​arrayZip

​arrayZipUnaligned

​countEqual

array

arrayAUCPR

arrayAll

arrayAutocorrelation

arrayAvg

arrayBottomK

arrayCompact

arrayConcat

arrayCount

arrayCumSum

arrayCumSumNonNegative

arrayDifference

arrayDistinct

arrayDotProduct

arrayElement

arrayElementOrNull

arrayEnumerate

arrayEnumerateDense

arrayEnumerateDenseRanked

arrayEnumerateUniq

arrayEnumerateUniqRanked

arrayExcept

arrayExists

arrayFill

arrayFilter

arrayFirst

arrayFirstIndex

arrayFirstOrNull

arrayFlatten

arrayFold

arrayIntersect

arrayJaccardIndex

arrayJoin

arrayLast

arrayLastIndex

arrayLastOrNull

arrayLevenshteinDistance

arrayLevenshteinDistanceWeighted

arrayMap

arrayMax

arrayMin

arrayNormalizedGini

arrayPartialReverseSort

arrayPartialShuffle

arrayPartialSort

arrayPopBack

arrayPopFront

arrayProduct

arrayPushBack

arrayPushFront

arrayROCAUC

arrayRandomSample

arrayReduce

arrayReduceInRanges

arrayRemove

arrayResize

arrayReverse

arrayReverseFill

arrayReverseSort

arrayReverseSplit

arrayRotateLeft

arrayRotateRight

arrayShiftLeft

arrayShiftRight

arrayShingles

arrayShuffle

arraySimilarity

arraySlice

arraySort

arraySplit

arraySum

arraySymmetricDifference

arrayTopK

arrayTranspose

arrayUnion

arrayUniq

arrayWithConstant

arrayZip

arrayZipUnaligned

countEqual