ARRAY_SLICE¶

Syntaxe¶

ARRAY_SLICE( <array> , <from> , <to> )

Arguments¶

array

Le tableau source dont un sous-ensemble d’éléments est utilisé pour construire le tableau résultant.

from

Une position dans le tableau source. La position du premier élément est 0. Les éléments dont les positions sont inférieures à from ne sont pas inclus dans le tableau obtenu.

to

Une position dans le tableau source. Les éléments dont les positions sont égales ou supérieures à to ne sont pas inclus dans le tableau obtenu.

Renvoie¶

Le type de données de la valeur renvoyée est ARRAY.

Notes sur l’utilisation¶

• La sortie comprend des éléments jusqu’à, mais sans inclure l’élément spécifié par le paramètre to.

• Si le tableau est NULL, le résultat est NULL.

• Si from ou to correspond à NULL, le résultat est NULL.

• Si from ou to est négatif, cela est relatif à la fin du tableau, pas au début du tableau. Par exemple, « -2 » fait référence à l’antépénultième position dans le tableau.

• Si from et to sont tous les deux situés au-delà de l’extrémité supérieure du tableau ou tous les deux au-delà de l’extrémité inférieure du tableau, le résultat est l’ensemble vide.

• Lorsque vous transmettez un ARRAY structuré à la fonction, celle-ci renvoie un ARRAY structuré du même type.

Notez que bon nombre de ces règles (par exemple, l’interprétation des nombres négatifs en tant qu’index à partir de la fin du tableau et la règle selon laquelle la tranche va to l’index, mais en l’excluant) sont similaires aux règles relatives aux tranches de tableau dans des langages de programmation tels que Python.

Chacune de ces règles est illustrée dans au moins un exemple ci-dessous.

Exemples¶

Cela montre un exemple simple de découpage d’un tableau :

select array_slice(array_construct(0,1,2,3,4,5,6), 0, 2);

Copy

Sortie :

+---------------------------------------------------+
| ARRAY_SLICE(ARRAY_CONSTRUCT(0,1,2,3,4,5,6), 0, 2) |
|---------------------------------------------------|
| [                                                 |
|   0,                                              |
|   1                                               |
| ]                                                 |
+---------------------------------------------------+

Copy

Cela montre l’effet de l’utilisation de NULL comme tableau d’entrée :

select array_slice(NULL, 2, 3);

Copy

Sortie :

+-------------------------+
| ARRAY_SLICE(NULL, 2, 3) |
|-------------------------|
| NULL                    |
+-------------------------+

Copy

Cela montre l’effet de l’utilisation de NULL comme l’un des index de tranches :

select array_slice(array_construct(0,1,2,3,4,5,6), NULL, 2);

Copy

Sortie :

+------------------------------------------------------+
| ARRAY_SLICE(ARRAY_CONSTRUCT(0,1,2,3,4,5,6), NULL, 2) |
|------------------------------------------------------|
| NULL                                                 |
+------------------------------------------------------+

Copy

Cela montre l’effet de l’utilisation d’un nombre négatif en tant qu’index ; le nombre est interprété comme le décalage par rapport à la fin du tableau :

select array_slice(array_construct(0,1,2,3,4,5,6), 0, -2);

Copy

Sortie :

+----------------------------------------------------+
| ARRAY_SLICE(ARRAY_CONSTRUCT(0,1,2,3,4,5,6), 0, -2) |
|----------------------------------------------------|
| [                                                  |
|   0,                                               |
|   1,                                               |
|   2,                                               |
|   3,                                               |
|   4                                                |
| ]                                                  |
+----------------------------------------------------+

Copy

Les deux index peuvent être négatifs, c’est-à-dire qu’ils peuvent être relatifs à la fin du tableau :

select array_slice(array_construct(0,1,2,3,4,5,6), -5, -3);

Copy

Sortie :

+-----------------------------------------------------+
| ARRAY_SLICE(ARRAY_CONSTRUCT(0,1,2,3,4,5,6), -5, -3) |
|-----------------------------------------------------|
| [                                                   |
|   2,                                                |
|   3                                                 |
| ]                                                   |
+-----------------------------------------------------+

Copy

Dans cet exemple, les deux index sont au-delà de la fin du tableau :

select array_slice(array_construct(0,1,2,3,4,5,6), 10, 12);

Copy

Sortie :

+-----------------------------------------------------+
| ARRAY_SLICE(ARRAY_CONSTRUCT(0,1,2,3,4,5,6), 10, 12) |
|-----------------------------------------------------|
| []                                                  |
+-----------------------------------------------------+

Copy

Dans cet exemple, les deux index sont avant le début du tableau :

select array_slice(array_construct(0,1,2,3,4,5,6), -10, -12);

Copy

Sortie :

+-------------------------------------------------------+
| ARRAY_SLICE(ARRAY_CONSTRUCT(0,1,2,3,4,5,6), -10, -12) |
|-------------------------------------------------------|
| []                                                    |
+-------------------------------------------------------+

Copy

Bien que les index doivent être numériques, les éléments du tableau n’ont pas besoin d’être numériques :

SELECT ARRAY_SLICE(ARRAY_CONSTRUCT('foo','snow','flake','bar'), 1, 3);

Copy

Sortie :

+----------------------------------------------------------------+
| ARRAY_SLICE(ARRAY_CONSTRUCT('FOO','SNOW','FLAKE','BAR'), 1, 3) |
|----------------------------------------------------------------|
| [                                                              |
|   "snow",                                                      |
|   "flake"                                                      |
| ]                                                              |
+----------------------------------------------------------------+

Copy