Kategorien:

Semistrukturierte Datenfunktionen (Array/Objekt)

ARRAY_EXCEPT

Gibt ein neues ARRAY zurück, das die Elemente aus einem Eingabe-ARRAY enthält, die nicht in einem anderen Eingabe-ARRAY enthalten sind.

Die Funktion ist NULL-sicher, d. h. sie behandelt NULL-Werte beim Vergleichen auf Gleichheit als bekannte Werte.

Siehe auch:

ARRAY_INTERSECTION

Syntax

ARRAY_EXCEPT( <source_array> , <array_of_elements_to_exclude> )

Argumente

source_array

Ein Array, das die Elemente enthält, die in das neue ARRAY eingefügt werden sollen.

array_of_elements_to_exclude

Ein Array, das die Elemente enthält, die nicht in das neue ARRAY eingefügt werden sollen.

Rückgabewerte

Diese Funktion gibt ein ARRAY zurück, das die Elemente aus source_array enthält, die nicht in array_of_elements_to_exclude enthalten sind.

Wenn nach Ausschluss der Elemente in array_of_elements_to_exclude aus source_array keine Elemente übrig bleiben, gibt die Funktion ein leeres ARRAY zurück.

Wenn eines oder beide Argumente NULL sind, gibt die Funktion NULL zurück.

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

Nutzungshinweise

  • Beim Vergleichen von Daten des Typs OBJECT müssen die Objekte identisch sein, um als übereinstimmend angesehen zu werden. Weitere Details dazu finden Sie unter Beispiele (unter diesem Thema).

  • In Snowflake sind Arrays Multimengen, keine Mengen. Mit anderen Worten: Arrays können mehrere Kopien desselben Wertes enthalten.

    ARRAY_EXCEPT vergleicht Arrays mithilfe der Multimengen-Semantik (engl. auch „Bag Semantics“ genannt). Wenn source_array mehrere Kopien eines Wertes enthält, entfernt die Funktion nur die Anzahl der Kopien dieses Wertes, die in array_of_elements_to_exclude angegeben sind.

    Mit anderen Worten, wenn source_array N Kopien eines Wertes hat und array_of_elements_to_exclude M Kopien desselben Wertes hat, schließt die Funktion M Kopien des Wertes aus dem zurückgegebenen Array aus. Die Anzahl der Kopien des Wertes im zurückgegebenen Array ist N-M oder 0, wenn M größer als N ist.

    Wenn beispielsweise source_array 5 Elemente mit dem Wert 'A' und array_of_elements_to_exclude 2 Elemente mit dem Wert 'A' enthält, enthält das zurückgegebene Array 3 Elemente mit dem Wert 'A'.

Beispiele

Die Beispiele in diesem Abschnitt verwenden die ARRAY-Konstanten und die OBJECT-Konstanten, um die ARRAYs und die OBJECTs anzugeben.

Im folgenden Beispiel wird die Verwendung der Funktion gezeigt:

SELECT ARRAY_EXCEPT(['A', 'B'], ['B', 'C']);

+--------------------------------------+
| ARRAY_EXCEPT(['A', 'B'], ['B', 'C']) |
|--------------------------------------|
| [                                    |
|   "A"                                |
| ]                                    |
+--------------------------------------+

Im folgenden Beispiel wird das Element 'C' zu source_array hinzugefügt. Das zurückgegebene ARRAY schließt 'C' aus, da 'C' auch in array_of_elements_to_exclude angegeben ist.

SELECT ARRAY_EXCEPT(['A', 'B', 'C'], ['B', 'C']);

+-------------------------------------------+
| ARRAY_EXCEPT(['A', 'B', 'C'], ['B', 'C']) |
|-------------------------------------------|
| [                                         |
|   "A"                                     |
| ]                                         |
+-------------------------------------------+

Im folgenden Beispiel enthält source_array 3 Elemente mit dem Wert 'B'. Da array_of_elements_to_exclude nur 1 'B'-Element enthält, schließt die Funktion nur 1 'B'-Element aus und gibt ein ARRAY zurück, das die anderen 2 'B'-Elemente enthält.

SELECT ARRAY_EXCEPT(['A', 'B', 'B', 'B', 'C'], ['B']);

+------------------------------------------------+
| ARRAY_EXCEPT(['A', 'B', 'B', 'B', 'C'], ['B']) |
|------------------------------------------------|
| [                                              |
|   "A",                                         |
|   "B",                                         |
|   "B",                                         |
|   "C"                                          |
| ]                                              |
+------------------------------------------------+

Im folgenden Beispiel bleiben nach dem Ausschluss der Elemente in array_of_elements_to_exclude aus source_array keine Elemente übrig. Als Ergebnis gibt die Funktion ein leeres ARRAY zurück.

SELECT ARRAY_EXCEPT(['A', 'B'], ['A', 'B']);

+--------------------------------------+
| ARRAY_EXCEPT(['A', 'B'], ['A', 'B']) |
|--------------------------------------|
| []                                   |
+--------------------------------------+

Im folgenden Beispiel wird gezeigt, wie die Funktion die NULL-Elemente als bekannte Werte behandelt. Wie bereits erläutert, enthält source_array ein NULL-Element mehr als array_of_elements_to_exclude, sodass das zurückgegebene ARRAY nur ein NULL-Element ausschließt und das andere (das als undefined ausgegeben wird) einschließt.

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

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

Im folgenden Beispiel enthalten source_array und array_of_elements_to_exclude die gleiche Anzahl von NULL-Elementen, sodass das zurückgegebene ARRAY die NULL-Elemente ausschließt.

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

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

Im folgenden Beispiel wird gezeigt, wie die Angabe desselben Objekts in source_array und array_of_elements_to_exclude dieses Objekt aus dem zurückgegebenen ARRAY ausschließt:

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

+------------------------------------------------------------+
| ARRAY_EXCEPT([{'A': 1, 'B': 2}, 1], [{'A': 1, 'B': 2}, 3]) |
|------------------------------------------------------------|
| [                                                          |
|   1                                                        |
| ]                                                          |
+------------------------------------------------------------+

Im folgenden Beispiel wird gezeigt, dass die Übergabe von NULL dazu führt, dass die Funktion NULL zurückgibt.

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

+--------------------------------+
| ARRAY_EXCEPT(['A', 'B'], NULL) |
|--------------------------------|
| NULL                           |
+--------------------------------+
Zurück zum Anfang