Categorias:

Funções de dados semiestruturados e estruturados (Matriz/objeto)

ARRAY_SLICE

Retorna uma matriz construída a partir de um subconjunto específico de elementos da matriz de entrada.

Sintaxe

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

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.

  • Quando você passa uma ARRAY estruturada para a função, a função retorna uma ARRAY estruturada do mesmo tipo.

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

Saída:

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

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

select array_slice(NULL, 2, 3);
Copy

Saída:

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

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

Saída:

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

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

Saída:

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

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

Saída:

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

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

Saída:

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

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

Saída:

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

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

Saída:

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