ClickHouse/docs/fr/sql-reference/functions/array-functions.md
BayoNet dba72d73fe
DOCS-624: Fixing links to nowhere (#10675)
* enbaskakova-DOCSUP-652 (#101)

* "docs(orNull&orDefault): Functions 'orNull&orDefault' have been edited"

* "docs(orNull&orDefault): Functions 'orNull&orDefault' have been edited"

* "docs(orNull&orDefault): Functions 'orNull&orDefault' have been edited"

* Update docs/en/sql_reference/aggregate_functions/combinators.md

Co-Authored-By: BayoNet <da-daos@yandex.ru>

* Update docs/en/sql_reference/aggregate_functions/combinators.md

Co-Authored-By: BayoNet <da-daos@yandex.ru>

* Update docs/en/sql_reference/aggregate_functions/combinators.md

Co-Authored-By: BayoNet <da-daos@yandex.ru>

* Update docs/en/sql_reference/aggregate_functions/combinators.md

Co-Authored-By: BayoNet <da-daos@yandex.ru>

* Update docs/en/sql_reference/aggregate_functions/combinators.md

Co-Authored-By: BayoNet <da-daos@yandex.ru>

* "docs(orNull&orDefault): Functions 'orNull&orDefault' have been edited"

* "docs(orNull&orDefault): Functions 'orNull&orDefault' have been edited"

* "docs(orNull&orDefault): Functions 'orNull&orDefault' have been edited"

Co-authored-by: elenbaskakova <elenbaskakova@yandex-team.ru>
Co-authored-by: BayoNet <da-daos@yandex.ru>

* Revert "enbaskakova-DOCSUP-652 (#101)" (#107)

This reverts commit 639fee7610.

* CLICKHOUSEDOCS-624: Fixed links. Was 60, became 13.

* CLICKHOUSEDOCS-624: Finished fix links in Enlish version.

* CLICKHOUSEDOCS-624: Fixed RU links

Co-authored-by: elenaspb2019 <47083263+elenaspb2019@users.noreply.github.com>
Co-authored-by: elenbaskakova <elenbaskakova@yandex-team.ru>
Co-authored-by: Sergei Shtykov <bayonet@yandex-team.ru>
2020-05-06 09:13:29 +03:00

34 KiB
Raw Blame History

machine_translated machine_translated_rev toc_priority toc_title
true f865c9653f 46 Travailler avec des tableaux

Fonctions Pour Travailler Avec Des Tableaux

vide

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

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

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

emptyArrayInt8, emptyArrayInt16, emptyArrayInt32, emptyArrayInt64

emptyArrayFloat32, emptyArrayFloat64

emptyArrayDate, emptyArrayDateTime

emptyArrayString

Accepte zéro argument et renvoie un tableau vide du type approprié.

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])

Retourne un tableau de nombres du début à la fin-1 par étape. Si largument start nest pas spécifié, la valeur par défaut est 0. Si largument step nest 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 darguments doivent être UInt nombre. Juste au cas où, une exception est levée si des tableaux dune longueur totale de plus de 100 000 000 déléments sont créés dans un bloc de données.

array(x1, …), 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 nest 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

Combine des tableaux passés comme arguments.

arrayConcat(arrays)

Paramètre

  • arrays Arbitrary number of arguments of Tableau type. Exemple
SELECT arrayConcat([1, 2], [3, 4], [5, 6]) AS res
┌─res───────────┐
│ [1,2,3,4,5,6] │
└───────────────┘

arrayElement(arr, n), opérateur arr[n]

Récupérer lélément avec lindex n à partir du tableau arr. n doit être nimporte quel type entier. Les index dans un tableau commencent à partir dun. 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 lindex est en dehors des limites dun 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)

Vérifie si le arr tableau a la elem élément. Retourne 0 si lélément nest pas dans le tableau, ou 1 si elle lest.

NULL est traitée comme une valeur.

SELECT has([1, 2, NULL], NULL)
┌─has([1, 2, NULL], NULL)─┐
│                       1 │
└─────────────────────────┘

hasAll

Vérifie si un tableau est un sous-ensemble de lautre.

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 dun tableau quelconque.
  • Null traitée comme une valeur.
  • Ordre des valeurs dans les deux tableaux na pas dimportance.

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

Vérifie si deux tableaux ont une intersection par certains éléments.

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 na pas dimportance.

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)

Renvoie lindex de la première x élément (à partir de 1) sil est dans le tableau, ou 0 sil ne lest pas.

