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. Os elementos de posições inferiores a from não são inclusos 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

Esta função retorna um valor do tipo ARRAY.

Retorna NULL se qualquer argumento for NULL, incluindo a entrada array, from ou to.

Notas de uso

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

  • 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 matriz estruturada para a função, a função retorna uma matriz estruturada do mesmo tipo.

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

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

Exemplos

Esses exemplos usam Constantes ARRAY para construir matrizes. Como alternativa, é possível usar a função ARRAY_CONSTRUCT para construir matrizes.

Este exemplo mostra uma fatia de matriz simples:

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

Este exemplo divide uma matriz até o último índice usando a função ARRAY_SIZE com a função ARRAY_SLICE:

SELECT ARRAY_SLICE([0,1,2,3,4,5,6], 3, ARRAY_SIZE([0,1,2,3,4,5,6])) AS slice_to_last_index;
Copy
+---------------------+
| SLICE_TO_LAST_INDEX |
|---------------------|
| [                   |
|   3,                |
|   4,                |
|   5,                |
|   6                 |
| ]                   |
+---------------------+

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

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

Este exemplo mostra o efeito de usar NULL como matriz de entrada:

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

Este exemplo mostra o efeito de usar NULL como um dos índices de fatia:

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

Este exemplo mostra o efeito do uso de um número negativo como índice. O número é interpretado como o deslocamento a partir do final da matriz:

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

Esse exemplo mostra que ambos os índices podem ser negativos (ou seja, ambos podem ser relativos ao final da matriz):

SELECT ARRAY_SLICE([0,1,2,3,4,5,6], -5, -3);
Copy
+--------------------------------------+
| ARRAY_SLICE([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([0,1,2,3,4,5,6], 10, 12);
Copy
+--------------------------------------+
| ARRAY_SLICE([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([0,1,2,3,4,5,6], -10, -12);
Copy
+----------------------------------------+
| ARRAY_SLICE([0,1,2,3,4,5,6], -10, -12) |
|----------------------------------------|
| []                                     |
+----------------------------------------+
Linguagem: Português