Kategorien:

Funktionen für semistrukturierte und strukturierte Daten (Array/Objekt)

ARRAY_SLICE

Gibt ein Array zurück, das aus einer Teilmenge von Elementen des Eingabearrays aufgebaut ist.

Syntax

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

Argumente

array

Das Quellarray, aus dem eine Teilmenge der Elemente zum Erstellen des resultierenden Arrays verwendet wird.

from

Eine Position im Quellarray. Die Position des ersten Elements ist 0. Elemente von Positionen, die kleiner als from sind, werden nicht in das resultierende Array aufgenommen.

to

Eine Position im Quellarray. Elemente mit Positionen, die größer oder gleich to sind, sind nicht im resultierenden Array enthalten.

Rückgabewerte

Gibt einen Wert vom Typ ARRAY zurück.

Gibt NULL zurück, wenn ein Argument NULL ist, einschließlich der Eingabe array, from oder to.

Nutzungshinweise

  • Die Ausgabe enthält die Elemente bis, aber nicht einschließlich des vom Parameter to angegebenen Elements.

  • Wenn from oder to einen negativen Wert haben, ist dies relativ zum Ende des Arrays und nicht zum Anfang des Arrays. Beispielsweise bezieht sich -2 auf die vorletzte Position im Array.

  • Wenn sowohl from als auch to über dem oberen Ende des Arrays oder über dem unteren Ende des Arrays liegen, ist das Ergebnis eine leere Menge.

  • Wenn Sie der Funktion ein strukturiertes Array übergeben, gibt die Funktion ein strukturiertes Array desselben Typs zurück.

Beachten Sie, dass viele dieser Regeln (z. B. Interpretation negativer Zahlen als Indizes vom Ende des Arrays, und die Regel, dass das Slice bis zum, aber nicht einschließlich des bis to-Index verläuft) den Regeln für Array-Slices in Programmiersprachen wie Python ähneln.

Jede dieser Regeln wird in mindestens einem der Beispiel unten veranschaulicht.

Beispiele

In diesen Beispielen werden ARRAY-Konstanten verwendet, um Arrays zu erstellen. Alternativ können Sie auch die Funktion ARRAY_CONSTRUCT verwenden, um Arrays zu erstellen.

Dieses Beispiel zeigt ein einfaches Array-Slice:

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                                |
| ]                                  |
+------------------------------------+

In diesem Beispiel wird ein Array bis zum letzten Index zerlegt, indem die Funktion ARRAY_SIZE mit der Funktion ARRAY_SLICE verwendet wird:

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                 |
| ]                   |
+---------------------+

Obwohl die Indizes numerisch sein müssen, müssen die Elemente des Arrays nicht numerisch sein:

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

Dieses Beispiel zeigt den Effekt der Verwendung von NULL als Eingabearray:

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

Dieses Beispiel zeigt den Effekt der Verwendung von NULL als einen der Slice-Indizes:

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                                  |
+---------------------------------------+

Dieses Beispiel zeigt Effekt der Verwendung einer negativen Zahl als Index. Die Zahl wird als Offset vom Ende des Arrays interpretiert:

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                                 |
| ]                                   |
+-------------------------------------+

Dieses Beispiel zeigt, dass beide Indizes negativ sein können (d. h. beide können relativ zum Ende des Arrays sein):

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                                  |
| ]                                    |
+--------------------------------------+

In diesem Beispiel befinden sich beide Indizes über dem Ende des Arrays:

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

In diesem Beispiel befinden sich beide Indizes vor dem Start des Arrays:

SELECT ARRAY_SLICE([0,1,2,3,4,5,6], -10, -12);
Copy
+----------------------------------------+
| ARRAY_SLICE([0,1,2,3,4,5,6], -10, -12) |
|----------------------------------------|
| []                                     |
+----------------------------------------+
Sprache: Deutsch