Exemple:

SELECT indexOf([1, 3, NULL, NULL], NULL)
┌─indexOf([1, 3, NULL, NULL], NULL)─┐
│                                 3 │
└───────────────────────────────────┘

Ensemble déléments de NULL sont traités comme des valeurs normales.

countEqual (arr, 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:

SELECT countEqual([1, 2, NULL, NULL], NULL)
┌─countEqual([1, 2, NULL, NULL], NULL)─┐
│                                    2 │
└──────────────────────────────────────┘

arrayEnumerate (arr)

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 lapplication de la jointure de tableau. Exemple:

SELECT
    count() AS Reaches,
    countIf(num = 1) AS Hits
FROM test.hits
ARRAY JOIN
    GoalsReached,
    arrayEnumerate(GoalsReached) AS num
WHERE CounterID = 160656
LIMIT 10
┌─Reaches─┬──Hits─┐
│   95606 │ 31406 │
└─────────┴───────┘

Dans cet exemple, Reaches est le nombre de conversions (les chaînes reçues après lapplication 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:

SELECT
    sum(length(GoalsReached)) AS Reaches,
    count() AS Hits
FROM test.hits
WHERE (CounterID = 160656) AND notEmpty(GoalsReached)
┌─Reaches─┬──Hits─┐
│   95606 │ 31406 │
└─────────┴───────┘

Cette fonction peut également être utilisée dans les fonctions dordre supérieur. Par exemple, vous pouvez lutiliser pour obtenir les indices de tableau pour les éléments qui correspondent à une condition.

arrayEnumerateUniq(arr, …)

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 Lutilisation de la jointure de tableau et de lagrégation déléments de tableau. Exemple:

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
┌──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 dobjectif 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, lunicité est considérée pour les tuples déléments dans les mêmes positions dans tous les tableaux.

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

Ceci est nécessaire lors de Lutilisation 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

Supprime le dernier élément du tableau.

arrayPopBack(array)

Paramètre

  • array Array.

Exemple

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

arrayPopFront

Supprime le premier élément de la matrice.

arrayPopFront(array)

Paramètre

  • array Array.

Exemple

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

arrayPushBack

Ajoute un élément à la fin du tableau.

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 dinformations sur les types de données dans ClickHouse, voir “Types de données”. Peut être NULL. La fonction ajoute un NULL tableau, et le type déléments de tableau convertit en Nullable.

Exemple

SELECT arrayPushBack(['a'], 'b') AS res
┌─res───────┐
│ ['a','b'] │
└───────────┘

arrayPushFront

Ajoute un élément au début du tableau.

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 dinformations sur les types de données dans ClickHouse, voir “Types de données”. Peut être NULL. La fonction ajoute un NULL tableau, et le type déléments de tableau convertit en Nullable.

Exemple

SELECT arrayPushFront(['b'], 'a') AS res
┌─res───────┐
│ ['a','b'] │
└───────────┘

arrayResize

Les changements de la longueur du tableau.

arrayResize(array, size[, extender])

Paramètre:

  • array — Array.
  • size — Required length of the array.
    • Si size est inférieure à la taille dorigine 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 dappels

SELECT arrayResize([1], 3)
┌─arrayResize([1], 3)─┐
│ [1,0,0]             │
└─────────────────────┘
SELECT arrayResize([1], 3, NULL)
┌─arrayResize([1], 3, NULL)─┐
│ [1,NULL,NULL]             │
└───────────────────────────┘

arraySlice

Retourne une tranche du tableau.

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

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

Éléments de tableau définis sur NULL sont traités comme des valeurs normales.

arraySort([func,] arr, …)

Trie les éléments de la arr tableau dans lordre croissant. Si l func fonction est spécifiée, lordre 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:

SELECT arraySort([1, 3, 3, 0]);
┌─arraySort([1, 3, 3, 0])─┐
│ [0,1,3,3]               │
└─────────────────────────┘

Exemple de tri des valeurs de chaîne:

SELECT arraySort(['hello', 'world', '!']);
┌─arraySort(['hello', 'world', '!'])─┐
│ ['!','hello','world']              │
└────────────────────────────────────┘

Considérez lordre de tri suivant pour le NULL, NaN et Inf valeur:

SELECT arraySort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]);
┌─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 dabord 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 dordre supérieur. Vous pouvez passer dune fonction lambda comme premier argument. Dans ce cas, lordre de classement est déterminé par le résultat de la fonction lambda appliquée aux éléments de la matrice.

