Fonctions Array

Introduit dans : v1.1.0

Crée un tableau à partir des arguments de la fonction.

Les arguments doivent être des constantes et avoir des types partageant un supertype commun. Au moins un argument doit être fourni, sinon le type de tableau à créer n’est pas clair. Cela signifie que vous ne pouvez pas utiliser cette fonction pour créer un tableau vide. Pour cela, utilisez la fonction emptyArray*.

Utilisez l’opérateur [ ] pour obtenir le même résultat.

Syntaxe

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

Arguments

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

Valeur renvoyée

Renvoie un tableau, où 'T' est le plus petit type commun parmi les arguments passés. Array(T)

Exemples

Utilisation valide

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

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

Utilisation incorrecte

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

┌─a───────────────────────────┬─toTypeName(a)─────────────────────────┐
│ [5,'1998-06-16 00:00:00',5] │ Array(Variant(DateTime, Int32, Int8)) │
└─────────────────────────────┴───────────────────────────────────────┘

Introduit dans : v20.4.0

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

Syntaxe

arrayAUCPR(scores, labels[, partial_offsets])

Alias : arrayPRAUC

Arguments

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

Valeur renvoyée

Renvoie l’aire sous la courbe précision-rappel (PR). Float64

Exemples

Exemple d’utilisation

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

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

Introduit dans : v1.1.0

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

Syntaxe

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

Arguments

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

Valeur renvoyée

Renvoie 1 si la fonction lambda renvoie true pour tous les éléments, 0 sinon UInt8

Exemples

Tous les éléments correspondent

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

1

Certains éléments ne correspondent pas

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

0

Introduite dans : v26.4.0

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

Syntaxe

arrayAutocorrelation(arr, [max_lag])

Arguments

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

Valeur renvoyée

Renvoie un tableau de Float64. Renvoie NaN si la variance est égale à 0. Array(Float64)

Exemples

Linéaire

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

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

Symétrique

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

[1,-0.6666666666666669,0.16666666666666674]

Constante

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

[nan,nan,nan]

Limité

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

[1,0.4]

Introduit dans : v21.1.0

Renvoie la moyenne des éléments du tableau source.

Si une fonction lambda func est spécifiée, renvoie la moyenne des éléments obtenus par la fonction lambda.

Syntaxe

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

Arguments

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

Valeur renvoyée

Renvoie la moyenne des éléments du tableau source, ou la moyenne des éléments résultant de la fonction lambda si elle est fournie. Float64

Exemples

Exemple de base

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

2.5

Utilisation avec une fonction lambda

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

6.5

Introduit dans : v26.6.0

Renvoie un tableau des K plus petits éléments du tableau d'entrée, triés par ordre croissant. Si une fonction lambda f est spécifiée, les éléments sont comparés selon le résultat de f appliqué à chaque élément. Si f accepte plusieurs arguments, des tableaux supplémentaires sont transmis à arrayBottomK ; leurs éléments correspondent aux arguments de f.

Les valeurs NULL sont ignorées et n'apparaissent pas dans le résultat. La taille du résultat est au plus K et peut être inférieure lorsque le tableau d'entrée contient moins de K éléments non nuls. Le type d'élément du résultat est la version non nullable du type d'élément d'entrée.

arrayBottomK est une fonction d'ordre supérieur.

Voir aussi :

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

Syntaxe

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

Arguments

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

Valeur renvoyée

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

Exemples

simple_int

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

[1,2,3]

skip_nulls

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

[1,2,5]

fewer_than_k

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

[1,2]

lambda_simple

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

[9,5]

lambda_multi

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

['b','c']

Introduit dans : v20.1.0

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

Syntaxe

arrayCompact(arr)

Arguments

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

Valeur renvoyée

Renvoie un tableau sans doublons Array(T)

Exemples

Exemple d'utilisation

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

[1,nan,2,3]

Introduit dans : v1.1.0

Combine les tableaux fournis en argument.

Syntaxe

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

Arguments

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

Valeur renvoyée

Renvoie un tableau unique obtenu à partir des tableaux fournis en arguments. Array(T)

Exemples

Exemple d’utilisation

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

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

Introduite dans : v1.1.0

Renvoie le nombre d’éléments pour lesquels func(arr1[i], ..., arrN[i]) renvoie true. Si func n’est pas spécifiée, arrayCount renvoie le nombre d’éléments non nuls du tableau.

arrayCount est une fonction d’ordre supérieur.

Syntaxe

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

Arguments

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

Valeur renvoyée

Renvoie le nombre d'éléments pour lesquels func renvoie true. Sinon, renvoie le nombre d'éléments non nuls du tableau. UInt32

Exemples

Exemple d'utilisation

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

5

Introduit dans : v1.1.0

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

Syntaxe

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

Arguments

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

Valeur renvoyée

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

Exemples

Utilisation de base

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

[1,2,3,4]

Avec une fonction lambda

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

[2,6,12]

Introduit dans : v18.12.0

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

Syntaxe

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

Arguments

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

Valeur renvoyée

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

Exemples

Utilisation de base

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

[1,2,0,1]

