ARRAY_CONTAINS¶

Syntax¶

ARRAY_CONTAINS( <value_expr> , <array> )

Argumente¶

value_expr

In array zu suchender Wert.

• Wenn array ein semistrukturiertes Array ist, muss value_expr einen VARIANT ergeben.

• Wenn array ein strukturiertes Array ist, muss value_expr einen Typ ergeben, der mit dem Array-Typ verglichen werden kann.

array

Das zu durchsuchende Array.

Rückgabewerte¶

Diese Funktion gibt einen Wert vom Typ BOOLEAN oder NULL zurück:

• Die Funktion gibt TRUE zurück, wenn value_expr in array vorhanden ist, einschließlich in den folgenden Fällen:

  • Wenn das Argument value_expr NULL lautet und der SQL-NULL-Wert im Array vorhanden ist (undefined).

  • Wenn das Argument value_expr „JSON null“ lautet und der JSON-Nullwert im Array vorhanden ist (null).

• Die Funktion gibt FALSE zurück, wenn value_expr nicht in array vorhanden ist, auch wenn das value_expr-Argument „JSON null“ ist und es keine JSON-Nullwerte im Array gibt.

• Die Funktion gibt NULL zurück, wenn das value_expr-Argument NULL ist und es keine SQL NULL-Werte im Array gibt.

Weitere Informationen über NULL-Werte in Arrays finden Sie unter NULL-Werte.

Nutzungshinweise¶

• Die Funktion unterstützt keine Platzhalter in value_expr. Sie können jedoch die Funktion ARRAY_TO_STRING verwenden, um ein Array in eine Zeichenfolge zu konvertieren und dann die Zeichenfolge mit Platzhaltern zu durchsuchen. Sie können zum Beispiel Platzhalter angeben, um die zurückgegebene Zeichenfolge mit den Funktionen [ NOT ] LIKE und REGEXP_LIKE zu durchsuchen.

• Wenn array ein semistrukturiertes Array ist, ist die explizite Umwandlung des value_expr-Wertes in einen VARIANT-Wert für Werte der folgenden Datentypen erforderlich:

  • Zeichenfolgen- und Binärdaten

  • Datum & Uhrzeit

  Das folgende Beispiel wandelt einen Zeichenfolgenwert explizit in einen VARIANT-Wert um:

  SELECT ARRAY_CONTAINS('mystring2'::VARIANT, ARRAY_CONSTRUCT('mystring1', 'mystring2'));
  

  Copy

  Die explizite Umwandlung ist für Werte anderer Datentypen nicht erforderlich.

Beispiele¶

Die folgenden Abfragen verwenden die ARRAY_CONTAINS-Funktion in einer SELECT-Liste.

In diesem Beispiel gibt die Funktion TRUE zurück, weil das Argument value_expr 'hello' ist und das Array einen VARIANT-Wert enthält, der die Zeichenfolge 'hello' speichert:

SELECT ARRAY_CONTAINS('hello'::VARIANT, ARRAY_CONSTRUCT('hello', 'hi'));

+------------------------------------------------------------------+
| ARRAY_CONTAINS('HELLO'::VARIANT, ARRAY_CONSTRUCT('HELLO', 'HI')) |
|------------------------------------------------------------------|
| True                                                             |
+------------------------------------------------------------------+

In diesem Beispiel gibt die Funktion FALSE zurück, weil das Argument value_expr 'hello' lautet, das Array aber keinen VARIANT-Wert enthält, der die Zeichenfolge 'hello' speichert:

SELECT ARRAY_CONTAINS('hello'::VARIANT, ARRAY_CONSTRUCT('hola', 'bonjour'));

+----------------------------------------------------------------------+
| ARRAY_CONTAINS('HELLO'::VARIANT, ARRAY_CONSTRUCT('HOLA', 'BONJOUR')) |
|----------------------------------------------------------------------|
| False                                                                |
+----------------------------------------------------------------------+

In diesem Beispiel gibt die Funktion NULL zurück, weil das Argument value_expr NULL ist, das Array aber keinen SQL NULL-Wert enthält:

SELECT ARRAY_CONTAINS(NULL, ARRAY_CONSTRUCT('hola', 'bonjour'));

+----------------------------------------------------------+
| ARRAY_CONTAINS(NULL, ARRAY_CONSTRUCT('HOLA', 'BONJOUR')) |
|----------------------------------------------------------|
| NULL                                                     |
+----------------------------------------------------------+

In diesem Beispiel gibt die Funktion TRUE zurück, weil das Argument value_expr NULL ist und das Array einen SQL NULL-Wert enthält:

SELECT ARRAY_CONTAINS(NULL, ARRAY_CONSTRUCT('hola', NULL));

+-----------------------------------------------------+
| ARRAY_CONTAINS(NULL, ARRAY_CONSTRUCT('HOLA', NULL)) |
|-----------------------------------------------------|
| True                                                |
+-----------------------------------------------------+

In diesem Beispiel gibt die Funktion TRUE zurück, weil das Argument value_expr ein JSON-Nullwert ist und das Array einen JSON-Nullwert enthält:

SELECT ARRAY_CONTAINS(PARSE_JSON('null'), ARRAY_CONSTRUCT('hola', PARSE_JSON('null')));

+---------------------------------------------------------------------------------+
| ARRAY_CONTAINS(PARSE_JSON('NULL'), ARRAY_CONSTRUCT('HOLA', PARSE_JSON('NULL'))) |
|---------------------------------------------------------------------------------|
| True                                                                            |
+---------------------------------------------------------------------------------+

In diesem Beispiel gibt die Funktion NULL zurück, weil das Argument value_expr NULL ist, aber das Array keinen SQL NULL-Wert enthält (obwohl es einen JSON-Nullwert enthält):

SELECT ARRAY_CONTAINS(NULL, ARRAY_CONSTRUCT('hola', PARSE_JSON('null')));

+-------------------------------------------------------------------+
| ARRAY_CONTAINS(NULL, ARRAY_CONSTRUCT('HOLA', PARSE_JSON('NULL'))) |
|-------------------------------------------------------------------|
| NULL                                                              |
+-------------------------------------------------------------------+

Die folgende Abfrage verwendet die Funktion ARRAY_CONTAINS in einer WHERE-Klausel. Erstellen Sie zunächst eine Tabelle mit einer ARRAY-Spalte und fügen Sie Daten ein:

CREATE OR REPLACE TABLE array_example (id INT, array_column ARRAY);

INSERT INTO array_example (id, array_column)
  SELECT 1, ARRAY_CONSTRUCT(1, 2, 3);

INSERT INTO array_example (id, array_column)
  SELECT 2, ARRAY_CONSTRUCT(4, 5, 6);

SELECT * FROM array_example;

+----+--------------+
| ID | ARRAY_COLUMN |
|----+--------------|
|  1 | [            |
|    |   1,         |
|    |   2,         |
|    |   3          |
|    | ]            |
|  2 | [            |
|    |   4,         |
|    |   5,         |
|    |   6          |
|    | ]            |
+----+--------------+

Führen Sie eine Abfrage aus, die den zu suchenden Wert für value_expr und die ARRAY-Spalte für array angibt:

SELECT * FROM array_example WHERE ARRAY_CONTAINS(5, array_column);

+----+--------------+
| ID | ARRAY_COLUMN |
|----+--------------|
|  2 | [            |
|    |   4,         |
|    |   5,         |
|    |   6          |
|    | ]            |
+----+--------------+