ARRAY_SLICE¶

Syntax¶

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

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

Der Datentyp des zurückgegebenen Werts ist ARRAY.

Nutzungshinweise¶

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

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

• Wenn from oder to den Wert NULL haben, ist das Ergebnis NULL.

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

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

Copy

Ausgabe:

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

Copy

Dies zeigt den Effekt der Verwendung von NULL als Eingabearray:

select array_slice(NULL, 2, 3);

Copy

Ausgabe:

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

Copy

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

Copy

Ausgabe:

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

Copy

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

Copy

Ausgabe:

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

Copy

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

Copy

Ausgabe:

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

Copy

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

Copy

Ausgabe:

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

Copy

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

Copy

Ausgabe:

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

Copy

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

Copy

Ausgabe:

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

Copy