Considérons lexemple suivant:

SELECT arraySort((x) -> -x, [1, 2, 3]) as res;
┌─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 lordre croissant, le résultat est [3, 2, 1]. Ainsi, l (x) > -x fonction lambda définit le lordre décroissant 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 dentrée; les éléments du(des) Tableau (s) dentrée suivant (s) spécifient les clés de tri. Exemple:

SELECT arraySort((x, y) -> y, ['hello', 'world'], [2, 1]) as res;
┌─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 doesnt use x, les valeurs réelles du tableau source naffectent pas lordre dans le résultat. Si, hello sera le deuxième élément du résultat, et world sera le premier.

Dautres exemples sont présentés ci-dessous.

SELECT arraySort((x, y) -> y, [0, 1, 2], ['c', 'b', 'a']) as res;
┌─res─────┐
│ [2,1,0] │
└─────────┘
SELECT arraySort((x, y) -> -y, [0, 1, 2], [1, 2, 3]) as res;
┌─res─────┐
│ [2,1,0] │
└─────────┘

!!! note "Note" Pour améliorer lefficacité du tri, de la Transformation schwartzienne est utilisée.

arrayReverseSort([func,] arr, …)

Trie les éléments de la arr tableau dans lordre 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:

SELECT arrayReverseSort([1, 3, 3, 0]);
┌─arrayReverseSort([1, 3, 3, 0])─┐
│ [3,3,1,0]                      │
└────────────────────────────────┘

Exemple de tri des valeurs de chaîne:

SELECT arrayReverseSort(['hello', 'world', '!']);
┌─arrayReverseSort(['hello', 'world', '!'])─┐
│ ['world','hello','!']                     │
└───────────────────────────────────────────┘

Considérez lordre de tri suivant pour le NULL, NaN et Inf valeur:

SELECT arrayReverseSort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]) as res;
┌─res───────────────────────────────────┐
│ [inf,3,2,1,-4,-inf,nan,nan,NULL,NULL] │
└───────────────────────────────────────┘
  • Inf les valeurs sont dabord 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 dordre supérieur. Vous pouvez passer dune fonction lambda comme premier argument. Exemple est montré ci-dessous.

SELECT arrayReverseSort((x) -> -x, [1, 2, 3]) as res;
┌─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 dentrée; les éléments du(des) Tableau (s) dentrée suivant (s) spécifient les clés de tri. Exemple:

SELECT arrayReverseSort((x, y) -> y, ['hello', 'world'], [2, 1]) as res;
┌─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].

Dautres exemples sont présentés ci-dessous.

SELECT arrayReverseSort((x, y) -> y, [4, 3, 5], ['a', 'b', 'c']) AS res;
┌─res─────┐
│ [5,3,4] │
└─────────┘
SELECT arrayReverseSort((x, y) -> -y, [4, 3, 5], [1, 2, 3]) AS res;
┌─res─────┐
│ [4,3,5] │
└─────────┘

arrayUniq(arr, …)

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)

Une fonction spéciale. Voir la section “ArrayJoin function”.

tableaudifférence

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

arrayDifference(array)

Paramètre

Valeurs renvoyées

Renvoie un tableau de différences entre les éléments adjacents.

Type: UInt*, Int*, Flottant*.

Exemple

Requête:

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

Résultat:

┌─arrayDifference([1, 2, 3, 4])─┐
│ [0,1,1,1]                     │
└───────────────────────────────┘

Exemple de débordement dû au type de résultat Int64:

Requête:

SELECT arrayDifference([0, 10000000000000000000])

Résultat:

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

arrayDistinct

Prend un tableau, retourne un tableau contenant les différents éléments seulement.

Syntaxe

arrayDistinct(array)

Paramètre

Valeurs renvoyées

Retourne un tableau contenant les éléments distincts.

Exemple

Requête:

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

Résultat:

┌─arrayDistinct([1, 2, 2, 3, 1])─┐
│ [1,2,3]                        │
└────────────────────────────────┘

arrayEnumerateDense(arr)

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:

SELECT arrayEnumerateDense([10, 20, 10, 30])
┌─arrayEnumerateDense([10, 20, 10, 30])─┐
│ [1,2,1,3]                             │
└───────────────────────────────────────┘

arrayIntersect (arr)

