Kategorien:

Semistrukturierte Datenfunktionen (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> )

Argumente

Array

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

von

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

bis

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

Rückgabewerte

Der Datentyp des zurückgegebenen Werts ist ARRAY.

Nutzungshinweise

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

  • Wenn das Array NULL ist, ist das Ergebnis NULL.

  • Wenn von oder bis NULL ist, ist das Ergebnis NULL.

  • Wenn von oder bis negativ ist, 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 von als auch bis über dem oberen Ende des Arrays oder über dem unteren Ende des Arrays liegen, ist das Ergebnis die leere Menge.

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

Dies zeigt ein einfaches Beispiel für das Aufteilen (Slicing) eines Arrays:

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

Ausgabe:

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

Dies zeigt den Effekt der Verwendung von NULL als Eingabearray:

select array_slice(NULL, 2, 3);

Ausgabe:

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

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

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

Ausgabe:

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

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

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

Ausgabe:

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

Beide Indizes können negativ sein, d. h. beide können relativ zum Ende des Arrays sein:

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

Ausgabe:

+-----------------------------------------------------+
| ARRAY_SLICE(ARRAY_CONSTRUCT(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(array_construct(0,1,2,3,4,5,6), 10, 12);

Ausgabe:

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

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

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

Ausgabe:

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

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

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

Ausgabe:

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