Kategorien:

Funktionen für semistrukturierte und strukturierte Daten (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> )
Copy

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

  • Wenn Sie Daten vom Typ OBJECT vergleiche, müssen die Objekte identisch sein, um als übereinstimmend zu gelten. 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'.

  • Wenn Sie ein strukturiertes ARRAY übergeben:

    • Das ARRAY im zweiten Argument muss vergleichbar mit dem ARRAY im ersten Argument sein.

    • Die Funktion gibt ein strukturiertes ARRAY vom gleichen Typ wie das ARRAY im ersten Argument zurück.

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

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

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

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']) |
|--------------------------------------|
| []                                   |
+--------------------------------------+
Copy

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

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

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

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                           |
+--------------------------------+
Copy
Sprache: Deutsch