Prend plusieurs tableaux, retourne un tableau avec des éléments présents dans tous les tableaux source. Lordre des éléments dans le tableau résultant est le même que dans le premier tableau.

Exemple:

SELECT
    arrayIntersect([1, 2], [1, 3], [2, 3]) AS no_intersect,
    arrayIntersect([1, 2], [1, 3], [1, 4]) AS intersect
┌─no_intersect─┬─intersect─┐
│ []           │ [1]       │
└──────────────┴───────────┘

arrayReduce

Applique une fonction dagrégation aux éléments du tableau et renvoie son résultat. Le nom de la fonction dagrégation est passé sous forme de chaîne entre guillemets simples 'max', 'sum'. Lorsque vous utilisez des fonctions dagrégat paramétriques, le paramètre est indiqué après le nom de la fonction entre parenthèses 'uniqUpTo(6)'.

Syntaxe

arrayReduce(agg_func, arr1, arr2, ..., arrN)

Paramètre

  • agg_func — The name of an aggregate function which should be a constant chaîne.
  • arr — Any number of tableau tapez les colonnes comme paramètres de la fonction dagrégation.

Valeur renvoyée

Exemple

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

Si une fonction dagrégation prend plusieurs arguments, cette fonction doit être appliqué à plusieurs ensembles de même taille.

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

Exemple avec une fonction dagrégat paramétrique:

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

arrayReduceInRanges

Applique une fonction dagré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

arrayReduceInRanges(agg_func, ranges, arr1, arr2, ..., arrN)

Paramètre

  • agg_func — The name of an aggregate function which should be a constant chaîne.
  • ranges — The ranges to aggretate which should be an tableau de tuple qui contient lindice et la longueur de chaque plage.
  • arr — Any number of tableau tapez les colonnes comme paramètres de la fonction dagrégation.

Valeur renvoyée

Exemple

SELECT arrayReduceInRanges(
    'sum',
    [(1, 5), (2, 3), (3, 4), (4, 4)],
    [1000000, 200000, 30000, 4000, 500, 60, 7]
) AS res
┌─res─────────────────────────┐
│ [1234500,234000,34560,4567] │
└─────────────────────────────┘

arrayReverse(arr)

Retourne un tableau de la même taille que loriginal tableau contenant les éléments dans lordre inverse.

Exemple:

SELECT arrayReverse([1, 2, 3])
┌─arrayReverse([1, 2, 3])─┐
│ [3,2,1]                 │
└─────────────────────────┘

inverse (arr)

Synonyme de “arrayReverse”

arrayFlatten

Convertit un tableau de tableaux dans un tableau associatif.

Fonction:

  • Sapplique à 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

flatten(array_of_arrays)

Alias: flatten.

Paramètre

  • array_of_arraysTableau de tableaux. Exemple, [[1,2,3], [4,5]].

Exemple

SELECT flatten([[[1]], [[2], [3]]])
┌─flatten(array(array([1]), array([2], [3])))─┐
│ [1,2,3]                                     │
└─────────────────────────────────────────────┘

arrayCompact

Supprime les éléments en double consécutifs dun tableau. Lordre des valeurs de résultat est déterminée par lordre dans le tableau source.

Syntaxe

arrayCompact(arr)

Paramètre

arr — The tableau inspecter.

Valeur renvoyée

Le tableau sans doublon.

Type: Array.

Exemple

Requête:

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

Résultat:

┌─arrayCompact([1, 1, nan, nan, 2, 3, 3, 3])─┐
│ [1,nan,nan,2,3]                            │
└────────────────────────────────────────────┘

arrayZip

Combine multiple Array type columns into one Array[Tuple(…)] column

Syntaxe

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

Paramètre

arr — Any number of tableau tapez les colonnes à combiner.

Valeur renvoyée

The result of Array[Tuple(…)] type after the combination of these arrays

Exemple

Requête:

SELECT arrayZip(['a', 'b', 'c'], ['d', 'e', 'f']);

Résultat:

┌─arrayZip(['a', 'b', 'c'], ['d', 'e', 'f'])─┐
│ [('a','d'),('b','e'),('c','f')]            │
└────────────────────────────────────────────┘

arrayAUC

Calculer AUC (zone sous la courbe, qui est un concept dans lapprentissage automatique, voir plus de détails: https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve).

Syntaxe

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:

select arrayAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1])

Résultat:

┌─arrayAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1])─┐
│                                          0.75 │
└────────────────────────────────────────---──┘

Article Original