mirror of
https://github.com/ClickHouse/ClickHouse.git
synced 2024-12-03 21:12:28 +00:00
9a26d48ad0
* Basic blog similar to docs * rename post * no post content in post_meta * update readme and template * more "en" content * complete "en" content * build blog redirects * redirects for migration * link sitemaps * update po * add "ru" content * ru redirects * remove old domain mentions * adjust styles * content improvements * +1 alt * use main images from CDN * use re-hosted in-content images * extra vertical margin around embedded youtube * minor improvements * adjust post page * adjust html meta * adjust post page * improve blog rendering
1062 lines
34 KiB
Markdown
1062 lines
34 KiB
Markdown
---
|
||
machine_translated: true
|
||
machine_translated_rev: 72537a2d527c63c07aa5d2361a8829f3895cf2bd
|
||
toc_priority: 46
|
||
toc_title: Travailler avec des tableaux
|
||
---
|
||
|
||
# Fonctions pour travailler avec des tableaux {#functions-for-working-with-arrays}
|
||
|
||
## vide {#function-empty}
|
||
|
||
Retourne 1 pour un tableau vide, ou 0 pour un non-vide.
|
||
Le type de résultat est UInt8.
|
||
La fonction fonctionne également pour les chaînes.
|
||
|
||
## notEmpty {#function-notempty}
|
||
|
||
Retourne 0 pour un tableau vide, ou 1 pour un non-vide.
|
||
Le type de résultat est UInt8.
|
||
La fonction fonctionne également pour les chaînes.
|
||
|
||
## longueur {#array_functions-length}
|
||
|
||
Retourne le nombre d'éléments dans le tableau.
|
||
Le type de résultat est UInt64.
|
||
La fonction fonctionne également pour les chaînes.
|
||
|
||
## emptyArrayUInt8, emptyArrayUInt16, emptyArrayUInt32, emptyArrayUInt64 {#emptyarrayuint8-emptyarrayuint16-emptyarrayuint32-emptyarrayuint64}
|
||
|
||
## emptyArrayInt8, emptyArrayInt16, emptyArrayInt32, emptyArrayInt64 {#emptyarrayint8-emptyarrayint16-emptyarrayint32-emptyarrayint64}
|
||
|
||
## emptyArrayFloat32, emptyArrayFloat64 {#emptyarrayfloat32-emptyarrayfloat64}
|
||
|
||
## emptyArrayDate, emptyArrayDateTime {#emptyarraydate-emptyarraydatetime}
|
||
|
||
## emptyArrayString {#emptyarraystring}
|
||
|
||
Accepte zéro argument et renvoie un tableau vide du type approprié.
|
||
|
||
## emptyArrayToSingle {#emptyarraytosingle}
|
||
|
||
Accepte un tableau vide et renvoie un élément de tableau qui est égal à la valeur par défaut.
|
||
|
||
## plage (fin), Plage(début, fin \[, étape\]) {#rangeend-rangestart-end-step}
|
||
|
||
Retourne un tableau de nombres du début à la fin-1 par étape.
|
||
Si l'argument `start` n'est pas spécifié, la valeur par défaut est 0.
|
||
Si l'argument `step` n'est pas spécifié, la valeur par défaut est 1.
|
||
Il se comporte presque comme pythonic `range`. Mais la différence est que tous les types d'arguments doivent être `UInt` nombre.
|
||
Juste au cas où, une exception est levée si des tableaux d'une longueur totale de plus de 100 000 000 d'éléments sont créés dans un bloc de données.
|
||
|
||
## array(x1, …), operator \[x1, …\] {#arrayx1-operator-x1}
|
||
|
||
Crée un tableau à partir des arguments de la fonction.
|
||
Les arguments doivent être des constantes et avoir des types qui ont le plus petit type commun. Au moins un argument doit être passé, sinon il n'est pas clair quel type de tableau créer. Qui est, vous ne pouvez pas utiliser cette fonction pour créer un tableau vide (pour ce faire, utilisez la ‘emptyArray\*’ la fonction décrite ci-dessus).
|
||
Retourne un ‘Array(T)’ type de résultat, où ‘T’ est le plus petit type commun parmi les arguments passés.
|
||
|
||
## arrayConcat {#arrayconcat}
|
||
|
||
Combine des tableaux passés comme arguments.
|
||
|
||
``` sql
|
||
arrayConcat(arrays)
|
||
```
|
||
|
||
**Paramètre**
|
||
|
||
- `arrays` – Arbitrary number of arguments of [Tableau](../../sql-reference/data-types/array.md) type.
|
||
**Exemple**
|
||
|
||
<!-- -->
|
||
|
||
``` sql
|
||
SELECT arrayConcat([1, 2], [3, 4], [5, 6]) AS res
|
||
```
|
||
|
||
``` text
|
||
┌─res───────────┐
|
||
│ [1,2,3,4,5,6] │
|
||
└───────────────┘
|
||
```
|
||
|
||
## arrayElement(arr, n), opérateur arr\[n\] {#arrayelementarr-n-operator-arrn}
|
||
|
||
Récupérer l'élément avec l'index `n` à partir du tableau `arr`. `n` doit être n'importe quel type entier.
|
||
Les index dans un tableau commencent à partir d'un.
|
||
Les index négatifs sont pris en charge. Dans ce cas, il sélectionne l'élément correspondant numérotées à partir de la fin. Exemple, `arr[-1]` est le dernier élément du tableau.
|
||
|
||
Si l'index est en dehors des limites d'un tableau, il renvoie une valeur (0 pour les nombres, une chaîne vide pour les cordes, etc.), sauf pour le cas avec un tableau non constant et un index constant 0 (dans ce cas, il y aura une erreur `Array indices are 1-based`).
|
||
|
||
## a (arr, elem) {#hasarr-elem}
|
||
|
||
Vérifie si le ‘arr’ tableau a la ‘elem’ élément.
|
||
Retourne 0 si l'élément n'est pas dans le tableau, ou 1 si elle l'est.
|
||
|
||
`NULL` est traitée comme une valeur.
|
||
|
||
``` sql
|
||
SELECT has([1, 2, NULL], NULL)
|
||
```
|
||
|
||
``` text
|
||
┌─has([1, 2, NULL], NULL)─┐
|
||
│ 1 │
|
||
└─────────────────────────┘
|
||
```
|
||
|
||
## hasAll {#hasall}
|
||
|
||
Vérifie si un tableau est un sous-ensemble de l'autre.
|
||
|
||
``` sql
|
||
hasAll(set, subset)
|
||
```
|
||
|
||
**Paramètre**
|
||
|
||
- `set` – Array of any type with a set of elements.
|
||
- `subset` – Array of any type with elements that should be tested to be a subset of `set`.
|
||
|
||
**Les valeurs de retour**
|
||
|
||
- `1`, si `set` contient tous les éléments de `subset`.
|
||
- `0`, autrement.
|
||
|
||
**Propriétés particulières**
|
||
|
||
- Un tableau vide est un sous-ensemble d'un tableau quelconque.
|
||
- `Null` traitée comme une valeur.
|
||
- Ordre des valeurs dans les deux tableaux n'a pas d'importance.
|
||
|
||
**Exemple**
|
||
|
||
`SELECT hasAll([], [])` retours 1.
|
||
|
||
`SELECT hasAll([1, Null], [Null])` retours 1.
|
||
|
||
`SELECT hasAll([1.0, 2, 3, 4], [1, 3])` retours 1.
|
||
|
||
`SELECT hasAll(['a', 'b'], ['a'])` retours 1.
|
||
|
||
`SELECT hasAll([1], ['a'])` renvoie 0.
|
||
|
||
`SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [3, 5]])` renvoie 0.
|
||
|
||
## hasAny {#hasany}
|
||
|
||
Vérifie si deux tableaux ont une intersection par certains éléments.
|
||
|
||
``` sql
|
||
hasAny(array1, array2)
|
||
```
|
||
|
||
**Paramètre**
|
||
|
||
- `array1` – Array of any type with a set of elements.
|
||
- `array2` – Array of any type with a set of elements.
|
||
|
||
**Les valeurs de retour**
|
||
|
||
- `1`, si `array1` et `array2` avoir un élément similaire au moins.
|
||
- `0`, autrement.
|
||
|
||
**Propriétés particulières**
|
||
|
||
- `Null` traitée comme une valeur.
|
||
- Ordre des valeurs dans les deux tableaux n'a pas d'importance.
|
||
|
||
**Exemple**
|
||
|
||
`SELECT hasAny([1], [])` retourner `0`.
|
||
|
||
`SELECT hasAny([Null], [Null, 1])` retourner `1`.
|
||
|
||
`SELECT hasAny([-128, 1., 512], [1])` retourner `1`.
|
||
|
||
`SELECT hasAny([[1, 2], [3, 4]], ['a', 'c'])` retourner `0`.
|
||
|
||
`SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [1, 2]])` retourner `1`.
|
||
|
||
## indexOf (arr, x) {#indexofarr-x}
|
||
|
||
Renvoie l'index de la première ‘x’ élément (à partir de 1) s'il est dans le tableau, ou 0 s'il ne l'est pas.
|
||
|
||
Exemple:
|
||
|
||
``` sql
|
||
SELECT indexOf([1, 3, NULL, NULL], NULL)
|
||
```
|
||
|
||
``` text
|
||
┌─indexOf([1, 3, NULL, NULL], NULL)─┐
|
||
│ 3 │
|
||
└───────────────────────────────────┘
|
||
```
|
||
|
||
Ensemble d'éléments de `NULL` sont traités comme des valeurs normales.
|
||
|
||
## countEqual (arr, x) {#countequalarr-x}
|
||
|
||
Renvoie le nombre d'éléments dans le tableau égal à X. équivalent à arrayCount (elem - \> elem = x, arr).
|
||
|
||
`NULL` les éléments sont traités comme des valeurs distinctes.
|
||
|
||
Exemple:
|
||
|
||
``` sql
|
||
SELECT countEqual([1, 2, NULL, NULL], NULL)
|
||
```
|
||
|
||
``` text
|
||
┌─countEqual([1, 2, NULL, NULL], NULL)─┐
|
||
│ 2 │
|
||
└──────────────────────────────────────┘
|
||
```
|
||
|
||
## arrayEnumerate (arr) {#array_functions-arrayenumerate}
|
||
|
||
Returns the array \[1, 2, 3, …, length (arr) \]
|
||
|
||
Cette fonction est normalement utilisée avec ARRAY JOIN. Il permet de compter quelque chose une seule fois pour chaque tableau après l'application de la jointure de tableau. Exemple:
|
||
|
||
``` sql
|
||
SELECT
|
||
count() AS Reaches,
|
||
countIf(num = 1) AS Hits
|
||
FROM test.hits
|
||
ARRAY JOIN
|
||
GoalsReached,
|
||
arrayEnumerate(GoalsReached) AS num
|
||
WHERE CounterID = 160656
|
||
LIMIT 10
|
||
```
|
||
|
||
``` text
|
||
┌─Reaches─┬──Hits─┐
|
||
│ 95606 │ 31406 │
|
||
└─────────┴───────┘
|
||
```
|
||
|
||
Dans cet exemple, Reaches est le nombre de conversions (les chaînes reçues après l'application de la jointure de tableau), et Hits est le nombre de pages vues (chaînes avant la jointure de tableau). Dans ce cas particulier, vous pouvez obtenir le même résultat dans une voie plus facile:
|
||
|
||
``` sql
|
||
SELECT
|
||
sum(length(GoalsReached)) AS Reaches,
|
||
count() AS Hits
|
||
FROM test.hits
|
||
WHERE (CounterID = 160656) AND notEmpty(GoalsReached)
|
||
```
|
||
|
||
``` text
|
||
┌─Reaches─┬──Hits─┐
|
||
│ 95606 │ 31406 │
|
||
└─────────┴───────┘
|
||
```
|
||
|
||
Cette fonction peut également être utilisée dans les fonctions d'ordre supérieur. Par exemple, vous pouvez l'utiliser pour obtenir les indices de tableau pour les éléments qui correspondent à une condition.
|
||
|
||
## arrayEnumerateUniq(arr, …) {#arrayenumerateuniqarr}
|
||
|
||
Renvoie un tableau de la même taille que le tableau source, indiquant pour chaque élément Quelle est sa position parmi les éléments de même valeur.
|
||
Par exemple: arrayEnumerateUniq(\[10, 20, 10, 30\]) = \[1, 1, 2, 1\].
|
||
|
||
Cette fonction est utile lors de L'utilisation de la jointure de tableau et de l'agrégation d'éléments de tableau.
|
||
Exemple:
|
||
|
||
``` sql
|
||
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
|
||
```
|
||
|
||
``` text
|
||
┌──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 │
|
||
└─────────┴─────────┴────────┘
|
||
```
|
||
|
||
Dans cet exemple, chaque ID d'objectif a un calcul du nombre de conversions (chaque élément de la structure de données imbriquées objectifs est un objectif atteint, que nous appelons une conversion) et le nombre de sessions. Sans array JOIN, nous aurions compté le nombre de sessions comme sum(signe). Mais dans ce cas particulier, les lignes ont été multipliées par la structure des objectifs imbriqués, donc pour compter chaque session une fois après cela, nous appliquons une condition à la valeur de arrayEnumerateUniq(Goals.ID) fonction.
|
||
|
||
La fonction arrayEnumerateUniq peut prendre plusieurs tableaux de la même taille que les arguments. Dans ce cas, l'unicité est considérée pour les tuples d'éléments dans les mêmes positions dans tous les tableaux.
|
||
|
||
``` sql
|
||
SELECT arrayEnumerateUniq([1, 1, 1, 2, 2, 2], [1, 1, 2, 1, 1, 2]) AS res
|
||
```
|
||
|
||
``` text
|
||
┌─res───────────┐
|
||
│ [1,2,1,1,2,1] │
|
||
└───────────────┘
|
||
```
|
||
|
||
Ceci est nécessaire lors de L'utilisation de Array JOIN avec une structure de données imbriquée et une agrégation supplémentaire entre plusieurs éléments de cette structure.
|
||
|
||
## arrayPopBack {#arraypopback}
|
||
|
||
Supprime le dernier élément du tableau.
|
||
|
||
``` sql
|
||
arrayPopBack(array)
|
||
```
|
||
|
||
**Paramètre**
|
||
|
||
- `array` – Array.
|
||
|
||
**Exemple**
|
||
|
||
``` sql
|
||
SELECT arrayPopBack([1, 2, 3]) AS res
|
||
```
|
||
|
||
``` text
|
||
┌─res───┐
|
||
│ [1,2] │
|
||
└───────┘
|
||
```
|
||
|
||
## arrayPopFront {#arraypopfront}
|
||
|
||
Supprime le premier élément de la matrice.
|
||
|
||
``` sql
|
||
arrayPopFront(array)
|
||
```
|
||
|
||
**Paramètre**
|
||
|
||
- `array` – Array.
|
||
|
||
**Exemple**
|
||
|
||
``` sql
|
||
SELECT arrayPopFront([1, 2, 3]) AS res
|
||
```
|
||
|
||
``` text
|
||
┌─res───┐
|
||
│ [2,3] │
|
||
└───────┘
|
||
```
|
||
|
||
## arrayPushBack {#arraypushback}
|
||
|
||
Ajoute un élément à la fin du tableau.
|
||
|
||
``` sql
|
||
arrayPushBack(array, single_value)
|
||
```
|
||
|
||
**Paramètre**
|
||
|
||
- `array` – Array.
|
||
- `single_value` – A single value. Only numbers can be added to an array with numbers, and only strings can be added to an array of strings. When adding numbers, ClickHouse automatically sets the `single_value` type pour le type de données du tableau. Pour plus d'informations sur les types de données dans ClickHouse, voir “[Types de données](../../sql-reference/data-types/index.md#data_types)”. Peut être `NULL`. La fonction ajoute un `NULL` tableau, et le type d'éléments de tableau convertit en `Nullable`.
|
||
|
||
**Exemple**
|
||
|
||
``` sql
|
||
SELECT arrayPushBack(['a'], 'b') AS res
|
||
```
|
||
|
||
``` text
|
||
┌─res───────┐
|
||
│ ['a','b'] │
|
||
└───────────┘
|
||
```
|
||
|
||
## arrayPushFront {#arraypushfront}
|
||
|
||
Ajoute un élément au début du tableau.
|
||
|
||
``` sql
|
||
arrayPushFront(array, single_value)
|
||
```
|
||
|
||
**Paramètre**
|
||
|
||
- `array` – Array.
|
||
- `single_value` – A single value. Only numbers can be added to an array with numbers, and only strings can be added to an array of strings. When adding numbers, ClickHouse automatically sets the `single_value` type pour le type de données du tableau. Pour plus d'informations sur les types de données dans ClickHouse, voir “[Types de données](../../sql-reference/data-types/index.md#data_types)”. Peut être `NULL`. La fonction ajoute un `NULL` tableau, et le type d'éléments de tableau convertit en `Nullable`.
|
||
|
||
**Exemple**
|
||
|
||
``` sql
|
||
SELECT arrayPushFront(['b'], 'a') AS res
|
||
```
|
||
|
||
``` text
|
||
┌─res───────┐
|
||
│ ['a','b'] │
|
||
└───────────┘
|
||
```
|
||
|
||
## arrayResize {#arrayresize}
|
||
|
||
Les changements de la longueur du tableau.
|
||
|
||
``` sql
|
||
arrayResize(array, size[, extender])
|
||
```
|
||
|
||
**Paramètre:**
|
||
|
||
- `array` — Array.
|
||
- `size` — Required length of the array.
|
||
- Si `size` est inférieure à la taille d'origine du tableau, le tableau est tronqué à partir de la droite.
|
||
- Si `size` est plus grande que la taille initiale du tableau, le tableau est étendu vers la droite avec `extender` valeurs ou valeurs par défaut pour le type de données des éléments du tableau.
|
||
- `extender` — Value for extending an array. Can be `NULL`.
|
||
|
||
**Valeur renvoyée:**
|
||
|
||
Un tableau de longueur `size`.
|
||
|
||
**Exemples d'appels**
|
||
|
||
``` sql
|
||
SELECT arrayResize([1], 3)
|
||
```
|
||
|
||
``` text
|
||
┌─arrayResize([1], 3)─┐
|
||
│ [1,0,0] │
|
||
└─────────────────────┘
|
||
```
|
||
|
||
``` sql
|
||
SELECT arrayResize([1], 3, NULL)
|
||
```
|
||
|
||
``` text
|
||
┌─arrayResize([1], 3, NULL)─┐
|
||
│ [1,NULL,NULL] │
|
||
└───────────────────────────┘
|
||
```
|
||
|
||
## arraySlice {#arrayslice}
|
||
|
||
Retourne une tranche du tableau.
|
||
|
||
``` sql
|
||
arraySlice(array, offset[, length])
|
||
```
|
||
|
||
**Paramètre**
|
||
|
||
- `array` – Array of data.
|
||
- `offset` – Indent from the edge of the array. A positive value indicates an offset on the left, and a negative value is an indent on the right. Numbering of the array items begins with 1.
|
||
- `length` - La longueur de la nécessaire tranche. Si vous spécifiez une valeur négative, la fonction renvoie un ouvert tranche `[offset, array_length - length)`. Si vous omettez la valeur, la fonction renvoie la tranche `[offset, the_end_of_array]`.
|
||
|
||
**Exemple**
|
||
|
||
``` sql
|
||
SELECT arraySlice([1, 2, NULL, 4, 5], 2, 3) AS res
|
||
```
|
||
|
||
``` text
|
||
┌─res────────┐
|
||
│ [2,NULL,4] │
|
||
└────────────┘
|
||
```
|
||
|
||
Éléments de tableau définis sur `NULL` sont traités comme des valeurs normales.
|
||
|
||
## arraySort(\[func,\] arr, …) {#array_functions-sort}
|
||
|
||
Trie les éléments de la `arr` tableau dans l'ordre croissant. Si l' `func` fonction est spécifiée, l'ordre de tri est déterminé par le résultat de la `func` fonction appliquée aux éléments du tableau. Si `func` accepte plusieurs arguments, le `arraySort` la fonction est passé plusieurs tableaux que les arguments de `func` correspond à. Des exemples détaillés sont présentés à la fin de `arraySort` Description.
|
||
|
||
Exemple de tri de valeurs entières:
|
||
|
||
``` sql
|
||
SELECT arraySort([1, 3, 3, 0]);
|
||
```
|
||
|
||
``` text
|
||
┌─arraySort([1, 3, 3, 0])─┐
|
||
│ [0,1,3,3] │
|
||
└─────────────────────────┘
|
||
```
|
||
|
||
Exemple de tri des valeurs de chaîne:
|
||
|
||
``` sql
|
||
SELECT arraySort(['hello', 'world', '!']);
|
||
```
|
||
|
||
``` text
|
||
┌─arraySort(['hello', 'world', '!'])─┐
|
||
│ ['!','hello','world'] │
|
||
└────────────────────────────────────┘
|
||
```
|
||
|
||
Considérez l'ordre de tri suivant pour le `NULL`, `NaN` et `Inf` valeur:
|
||
|
||
``` sql
|
||
SELECT arraySort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]);
|
||
```
|
||
|
||
``` text
|
||
┌─arraySort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf])─┐
|
||
│ [-inf,-4,1,2,3,inf,nan,nan,NULL,NULL] │
|
||
└───────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
- `-Inf` les valeurs sont d'abord dans le tableau.
|
||
- `NULL` les valeurs sont les derniers dans le tableau.
|
||
- `NaN` les valeurs sont juste avant `NULL`.
|
||
- `Inf` les valeurs sont juste avant `NaN`.
|
||
|
||
Notez que `arraySort` est un [fonction d'ordre supérieur](higher-order-functions.md). Vous pouvez passer d'une fonction lambda comme premier argument. Dans ce cas, l'ordre de classement est déterminé par le résultat de la fonction lambda appliquée aux éléments de la matrice.
|
||
|
||
Considérons l'exemple suivant:
|
||
|
||
``` sql
|
||
SELECT arraySort((x) -> -x, [1, 2, 3]) as res;
|
||
```
|
||
|
||
``` text
|
||
┌─res─────┐
|
||
│ [3,2,1] │
|
||
└─────────┘
|
||
```
|
||
|
||
For each element of the source array, the lambda function returns the sorting key, that is, \[1 –\> -1, 2 –\> -2, 3 –\> -3\]. Since the `arraySort` fonction trie les touches dans l'ordre croissant, le résultat est \[3, 2, 1\]. Ainsi, l' `(x) –> -x` fonction lambda définit le [l'ordre décroissant](#array_functions-reverse-sort) dans un tri.
|
||
|
||
La fonction lambda peut accepter plusieurs arguments. Dans ce cas, vous avez besoin de passer l' `arraySort` fonction plusieurs tableaux de longueur identique à laquelle correspondront les arguments de la fonction lambda. Le tableau résultant sera composé d'éléments du premier tableau d'entrée; les éléments du(des) Tableau (s) d'entrée suivant (s) spécifient les clés de tri. Exemple:
|
||
|
||
``` sql
|
||
SELECT arraySort((x, y) -> y, ['hello', 'world'], [2, 1]) as res;
|
||
```
|
||
|
||
``` text
|
||
┌─res────────────────┐
|
||
│ ['world', 'hello'] │
|
||
└────────────────────┘
|
||
```
|
||
|
||
Ici, les éléments qui sont passés dans le deuxième tableau (\[2, 1\]) définissent une clé de tri pour l'élément correspondant à partir du tableau source (\[‘hello’, ‘world’\]), qui est, \[‘hello’ –\> 2, ‘world’ –\> 1\]. Since the lambda function doesn't use `x`, les valeurs réelles du tableau source n'affectent pas l'ordre dans le résultat. Si, ‘hello’ sera le deuxième élément du résultat, et ‘world’ sera le premier.
|
||
|
||
D'autres exemples sont présentés ci-dessous.
|
||
|
||
``` sql
|
||
SELECT arraySort((x, y) -> y, [0, 1, 2], ['c', 'b', 'a']) as res;
|
||
```
|
||
|
||
``` text
|
||
┌─res─────┐
|
||
│ [2,1,0] │
|
||
└─────────┘
|
||
```
|
||
|
||
``` sql
|
||
SELECT arraySort((x, y) -> -y, [0, 1, 2], [1, 2, 3]) as res;
|
||
```
|
||
|
||
``` text
|
||
┌─res─────┐
|
||
│ [2,1,0] │
|
||
└─────────┘
|
||
```
|
||
|
||
!!! note "Note"
|
||
Pour améliorer l'efficacité du tri, de la [Transformation schwartzienne](https://en.wikipedia.org/wiki/Schwartzian_transform) est utilisée.
|
||
|
||
## arrayReverseSort(\[func,\] arr, …) {#array_functions-reverse-sort}
|
||
|
||
Trie les éléments de la `arr` tableau dans l'ordre décroissant. Si l' `func` la fonction est spécifiée, `arr` est trié en fonction du résultat de la `func` fonction appliquée aux éléments du tableau, puis le tableau trié est inversé. Si `func` accepte plusieurs arguments, le `arrayReverseSort` la fonction est passé plusieurs tableaux que les arguments de `func` correspond à. Des exemples détaillés sont présentés à la fin de `arrayReverseSort` Description.
|
||
|
||
Exemple de tri de valeurs entières:
|
||
|
||
``` sql
|
||
SELECT arrayReverseSort([1, 3, 3, 0]);
|
||
```
|
||
|
||
``` text
|
||
┌─arrayReverseSort([1, 3, 3, 0])─┐
|
||
│ [3,3,1,0] │
|
||
└────────────────────────────────┘
|
||
```
|
||
|
||
Exemple de tri des valeurs de chaîne:
|
||
|
||
``` sql
|
||
SELECT arrayReverseSort(['hello', 'world', '!']);
|
||
```
|
||
|
||
``` text
|
||
┌─arrayReverseSort(['hello', 'world', '!'])─┐
|
||
│ ['world','hello','!'] │
|
||
└───────────────────────────────────────────┘
|
||
```
|
||
|
||
Considérez l'ordre de tri suivant pour le `NULL`, `NaN` et `Inf` valeur:
|
||
|
||
``` sql
|
||
SELECT arrayReverseSort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]) as res;
|
||
```
|
||
|
||
``` text
|
||
┌─res───────────────────────────────────┐
|
||
│ [inf,3,2,1,-4,-inf,nan,nan,NULL,NULL] │
|
||
└───────────────────────────────────────┘
|
||
```
|
||
|
||
- `Inf` les valeurs sont d'abord dans le tableau.
|
||
- `NULL` les valeurs sont les derniers dans le tableau.
|
||
- `NaN` les valeurs sont juste avant `NULL`.
|
||
- `-Inf` les valeurs sont juste avant `NaN`.
|
||
|
||
Notez que l' `arrayReverseSort` est un [fonction d'ordre supérieur](higher-order-functions.md). Vous pouvez passer d'une fonction lambda comme premier argument. Exemple est montré ci-dessous.
|
||
|
||
``` sql
|
||
SELECT arrayReverseSort((x) -> -x, [1, 2, 3]) as res;
|
||
```
|
||
|
||
``` text
|
||
┌─res─────┐
|
||
│ [1,2,3] │
|
||
└─────────┘
|
||
```
|
||
|
||
Le tableau est trié de la façon suivante:
|
||
|
||
1. Dans un premier temps, le tableau source (\[1, 2, 3\]) est trié en fonction du résultat de la fonction lambda appliquée aux éléments du tableau. Le résultat est un tableau \[3, 2, 1\].
|
||
2. Tableau qui est obtenu à l'étape précédente, est renversé. Donc, le résultat final est \[1, 2, 3\].
|
||
|
||
La fonction lambda peut accepter plusieurs arguments. Dans ce cas, vous avez besoin de passer l' `arrayReverseSort` fonction plusieurs tableaux de longueur identique à laquelle correspondront les arguments de la fonction lambda. Le tableau résultant sera composé d'éléments du premier tableau d'entrée; les éléments du(des) Tableau (s) d'entrée suivant (s) spécifient les clés de tri. Exemple:
|
||
|
||
``` sql
|
||
SELECT arrayReverseSort((x, y) -> y, ['hello', 'world'], [2, 1]) as res;
|
||
```
|
||
|
||
``` text
|
||
┌─res───────────────┐
|
||
│ ['hello','world'] │
|
||
└───────────────────┘
|
||
```
|
||
|
||
Dans cet exemple, le tableau est trié de la façon suivante:
|
||
|
||
1. Au début, le tableau source (\[‘hello’, ‘world’\]) est triée selon le résultat de la fonction lambda appliquée aux éléments de tableaux. Les éléments qui sont passés dans le deuxième tableau (\[2, 1\]), définissent les clés de tri pour les éléments correspondants du tableau source. Le résultat est un tableau \[‘world’, ‘hello’\].
|
||
2. Tableau trié lors de l'étape précédente, est renversé. Donc, le résultat final est \[‘hello’, ‘world’\].
|
||
|
||
D'autres exemples sont présentés ci-dessous.
|
||
|
||
``` sql
|
||
SELECT arrayReverseSort((x, y) -> y, [4, 3, 5], ['a', 'b', 'c']) AS res;
|
||
```
|
||
|
||
``` text
|
||
┌─res─────┐
|
||
│ [5,3,4] │
|
||
└─────────┘
|
||
```
|
||
|
||
``` sql
|
||
SELECT arrayReverseSort((x, y) -> -y, [4, 3, 5], [1, 2, 3]) AS res;
|
||
```
|
||
|
||
``` text
|
||
┌─res─────┐
|
||
│ [4,3,5] │
|
||
└─────────┘
|
||
```
|
||
|
||
## arrayUniq(arr, …) {#arrayuniqarr}
|
||
|
||
Si un argument est passé, il compte le nombre de différents éléments dans le tableau.
|
||
Si plusieurs arguments sont passés, il compte le nombre de tuples différents d'éléments aux positions correspondantes dans plusieurs tableaux.
|
||
|
||
Si vous souhaitez obtenir une liste des éléments dans un tableau, vous pouvez utiliser arrayReduce(‘groupUniqArray’, arr).
|
||
|
||
## arrayJoin (arr) {#array-functions-join}
|
||
|
||
Une fonction spéciale. Voir la section [“ArrayJoin function”](array-join.md#functions_arrayjoin).
|
||
|
||
## tableaudifférence {#arraydifference}
|
||
|
||
Calcule la différence entre les éléments de tableau adjacents. Renvoie un tableau où le premier élément sera 0, le second est la différence entre `a[1] - a[0]`, etc. The type of elements in the resulting array is determined by the type inference rules for subtraction (e.g. `UInt8` - `UInt8` = `Int16`).
|
||
|
||
**Syntaxe**
|
||
|
||
``` sql
|
||
arrayDifference(array)
|
||
```
|
||
|
||
**Paramètre**
|
||
|
||
- `array` – [Tableau](https://clickhouse.tech/docs/en/data_types/array/).
|
||
|
||
**Valeurs renvoyées**
|
||
|
||
Renvoie un tableau de différences entre les éléments adjacents.
|
||
|
||
Type: [UInt\*](https://clickhouse.tech/docs/en/data_types/int_uint/#uint-ranges), [Int\*](https://clickhouse.tech/docs/en/data_types/int_uint/#int-ranges), [Flottant\*](https://clickhouse.tech/docs/en/data_types/float/).
|
||
|
||
**Exemple**
|
||
|
||
Requête:
|
||
|
||
``` sql
|
||
SELECT arrayDifference([1, 2, 3, 4])
|
||
```
|
||
|
||
Résultat:
|
||
|
||
``` text
|
||
┌─arrayDifference([1, 2, 3, 4])─┐
|
||
│ [0,1,1,1] │
|
||
└───────────────────────────────┘
|
||
```
|
||
|
||
Exemple de débordement dû au type de résultat Int64:
|
||
|
||
Requête:
|
||
|
||
``` sql
|
||
SELECT arrayDifference([0, 10000000000000000000])
|
||
```
|
||
|
||
Résultat:
|
||
|
||
``` text
|
||
┌─arrayDifference([0, 10000000000000000000])─┐
|
||
│ [0,-8446744073709551616] │
|
||
└────────────────────────────────────────────┘
|
||
```
|
||
|
||
## arrayDistinct {#arraydistinct}
|
||
|
||
Prend un tableau, retourne un tableau contenant les différents éléments seulement.
|
||
|
||
**Syntaxe**
|
||
|
||
``` sql
|
||
arrayDistinct(array)
|
||
```
|
||
|
||
**Paramètre**
|
||
|
||
- `array` – [Tableau](https://clickhouse.tech/docs/en/data_types/array/).
|
||
|
||
**Valeurs renvoyées**
|
||
|
||
Retourne un tableau contenant les éléments distincts.
|
||
|
||
**Exemple**
|
||
|
||
Requête:
|
||
|
||
``` sql
|
||
SELECT arrayDistinct([1, 2, 2, 3, 1])
|
||
```
|
||
|
||
Résultat:
|
||
|
||
``` text
|
||
┌─arrayDistinct([1, 2, 2, 3, 1])─┐
|
||
│ [1,2,3] │
|
||
└────────────────────────────────┘
|
||
```
|
||
|
||
## arrayEnumerateDense(arr) {#array_functions-arrayenumeratedense}
|
||
|
||
Renvoie un tableau de la même taille que le tableau source, indiquant où chaque élément apparaît en premier dans le tableau source.
|
||
|
||
Exemple:
|
||
|
||
``` sql
|
||
SELECT arrayEnumerateDense([10, 20, 10, 30])
|
||
```
|
||
|
||
``` text
|
||
┌─arrayEnumerateDense([10, 20, 10, 30])─┐
|
||
│ [1,2,1,3] │
|
||
└───────────────────────────────────────┘
|
||
```
|
||
|
||
## arrayIntersect (arr) {#array-functions-arrayintersect}
|
||
|
||
Prend plusieurs tableaux, retourne un tableau avec des éléments présents dans tous les tableaux source. L'ordre des éléments dans le tableau résultant est le même que dans le premier tableau.
|
||
|
||
Exemple:
|
||
|
||
``` sql
|
||
SELECT
|
||
arrayIntersect([1, 2], [1, 3], [2, 3]) AS no_intersect,
|
||
arrayIntersect([1, 2], [1, 3], [1, 4]) AS intersect
|
||
```
|
||
|
||
``` text
|
||
┌─no_intersect─┬─intersect─┐
|
||
│ [] │ [1] │
|
||
└──────────────┴───────────┘
|
||
```
|
||
|
||
## arrayReduce {#arrayreduce}
|
||
|
||
Applique une fonction d'agrégation aux éléments du tableau et renvoie son résultat. Le nom de la fonction d'agrégation est passé sous forme de chaîne entre guillemets simples `'max'`, `'sum'`. Lorsque vous utilisez des fonctions d'agrégat paramétriques, le paramètre est indiqué après le nom de la fonction entre parenthèses `'uniqUpTo(6)'`.
|
||
|
||
**Syntaxe**
|
||
|
||
``` sql
|
||
arrayReduce(agg_func, arr1, arr2, ..., arrN)
|
||
```
|
||
|
||
**Paramètre**
|
||
|
||
- `agg_func` — The name of an aggregate function which should be a constant [chaîne](../../sql-reference/data-types/string.md).
|
||
- `arr` — Any number of [tableau](../../sql-reference/data-types/array.md) tapez les colonnes comme paramètres de la fonction d'agrégation.
|
||
|
||
**Valeur renvoyée**
|
||
|
||
**Exemple**
|
||
|
||
``` sql
|
||
SELECT arrayReduce('max', [1, 2, 3])
|
||
```
|
||
|
||
``` text
|
||
┌─arrayReduce('max', [1, 2, 3])─┐
|
||
│ 3 │
|
||
└───────────────────────────────┘
|
||
```
|
||
|
||
Si une fonction d'agrégation prend plusieurs arguments, cette fonction doit être appliqué à plusieurs ensembles de même taille.
|
||
|
||
``` sql
|
||
SELECT arrayReduce('maxIf', [3, 5], [1, 0])
|
||
```
|
||
|
||
``` text
|
||
┌─arrayReduce('maxIf', [3, 5], [1, 0])─┐
|
||
│ 3 │
|
||
└──────────────────────────────────────┘
|
||
```
|
||
|
||
Exemple avec une fonction d'agrégat paramétrique:
|
||
|
||
``` sql
|
||
SELECT arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
|
||
```
|
||
|
||
``` text
|
||
┌─arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])─┐
|
||
│ 4 │
|
||
└─────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
## arrayReduceInRanges {#arrayreduceinranges}
|
||
|
||
Applique une fonction d'agrégation d'éléments de tableau dans des plages et retourne un tableau contenant le résultat correspondant à chaque gamme. La fonction retourne le même résultat que plusieurs `arrayReduce(agg_func, arraySlice(arr1, index, length), ...)`.
|
||
|
||
**Syntaxe**
|
||
|
||
``` sql
|
||
arrayReduceInRanges(agg_func, ranges, arr1, arr2, ..., arrN)
|
||
```
|
||
|
||
**Paramètre**
|
||
|
||
- `agg_func` — The name of an aggregate function which should be a constant [chaîne](../../sql-reference/data-types/string.md).
|
||
- `ranges` — The ranges to aggretate which should be an [tableau](../../sql-reference/data-types/array.md) de [tuple](../../sql-reference/data-types/tuple.md) qui contient l'indice et la longueur de chaque plage.
|
||
- `arr` — Any number of [tableau](../../sql-reference/data-types/array.md) tapez les colonnes comme paramètres de la fonction d'agrégation.
|
||
|
||
**Valeur renvoyée**
|
||
|
||
**Exemple**
|
||
|
||
``` sql
|
||
SELECT arrayReduceInRanges(
|
||
'sum',
|
||
[(1, 5), (2, 3), (3, 4), (4, 4)],
|
||
[1000000, 200000, 30000, 4000, 500, 60, 7]
|
||
) AS res
|
||
```
|
||
|
||
``` text
|
||
┌─res─────────────────────────┐
|
||
│ [1234500,234000,34560,4567] │
|
||
└─────────────────────────────┘
|
||
```
|
||
|
||
## arrayReverse(arr) {#arrayreverse}
|
||
|
||
Retourne un tableau de la même taille que l'original tableau contenant les éléments dans l'ordre inverse.
|
||
|
||
Exemple:
|
||
|
||
``` sql
|
||
SELECT arrayReverse([1, 2, 3])
|
||
```
|
||
|
||
``` text
|
||
┌─arrayReverse([1, 2, 3])─┐
|
||
│ [3,2,1] │
|
||
└─────────────────────────┘
|
||
```
|
||
|
||
## inverse (arr) {#array-functions-reverse}
|
||
|
||
Synonyme de [“arrayReverse”](#arrayreverse)
|
||
|
||
## arrayFlatten {#arrayflatten}
|
||
|
||
Convertit un tableau de tableaux dans un tableau associatif.
|
||
|
||
Fonction:
|
||
|
||
- S'applique à toute profondeur de tableaux imbriqués.
|
||
- Ne change pas les tableaux qui sont déjà plats.
|
||
|
||
Le tableau aplati contient tous les éléments de tous les tableaux source.
|
||
|
||
**Syntaxe**
|
||
|
||
``` sql
|
||
flatten(array_of_arrays)
|
||
```
|
||
|
||
Alias: `flatten`.
|
||
|
||
**Paramètre**
|
||
|
||
- `array_of_arrays` — [Tableau](../../sql-reference/data-types/array.md) de tableaux. Exemple, `[[1,2,3], [4,5]]`.
|
||
|
||
**Exemple**
|
||
|
||
``` sql
|
||
SELECT flatten([[[1]], [[2], [3]]])
|
||
```
|
||
|
||
``` text
|
||
┌─flatten(array(array([1]), array([2], [3])))─┐
|
||
│ [1,2,3] │
|
||
└─────────────────────────────────────────────┘
|
||
```
|
||
|
||
## arrayCompact {#arraycompact}
|
||
|
||
Supprime les éléments en double consécutifs d'un tableau. L'ordre des valeurs de résultat est déterminée par l'ordre dans le tableau source.
|
||
|
||
**Syntaxe**
|
||
|
||
``` sql
|
||
arrayCompact(arr)
|
||
```
|
||
|
||
**Paramètre**
|
||
|
||
`arr` — The [tableau](../../sql-reference/data-types/array.md) inspecter.
|
||
|
||
**Valeur renvoyée**
|
||
|
||
Le tableau sans doublon.
|
||
|
||
Type: `Array`.
|
||
|
||
**Exemple**
|
||
|
||
Requête:
|
||
|
||
``` sql
|
||
SELECT arrayCompact([1, 1, nan, nan, 2, 3, 3, 3])
|
||
```
|
||
|
||
Résultat:
|
||
|
||
``` text
|
||
┌─arrayCompact([1, 1, nan, nan, 2, 3, 3, 3])─┐
|
||
│ [1,nan,nan,2,3] │
|
||
└────────────────────────────────────────────┘
|
||
```
|
||
|
||
## arrayZip {#arrayzip}
|
||
|
||
Combine plusieurs tableaux en un seul tableau. Le tableau résultant contient les éléments correspondants des tableaux source regroupés en tuples dans l'ordre des arguments listés.
|
||
|
||
**Syntaxe**
|
||
|
||
``` sql
|
||
arrayZip(arr1, arr2, ..., arrN)
|
||
```
|
||
|
||
**Paramètre**
|
||
|
||
- `arrN` — [Tableau](../data-types/array.md).
|
||
|
||
La fonction peut prendre n'importe quel nombre de tableaux de différents types. Tous les tableaux doivent être de taille égale.
|
||
|
||
**Valeur renvoyée**
|
||
|
||
- Tableau avec des éléments des tableaux source regroupés en [tuple](../data-types/tuple.md). Types de données dans le tuple sont les mêmes que les types de l'entrée des tableaux et dans le même ordre que les tableaux sont passés.
|
||
|
||
Type: [Tableau](../data-types/array.md).
|
||
|
||
**Exemple**
|
||
|
||
Requête:
|
||
|
||
``` sql
|
||
SELECT arrayZip(['a', 'b', 'c'], [5, 2, 1])
|
||
```
|
||
|
||
Résultat:
|
||
|
||
``` text
|
||
┌─arrayZip(['a', 'b', 'c'], [5, 2, 1])─┐
|
||
│ [('a',5),('b',2),('c',1)] │
|
||
└──────────────────────────────────────┘
|
||
```
|
||
|
||
## arrayAUC {#arrayauc}
|
||
|
||
Calculer AUC (zone sous la courbe, qui est un concept dans l'apprentissage automatique, voir plus de détails: https://en.wikipedia.org/wiki/Receiver\_operating\_characteristic\#Area\_under\_the\_curve).
|
||
|
||
**Syntaxe**
|
||
|
||
``` sql
|
||
arrayAUC(arr_scores, arr_labels)
|
||
```
|
||
|
||
**Paramètre**
|
||
- `arr_scores` — scores prediction model gives.
|
||
- `arr_labels` — labels of samples, usually 1 for positive sample and 0 for negtive sample.
|
||
|
||
**Valeur renvoyée**
|
||
Renvoie la valeur AUC avec le type Float64.
|
||
|
||
**Exemple**
|
||
Requête:
|
||
|
||
``` sql
|
||
select arrayAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1])
|
||
```
|
||
|
||
Résultat:
|
||
|
||
``` text
|
||
┌─arrayAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1])─┐
|
||
│ 0.75 │
|
||
└────────────────────────────────────────---──┘
|
||
```
|
||
|
||
[Article Original](https://clickhouse.tech/docs/en/query_language/functions/array_functions/) <!--hide-->
|