Avec une fonction lambda

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

[2,0,6]

Introduit dans : v1.1.0

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

Syntaxe

arrayDifference(arr)

Arguments

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

Valeur renvoyée

Renvoie un tableau contenant les différences entre les éléments consécutifs du tableau UInt*

Exemples

Exemple d'utilisation

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

[0,1,1,1]

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

SELECT arrayDifference([0, 10000000000000000000]);

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

Introduit dans : v1.1.0

Renvoie un tableau contenant uniquement les éléments distincts d’un tableau.

Syntaxe

arrayDistinct(arr)

Arguments

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

Valeur renvoyée

Renvoie un tableau contenant les éléments distincts Array(T)

Exemples

Exemple d'utilisation

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

[1,2,3]

Introduit dans : v23.5.0

Renvoie le produit scalaire de deux tableaux.

Syntaxe

arrayDotProduct(v1, v2)

Arguments

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

Valeur renvoyée

Le produit scalaire des deux vecteurs.

(U)Int* ou Float* ou Decimal

Exemples

Exemple avec Array

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

32	UInt16

Exemple de Tuple

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

32	Float64

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.

Lorsque n est un tableau d'entiers, renvoie un tableau contenant les éléments aux positions spécifiées (opération de collecte). Cela équivaut à arrayMap(i -> arr[i], n), mais possède une implémentation distincte et plus efficace. Les positions hors limites produisent la valeur par défaut, comme pour un indice scalaire. Les éléments d'indice peuvent être nullable. Un indice NULL produit NULL (et rend le type d'élément du résultat nullable) lorsque le type d'élément peut être encapsulé dans Nullable ; pour les types d'éléments qui ne peuvent pas être contenus dans Nullable (comme Array, Map), un indice NULL produit à la place la valeur par défaut. Il s'agit du même comportement que pour un indice scalaire NULL.

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é.

Le premier argument peut également être un QBit : le n-ième élément du vecteur est reconstruit avec la précision complète du type d'élément QBit, en ne lisant que les plans de bits du groupe de stride auquel il appartient.

Syntaxe

arrayElement(arr, n)

Arguments

• arr — Le tableau à parcourir. Array(T) ou QBit. - n — Position de l'élément à récupérer, ou tableau de positions. Les positions peuvent être nullables. (U)Int* ou Array((U)Int*).

Valeur renvoyée

Lorsque n est un scalaire, renvoie l'élément de type T. Lorsque n est un tableau, renvoie Array(Nullable(T)) si les éléments d'indice sont nullables et que T peut être encapsulé dans Nullable, sinon Array(T). Any ou Array(T) ou Array(Nullable(T))

Exemples

Exemple d'utilisation

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

2

Indices négatifs

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

3

Utiliser la notation [n]

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

2

Indice hors limites du tableau

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

0

Tableau d’indices

SELECT [10, 20, 30, 40][[2, 4, 1]]

[20,40,10]

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, à condition que le type de résultat puisse être nullable. Pour les types d’éléments qui ne sont pas déjà nullable et ne peuvent pas être placés dans Nullable (comme Array, Map), la valeur par défaut du type d’élément est renvoyée à la place.

Lorsque n est un tableau d’entiers, renvoie un tableau contenant les éléments aux positions spécifiées. Cela équivaut à arrayMap(i -> arrayElementOrNull(arr, i), n), mais bénéficie d’une implémentation distincte et plus efficace. Les positions hors limites et les indices NULL produisent des valeurs NULL dans le tableau résultant, suivant la même règle que pour un indice scalaire.

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

arrayElementOrNull(arr, n)

Arguments

• arr — Le tableau dans lequel effectuer la recherche. Array(T). - n — Position de l’élément à récupérer, ou tableau de positions. Les positions peuvent être nullables. (U)Int* ou Array((U)Int*).

Valeur renvoyée

Lorsque n est un scalaire, renvoie Nullable(T) si T peut être encapsulé dans Nullable, sinon T. Lorsque n est un tableau, renvoie Array(Nullable(T)) si T peut être encapsulé dans Nullable, sinon Array(T). Any ou Nullable(T) ou Array(T) ou Array(Nullable(T))

Exemples

Exemple d'utilisation

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

2

Indices négatifs

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

3

Indice hors limites du tableau

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

\N

Tableau d’indices

SELECT arrayElementOrNull([10, 20, 30], [1, 5, 2])

[10,NULL,20]

Introduit dans : v1.1.0

Renvoie le tableau [1, 2, 3, ..., length (arr)]

Cette fonction est généralement utilisée avec la clause ARRAY JOIN. Elle permet de ne compter quelque chose qu'une seule fois pour chaque tableau après l'application de ARRAY JOIN. Cette fonction peut également être utilisée dans des fonctions d'ordre supérieur. Par exemple, vous pouvez l'utiliser pour obtenir les indices des éléments d'un tableau qui correspondent à une condition.

Syntaxe

arrayEnumerate(arr)

Arguments

• arr — Le tableau à énumérer. Array

Valeur renvoyée

Renvoie le tableau [1, 2, 3, ..., length (arr)]. Array(UInt32)

Exemples

Exemple de base avec ARRAY JOIN

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

┌─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 │
└────┴────────────────┴─────────────┴─────┘

Introduit dans : v18.12.0

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

Syntaxe

arrayEnumerateDense(arr)

Arguments

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

Valeur renvoyée

Renvoie un tableau de même taille que arr, indiquant la position de la première occurrence de chaque élément dans le tableau source Array(T)

Exemples

Exemple d'utilisation

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

[1,2,1,3]

Introduite dans : v20.1.0

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

Syntaxe

arrayEnumerateDenseRanked(clear_depth, arr, max_array_depth)

Arguments

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

Valeur renvoyée

Renvoie un tableau indiquant où chaque élément apparaît pour la première fois dans le tableau source Array

Exemples

Utilisation de base

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

[1,2,1,3]

Utilisation avec un tableau multidimensionnel

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

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

Exemple avec clear_depth augmenté

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

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

Introduit dans : v1.1.0

Renvoie un tableau de même taille que le tableau source, où chaque élément indique sa position parmi les éléments de même valeur.

Cette fonction est utile lors de l'utilisation de ARRAY JOIN et de l'agrégation des éléments du tableau.

La fonction peut prendre plusieurs tableaux de même taille comme arguments. Dans ce cas, l'unicité est évaluée sur les tuples d'éléments occupant les mêmes positions dans tous les tableaux.

Syntaxe

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

Arguments

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

Valeur renvoyée

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

Exemples

Utilisation de base

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

[1,1,2,1]

Plusieurs tableaux

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

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

Agrégation avec ARRAY JOIN

-- 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.

CREATE TABLE visits (CounterID UInt32, Sign Int8, Goals Nested(ID UInt32)) ENGINE = Memory;

INSERT INTO visits VALUES
    (160656, 1, [53225, 53225, 56600]),
    (160656, 1, [53225, 2825062]),
    (160656, 1, [56600, 56600, 2825062]),
    (160657, 1, [53225]);

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

┌──GoalID─┬─Reaches─┬─Visits─┐
│   53225 │       3 │      2 │
│   56600 │       3 │      2 │
│ 2825062 │       2 │      2 │
└─────────┴─────────┴────────┘

Introduit dans : v20.1.0

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

Syntaxe

arrayEnumerateUniqRanked(clear_depth, arr, max_array_depth)

Arguments

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

Valeur renvoyée

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

Exemples

Exemple 1

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

[1,1,2]

Exemple 2

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

Exemple 3

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

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

Exemple 4

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

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

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

arrayExcept(source, except)

Arguments

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

Valeur renvoyée

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

Exemples

basic

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

[1,2,2,4]

with_nulls1

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

[1,NULL,NULL]

with_nulls2

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

[1]

chaînes

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

['apple','cherry']

Introduit dans : v1.1.0

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

Syntaxe

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

Arguments

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

Valeur renvoyée

Renvoie 1 si la fonction lambda renvoie true pour au moins un élément, sinon 0 UInt8

Exemples

Exemple d'utilisation

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

0

Introduit dans : v20.1.0

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

Syntaxe

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

Arguments

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

Valeur renvoyée

Renvoie un tableau Array(T)

Exemples

Exemple avec un seul tableau

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

[1,1,2,2]

Exemple avec deux tableaux

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

[5,5,6,6]

Introduit dans : v1.1.0

Renvoie un tableau contenant uniquement les éléments du tableau source pour lesquels une fonction lambda renvoie true.

Syntaxe

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

Arguments

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

Valeur renvoyée

Renvoie un sous-ensemble du tableau source Array(T)

Exemples

Exemple 1

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

['abc World']

Exemple 2

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

[2]

Introduit dans : v1.1.0

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

Syntaxe

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

Arguments

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

Valeur renvoyée

Renvoie le premier élément du tableau source pour lequel λ vaut true ; sinon, renvoie la valeur par défaut de T.

Exemples

Exemple d'utilisation

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

b

Aucune correspondance

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

0	UInt8

Introduit dans : v1.1.0

Renvoie l’indice du premier élément du tableau d’entrée pour lequel func(x[, y1, y2, ... yN]) renvoie vrai, sinon renvoie '0'.

Syntaxe

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

Arguments

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

Valeur renvoyée

Renvoie l’indice du premier élément du tableau source pour lequel func est vrai ; sinon, renvoie 0 UInt32

Exemples

Exemple d’utilisation

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

2

Aucune correspondance

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

0

Introduit dans : v1.1.0

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

Syntaxe

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

Arguments

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

Valeur renvoyée

Renvoie le premier élément du tableau source pour lequel func est vrai ; sinon, renvoie NULL.

Exemples

Exemple d’utilisation

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

b

Aucun résultat

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

\N	Nullable(UInt8)

Introduit dans : v20.1.0

Convertit un tableau de tableaux en un tableau à plat.

Fonction :

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

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

Syntaxe

arrayFlatten(arr)

Alias : flatten

Arguments

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

Valeur renvoyée

Renvoie un tableau aplati Array(T) à partir du tableau multidimensionnel.

Exemples

Exemple d'utilisation

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

[1,2,3]

Introduit dans : v23.10.0

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

Syntaxe

arrayFold(λ

Arguments

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

Valeur renvoyée

Renvoie la valeur finale de acc.

Exemples

Exemple d'utilisation

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

23

Suite de Fibonacci

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

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

Exemple avec plusieurs tableaux

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

300

Introduite dans : v1.1.0

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

Syntaxe

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

Arguments

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

Valeur renvoyée

Renvoie un tableau contenant les éléments distincts présents dans les N tableaux Array(T)

Exemples

Exemple d'utilisation

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

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

Introduit dans : v23.7.0

Renvoie l’indice de Jaccard de deux tableaux.

Syntaxe

arrayJaccardIndex(arr_x, arr_y)

Arguments

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

Valeur renvoyée

Renvoie l’indice de Jaccard entre arr_x et arr_y Float64

Exemples

Exemple d’utilisation

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

0.3333333333333333

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.

unnest (depuis la version 26.5) est un alias insensible à la casse de arrayJoin sous forme d’appel de fonction (SELECT unnest(arr)). La syntaxe PostgreSQL de source de table n’est pas prise en charge (FROM unnest(...), CROSS JOIN UNNEST(...) et LATERAL). Utilisez la clause ARRAY JOIN pour ces requêtes.

arrayJoin, y compris via son alias unnest, ne peut pas être utilisé dans une condition JOIN ON évaluée lors de la jointure, car une telle condition doit préserver le nombre de lignes. Une condition qui ne porte que sur un seul côté, ainsi qu’une clé d’égalité sur arrayJoin, sont extraites avant la jointure et ne sont pas affectées. Une condition ALL INNER JOIN sans disjonction n’est pas non plus affectée, car la condition y est appliquée après la jointure. Lorsque l’expansion ne dépend que d’un côté, déplacez-la dans un ARRAY JOIN d’une sous-requête avant la jointure ; une condition dont l’argument arrayJoin lit des colonnes des deux côtés doit être restructurée.

Syntaxe

arrayJoin(arr)

Alias : unnest

Arguments

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

Valeur renvoyée

Renvoie un ensemble de lignes obtenues en dépliant arr.

Exemples

Utilisation de base

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

┌─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

-- 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'];

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

Utiliser plusieurs fonctions arrayJoin

-- 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
ORDER BY
    city,
    browser

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

Résultats inattendus liés aux optimisations

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

┌─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

-- 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
ORDER BY
    2,
    3

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

Utiliser Tuple

-- 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
ORDER BY
    2,
    3

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

Introduit dans : v1.1.0

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

Syntaxe

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

Arguments

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

Valeur renvoyée

Renvoie le dernier élément du tableau source pour lequel func vaut true, sinon renvoie la valeur par défaut de T.

Exemples

Exemple d'utilisation

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

c

Aucune correspondance

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

0	UInt8

Introduit dans : v1.1.0

Renvoie l’indice du dernier élément du tableau source pour lequel func(x[, y1, y2, ... yN]) renvoie true ; sinon, renvoie '0'.

Syntaxe

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

Arguments

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

Valeur renvoyée

Renvoie l’indice du dernier élément du tableau source pour lequel func est true, sinon renvoie 0 UInt32

Exemples

Exemple d’utilisation

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

3

Aucune correspondance

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

0

Introduit dans : v1.1.0

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

Syntaxe

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

Arguments

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

Valeur renvoyée

Renvoie le dernier élément du tableau source pour lequel λ n’est pas true, sinon renvoie NULL.

Exemples

Exemple d'utilisation

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

c

Aucune correspondance

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

\N	Nullable(UInt8)

Introduit dans : v25.4.0

Calcule la distance de Levenshtein entre deux tableaux.

Syntaxe

arrayLevenshteinDistance(from, to)

Arguments

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

Valeur renvoyée

Distance de Levenshtein entre le premier tableau et le deuxième. Float64

Exemples

Exemple d'utilisation

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

1

Introduit dans : v25.4.0

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

Syntaxe

arrayLevenshteinDistanceWeighted(from, to, from_weights, to_weights)

Arguments

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

Valeur renvoyée

Distance de Levenshtein entre le premier et le deuxième tableaux, avec des poids personnalisés pour chaque élément Float64

Exemples

Exemple d'utilisation

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

14

Introduit dans : v1.1.0

Renvoie un tableau obtenu à partir des tableaux d’origine en appliquant une fonction lambda à chaque élément.

Syntaxe

arrayMap(func, arr)

Arguments

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

Valeur renvoyée

Renvoie un tableau contenant les résultats de la fonction lambda Array(T)

Exemples

Exemple d'utilisation

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

[3,4,5]

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

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

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

Introduit dans : v21.1.0

Renvoie l’élément maximal du tableau source.

Si une fonction lambda func est spécifiée, renvoie l’élément maximal des résultats de la fonction lambda.

Syntaxe

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

Arguments

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

Valeur renvoyée

Renvoie l'élément maximal du tableau source, ou l'élément maximal des résultats de la fonction lambda si elle est fournie.

Exemples

Exemple simple

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

7

Utilisation d'une fonction lambda

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

12

Introduit dans : v21.1.0

Renvoie le plus petit élément du tableau source.

Si une fonction lambda func est spécifiée, renvoie le plus petit élément parmi les résultats de la fonction lambda.

Syntaxe

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

Arguments

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

Valeur renvoyée

Renvoie l’élément minimal du tableau source, ou l’élément minimal des résultats de la fonction lambda si elle est fournie.

Exemples

Exemple simple

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

2

Utilisation avec une fonction lambda

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

4

Introduit dans : v25.1.0

Calcule le coefficient de Gini normalisé.

Syntaxe

arrayNormalizedGini(predicted, label)

Arguments

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

Valeur renvoyée

Un tuple contenant les coefficients de Gini des valeurs prédites, le coefficient de Gini des valeurs normalisées et le coefficient de Gini normalisé (= le rapport entre les deux premiers coefficients de Gini) Tuple(Float64, Float64, Float64)

Exemples

Exemple d'utilisation

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

(0.18055555555555558,0.2638888888888889,0.6842105263157896)

Introduit dans : v23.2.0

Cette fonction est identique à arrayReverseSort, mais avec un argument limit supplémentaire permettant un tri partiel.

Syntaxe

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

Arguments

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

Valeur renvoyée

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

Exemples

simple_int

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

[9,5,1,3]

simple_string

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

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

retain_sorted

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

[9,5]

lambda_simple

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

[1,3,5,9]

lambda_complex

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

[0,1,2]

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 :

Syntaxe

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

Arguments

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

Valeur renvoyée

Tableau dont les éléments sont partiellement mélangés. Array(T)

Exemples

no_limit1

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

[2, 4, 3, 1]

no_limit2

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

[2,3,4,1]

random_seed

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

[3, 4, 1, 2]

explicit_seed

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

[3,2,1,4]

matérialiser

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

┌─arrayPartialShuffle(materialize([1, 2, 3, 4]), 2, 42)─┬─arrayPartialShuffle([1, 2, 3], 2, 42)─┐
│ [3,2,1,4]                                             │ [3,2,1]                               │
│ [3,2,1,4]                                             │ [3,1,2]                               │
│ [4,3,2,1]                                             │ [1,3,2]                               │
│ [1,4,3,2]                                             │ [2,1,3]                               │
│ [3,4,1,2]                                             │ [3,2,1]                               │
│ [1,2,3,4]                                             │ [3,2,1]                               │
│ [1,4,3,2]                                             │ [1,2,3]                               │
│ [1,4,3,2]                                             │ [3,2,1]                               │
│ [3,1,2,4]                                             │ [3,2,1]                               │
│ [1,3,2,4]                                             │ [2,1,3]                               │
└───────────────────────────────────────────────────────┴───────────────────────────────────────┘

Introduit dans : v23.2.0

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

Syntaxe

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

Arguments

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

Valeur renvoyée

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

Exemples

simple_int

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

[1,3,5,9]

simple_string

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

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

retain_sorted

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

[1,3]

lambda_simple

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

[9,5,1,3]

lambda_complex

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

[2,1,0]

Introduit dans : v1.1.0

Supprime le dernier élément du tableau.

Syntaxe

arrayPopBack(arr)

Arguments

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

Valeur renvoyée

Renvoie un tableau identique à arr, mais sans son dernier élément Array(T)

Exemples

Exemple d'utilisation

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

[1,2]

Introduit dans : v1.1.0

Supprime le premier élément du tableau.

Syntaxe

arrayPopFront(arr)

Arguments

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

Valeur renvoyée

Renvoie un tableau identique à arr, mais sans son premier élément Array(T)

Exemples

Exemple d'utilisation

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

[2,3]

Introduit dans : v21.1.0

Renvoie le produit des éléments du tableau source.

Si une fonction lambda func est spécifiée, renvoie le produit des éléments renvoyés par la fonction lambda.

Syntaxe

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

Arguments

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

Valeur renvoyée

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

Exemples

Exemple de base

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

24

Utilisation avec une fonction lambda

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

16

Introduit dans : v1.1.0

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

Syntaxe

arrayPushBack(arr, x)

Arguments

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

Valeur renvoyée

Renvoie un tableau identique à arr, mais avec une valeur x supplémentaire à la fin du tableau Array(T)

Exemples

Exemple d’utilisation

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

['a','b']

Introduite dans : v1.1.0

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

Syntaxe

arrayPushFront(arr, x)

Arguments

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

Valeur renvoyée

Renvoie un tableau identique à arr, mais avec une valeur supplémentaire x au début du tableau Array(T)

Exemples

Exemple d’utilisation

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

['a','b']

Introduit dans : v20.4.0

Calcule l’aire sous la courbe ROC (receiver operating characteristic). Une courbe ROC est obtenue en traçant le taux de vrais positifs (True Positive Rate, TPR) sur l’axe des ordonnées et le taux de faux positifs (False Positive Rate, FPR) sur l’axe des abscisses pour tous les seuils. La valeur obtenue varie de zéro à un, une valeur plus élevée indiquant de meilleures performances du modèle.

La ROC AUC (également appelée simplement AUC) est un concept d’apprentissage automatique. Pour plus de détails, veuillez consulter ici, ici et ici.

Syntaxe

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

Alias : arrayAUC

Arguments

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

Valeur renvoyée

Renvoie l’aire sous la courbe ROC (receiver operating characteristic). Float64

Exemples

Exemple d’utilisation

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

0.75

Introduit dans : v23.10.0

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

Syntaxe

arrayRandomSample(arr, samples)

Arguments

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

Valeur renvoyée

Un tableau contenant un échantillon aléatoire d'éléments du tableau d'entrée Array(T)

Exemples

Exemple d'utilisation

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

['cherry','apple']

Utiliser un tableau multidimensionnel

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

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

Introduit dans : v1.1.0

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

Syntaxe

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

Arguments

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

Valeur renvoyée

Renvoie le résultat de la fonction d’agrégation

Exemples

Exemple d’utilisation

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

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

Exemple de fonction d’agrégation avec plusieurs arguments

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

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

Exemple avec une fonction d’agrégation 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 │
└─────────────────────────────────────────────────────────────┘

Introduit dans : v20.4.0

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

Syntaxe

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

Arguments

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

Valeur renvoyée

Renvoie un tableau contenant les résultats de la fonction d'agrégation sur les plages spécifiées Array(T)

Exemples

Exemple d'utilisation

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] │
└─────────────────────────────┘

Introduit dans : v25.11.0

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

Syntaxe

arrayRemove(arr, elem)

Alias : array_remove

Arguments

• arr — Array(T) - elem — T

Valeur renvoyée

Renvoie un sous-ensemble du tableau source Array(T)

Exemples

Exemple 1

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

[1,3]

Exemple 2

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

['a','b']

Introduit dans : v1.1.0

Modifie la longueur du tableau.

Syntaxe

arrayResize(arr, size[, extender])

Arguments

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

Valeur renvoyée

Un tableau de longueur size. Array(T)

Exemples

Exemple 1

SELECT arrayResize([1], 3);

[1,0,0]

Exemple 2

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

[1,NULL,NULL]

Introduit dans : v1.1.0

Inverse l’ordre des éléments du tableau donné.

Syntaxe

arrayReverse(arr)

Arguments

• arr — Le tableau à inverser. Array(T)

Valeur renvoyée

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

Exemples

Exemple d'utilisation

SELECT arrayReverse([1, 2, 3])

[3,2,1]

Introduit dans : v20.1.0

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

Syntaxe

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

Arguments

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

Valeur renvoyée

Renvoie un tableau dont les éléments du tableau source sont remplacés par les résultats de la fonction lambda. Array(T)

Exemples

Exemple avec un seul tableau

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

[1,2,2,NULL]

Exemple avec deux tableaux

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

[5,6,6,2]

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.

Syntaxe

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

Arguments

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

Valeur renvoyée

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

Exemples

Exemple 1

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

[5,3,4]

Exemple 2

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

[4,3,5]

Introduit dans : v20.1.0

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

Syntaxe

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

Arguments

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

Valeur renvoyée

Renvoie un tableau de tableaux. Array(Array(T))

Exemples

Exemple d’utilisation

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

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

Introduit dans : v23.8.0

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

Syntaxe

arrayRotateLeft(arr, n)

Arguments

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

Valeur renvoyée

Un tableau décalé par rotation vers la gauche du nombre d’éléments spécifié Array(T)

Exemples

Exemple d’utilisation

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

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

Valeur négative de n

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

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

Introduit dans : v23.8.0

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

Syntaxe

arrayRotateRight(arr, n)

Arguments

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

Valeur renvoyée

Un tableau décalé par rotation vers la droite du nombre d'éléments spécifié Array(T)

Exemples

Exemple d'utilisation

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

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

Valeur négative de n

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

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

Introduit dans : v23.8.0

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

Syntaxe

arrayShiftLeft(arr, n[, default])

Arguments

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

Valeur renvoyée

Un tableau décalé vers la gauche du nombre d'éléments spécifié Array(T)

Exemples

Exemple d'utilisation

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

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

Valeur négative de n

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

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

Utiliser une valeur par défaut

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

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

Introduit dans : v23.8.0

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

Syntaxe

arrayShiftRight(arr, n[, default])

Arguments

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

Valeur renvoyée

Un tableau décalé vers la droite du nombre d'éléments spécifié Array(T)

Exemples

Exemple d'utilisation

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

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

Valeur négative de n

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

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

Utilisation d’une valeur par défaut

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

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

Introduit dans : v24.1.0

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

Syntaxe

arrayShingles(arr, l)

Arguments

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

Valeur renvoyée

Un tableau contenant les shingles générés Array(T)

Exemples

Exemple d'utilisation

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

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

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.

Syntaxe

arrayShuffle(arr [, seed])

Arguments

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

Valeur renvoyée

Tableau dont les éléments sont mélangés Array(T)

Exemples

Exemple sans graine (résultats non déterministes)

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

[1,4,2,3]

Exemple sans graine (résultats stables)

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

[3,2,1,4]

Introduit dans : v25.4.0

Calcule la similarité entre deux tableaux, de 0 à 1, sur la base de la distance de Levenshtein pondérée.

Syntaxe

arraySimilarity(from, to, from_weights, to_weights)

Arguments

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

Valeur renvoyée

Renvoie le degré de similarité entre 0 et 1 des deux tableaux, calculé à partir de la distance de Levenshtein pondérée Float64

Exemples

Exemple d'utilisation

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

0.2222222222222222

Introduit dans : v1.1.0

Renvoie un secteur du tableau, en incluant les éléments NULL.

Le premier argument peut également être un QBit : le résultat est un QBit sur les dimensions sélectionnées (une projection sur un sous-ensemble de dimensions). Dans ce cas, offset et length doivent être des constantes, car la dimension d’un QBit fait partie de son type et le secteur doit sélectionner au moins une dimension. Un secteur aligné sur les limites des groupes de pas du QBit conserve le pas et réutilise les flux de plans de bits stockés sans copie.

Syntaxe

arraySlice(arr, offset [, length])

Arguments

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

Valeur renvoyée

Renvoie un secteur du tableau contenant length éléments à partir de l’offset spécifié Array(T)

Exemples

Exemple d’utilisation

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

[2,NULL,4]

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.

Syntaxe

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

Arguments

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

Valeur renvoyée

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

Exemples

Exemple 1

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

[0,1,3,3]

Exemple 2

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

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

Exemple 3

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

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

Introduit dans : v20.1.0

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

Syntaxe

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

Arguments

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

Valeur renvoyée

Renvoie un tableau de tableaux Array(Array(T))

Exemples

Exemple d'utilisation

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

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

Introduit dans : v21.1.0

Renvoie la somme des éléments du tableau source.

Si une fonction lambda func est spécifiée, renvoie la somme des éléments issus des résultats de cette fonction lambda.

Syntaxe

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

Arguments

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

Valeur renvoyée

Retourne la somme des éléments du tableau source, ou la somme des éléments résultant de la fonction lambda si elle est fournie.

Exemples

Exemple simple

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

10

Utilisation avec une fonction lambda

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

8

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.

Syntaxe

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

Arguments

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

Valeur renvoyée

Renvoie un tableau contenant des éléments distincts qui ne sont pas présents dans tous les tableaux sources Array(T)

Exemples

Exemple d'utilisation

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

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

Introduit dans : v26.6.0

Renvoie un tableau des K plus grands éléments du tableau d'entrée, triés par ordre décroissant. Si une fonction lambda f est spécifiée, les éléments sont comparés en fonction du résultat de f appliqué à chaque élément. Si f accepte plusieurs arguments, des tableaux supplémentaires sont transmis à arrayTopK et leurs éléments correspondent aux arguments de f.

Les valeurs NULL sont ignorées et n'apparaissent pas dans le résultat. La taille du résultat est au plus de K et peut être inférieure si le tableau d'entrée contient moins de K éléments non NULL. Le type d'élément du résultat est la version non nullable du type d'élément d'entrée.

arrayTopK est une fonction d'ordre supérieur.

Voir aussi arrayBottomK, qui renvoie à la place les K plus petits éléments.

Syntaxe

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

Arguments

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

Valeur renvoyée

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

Exemples

simple_int

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

[7,5,3]

skip_nulls

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

[7,5,2]

fewer_than_k

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

[2,1]

lambda_simple

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

[1,3]

lambda_multi

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

['a','c']

Introduit dans : v26.4.0

Transpose un tableau bidimensionnel.

Tous les tableaux imbriqués doivent avoir la même longueur.

Syntaxe

arrayTranspose(arr)

Arguments

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

Valeur renvoyée

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

Exemples

Matrice carrée

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

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

Matrice non carrée

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

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

Éléments de type String

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

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

Introduit dans : v24.10.0

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

Syntaxe

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

Arguments

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

Valeur renvoyée

Renvoie un tableau contenant les éléments distincts des tableaux source Array(T)

Exemples

Exemple d'utilisation

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

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

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.

Syntaxe

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

Arguments

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

Valeur renvoyée

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

Exemples

Un seul argument

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

2

Plusieurs arguments

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

3

Introduit dans : v20.1.0

Crée un tableau de longueur length, rempli de la constante x.

Syntaxe

arrayWithConstant(N, x)

Arguments

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

Valeur renvoyée

Renvoie un tableau contenant N éléments ayant pour valeur x. Array(T)

Exemples

Exemple d'utilisation

SELECT arrayWithConstant(3, 1)

[1,1,1]

Introduit dans : v20.1.0

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

Syntaxe

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

Arguments

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

Valeur renvoyée

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

Exemples

Exemple d'utilisation

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

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

Introduit dans : v20.1.0

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

Syntaxe

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

Arguments

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

Valeur renvoyée

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

Exemples

Exemple d'utilisation

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

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

Introduit dans : v1.1.0

Renvoie le nombre d’éléments du tableau dont la valeur est égale à x. Équivalent à arrayCount(elem -> elem = x, arr).

Les éléments NULL sont traités comme des valeurs distinctes.

Syntaxe

countEqual(arr, x)

Arguments

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

Valeur renvoyée

Renvoie le nombre d’éléments du tableau égaux à x UInt64

Exemples

Exemple d’utilisation

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

2

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.

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

Syntaxe

empty(arr)

Arguments

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

Valeur renvoyée

Renvoie 1 pour un tableau vide ou 0 pour un tableau non vide UInt8

Exemples

Exemple d'utilisation

SELECT empty([]);

1

Introduit dans : v1.1.0

Renvoie un tableau de Date vide

Syntaxe

emptyArrayDate()

Arguments

• Aucun.

Valeur renvoyée

Un tableau Date vide. Array(T)

Exemples

Exemple d'utilisation

SELECT emptyArrayDate()

[]

Introduit dans : v1.1.0

Renvoie un tableau DateTime vide

Syntaxe

emptyArrayDateTime()

Arguments

• Aucun.

Valeur renvoyée

Un tableau DateTime vide. Array(T)

Exemples

Exemple d'utilisation

SELECT emptyArrayDateTime()

[]

Introduit dans : v1.1.0

Renvoie un tableau vide de Float32

Syntaxe

emptyArrayFloat32()

Arguments

• Aucun.

Valeur renvoyée

Un tableau vide de Float32. Array(T)

Exemples

Exemple d'utilisation

SELECT emptyArrayFloat32()

[]

Introduit dans : v1.1.0

Renvoie un tableau(Float64) vide

Syntaxe

emptyArrayFloat64()

Arguments

• Aucun.

Valeur renvoyée

Un tableau Float64 vide. Array(T)

Exemples

Exemple d’utilisation

SELECT emptyArrayFloat64()

[]

Introduit dans : v1.1.0

Renvoie un tableau Int16 vide

Syntaxe

emptyArrayInt16()

Arguments

• Aucun.

Valeur renvoyée

Un tableau vide de type Int16. Array(T)

Exemples

Exemple d'utilisation

SELECT emptyArrayInt16()

[]

Introduit dans : v1.1.0

Renvoie un tableau Int32 vide

Syntaxe

emptyArrayInt32()

Arguments

• Aucun.

Valeur renvoyée

Un tableau Int32 vide. Array(T)

Exemples

Exemple d'utilisation

SELECT emptyArrayInt32()

[]

Introduit dans : v1.1.0

Renvoie un tableau Int64 vide

Syntaxe

emptyArrayInt64()

Arguments

• Aucun.

Valeur renvoyée

Un tableau Int64 vide. Array(T)

Exemples

Exemple d’utilisation

SELECT emptyArrayInt64()

[]

Disponible à partir de : v1.1.0

Renvoie un tableau vide de type Int8

Syntaxe

emptyArrayInt8()

Arguments

• Aucun.

Valeur renvoyée

Un tableau Int8 vide. Array(T)

Exemples

Exemple d’utilisation

SELECT emptyArrayInt8()

[]

Introduit dans : v1.1.0

Renvoie un tableau vide de String

Syntaxe

emptyArrayString()

Arguments

• Aucun.

Valeur renvoyée

Un tableau vide de String. Array(T)

Exemples

Exemple d'utilisation

SELECT emptyArrayString()

[]

Introduit dans : v1.1.0

Accepte un tableau vide et renvoie un tableau d’un seul élément correspondant à la valeur par défaut.

Syntaxe

emptyArrayToSingle(arr)

Arguments

• arr — Un tableau vide. Array(T)

Valeur renvoyée

Un tableau contenant une seule valeur du type par défaut du tableau. Array(T)

Exemples

Exemple simple

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;

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

Introduit dans : v1.1.0

Renvoie un tableau UInt16 vide

Syntaxe

emptyArrayUInt16()

Arguments

• Aucun.

Valeur renvoyée

Un tableau UInt16 vide. Array(T)

Exemples

Exemple d'utilisation

SELECT emptyArrayUInt16()

[]

Introduit dans : v1.1.0

Renvoie un tableau vide de UInt32

Syntaxe

emptyArrayUInt32()

Arguments

• Aucun.

Valeur renvoyée

Un tableau UInt32 vide. Array(T)

Exemples

Exemple d'utilisation

SELECT emptyArrayUInt32()

[]

Introduit dans : v1.1.0

Renvoie un tableau UInt64 vide

Syntaxe

emptyArrayUInt64()

Arguments

• Aucun.

Valeur de retour

Un tableau UInt64 vide. Array(T)

Exemples

Exemple d’utilisation

SELECT emptyArrayUInt64()

[]

Introduit dans : v1.1.0

Renvoie un tableau UInt8 vide

Syntaxe

emptyArrayUInt8()

Arguments

• Aucun.

Valeur de retour

Un tableau UInt8 vide. Array(T)

Exemples

Exemple d'utilisation

SELECT emptyArrayUInt8()