Kategorien:

Semistrukturierte Datenfunktionen (Array/Objekt)

ARRAY_DISTINCT

Gibt ein neues ARRAY zurück, das nur die eindeutigen Elemente des Eingabe-ARRAY enthält. Die Funktion schließt alle doppelten Elemente aus, die im Eingabe-ARRAY vorhanden sind.

Die Funktion garantiert nicht, dass die Elemente im ARRAY in einer bestimmten Reihenfolge zurückgegeben werden.

Die Funktion ist NULL-sicher, was bedeutet, dass sie beim Identifizieren doppelter Elemente NULL-Werte als bekannte Werte behandelt.

Syntax

ARRAY_DISTINCT( <array> )

Argumente

array

Ein Array, das möglicherweise doppelte Elemente enthält, die entfernt werden sollen.

Rückgabewerte

Diese Funktion gibt ein ARRAY zurück, das die Elemente des Eingabearrays ohne doppelte Elemente enthält. Wenn beispielsweise der Wert 'x' im Eingabe-ARRAY mehrfach vorkommt, hat im zurückgegebenen ARRAY nur ein Element den Wert 'x'.

Wenn das Eingabeargument NULL ist, gibt die Funktion NULL zurück.

Die Reihenfolge der Werte innerhalb des zurückgegebenen Arrays ist nicht angegeben.

Nutzungshinweise

  • Bei Elementen des Typs OBJECT müssen die Objekte identisch sein, um als Duplikat zu gelten. Weitere Details dazu finden Sie unter Beispiele (unter diesem Thema).

  • Beim Identifizieren von doppelten Elementen geht die Funktion davon aus, dass NULL ein bekannter Wert ist (d. h. NULL ist kein Duplikat eines beliebigen anderen Wertes außer NULL).

Beispiele

Das folgende Beispiel zeigt, wie die Funktion ein ARRAY ohne die doppelten Elemente A und NULL aus einer Eingabe-ARRAY-Konstante zurückgibt:

SELECT ARRAY_DISTINCT(['A', 'A', 'B', NULL, NULL]);

+---------------------------------------------+
| ARRAY_DISTINCT(['A', 'A', 'B', NULL, NULL]) |
|---------------------------------------------|
| [                                           |
|   "A",                                      |
|   "B",                                      |
|   undefined                                 |
| ]                                           |
+---------------------------------------------+

Im folgenden Beispiel wird gezeigt, wie die Übergabe von NULL (anstelle von ARRAY) NULL ergibt:

SELECT ARRAY_DISTINCT(NULL);

+----------------------+
| ARRAY_DISTINCT(NULL) |
|----------------------|
| NULL                 |
+----------------------+

Im folgenden Beispiel wird gezeigt, wie die Funktion doppelte OBJECT-Werte entfernt, die Elemente des Eingabe-ARRAY sind. Im Beispiel werden OBJECT-Konstanten und ARRAY-Konstanten verwendet, um die OBJECT-Werte und das ARRAY zu konstruieren.

SELECT ARRAY_DISTINCT( [ {'a': 1, 'b': 2}, {'a': 1, 'b': 2}, {'a': 1, 'b': 3} ] );

+----------------------------------------------------------------------------+
| ARRAY_DISTINCT( [ {'A': 1, 'B': 2}, {'A': 1, 'B': 2}, {'A': 1, 'B': 3} ] ) |
|----------------------------------------------------------------------------|
| [                                                                          |
|   {                                                                        |
|     "a": 1,                                                                |
|     "b": 2                                                                 |
|   },                                                                       |
|   {                                                                        |
|     "a": 1,                                                                |
|     "b": 3                                                                 |
|   }                                                                        |
| ]                                                                          |
+----------------------------------------------------------------------------+

Wie im Beispiel gezeigt, wird das letzte Element nicht als Duplikat betrachtet, da b einen anderen Wert hat (3, nicht 2).

Zurück zum Anfang