ARRAY_SLICE¶

Sintaxe¶

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

Argumentos¶

array

A matriz de origem da qual um subconjunto dos elementos é usado para criar a matriz resultante.

from

Uma posição na matriz da origem. A posição do primeiro elemento é 0. Elementos de posições inferiores a from não estão incluídos na matriz resultante.

to

Uma posição na matriz da origem. Elementos de posições iguais ou maiores que to não estão incluídos na matriz resultante.

Retornos¶

O tipo de dados do valor retornado é ARRAY.

Notas de uso¶

• A saída inclui elementos até, mas não inclui o elemento especificado pelo parâmetro to.

• Se a matriz for NULL, o resultado será NULL.

• Se from ou to for NULL, o resultado será NULL.

• Se from ou to for negativo, ele é relativo ao fim da matriz, não ao início da matriz. Por exemplo, “-2” refere-se à penúltima posição da matriz.

• Se from e to estiverem ambos além da extremidade superior da matriz, ou estiverem ambos além da extremidade inferior da matriz, então o resultado será o conjunto vazio.

Observe que muitas destas regras (por exemplo, interpretação de números negativos como índices do fim da matriz e a regra de que a fatia é até, mas não inclui, o índice to), são semelhantes às regras para as fatias da matriz em linguagens de programação como Python.

Cada uma dessas regras é ilustrada em pelo menos um exemplo abaixo.

Exemplos¶

Isso mostra um exemplo simples ao fatiar uma matriz:

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

Saída:

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

Isto mostra o efeito de usar NULL como matriz de entrada:

select array_slice(NULL, 2, 3);

Saída:

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

Isto mostra o efeito de usar NULL como um dos índices de fatias:

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

Saída:

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

Isto mostra o efeito do uso de um número negativo como índice; o número é interpretado como a compensação a partir do final da matriz:

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

Saída:

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

Ambos os índices podem ser negativos, ou seja, ambos podem ser relativos ao final da matriz:

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

Saída:

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

Neste exemplo, ambos os índices estão além do final da matriz:

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

Saída:

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

Neste exemplo, ambos os índices são anteriores ao início da matriz:

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

Saída:

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

Embora os índices devam ser numéricos, os elementos da matriz não precisam ser numéricos:

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

Saída:

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