> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-fbfa8bee.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> Documentation des fonctions liées à Array
# Fonctions Array
{/*AUTOGENERATED_START*/}
## 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**
```sql theme={null}
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)`](/fr/reference/data-types/array)
**Exemples**
**Utilisation valide**
```sql title=Query theme={null}
SELECT array(toInt32(1), toUInt16(2), toInt8(3)) AS a, toTypeName(a)
```
```response title=Response theme={null}
┌─a───────┬─toTypeName(a)─┐
│ [1,2,3] │ Array(Int32) │
└─────────┴───────────────┘
```
**Utilisation incorrecte**
```sql title=Query theme={null}
SELECT array(toInt32(5), toDateTime('1998-06-16'), toInt8(5)) AS a, toTypeName(a)
```
```response title=Response theme={null}
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](https://developers.google.com/machine-learning/glossary#pr-auc-area-under-the-pr-curve), [ici](https://developers.google.com/machine-learning/crash-course/classification/roc-and-auc#expandable-1) et [ici](https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve).
**Syntaxe**
```sql theme={null}
arrayAUCPR(scores, labels[, partial_offsets])
```
**Alias** : `arrayPRAUC`
**Arguments**
* `cores` — Scores fournis par le modèle de prédiction. [`Array((U)Int*)`](/fr/reference/data-types/array) or [`Array(Float*)`](/fr/reference/data-types/array)
* `labels` — Étiquettes des échantillons, généralement 1 pour un échantillon positif et 0 pour un échantillon négatif. [`Array((U)Int*)`](/fr/reference/data-types/array) or [`Array(Enum)`](/fr/reference/data-types/array)
* `partial_offsets` —
* Facultatif. Un [`Array(T)`](/fr/reference/data-types/array) 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`](/fr/reference/data-types/float)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT arrayAUCPR([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);
```
```response title=Response theme={null}
┌─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**
```sql theme={null}
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`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — Le tableau source à traiter. [`Array(T)`](/fr/reference/data-types/array)
* `cond1_arr, ...` — Facultatif. N tableaux de condition fournissant des arguments supplémentaires à la fonction lambda. [`Array(T)`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoie `1` si la fonction lambda renvoie `true` pour tous les éléments, `0` sinon [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Tous les éléments correspondent**
```sql title=Query theme={null}
SELECT arrayAll(x, y -> x=y, [1, 2, 3], [1, 2, 3])
```
```response title=Response theme={null}
1
```
**Certains éléments ne correspondent pas**
```sql title=Query theme={null}
SELECT arrayAll(x, y -> x=y, [1, 2, 3], [1, 1, 1])
```
```response title=Response theme={null}
0
```
## 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**
```sql theme={null}
arrayAutocorrelation(arr, [max_lag])
```
**Arguments**
* `arr` — Tableau de nombres. [`Array(T)`](/fr/reference/data-types/array)
* `max_lag` — Facultatif. Nombre maximal de retards à calculer. Doit être un entier non négatif. [`Integer`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie un tableau de `Float64`. Renvoie `NaN` si la variance est égale à 0. [`Array(Float64)`](/fr/reference/data-types/array)
**Exemples**
**Linéaire**
```sql title=Query theme={null}
SELECT arrayAutocorrelation([1, 2, 3, 4, 5]);
```
```response title=Response theme={null}
[1, 0.4, -0.1, -0.4, -0.4]
```
**Symétrique**
```sql title=Query theme={null}
SELECT arrayAutocorrelation([10, 20, 10]);
```
```response title=Response theme={null}
[1, -0.6666666666666669, 0.16666666666666674]
```
**Constante**
```sql title=Query theme={null}
SELECT arrayAutocorrelation([5, 5, 5]);
```
```response title=Response theme={null}
[nan, nan, nan]
```
**Limité**
```sql title=Query theme={null}
SELECT arrayAutocorrelation([1, 2, 3, 4, 5], 2);
```
```response title=Response theme={null}
[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**
```sql theme={null}
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`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — Le tableau source à traiter. [`Array(T)`](/fr/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — Facultatif. N tableaux de conditions fournissant des arguments supplémentaires à la fonction lambda. [`Array(T)`](/fr/reference/data-types/array)
**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`](/fr/reference/data-types/float)
**Exemples**
**Exemple de base**
```sql title=Query theme={null}
SELECT arrayAvg([1, 2, 3, 4]);
```
```response title=Response theme={null}
2.5
```
**Utilisation avec une fonction lambda**
```sql title=Query theme={null}
SELECT arrayAvg(x, y -> x*y, [2, 3], [2, 3]) AS res;
```
```response title=Response theme={null}
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](/fr/reference/functions/regular-functions/overview#higher-order-functions).
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**
```sql theme={null}
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`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `K` — Le nombre de plus petits éléments à renvoyer. [`(U)Int8/16/32/64`](/fr/reference/data-types/int-uint)
* `arr` — Un tableau. [`Array(T)`](/fr/reference/data-types/array)
* `arr1, ... ,arrN` — N tableaux supplémentaires, si `f` accepte plusieurs arguments. [`Array(T)`](/fr/reference/data-types/array)
**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**
```sql title=Query theme={null}
SELECT arrayBottomK(3, [1, 5, 2, 7, 3])
```
```response title=Response theme={null}
[1,2,3]
```
**skip\_nulls**
```sql title=Query theme={null}
SELECT arrayBottomK(3, [1, NULL, 5, 2, NULL, 7])
```
```response title=Response theme={null}
[1,2,5]
```
**fewer\_than\_k**
```sql title=Query theme={null}
SELECT arrayBottomK(5, [1, NULL, 2])
```
```response title=Response theme={null}
[1,2]
```
**lambda\_simple**
```sql title=Query theme={null}
SELECT arrayBottomK((x) -> -x, 2, [5, 9, 1, 3])
```
```response title=Response theme={null}
[9,5]
```
**lambda\_multi**
```sql title=Query theme={null}
SELECT arrayBottomK((x, y) -> y, 2, ['a', 'b', 'c'], [3, 1, 2])
```
```response title=Response theme={null}
['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**
```sql theme={null}
arrayCompact(arr)
```
**Arguments**
* `arr` — Un tableau dont les doublons doivent être supprimés. [`Array(T)`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoie un tableau sans doublons [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT arrayCompact([1, 1, nan, nan, 2, 3, 3, 3]);
```
```response title=Response theme={null}
[1,nan,2,3]
```
## arrayConcat
Introduit dans : v1.1.0
Combine les tableaux fournis en argument.
**Syntaxe**
```sql theme={null}
arrayConcat(arr1 [, arr2, ... , arrN])
```
**Arguments**
* `arr1 [, arr2, ... , arrN]` — N tableaux à concaténer. [`Array(T)`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoie un tableau unique obtenu à partir des tableaux fournis en arguments. [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT arrayConcat([1, 2], [3, 4], [5, 6]) AS res
```
```response title=Response theme={null}
[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](/fr/reference/functions/regular-functions/overview#higher-order-functions).
**Syntaxe**
```sql theme={null}
arrayCount([func, ] arr1, ...)
```
**Arguments**
* `func` — Facultatif. Fonction à appliquer à chaque élément du ou des tableaux. [`fonction lambda`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr1, ..., arrN` — N tableaux. [`Array(T)`](/fr/reference/data-types/array)
**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`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT arrayCount(x -> (x % 2), groupArray(number)) FROM numbers(10)
```
```response title=Response theme={null}
5
```
## 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**
```sql theme={null}
arrayCumSum([func,] arr1[, arr2, ... , arrN])
```
**Arguments**
* `func` — Facultatif. Fonction lambda à appliquer aux éléments du tableau à chaque position. [`fonction lambda`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr1` — Le tableau source de valeurs numériques. [`Array(T)`](/fr/reference/data-types/array)
* `[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)`](/fr/reference/data-types/array)
**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)`](/fr/reference/data-types/array)
**Exemples**
**Utilisation de base**
```sql title=Query theme={null}
SELECT arrayCumSum([1, 1, 1, 1]) AS res
```
```response title=Response theme={null}
[1, 2, 3, 4]
```
**Avec une fonction lambda**
```sql title=Query theme={null}
SELECT arrayCumSum(x -> x * 2, [1, 2, 3]) AS res
```
```response title=Response theme={null}
[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**
```sql theme={null}
arrayCumSumNonNegative([func,] arr1[, arr2, ... , arrN])
```
**Arguments**
* `func` — Facultatif. Une fonction lambda à appliquer aux éléments du tableau à chaque position. [`fonction lambda`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr1` — Le tableau source de valeurs numériques. [`Array(T)`](/fr/reference/data-types/array)
* `[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)`](/fr/reference/data-types/array)
**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)`](/fr/reference/data-types/array)
**Exemples**
**Utilisation de base**
```sql title=Query theme={null}
SELECT arrayCumSumNonNegative([1, 1, -4, 1]) AS res
```
```response title=Response theme={null}
[1, 2, 0, 1]
```
**Avec une fonction lambda**
```sql title=Query theme={null}
SELECT arrayCumSumNonNegative(x -> x * 2, [1, -2, 3]) AS res
```
```response title=Response theme={null}
[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**
```sql theme={null}
arrayDifference(arr)
```
**Arguments**
* `arr` — Tableau pour lequel calculer les différences entre des éléments consécutifs. [`Array(T)`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoie un tableau contenant les différences entre les éléments consécutifs du tableau [`UInt*`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT arrayDifference([1, 2, 3, 4]);
```
```response title=Response theme={null}
[0,1,1,1]
```
**Exemple de dépassement de capacité dû au type de résultat Int64**
```sql title=Query theme={null}
SELECT arrayDifference([0, 10000000000000000000]);
```
```response title=Response theme={null}
┌─arrayDifference([0, 10000000000000000000])─┐
│ [0,-8446744073709551616] │
└────────────────────────────────────────────┘
```
## arrayDistinct
Introduit dans : v1.1.0
Renvoie un tableau contenant uniquement les éléments distincts d’un tableau.
**Syntaxe**
```sql theme={null}
arrayDistinct(arr)
```
**Arguments**
* `arr` — Tableau à partir duquel extraire les éléments distincts. [`Array(T)`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoie un tableau contenant les éléments distincts [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT arrayDistinct([1, 2, 2, 3, 1]);
```
```response title=Response theme={null}
[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**
```sql theme={null}
arrayDotProduct(v1, v2)
```
**Arguments**
* `v1` — Premier vecteur. [`Array((U)Int* | Float* | Decimal)`](/fr/reference/data-types/array) ou [`Tuple((U)Int* | Float* | Decimal)`](/fr/reference/data-types/tuple)
* `v2` — Deuxième vecteur. [`Array((U)Int* | Float* | Decimal)`](/fr/reference/data-types/array) ou [`Tuple((U)Int* | Float* | Decimal)`](/fr/reference/data-types/tuple)
**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*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
**Exemples**
**Exemple avec Array**
```sql title=Query theme={null}
SELECT arrayDotProduct([1, 2, 3], [4, 5, 6]) AS res, toTypeName(res);
```
```response title=Response theme={null}
32 UInt16
```
**Exemple de Tuple**
```sql title=Query theme={null}
SELECT dotProduct((1::UInt16, 2::UInt8, 3::Float32),(4::Int16, 5::Float32, 6::UInt8)) AS res, toTypeName(res);
```
```response title=Response theme={null}
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**
```sql theme={null}
arrayElement(arr, n)
```
**Arguments**
* `arr` — Le tableau à parcourir. [`Array(T)`](/fr/reference/data-types/array). - `n` — Position de l'élément à récupérer. [`(U)Int*`](/fr/reference/data-types/int-uint).
**Valeur renvoyée**
Renvoie un tableau unique combiné à partir des arguments de tableau fournis [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT arrayElement(arr, 2) FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
2
```
**Indices négatifs**
```sql title=Query theme={null}
SELECT arrayElement(arr, -1) FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
3
```
**Utiliser la notation \[n]**
```sql title=Query theme={null}
SELECT arr[2] FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
2
```
**Indice hors limites du tableau**
```sql title=Query theme={null}
SELECT arrayElement(arr, 4) FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
0
```
## 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.
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.
**Syntaxe**
```sql theme={null}
arrayElementOrNull(arrays)
```
**Arguments**
* `arrays` — Nombre arbitraire d'arguments de type tableau. [`Array`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoie un seul tableau combiné à partir des arguments de tableau fournis. [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT arrayElementOrNull(arr, 2) FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
2
```
**Indices négatifs**
```sql title=Query theme={null}
SELECT arrayElementOrNull(arr, -1) FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
3
```
**Indice hors limites du tableau**
```sql title=Query theme={null}
SELECT arrayElementOrNull(arr, 4) FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
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`](/fr/reference/statements/select/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**
```sql theme={null}
arrayEnumerate(arr)
```
**Arguments**
* `arr` — Le tableau à énumérer. [`Array`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoie le tableau `[1, 2, 3, ..., length (arr)]`. [`Array(UInt32)`](/fr/reference/data-types/array)
**Exemples**
**Exemple de base avec ARRAY JOIN**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─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**
```sql theme={null}
arrayEnumerateDense(arr)
```
**Arguments**
* `arr` — Le tableau à énumérer. [`Array(T)`](/fr/reference/data-types/array)
**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)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT arrayEnumerateDense([10, 20, 10, 30])
```
```response title=Response theme={null}
[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**
```sql theme={null}
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*`](/fr/reference/data-types/int-uint)
* `arr` — Tableau à N dimensions à énumérer. [`Array(T)`](/fr/reference/data-types/array)
* `max_array_depth` — Profondeur effective maximale. Doit être inférieure ou égale à la profondeur de `arr`. [`UInt*`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie un tableau indiquant où chaque élément apparaît pour la première fois dans le tableau source [`Array`](/fr/reference/data-types/array)
**Exemples**
**Utilisation de base**
```sql title=Query theme={null}
-- 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 title=Response theme={null}
[1,2,1,3]
```
**Utilisation avec un tableau multidimensionnel**
```sql title=Query theme={null}
-- 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 title=Response theme={null}
[[1,1,2,3],[4,5,1,2]]
```
**Exemple avec clear\_depth augmenté**
```sql title=Query theme={null}
-- 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 title=Response theme={null}
[[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**
```sql theme={null}
arrayEnumerateUniq(arr1[, arr2, ... , arrN])
```
**Arguments**
* `arr1` — Premier tableau à traiter. [`Array(T)`](/fr/reference/data-types/array)
* `arr2, ...` — Facultatif. Tableaux supplémentaires de même taille pour garantir l’unicité des tuples. [`Array(UInt32)`](/fr/reference/data-types/array)
**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)`](/fr/reference/data-types/array)
**Exemples**
**Utilisation de base**
```sql title=Query theme={null}
SELECT arrayEnumerateUniq([10, 20, 10, 30]);
```
```response title=Response theme={null}
[1, 1, 2, 1]
```
**Plusieurs arrays**
```sql title=Query theme={null}
SELECT arrayEnumerateUniq([1, 1, 1, 2, 2, 2], [1, 1, 2, 1, 1, 2]);
```
```response title=Response theme={null}
[1,2,1,1,2,1]
```
**Agrégation avec ARRAY JOIN**
```sql title=Query theme={null}
-- 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 title=Response theme={null}
┌──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**
```sql theme={null}
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*`](/fr/reference/data-types/int-uint)
* `arr` — Tableau à N dimensions à énumérer. [`Array(T)`](/fr/reference/data-types/array)
* `max_array_depth` — Profondeur effective maximale. Entier positif inférieur ou égal à la profondeur de `arr`. [`UInt*`](/fr/reference/data-types/int-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)`](/fr/reference/data-types/array)
**Exemples**
**Exemple 1**
```sql title=Query theme={null}
-- 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 title=Response theme={null}
[1, 1, 2]
```
**Exemple 2**
```sql title=Query theme={null}
-- 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 title=Response theme={null}
[1, 1, 2]
```
**Exemple 3**
```sql title=Query theme={null}
-- 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 title=Response theme={null}
[[1, 1, 1], [2, 3, 2], [2]]
```
**Exemple 4**
```sql title=Query theme={null}
-- 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 title=Response theme={null}
[[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 :
1. L’ordre des éléments de `source` est préservé
2. Les doublons de `source` sont conservés s’ils n’existent pas dans `except`
3. NULL est traité comme une valeur distincte
**Syntaxe**
```sql theme={null}
arrayExcept(source, except)
```
**Arguments**
* `source` — Le tableau source contenant les éléments à filtrer. [`Array(T)`](/fr/reference/data-types/array)
* `except` — Le tableau contenant les éléments à exclure du résultat. [`Array(T)`](/fr/reference/data-types/array)
**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)`](/fr/reference/data-types/array)
**Exemples**
**basic**
```sql title=Query theme={null}
SELECT arrayExcept([1, 2, 3, 2, 4], [3, 5])
```
```response title=Response theme={null}
[1, 2, 2, 4]
```
**with\_nulls1**
```sql title=Query theme={null}
SELECT arrayExcept([1, NULL, 2, NULL], [2])
```
```response title=Response theme={null}
[1, NULL, NULL]
```
**with\_nulls2**
```sql title=Query theme={null}
SELECT arrayExcept([1, NULL, 2, NULL], [NULL, 2, NULL])
```
```response title=Response theme={null}
[1]
```
**chaînes**
```sql title=Query theme={null}
SELECT arrayExcept(['apple', 'banana', 'cherry'], ['banana', 'date'])
```
```response title=Response theme={null}
['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**
```sql theme={null}
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`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — Le tableau source à traiter. [`Array(T)`](/fr/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — Facultatif. N tableaux de condition fournissant des arguments supplémentaires à la fonction lambda. [`Array(T)`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoie `1` si la fonction lambda renvoie `true` pour au moins un élément, sinon `0` [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT arrayExists(x, y -> x=y, [1, 2, 3], [0, 0, 0])
```
```response title=Response theme={null}
0
```
## 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**
```sql theme={null}
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`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — Le tableau source à traiter. [`fonction lambda`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `[, cond1_arr, ... , condN_arr]` — Facultatif. N tableaux de condition fournissant des arguments supplémentaires à la fonction lambda. [`Array(T)`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoie un tableau [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple avec un seul tableau**
```sql title=Query theme={null}
SELECT arrayFill(x -> not isNull(x), [1, null, 2, null]) AS res
```
```response title=Response theme={null}
[1, 1, 2, 2]
```
**Exemple avec deux tableaux**
```sql title=Query theme={null}
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 title=Response theme={null}
[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**
```sql theme={null}
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`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — Le tableau source à traiter. [`Array(T)`](/fr/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — Facultatif. N tableaux de condition fournissant des arguments supplémentaires à la fonction lambda. [`Array(T)`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoie un sous-ensemble du tableau source [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple 1**
```sql title=Query theme={null}
SELECT arrayFilter(x -> x LIKE '%World%', ['Hello', 'abc World']) AS res
```
```response title=Response theme={null}
['abc World']
```
**Exemple 2**
```sql title=Query theme={null}
SELECT
arrayFilter(
(i, x) -> x LIKE '%World%',
arrayEnumerate(arr),
['Hello', 'abc World'] AS arr)
AS res
```
```response title=Response theme={null}
[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**
```sql theme={null}
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](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda). - `source_arr` — Le tableau source à traiter. [`Array(T)`](/fr/reference/data-types/array). - `[, cond1_arr, ... , condN_arr]` — Facultatif. N tableaux de condition fournissant des arguments supplémentaires à la fonction lambda. [`Array(T)`](/fr/reference/data-types/array).
**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**
```sql title=Query theme={null}
SELECT arrayFirst(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])
```
```response title=Response theme={null}
b
```
**Aucune correspondance**
```sql title=Query theme={null}
SELECT arrayFirst(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)
```
```response title=Response theme={null}
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**
```sql theme={null}
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](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda). - `source_arr` — Le tableau source à traiter. [`Array(T)`](/fr/reference/data-types/array). - `[, cond1_arr, ... , condN_arr]` — Facultatif. N tableaux de condition fournissant des arguments supplémentaires à la fonction lambda. [`Array(T)`](/fr/reference/data-types/array).
**Valeur renvoyée**
Renvoie l’indice du premier élément du tableau source pour lequel `func` est vrai ; sinon, renvoie `0` [`UInt32`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT arrayFirstIndex(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])
```
```response title=Response theme={null}
2
```
**Aucune correspondance**
```sql title=Query theme={null}
SELECT arrayFirstIndex(x, y -> x=y, ['a', 'b', 'c'], ['d', 'e', 'f'])
```
```response title=Response theme={null}
0
```
## 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**
```sql theme={null}
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`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — Le tableau source à traiter. [`Array(T)`](/fr/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — Facultatif. N tableaux de condition fournissant des arguments supplémentaires à la fonction lambda. [`Array(T)`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoie le premier élément du tableau source pour lequel `func` est vrai ; sinon, renvoie `NULL`.
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT arrayFirstOrNull(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])
```
```response title=Response theme={null}
b
```
**Aucun résultat**
```sql title=Query theme={null}
SELECT arrayFirstOrNull(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)
```
```response title=Response theme={null}
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**
```sql theme={null}
arrayFlatten(arr)
```
**Alias** : `flatten`
**Arguments**
* `arr` — Un tableau multidimensionnel. [`Array(Array(T))`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoie un tableau aplati [`Array(T)`](/fr/reference/data-types/array) à partir du tableau multidimensionnel.
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT arrayFlatten([[[1]], [[2], [3]]]);
```
```response title=Response theme={null}
[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**
```sql theme={null}
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`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr1 [, arr2, arr3, ... arrN]` — N tableaux sur lesquels effectuer l'opération. [`Array(T)`](/fr/reference/data-types/array)
* `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**
```sql title=Query theme={null}
SELECT arrayFold(acc,x -> acc + x*2, [1, 2, 3, 4], 3::Int64) AS res;
```
```response title=Response theme={null}
23
```
**Suite de Fibonacci**
```sql title=Query theme={null}
SELECT arrayFold(acc, x -> (acc.2, acc.2 + acc.1),range(number),(1::Int64, 0::Int64)).1 AS fibonacci FROM numbers(1,10);
```
```response title=Response theme={null}
┌─fibonacci─┐
│ 0 │
│ 1 │
│ 1 │
│ 2 │
│ 3 │
│ 5 │
│ 8 │
│ 13 │
│ 21 │
│ 34 │
└───────────┘
```
**Exemple avec plusieurs tableaux**
```sql title=Query theme={null}
SELECT arrayFold(
(acc, x, y) -> acc + (x * y),
[1, 2, 3, 4],
[10, 20, 30, 40],
0::Int64
) AS res;
```
```response title=Response theme={null}
300
```
## 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**
```sql theme={null}
arrayIntersect(arr, arr1, ..., arrN)
```
**Arguments**
* `arrN` — N tableaux à partir desquels former le nouveau tableau. [`Array(T)`](/fr/reference/data-types/array).
**Valeur renvoyée**
Renvoie un tableau contenant les éléments distincts présents dans les N tableaux [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
arrayIntersect([1, 2], [1, 3], [2, 3]) AS empty_intersection,
arrayIntersect([1, 2], [1, 3], [1, 4]) AS non_empty_intersection
```
```response title=Response theme={null}
┌─empty_intersection─┬─non_empty_intersection─┐
│ [] │ [1] │
└────────────────────┴────────────────────────┘
```
## arrayJaccardIndex
Introduit dans : v23.7.0
Renvoie l’[indice de Jaccard](https://en.wikipedia.org/wiki/Jaccard_index) de deux tableaux.
**Syntaxe**
```sql theme={null}
arrayJaccardIndex(arr_x, arr_y)
```
**Arguments**
* `arr_x` — Premier tableau. [`Array(T)`](/fr/reference/data-types/array)
* `arr_y` — Deuxième tableau. [`Array(T)`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoie l’indice de Jaccard entre `arr_x` et `arr_y` [`Float64`](/fr/reference/data-types/float)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT arrayJaccardIndex([1, 2], [2, 3]) AS res
```
```response title=Response theme={null}
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**
```sql theme={null}
arrayJoin(arr)
```
**Alias** : `unnest`
**Arguments**
* `arr` — Un tableau à déplier. [`Array(T)`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoie un ensemble de lignes obtenues en dépliant `arr`.
**Exemples**
**Utilisation de base**
```sql title=Query theme={null}
SELECT arrayJoin([1, 2, 3] AS src) AS dst, 'Hello', src
```
```response title=Response theme={null}
┌─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**
```sql title=Query theme={null}
-- 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 title=Response theme={null}
┌─impressions─┐
│ 2 │
└─────────────┘
```
**Utiliser plusieurs fonctions arrayJoin**
```sql title=Query theme={null}
- 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 title=Response theme={null}
┌─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**
```sql title=Query theme={null}
-- 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 title=Response theme={null}
┌─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**
```sql title=Query theme={null}
-- 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 title=Response theme={null}
┌─impressions─┬─city─────┬─browser─┐
│ 1 │ Istanbul │ Firefox │
│ 1 │ Berlin │ Chrome │
│ 1 │ Bobruisk │ Chrome │
└─────────────┴──────────┴─────────┘
```
**Utiliser Tuple**
```sql title=Query theme={null}
-- 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 title=Response theme={null}
┌─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**
```sql theme={null}
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](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda). - `source` — Le tableau source à traiter. [`Array(T)`](/fr/reference/data-types/array). - `[, cond1, ... , condN]` — Facultatif. N tableaux de condition fournissant des arguments supplémentaires à la fonction lambda. [`Array(T)`](/fr/reference/data-types/array).
**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**
```sql title=Query theme={null}
SELECT arrayLast(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c'])
```
```response title=Response theme={null}
c
```
**Aucune correspondance**
```sql title=Query theme={null}
SELECT arrayFirst(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)
```
```response title=Response theme={null}
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**
```sql theme={null}
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`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — Le tableau source à traiter. [`Array(T)`](/fr/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — Facultatif. N tableaux de condition fournissant des arguments supplémentaires à la fonction lambda. [`Array(T)`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoie l’indice du dernier élément du tableau source pour lequel `func` est true, sinon renvoie `0` [`UInt32`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT arrayLastIndex(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c']);
```
```response title=Response theme={null}
3
```
**Aucune correspondance**
```sql title=Query theme={null}
SELECT arrayLastIndex(x, y -> x=y, ['a', 'b', 'c'], ['d', 'e', 'f']);
```
```response title=Response theme={null}
0
```
## 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**
```sql theme={null}
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](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda). - `source_arr` — Le tableau source à traiter. [`Array(T)`](/fr/reference/data-types/array). - `[, cond1_arr, ... , condN_arr]` — Facultatif. N tableaux de condition fournissant des arguments supplémentaires à la fonction lambda. [`Array(T)`](/fr/reference/data-types/array).
**Valeur renvoyée**
Retourne le dernier élément du tableau source pour lequel `λ` n’est pas true, sinon retourne `NULL`.
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT arrayLastOrNull(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c'])
```
```response title=Response theme={null}
c
```
**Aucune correspondance**
```sql title=Query theme={null}
SELECT arrayLastOrNull(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)
```
```response title=Response theme={null}
NULL Nullable(UInt8)
```
## arrayLevenshteinDistance
Introduit dans : v25.4.0
Calcule la distance de Levenshtein entre deux tableaux.
**Syntaxe**
```sql theme={null}
arrayLevenshteinDistance(from, to)
```
**Arguments**
* `from` — Le premier tableau. [`Array(T)`](/fr/reference/data-types/array). - `to` — Le deuxième tableau. [`Array(T)`](/fr/reference/data-types/array).
**Valeur renvoyée**
Distance de Levenshtein entre le premier tableau et le deuxième. [`Float64`](/fr/reference/data-types/float)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT arrayLevenshteinDistance([1, 2, 4], [1, 2, 3])
```
```response title=Response theme={null}
1
```
## 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**
```sql theme={null}
arrayLevenshteinDistanceWeighted(from, to, from_weights, to_weights)
```
**Arguments**
* `from` — premier tableau. [`Array(T)`](/fr/reference/data-types/array). - `to` — deuxième tableau. [`Array(T)`](/fr/reference/data-types/array). - `from_weights` — poids du premier tableau. [`Array((U)Int*|Float*)`](/fr/reference/data-types/array)
* `to_weights` — poids du deuxième tableau. [`Array((U)Int*|Float*)`](/fr/reference/data-types/array)
**Valeur renvoyée**
Distance de Levenshtein entre le premier et le deuxième tableaux, avec des poids personnalisés pour chaque élément [`Float64`](/fr/reference/data-types/float)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT arrayLevenshteinDistanceWeighted(['A', 'B', 'C'], ['A', 'K', 'L'], [1.0, 2, 3], [3.0, 4, 5])
```
```response title=Response theme={null}
14
```
## arrayMap
Introduit dans : v1.1.0
Renvoie un tableau obtenu à partir des tableaux d’origine en appliquant une fonction lambda à chaque élément.
**Syntaxe**
```sql theme={null}
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`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr` — N tableaux à traiter. [`Array(T)`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoie un tableau contenant les résultats de la fonction lambda [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT arrayMap(x -> (x + 2), [1, 2, 3]) as res;
```
```response title=Response theme={null}
[3, 4, 5]
```
**Création d’un tuple d’éléments à partir de plusieurs tableaux**
```sql title=Query theme={null}
SELECT arrayMap((x, y) -> (x, y), [1, 2, 3], [4, 5, 6]) AS res
```
```response title=Response theme={null}
[(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**
```sql theme={null}
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`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — Le tableau source à traiter. [`Array(T)`](/fr/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — Facultatif. N tableaux de condition fournissant des arguments supplémentaires à la fonction lambda. [`Array(T)`](/fr/reference/data-types/array)
**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**
```sql title=Query theme={null}
SELECT arrayMax([5, 3, 2, 7]);
```
```response title=Response theme={null}
7
```
**Utilisation d'une fonction lambda**
```sql title=Query theme={null}
SELECT arrayMax(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);
```
```response title=Response theme={null}
12
```
## 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**
```sql theme={null}
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`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — Tableau source à traiter. [`Array(T)`](/fr/reference/data-types/array)
* `cond1_arr, ...` — Facultatif. N tableaux de conditions fournissant des arguments supplémentaires à la fonction lambda. [`Array(T)`](/fr/reference/data-types/array)
**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**
```sql title=Query theme={null}
SELECT arrayMin([5, 3, 2, 7]);
```
```response title=Response theme={null}
2
```
**Utilisation avec une fonction lambda**
```sql title=Query theme={null}
SELECT arrayMin(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);
```
```response title=Response theme={null}
4
```
## arrayNormalizedGini
Introduit dans : v25.1.0
Calcule le coefficient de Gini normalisé.
**Syntaxe**
```sql theme={null}
arrayNormalizedGini(predicted, label)
```
**Arguments**
* `predicted` — La valeur prédite. [`Array(T)`](/fr/reference/data-types/array)
* `label` — La valeur réelle. [`Array(T)`](/fr/reference/data-types/array)
**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)`](/fr/reference/data-types/tuple)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT arrayNormalizedGini([0.9, 0.3, 0.8, 0.7],[6, 1, 0, 2]);
```
```response title=Response theme={null}
(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**
```sql theme={null}
arrayPartialReverseSort([f,] limit, arr [, arr1, ... ,arrN])
```
**Arguments**
* `f(arr[, arr1, ... ,arrN])` — La fonction lambda à appliquer aux éléments du tableau `x`. [`Fonction lambda`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `limit` — Valeur d’indice jusqu’à laquelle le tri s’effectue. [`(U)Int*`](/fr/reference/data-types/int-uint)
* `arr` — Tableau à trier. [`Array(T)`](/fr/reference/data-types/array)
* `arr1, ... ,arrN` — N tableaux supplémentaires, dans le cas où `f` accepte plusieurs arguments. [`Array(T)`](/fr/reference/data-types/array)
**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**
```sql title=Query theme={null}
SELECT arrayPartialReverseSort(2, [5, 9, 1, 3])
```
```response title=Response theme={null}
[9, 5, 1, 3]
```
**simple\_string**
```sql title=Query theme={null}
SELECT arrayPartialReverseSort(2, ['expenses','lasso','embolism','gladly'])
```
```response title=Response theme={null}
['lasso','gladly','expenses','embolism']
```
**retain\_sorted**
```sql title=Query theme={null}
SELECT arrayResize(arrayPartialReverseSort(2, [5, 9, 1, 3]), 2)
```
```response title=Response theme={null}
[9, 5]
```
**lambda\_simple**
```sql title=Query theme={null}
SELECT arrayPartialReverseSort((x) -> -x, 2, [5, 9, 1, 3])
```
```response title=Response theme={null}
[1, 3, 5, 9]
```
**lambda\_complex**
```sql title=Query theme={null}
SELECT arrayPartialReverseSort((x, y) -> -y, 1, [0, 1, 2], [1, 2, 3]) as res
```
```response title=Response theme={null}
[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`](#arrayShuffle) complet.
**Syntaxe**
```sql theme={null}
arrayPartialShuffle(arr [, limit[, seed]])
```
**Arguments**
* `arr` — Le tableau à mélanger. [`Array(T)`](/fr/reference/data-types/array)
* `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*`](/fr/reference/data-types/int-uint)
* `limit` — Facultatif. Le nombre d’échanges d’éléments à limiter, dans l’intervalle `[1..N]`. [`(U)Int*`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Tableau dont les éléments sont partiellement mélangés. [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**no\_limit1**
```sql title=Query theme={null}
SELECT arrayPartialShuffle([1, 2, 3, 4], 0)
```
```response title=Response theme={null}
[2, 4, 3, 1]
```
**no\_limit2**
```sql title=Query theme={null}
SELECT arrayPartialShuffle([1, 2, 3, 4])
```
```response title=Response theme={null}
[4, 1, 3, 2]
```
**random\_seed**
```sql title=Query theme={null}
SELECT arrayPartialShuffle([1, 2, 3, 4], 2)
```
```response title=Response theme={null}
[3, 4, 1, 2]
```
**explicit\_seed**
```sql title=Query theme={null}
SELECT arrayPartialShuffle([1, 2, 3, 4], 2, 41)
```
```response title=Response theme={null}
[3, 2, 1, 4]
```
**matérialiser**
```sql title=Query theme={null}
SELECT arrayPartialShuffle(materialize([1, 2, 3, 4]), 2, 42), arrayPartialShuffle([1, 2, 3], 2, 42) FROM numbers(10)
```
```response title=Response theme={null}
┌─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**
```sql theme={null}
arrayPartialSort([f,] limit, arr [, arr1, ... ,arrN])
```
**Arguments**
* `f(arr[, arr1, ... ,arrN])` — La fonction lambda à appliquer aux éléments du tableau `x`. [`fonction lambda`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `limit` — Valeur d’index jusqu’à laquelle le tri est effectué. [`(U)Int*`](/fr/reference/data-types/int-uint)
* `arr` — Tableau à trier. [`Array(T)`](/fr/reference/data-types/array)
* `arr1, ... ,arrN` — N tableaux supplémentaires, lorsque `f` accepte plusieurs arguments. [`Array(T)`](/fr/reference/data-types/array)
**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**
```sql title=Query theme={null}
SELECT arrayPartialSort(2, [5, 9, 1, 3])
```
```response title=Response theme={null}
[1, 3, 5, 9]
```
**simple\_string**
```sql title=Query theme={null}
SELECT arrayPartialSort(2, ['expenses', 'lasso', 'embolism', 'gladly'])
```
```response title=Response theme={null}
['embolism', 'expenses', 'gladly', 'lasso']
```
**retain\_sorted**
```sql title=Query theme={null}
SELECT arrayResize(arrayPartialSort(2, [5, 9, 1, 3]), 2)
```
```response title=Response theme={null}
[1, 3]
```
**lambda\_simple**
```sql title=Query theme={null}
SELECT arrayPartialSort((x) -> -x, 2, [5, 9, 1, 3])
```
```response title=Response theme={null}
[9, 5, 1, 3]
```
**lambda\_complex**
```sql title=Query theme={null}
SELECT arrayPartialSort((x, y) -> -y, 1, [0, 1, 2], [1, 2, 3]) as res
```
```response title=Response theme={null}
[2, 1, 0]
```
## arrayPopBack
Introduit dans : v1.1.0
Supprime le dernier élément du tableau.
**Syntaxe**
```sql theme={null}
arrayPopBack(arr)
```
**Arguments**
* `arr` — Le tableau dont il faut supprimer le dernier élément. [`Array(T)`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoie un tableau identique à `arr`, mais sans son dernier élément [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT arrayPopBack([1, 2, 3]) AS res;
```
```response title=Response theme={null}
[1, 2]
```
## arrayPopFront
Introduit dans : v1.1.0
Supprime le premier élément du tableau.
**Syntaxe**
```sql theme={null}
arrayPopFront(arr)
```
**Arguments**
* `arr` — Le tableau dont le premier élément doit être supprimé. [`Array(T)`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoie un tableau identique à `arr`, mais sans son premier élément [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT arrayPopFront([1, 2, 3]) AS res;
```
```response title=Response theme={null}
[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**
```sql theme={null}
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`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — Le tableau source à traiter. [`Array(T)`](/fr/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — Facultatif. N tableaux de conditions fournissant des arguments supplémentaires à la fonction lambda. [`Array(T)`](/fr/reference/data-types/array)
**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`](/fr/reference/data-types/float)
**Exemples**
**Exemple de base**
```sql title=Query theme={null}
SELECT arrayProduct([1, 2, 3, 4]);
```
```response title=Response theme={null}
24
```
**Utilisation avec une fonction lambda**
```sql title=Query theme={null}
SELECT arrayProduct(x, y -> x+y, [2, 2], [2, 2]) AS res;
```
```response title=Response theme={null}
16
```
## arrayPushBack
Introduit dans : v1.1.0
Ajoute un élément à la fin du tableau.
**Syntaxe**
```sql theme={null}
arrayPushBack(arr, x)
```
**Arguments**
* `arr` — Le tableau à la fin duquel ajouter la valeur `x`. [`Array(T)`](/fr/reference/data-types/array)
* `x` —
* Valeur unique à ajouter à la fin du tableau. [`Array(T)`](/fr/reference/data-types/array).
- 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](/fr/reference/data-types/index).
**Valeur renvoyée**
Renvoie un tableau identique à `arr`, mais avec une valeur `x` supplémentaire à la fin du tableau [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT arrayPushBack(['a'], 'b') AS res;
```
```response title=Response theme={null}
['a','b']
```
## arrayPushFront
Introduite dans : v1.1.0
Ajoute un élément au début du tableau.
**Syntaxe**
```sql theme={null}
arrayPushFront(arr, x)
```
**Arguments**
* `arr` — Tableau auquel ajouter la valeur `x` à la fin. [`Array(T)`](/fr/reference/data-types/array). - `x` —
* Valeur unique à ajouter au début du tableau. [`Array(T)`](/fr/reference/data-types/array).
- 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](/fr/reference/data-types/index).
**Valeur renvoyée**
Renvoie un tableau identique à `arr`, mais avec une valeur supplémentaire `x` au début du tableau [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT arrayPushFront(['b'], 'a') AS res;
```
```response title=Response theme={null}
['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](https://developers.google.com/machine-learning/glossary#pr-auc-area-under-the-pr-curve), [ici](https://developers.google.com/machine-learning/crash-course/classification/roc-and-auc#expandable-1) et [ici](https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve).
**Syntaxe**
```sql theme={null}
arrayROCAUC(scores, labels[, scale[, partial_offsets]])
```
**Alias** : `arrayAUC`
**Arguments**
* `scores` — Scores produits par le modèle de prédiction. [`Array((U)Int*)`](/fr/reference/data-types/array) ou [`Array(Float*)`](/fr/reference/data-types/array)
* `labels` — Étiquettes des échantillons, généralement 1 pour un échantillon positif et 0 pour un échantillon négatif. [`Array((U)Int*)`](/fr/reference/data-types/array) ou [`Enum`](/fr/reference/data-types/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`](/fr/reference/data-types/boolean)
* `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](/fr/reference/data-types/array) d’[entiers](/fr/reference/data-types/int-uint) 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`](/fr/reference/data-types/float)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT arrayROCAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);
```
```response title=Response theme={null}
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**
```sql theme={null}
arrayRandomSample(arr, samples)
```
**Arguments**
* `arr` — Le tableau d'entrée ou le tableau multidimensionnel à partir duquel prélever des éléments. [`Array(T)`](/fr/reference/data-types/array)
* `samples` — Le nombre d'éléments à inclure dans l'échantillon aléatoire. [`(U)Int*`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Un tableau contenant un échantillon aléatoire d'éléments du tableau d'entrée [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT arrayRandomSample(['apple', 'banana', 'cherry', 'date'], 2) as res;
```
```response title=Response theme={null}
['cherry','apple']
```
**Utiliser un tableau multidimensionnel**
```sql title=Query theme={null}
SELECT arrayRandomSample([[1, 2], [3, 4], [5, 6]], 2) as res;
```
```response title=Response theme={null}
[[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**
```sql theme={null}
arrayReduce(agg_f, arr1[, arr2, ... , arrN])
```
**Arguments**
* `agg_f` — Nom d’une fonction d’agrégation, qui doit être une constante. [`String`](/fr/reference/data-types/string)
* `arr1[, arr2, ... , arrN]` — N tableaux correspondant aux arguments de `agg_f`. [`Array(T)`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoie le résultat de la fonction d’agrégation
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT arrayReduce('max', [1, 2, 3]);
```
```response title=Response theme={null}
┌─arrayReduce('max', [1, 2, 3])─┐
│ 3 │
└───────────────────────────────┘
```
**Exemple de fonction d’agrégation avec plusieurs arguments**
```sql title=Query theme={null}
--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 title=Response theme={null}
┌─arrayReduce('maxIf', [3, 5], [1, 0])─┐
│ 3 │
└──────────────────────────────────────┘
```
**Exemple avec une fonction d’agrégation paramétrique**
```sql title=Query theme={null}
SELECT arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
```
```response title=Response theme={null}
┌─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**
```sql theme={null}
arrayReduceInRanges(agg_f, ranges, arr1[, arr2, ... ,arrN])
```
**Arguments**
* `agg_f` — Nom de la fonction d'agrégation à utiliser. [`String`](/fr/reference/data-types/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)`](/fr/reference/data-types/array) ou [`Tuple(T)`](/fr/reference/data-types/tuple)
* `arr1[, arr2, ... ,arrN]` — N tableaux passés comme arguments à la fonction d'agrégation. [`Array(T)`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoie un tableau contenant les résultats de la fonction d'agrégation sur les plages spécifiées [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT arrayReduceInRanges(
'sum',
[(1, 5), (2, 3), (3, 4), (4, 4)],
[1000000, 200000, 30000, 4000, 500, 60, 7]
) AS res
```
```response title=Response theme={null}
┌─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**
```sql theme={null}
arrayRemove(arr, elem)
```
**Alias** : `array_remove`
**Arguments**
* `arr` — Array(T) - `elem` — T
**Valeur renvoyée**
Renvoie un sous-ensemble du tableau source [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple 1**
```sql title=Query theme={null}
SELECT arrayRemove([1, 2, 2, 3], 2)
```
```response title=Response theme={null}
[1, 3]
```
**Exemple 2**
```sql title=Query theme={null}
SELECT arrayRemove(['a', NULL, 'b', NULL], NULL)
```
```response title=Response theme={null}
['a', 'b']
```
## arrayResize
Introduit dans : v1.1.0
Modifie la longueur du tableau.
**Syntaxe**
```sql theme={null}
arrayResize(arr, size[, extender])
```
**Arguments**
* `arr` — Tableau à redimensionner. [`Array(T)`](/fr/reference/data-types/array)
* `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)`](/fr/reference/data-types/array)
**Exemples**
**Exemple 1**
```sql title=Query theme={null}
SELECT arrayResize([1], 3);
```
```response title=Response theme={null}
[1,0,0]
```
**Exemple 2**
```sql title=Query theme={null}
SELECT arrayResize([1], 3, NULL);
```
```response title=Response theme={null}
[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**
```sql theme={null}
arrayReverse(arr)
```
**Arguments**
* `arr` — Le tableau à inverser. [`Array(T)`](/fr/reference/data-types/array)
**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)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT arrayReverse([1, 2, 3])
```
```response title=Response theme={null}
[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**
```sql theme={null}
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`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — Le tableau source à traiter. [`Array(T)`](/fr/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — Facultatif. N tableaux de conditions fournissant des arguments supplémentaires à la fonction lambda. [`Array(T)`](/fr/reference/data-types/array)
**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)`](/fr/reference/data-types/array)
**Exemples**
**Exemple avec un seul tableau**
```sql title=Query theme={null}
SELECT arrayReverseFill(x -> not isNull(x), [1, null, 2, null]) AS res
```
```response title=Response theme={null}
[1, 2, 2, NULL]
```
**Exemple avec deux tableaux**
```sql title=Query theme={null}
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 title=Response theme={null}
[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 :
1. `-Inf`
2. `Inf`
3. `NaN`
4. `NULL`
`arrayReverseSort` est une [fonction d’ordre supérieur](/fr/reference/functions/regular-functions/overview#higher-order-functions).
**Syntaxe**
```sql theme={null}
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)`](/fr/reference/data-types/array) - `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)`](/fr/reference/data-types/array).
**Exemples**
**Exemple 1**
```sql title=Query theme={null}
SELECT arrayReverseSort((x, y) -> y, [4, 3, 5], ['a', 'b', 'c']) AS res;
```
```response title=Response theme={null}
[5,3,4]
```
**Exemple 2**
```sql title=Query theme={null}
SELECT arrayReverseSort((x, y) -> -y, [4, 3, 5], [1, 2, 3]) AS res;
```
```response title=Response theme={null}
[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**
```sql theme={null}
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`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — Le tableau source à traiter. [`Fonction lambda`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `[, cond1_arr, ... , condN_arr]` — Facultatif. N tableaux de condition fournissant des arguments supplémentaires à la fonction lambda. [`Array(T)`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoie un tableau de tableaux. [`Array(Array(T))`](/fr/reference/data-types/array)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT arrayReverseSplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res
```
```response title=Response theme={null}
[[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**
```sql theme={null}
arrayRotateLeft(arr, n)
```
**Arguments**
* `arr` — Le tableau dont les éléments doivent être décalés par rotation.[`Array(T)`](/fr/reference/data-types/array). - `n` — Nombre d’éléments à décaler par rotation. [`(U)Int8/16/32/64`](/fr/reference/data-types/int-uint).
**Valeur renvoyée**
Un tableau décalé par rotation vers la gauche du nombre d’éléments spécifié [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT arrayRotateLeft([1,2,3,4,5,6], 2) as res;
```
```response title=Response theme={null}
[3,4,5,6,1,2]
```
**Valeur négative de n**
```sql title=Query theme={null}
SELECT arrayRotateLeft([1,2,3,4,5,6], -2) as res;
```
```response title=Response theme={null}
[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**
```sql theme={null}
arrayRotateRight(arr, n)
```
**Arguments**
* `arr` — Le tableau dont les éléments doivent être décalés par rotation.[`Array(T)`](/fr/reference/data-types/array). - `n` — Nombre d'éléments à décaler par rotation. [`(U)Int8/16/32/64`](/fr/reference/data-types/int-uint).
**Valeur renvoyée**
Un tableau décalé par rotation vers la droite du nombre d'éléments spécifié [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT arrayRotateRight([1,2,3,4,5,6], 2) as res;
```
```response title=Response theme={null}
[5,6,1,2,3,4]
```
**Valeur négative de n**
```sql title=Query theme={null}
SELECT arrayRotateRight([1,2,3,4,5,6], -2) as res;
```
```response title=Response theme={null}
[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**
```sql theme={null}
arrayShiftLeft(arr, n[, default])
```
**Arguments**
* `arr` — Le tableau dont les éléments sont à décaler.[`Array(T)`](/fr/reference/data-types/array). - `n` — Nombre d'éléments à décaler.[`(U)Int8/16/32/64`](/fr/reference/data-types/int-uint). - `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)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT arrayShiftLeft([1,2,3,4,5,6], 2) as res;
```
```response title=Response theme={null}
[3,4,5,6,0,0]
```
**Valeur négative de n**
```sql title=Query theme={null}
SELECT arrayShiftLeft([1,2,3,4,5,6], -2) as res;
```
```response title=Response theme={null}
[0,0,1,2,3,4]
```
**Utiliser une valeur par défaut**
```sql title=Query theme={null}
SELECT arrayShiftLeft([1,2,3,4,5,6], 2, 42) as res;
```
```response title=Response theme={null}
[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**
```sql theme={null}
arrayShiftRight(arr, n[, default])
```
**Arguments**
* `arr` — Le tableau dont les éléments doivent être décalés. [`Array(T)`](/fr/reference/data-types/array)
* `n` — Nombre d'éléments à décaler. [`(U)Int8/16/32/64`](/fr/reference/data-types/int-uint)
* `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)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], 2) as res;
```
```response title=Response theme={null}
[0, 0, 1, 2, 3, 4]
```
**Valeur négative de n**
```sql title=Query theme={null}
SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], -2) as res;
```
```response title=Response theme={null}
[3, 4, 5, 6, 0, 0]
```
**Utilisation d’une valeur par défaut**
```sql title=Query theme={null}
SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], 2, 42) as res;
```
```response title=Response theme={null}
[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**
```sql theme={null}
arrayShingles(arr, l)
```
**Arguments**
* `arr` — Tableau à partir duquel générer un tableau de shingles. [`Array(T)`](/fr/reference/data-types/array)
* `l` — La longueur de chaque shingle. [`(U)Int*`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Un tableau contenant les shingles générés [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT arrayShingles([1, 2, 3, 4], 3) as res;
```
```response title=Response theme={null}
[[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**
```sql theme={null}
arrayShuffle(arr [, seed])
```
**Arguments**
* `arr` — Le tableau à mélanger. [`Array(T)`](/fr/reference/data-types/array)
* `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*`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Tableau dont les éléments sont mélangés [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple sans graine (résultats non déterministes)**
```sql title=Query theme={null}
SELECT arrayShuffle([1, 2, 3, 4]);
```
```response title=Response theme={null}
[1,4,2,3]
```
**Exemple sans seed (résultats stables)**
```sql title=Query theme={null}
SELECT arrayShuffle([1, 2, 3, 4], 41);
```
```response title=Response theme={null}
[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**
```sql theme={null}
arraySimilarity(from, to, from_weights, to_weights)
```
**Arguments**
* `from` — premier tableau [`Array(T)`](/fr/reference/data-types/array)
* `to` — second tableau [`Array(T)`](/fr/reference/data-types/array)
* `from_weights` — pondérations du premier tableau. [`Array((U)Int*|Float*)`](/fr/reference/data-types/array)
* `to_weights` — pondérations du second tableau. [`Array((U)Int*|Float*)`](/fr/reference/data-types/array)
**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`](/fr/reference/data-types/float)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT arraySimilarity(['A', 'B', 'C'], ['A', 'K', 'L'], [1.0, 2, 3], [3.0, 4, 5]);
```
```response title=Response theme={null}
0.2222222222222222
```
## arraySlice
Introduit dans : v1.1.0
Renvoie une portion du tableau, en incluant les éléments `NULL`.
**Syntaxe**
```sql theme={null}
arraySlice(arr, offset [, length])
```
**Arguments**
* `arr` — Tableau à découper. [`Array(T)`](/fr/reference/data-types/array)
* `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*`](/fr/reference/data-types/int-uint)
* `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*`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une tranche du tableau contenant `length` éléments à partir de l’`offset` spécifié [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT arraySlice([1, 2, NULL, 4, 5], 2, 3) AS res;
```
```response title=Response theme={null}
[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 :
1. `-Inf`
2. `Inf`
3. `NaN`
4. `NULL`
`arraySort` est une [fonction d'ordre supérieur](/fr/reference/functions/regular-functions/overview#higher-order-functions).
**Syntaxe**
```sql theme={null}
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)`](/fr/reference/data-types/array) - `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)`](/fr/reference/data-types/array).
**Exemples**
**Exemple 1**
```sql title=Query theme={null}
SELECT arraySort([1, 3, 3, 0]);
```
```response title=Response theme={null}
[0,1,3,3]
```
**Exemple 2**
```sql title=Query theme={null}
SELECT arraySort(['hello', 'world', '!']);
```
```response title=Response theme={null}
['!','hello','world']
```
**Exemple 3**
```sql title=Query theme={null}
SELECT arraySort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]);
```
```response title=Response theme={null}
[-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**
```sql theme={null}
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](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda). - `source_arr` — Le tableau source à scinder [`Array(T)`](/fr/reference/data-types/array). - `[, cond1_arr, ... , condN_arr]` — Facultatif. N tableaux de conditions fournissant des arguments supplémentaires à la fonction lambda. [`Array(T)`](/fr/reference/data-types/array).
**Valeur renvoyée**
Renvoie un tableau de tableaux [`Array(Array(T))`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT arraySplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res
```
```response title=Response theme={null}
[[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**
```sql theme={null}
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`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — Le tableau source à traiter. [`Array(T)`](/fr/reference/data-types/array)
* `, cond1_arr, ... , condN_arr]` — Facultatif. N tableaux de condition fournissant des arguments supplémentaires à la fonction lambda. [`Array(T)`](/fr/reference/data-types/array)
**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**
```sql title=Query theme={null}
SELECT arraySum([1, 2, 3, 4]);
```
```response title=Response theme={null}
10
```
**Utilisation avec une fonction lambda**
```sql title=Query theme={null}
SELECT arraySum(x, y -> x+y, [1, 1, 1, 1], [1, 1, 1, 1]);
```
```response title=Response theme={null}
8
```
## 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](https://en.wikipedia.org/wiki/Symmetric_difference#n-ary_symmetric_difference)
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**
```sql theme={null}
arraySymmetricDifference(arr1, arr2, ... , arrN)
```
**Arguments**
* `arrN` — N tableaux à partir desquels le nouveau tableau est créé. [`Array(T)`](/fr/reference/data-types/array).
**Valeur renvoyée**
Renvoie un tableau contenant des éléments distincts qui ne sont pas présents dans tous les tableaux sources [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─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](/fr/reference/functions/regular-functions/overview#higher-order-functions).
Voir aussi `arrayBottomK`, qui renvoie à la place les `K` plus petits éléments.
**Syntaxe**
```sql theme={null}
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`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `K` — Le nombre des plus grands éléments à renvoyer. [`(U)Int8/16/32/64`](/fr/reference/data-types/int-uint)
* `arr` — Un tableau. [`Array(T)`](/fr/reference/data-types/array)
* `arr1, ... ,arrN` — N tableaux supplémentaires, si `f` accepte plusieurs arguments. [`Array(T)`](/fr/reference/data-types/array)
**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**
```sql title=Query theme={null}
SELECT arrayTopK(3, [1, 5, 2, 7, 3])
```
```response title=Response theme={null}
[7,5,3]
```
**skip\_nulls**
```sql title=Query theme={null}
SELECT arrayTopK(3, [1, NULL, 5, 2, NULL, 7])
```
```response title=Response theme={null}
[7,5,2]
```
**fewer\_than\_k**
```sql title=Query theme={null}
SELECT arrayTopK(5, [1, NULL, 2])
```
```response title=Response theme={null}
[2,1]
```
**lambda\_simple**
```sql title=Query theme={null}
SELECT arrayTopK((x) -> -x, 2, [5, 9, 1, 3])
```
```response title=Response theme={null}
[1,3]
```
**lambda\_multi**
```sql title=Query theme={null}
SELECT arrayTopK((x, y) -> y, 2, ['a', 'b', 'c'], [3, 1, 2])
```
```response title=Response theme={null}
['a','c']
```
## arrayTranspose
Introduit dans : v26.4.0
Transpose un tableau bidimensionnel.
Tous les tableaux imbriqués doivent avoir la même longueur.
**Syntaxe**
```sql theme={null}
arrayTranspose(arr)
```
**Arguments**
* `arr` — Un tableau bidimensionnel à transposer. Tous les sous-tableaux doivent avoir la même longueur. [`Array(Array(T))`](/fr/reference/data-types/array)
**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))`](/fr/reference/data-types/array)
**Exemples**
**Matrice carrée**
```sql title=Query theme={null}
SELECT arrayTranspose([[1, 2], [3, 4]])
```
```response title=Response theme={null}
[[1, 3], [2, 4]]
```
**Matrice non carrée**
```sql title=Query theme={null}
SELECT arrayTranspose([[1, 2, 3], [4, 5, 6]])
```
```response title=Response theme={null}
[[1, 4], [2, 5], [3, 6]]
```
**Éléments de type String**
```sql title=Query theme={null}
SELECT arrayTranspose([['a', 'b'], ['c', 'd']])
```
```response title=Response theme={null}
[['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**
```sql theme={null}
arrayUnion(arr1, arr2, ..., arrN)
```
**Arguments**
* `arrN` — N tableaux à partir desquels créer le nouveau tableau. [`Array(T)`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoie un tableau contenant les éléments distincts des tableaux source [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─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**
```sql theme={null}
arrayUniq(arr1[, arr2, ..., arrN])
```
**Arguments**
* `arr1` — Tableau dont il faut compter le nombre d’éléments uniques. [`Array(T)`](/fr/reference/data-types/array)
* `[, 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)`](/fr/reference/data-types/array)
**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`](/fr/reference/data-types/int-uint)
**Exemples**
**Un seul argument**
```sql title=Query theme={null}
SELECT arrayUniq([1, 1, 2, 2])
```
```response title=Response theme={null}
2
```
**Plusieurs arguments**
```sql title=Query theme={null}
SELECT arrayUniq([1, 2, 3, 1], [4, 5, 6, 4])
```
```response title=Response theme={null}
3
```
## arrayWithConstant
Introduit dans : v20.1.0
Crée un tableau de longueur `length`, rempli de la constante `x`.
**Syntaxe**
```sql theme={null}
arrayWithConstant(N, x)
```
**Arguments**
* `length` — Nombre d'éléments du tableau. [`(U)Int*`](/fr/reference/data-types/int-uint)
* `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)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT arrayWithConstant(3, 1)
```
```response title=Response theme={null}
[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**
```sql theme={null}
arrayZip(arr1, arr2, ... , arrN)
```
**Arguments**
* `arr1, arr2, ... , arrN` — N tableaux à combiner en un seul tableau. [`Array(T)`](/fr/reference/data-types/array)
**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)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT arrayZip(['a', 'b', 'c'], [5, 2, 1]);
```
```response title=Response theme={null}
[('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**
```sql theme={null}
arrayZipUnaligned(arr1, arr2, ..., arrN)
```
**Arguments**
* `arr1, arr2, ..., arrN` — N tableaux à combiner en un seul tableau. [`Array(T)`](/fr/reference/data-types/array)
**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)`](/fr/reference/data-types/array) ou [`Tuple(T1, T2, ...)`](/fr/reference/data-types/tuple)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT arrayZipUnaligned(['a'], [1, 2, 3]);
```
```response title=Response theme={null}
[('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**
```sql theme={null}
countEqual(arr, x)
```
**Arguments**
* `arr` — Tableau dans lequel effectuer la recherche. [`Array(T)`](/fr/reference/data-types/array)
* `x` — Valeur à compter dans le tableau. N’importe quel type.
**Valeur renvoyée**
Renvoie le nombre d’éléments du tableau égaux à `x` [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT countEqual([1, 2, NULL, NULL], NULL)
```
```response title=Response theme={null}
2
```
## 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`](/fr/reference/settings/session-settings#optimize_functions_to_subcolumns). Avec `optimize_functions_to_subcolumns = 1`, la fonction lit uniquement la subcolumn [size0](/fr/reference/data-types/array#array-size) 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**
```sql theme={null}
empty(arr)
```
**Arguments**
* `arr` — Tableau en entrée. [`Array(T)`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoie `1` pour un tableau vide ou `0` pour un tableau non vide [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT empty([]);
```
```response title=Response theme={null}
1
```
## emptyArrayDate
Introduit dans : v1.1.0
Renvoie un Array de Date vide
**Syntaxe**
```sql theme={null}
emptyArrayDate()
```
**Arguments**
* Aucun.
**Valeur renvoyée**
Un tableau Date vide. [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT emptyArrayDate
```
```response title=Response theme={null}
[]
```
## emptyArrayDateTime
Introduit dans : v1.1.0
Renvoie un tableau DateTime vide
**Syntaxe**
```sql theme={null}
emptyArrayDateTime()
```
**Arguments**
* Aucun.
**Valeur retournée**
Un tableau DateTime vide. [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT emptyArrayDateTime
```
```response title=Response theme={null}
[]
```
## emptyArrayFloat32
Introduit dans : v1.1.0
Renvoie un tableau vide de Float32
**Syntaxe**
```sql theme={null}
emptyArrayFloat32()
```
**Arguments**
* Aucun.
**Valeur renvoyée**
Un tableau vide de Float32. [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT emptyArrayFloat32
```
```response title=Response theme={null}
[]
```
## emptyArrayFloat64
Introduit dans : v1.1.0
Renvoie un tableau(Float64) vide
**Syntaxe**
```sql theme={null}
emptyArrayFloat64()
```
**Arguments**
* Aucun.
**Valeur renvoyée**
Un tableau Float64 vide. [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT emptyArrayFloat64
```
```response title=Response theme={null}
[]
```
## emptyArrayInt16
Introduit dans : v1.1.0
Renvoie un tableau Int16 vide
**Syntaxe**
```sql theme={null}
emptyArrayInt16()
```
**Arguments**
* Aucun.
**Valeur renvoyée**
Un tableau vide de type Int16. [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT emptyArrayInt16
```
```response title=Response theme={null}
[]
```
## emptyArrayInt32
Introduit dans : v1.1.0
Renvoie un tableau Int32 vide
**Syntaxe**
```sql theme={null}
emptyArrayInt32()
```
**Arguments**
* Aucun.
**Valeur renvoyée**
Un tableau Int32 vide. [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT emptyArrayInt32
```
```response title=Response theme={null}
[]
```
## emptyArrayInt64
Introduit dans : v1.1.0
Renvoie un tableau Int64 vide
**Syntaxe**
```sql theme={null}
emptyArrayInt64()
```
**Arguments**
* Aucun.
**Valeur renvoyée**
Un tableau Int64 vide. [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT emptyArrayInt64
```
```response title=Response theme={null}
[]
```
## emptyArrayInt8
Disponible à partir de : v1.1.0
Renvoie un tableau vide de type Int8
**Syntaxe**
```sql theme={null}
emptyArrayInt8()
```
**Arguments**
* Aucun.
**Valeur renvoyée**
Un tableau Int8 vide. [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT emptyArrayInt8
```
```response title=Response theme={null}
[]
```
## emptyArrayString
Introduit dans : v1.1.0
Renvoie un tableau vide de String
**Syntaxe**
```sql theme={null}
emptyArrayString()
```
**Arguments**
* Aucun.
**Valeur renvoyée**
Un tableau vide de String. [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT emptyArrayString
```
```response title=Response theme={null}
[]
```
## 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**
```sql theme={null}
emptyArrayToSingle(arr)
```
**Arguments**
* `arr` — Un tableau vide. [`Array(T)`](/fr/reference/data-types/array)
**Valeur renvoyée**
Un tableau contenant une seule valeur du type par défaut du tableau. [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple simple**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─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**
```sql theme={null}
emptyArrayUInt16()
```
**Arguments**
* Aucun.
**Valeur retournée**
Un tableau UInt16 vide. [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT emptyArrayUInt16
```
```response title=Response theme={null}
[]
```
## emptyArrayUInt32
Introduit dans : v1.1.0
Renvoie un tableau vide de UInt32
**Syntaxe**
```sql theme={null}
emptyArrayUInt32()
```
**Arguments**
* Aucun.
**Valeur renvoyée**
Un tableau UInt32 vide. [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT emptyArrayUInt32
```
```response title=Response theme={null}
[]
```
## emptyArrayUInt64
Introduit dans : v1.1.0
Renvoie un tableau UInt64 vide
**Syntaxe**
```sql theme={null}
emptyArrayUInt64()
```
**Arguments**
* Aucun.
**Valeur de retour**
Un tableau UInt64 vide. [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT emptyArrayUInt64
```
```response title=Response theme={null}
[]
```
## emptyArrayUInt8
Introduit dans : v1.1.0
Renvoie un tableau UInt8 vide
**Syntaxe**
```sql theme={null}
emptyArrayUInt8()
```
**Arguments**
* Aucun.
**Valeur de retour**
Un tableau UInt8 vide. [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT emptyArrayUInt8
```
```response title=Response theme={null}
[]
```
## 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**
```sql theme={null}
has(haystack, needle)
```
**Arguments**
* `haystack` — Le tableau source, la map ou le JSON. [`Array`](/fr/reference/data-types/array) ou [`Map`](/fr/reference/data-types/map) ou [`JSON`](/fr/reference/data-types/newjson)
* `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`](/fr/reference/data-types/int-uint)
**Exemples**
**Utilisation de base de tableau**
```sql title=Query theme={null}
SELECT has([1, 2, 3], 2)
```
```response title=Response theme={null}
1
```
**tableau introuvable**
```sql title=Query theme={null}
SELECT has([1, 2, 3], 4)
```
```response title=Response theme={null}
0
```
**Utilisation de base du type Map**
```sql title=Query theme={null}
SELECT has(map('a', 1, 'b', 2), 'b')
```
```response title=Response theme={null}
1
```
**Chemin JSON**
```sql title=Query theme={null}
SELECT has('{"a": {"b": 1}}'::JSON, 'a.b')
```
```response title=Response theme={null}
1
```
## 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**
```sql theme={null}
hasAll(set, subset)
```
**Arguments**
* `set` — tableau de n’importe quel type contenant un ensemble d’éléments. [`Array(T)`](/fr/reference/data-types/array)
* `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)`](/fr/reference/data-types/array)
**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**
```sql title=Query theme={null}
SELECT hasAll([], [])
```
```response title=Response theme={null}
1
```
**Tableaux contenant des valeurs NULL**
```sql title=Query theme={null}
SELECT hasAll([1, Null], [Null])
```
```response title=Response theme={null}
1
```
**Tableaux contenant des valeurs d’un type différent**
```sql title=Query theme={null}
SELECT hasAll([1.0, 2, 3, 4], [1, 3])
```
```response title=Response theme={null}
1
```
**Tableaux contenant des valeurs de type String**
```sql title=Query theme={null}
SELECT hasAll(['a', 'b'], ['a'])
```
```response title=Response theme={null}
1
```
**Tableaux sans type en commun**
```sql title=Query theme={null}
SELECT hasAll([1], ['a'])
```
```response title=Response theme={null}
Raises a NO_COMMON_TYPE exception
```
**Tableau de tableaux**
```sql title=Query theme={null}
SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [3, 5]])
```
```response title=Response theme={null}
0
```
## 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**
```sql theme={null}
hasAny(arr_x, arr_y)
```
**Arguments**
* `arr_x` — tableau de n’importe quel type contenant un ensemble d’éléments. [`Array(T)`](/fr/reference/data-types/array)
* `arr_y` — tableau de n’importe quel type partageant un supertype commun avec le tableau `arr_x`. [`Array(T)`](/fr/reference/data-types/array)
**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**
```sql title=Query theme={null}
SELECT hasAny([1], [])
```
```response title=Response theme={null}
0
```
**Tableaux avec des valeurs NULL**
```sql title=Query theme={null}
SELECT hasAny([Null], [Null, 1])
```
```response title=Response theme={null}
1
```
**Tableaux contenant des valeurs d’un autre type**
```sql title=Query theme={null}
SELECT hasAny([-128, 1., 512], [1])
```
```response title=Response theme={null}
1
```
**Tableaux sans type commun**
```sql title=Query theme={null}
SELECT hasAny([[1, 2], [3, 4]], ['a', 'c'])
```
```response title=Response theme={null}
Raises a `NO_COMMON_TYPE` exception
```
**Tableau de tableaux**
```sql title=Query theme={null}
SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [1, 2]])
```
```response title=Response theme={null}
1
```
## 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**
```sql theme={null}
hasSubstr(arr1, arr2)
```
**Arguments**
* `arr1` — tableau de n’importe quel type contenant un ensemble d’éléments. [`Array(T)`](/fr/reference/data-types/array)
* `arr2` — tableau de n’importe quel type contenant un ensemble d’éléments. [`Array(T)`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoie `1` si le tableau `arr1` contient le tableau `arr2`. Sinon, renvoie `0`. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Les deux tableaux sont vides**
```sql title=Query theme={null}
SELECT hasSubstr([], [])
```
```response title=Response theme={null}
1
```
**Tableaux contenant des valeurs NULL**
```sql title=Query theme={null}
SELECT hasSubstr([1, Null], [Null])
```
```response title=Response theme={null}
1
```
**Tableaux contenant des valeurs de type différent**
```sql title=Query theme={null}
SELECT hasSubstr([1.0, 2, 3, 4], [1, 3])
```
```response title=Response theme={null}
0
```
**Tableaux contenant des chaînes de caractères**
```sql title=Query theme={null}
SELECT hasSubstr(['a', 'b'], ['a'])
```
```response title=Response theme={null}
1
```
**Tableaux dont l’ordre est valide**
```sql title=Query theme={null}
SELECT hasSubstr(['a', 'b' , 'c'], ['a', 'b'])
```
```response title=Response theme={null}
1
```
**Tableaux avec un ordre incorrect**
```sql title=Query theme={null}
SELECT hasSubstr(['a', 'b' , 'c'], ['a', 'c'])
```
```response title=Response theme={null}
0
```
**tableau de tableaux**
```sql title=Query theme={null}
SELECT hasSubstr([[1, 2], [3, 4], [5, 6]], [[1, 2], [3, 4]])
```
```response title=Response theme={null}
1
```
**Tableaux sans type en commun**
```sql title=Query theme={null}
SELECT hasSubstr([1, 2, NULL, 3, 4], ['a'])
```
```response title=Response theme={null}
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**
```sql theme={null}
indexOf(arr, x)
```
**Arguments**
* `arr` — Tableau dans lequel rechercher `x`. [`Array(T)`](/fr/reference/data-types/array)
* `x` — Valeur du premier élément correspondant dans `arr` dont l’indice doit être renvoyé. [`UInt64`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie l’indice (numéroté à partir de 1) du premier `x` dans `arr` s’il existe. Sinon, renvoie `0`. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple de base**
```sql title=Query theme={null}
SELECT indexOf([5, 4, 1, 3], 3)
```
```response title=Response theme={null}
4
```
**Tableau contenant des valeurs NULL**
```sql title=Query theme={null}
SELECT indexOf([1, 3, NULL, NULL], NULL)
```
```response title=Response theme={null}
3
```
## 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**
```sql theme={null}
indexOfAssumeSorted(arr, x)
```
**Arguments**
* `arr` — Un tableau trié dans lequel effectuer la recherche. [`Array(T)`](/fr/reference/data-types/array)
* `x` — Valeur du premier élément correspondant dans `arr` trié dont l’indice doit être renvoyé. [`UInt64`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie l’indice (numéroté à partir de 1) du premier `x` dans `arr` s’il existe. Sinon, renvoie `0`. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple simple**
```sql title=Query theme={null}
SELECT indexOfAssumeSorted([1, 3, 3, 3, 4, 4, 5], 4)
```
```response title=Response theme={null}
5
```
## 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**
```sql theme={null}
kql_array_sort_asc(array1[, array2, ..., nulls_last])
```
**Arguments**
* `array1` — Le tableau à trier. [`Array(T)`](/fr/reference/data-types/array)
* `array2` — Facultatif. Tableaux supplémentaires à réordonner selon l’ordre de tri de `array1`. [`Array(T)`](/fr/reference/data-types/array)
* `nulls_last` — Facultatif. Booléen indiquant si les valeurs nulles doivent apparaître en dernier. La valeur par défaut est `true`. [`UInt8`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie un tuple de tableaux triés par ordre croissant. [`Tuple(Array, ...)`](/fr/reference/data-types/tuple)
**Exemples**
**Utilisation de base**
```sql title=Query theme={null}
SELECT kql_array_sort_asc([3, 1, 2])
```
```response title=Response theme={null}
([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**
```sql theme={null}
kql_array_sort_desc(array1[, array2, ..., nulls_last])
```
**Arguments**
* `array1` — Le tableau à trier. [`Array(T)`](/fr/reference/data-types/array)
* `array2` — Tableaux supplémentaires facultatifs à réordonner selon l’ordre de tri de `array1`. [`Array(T)`](/fr/reference/data-types/array)
* `nulls_last` — Booléen facultatif indiquant si les valeurs NULL doivent apparaître en dernier. La valeur par défaut est `true`. [`UInt8`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie un tuple de tableaux triés par ordre décroissant. [`Tuple(Array, ...)`](/fr/reference/data-types/tuple)
**Exemples**
**Utilisation de base**
```sql title=Query theme={null}
SELECT kql_array_sort_desc([3, 1, 2])
```
```response title=Response theme={null}
([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**
```sql theme={null}
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`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring) ou [`Array(T)`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoie le nombre d’octets de la String/FixedString `x` / le nombre d’éléments du tableau `x` [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple de chaîne**
```sql title=Query theme={null}
SELECT length('Hello, world!')
```
```response title=Response theme={null}
13
```
**Exemple : Array**
```sql title=Query theme={null}
SELECT length(['Hello', 'world'])
```
```response title=Response theme={null}
2
```
**exemple de constexpr**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─str────┬─str_length_is_constant─┬─fixed_str_length_is_constant─┐
│ hello0 │ 0 │ 1 │
│ hello1 │ 0 │ 1 │
│ hello2 │ 0 │ 1 │
└────────┴────────────────────────┴──────────────────────────────┘
```
**exemple Unicode**
```sql title=Query theme={null}
SELECT 'ёлка' AS str1, length(str1), lengthUTF8(str1), normalizeUTF8NFKD(str1) AS str2, length(str2), lengthUTF8(str2)
```
```response title=Response theme={null}
┌─str1─┬─length(str1)─┬─lengthUTF8(str1)─┬─str2─┬─length(str2)─┬─lengthUTF8(str2)─┐
│ ёлка │ 8 │ 4 │ ёлка │ 10 │ 5 │
└──────┴──────────────┴──────────────────┴──────┴──────────────┴──────────────────┘
```
**ascii\_vs\_utf8 exemple**
```sql title=Query theme={null}
SELECT 'ábc' AS str, length(str), lengthUTF8(str)
```
```response title=Response theme={null}
┌─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`](/fr/reference/settings/session-settings#optimize_functions_to_subcolumns). Avec `optimize_functions_to_subcolumns = 1`, la fonction lit uniquement la sous-colonne [size0](/fr/reference/data-types/array#array-size), 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**
```sql theme={null}
notEmpty(arr)
```
**Arguments**
* `arr` — Tableau en entrée. [`Array(T)`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoie `1` pour un tableau non vide ou `0` pour un tableau vide [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT notEmpty([1,2]);
```
```response title=Response theme={null}
1
```
## 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`](/fr/reference/settings/session-settings#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**
```sql theme={null}
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)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT range(5), range(1, 5), range(1, 5, 2), range(-1, 5, 2);
```
```response title=Response theme={null}
┌─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**
```sql theme={null}
replicate(x, arr)
```
**Arguments**
* `x` — La valeur avec laquelle remplir le tableau résultant. [`Any`](/fr/reference/data-types/index)
* `arr` — Un tableau. [`Array(T)`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoie un tableau de même longueur que `arr`, rempli avec la valeur `x`. [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT replicate(1, ['a', 'b', 'c']);
```
```response title=Response theme={null}
┌─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**
```sql theme={null}
reverse(arr | str)
```
**Arguments**
* `arr | str` — Le tableau source ou la chaîne. [`Array(T)`](/fr/reference/data-types/array) ou [`String`](/fr/reference/data-types/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é**
```sql title=Query theme={null}
SELECT reverse([1, 2, 3, 4]);
```
```response title=Response theme={null}
[4, 3, 2, 1]
```
**Inverser une chaîne de caractères**
```sql title=Query theme={null}
SELECT reverse('abcd');
```
```response title=Response theme={null}
'dcba'
```
## Fonctions de distance
Toutes les fonctions prises en charge sont décrites dans la [documentation sur les fonctions de distance](/fr/reference/functions/regular-functions/distance-functions).