Catégories :

Fonctions de données semi-structurées (tableau/objet)

ARRAY_SLICE

Renvoie un tableau construit à partir d’un sous-ensemble spécifié d’éléments du tableau d’entrée.

Syntaxe

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

Arguments

tableau

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

de

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

à

Une position dans le tableau source. Les éléments dont les positions sont égales ou supérieures à à 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 à.

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

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

  • Si de ou à 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 de et à 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.

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 jusqu’à 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);

Sortie :

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

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

select array_slice(NULL, 2, 3);

Sortie :

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

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

Sortie :

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

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

Sortie :

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

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

Sortie :

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

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

Sortie :

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

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

Sortie :

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

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

Sortie :

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