Operatoren

Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Google-Standard-SQL für BigQuery unterstützt Operatoren. Operatoren werden durch Sonderzeichen oder Schlüsselwörter dargestellt; sie verwenden keine Funktionsaufrufsyntax. Ein Operator manipuliert eine beliebige Anzahl von Dateneingaben, auch Operanden genannt, und gibt ein Ergebnis zurück.

Allgemeine Konventionen:

  • Wenn nicht anders angegeben, geben alle Operatoren NULL zurück, wenn einer der Operanden NULL ist.
  • Alle Operatoren geben einen Fehler aus, wenn das Berechnungsergebnis überläuft.
  • Bei allen Gleitkommaoperationen werden +/-inf und NaN nur zurückgegeben, wenn einer der Operanden +/-inf oder NaN ist. In anderen Fällen wird ein Fehler zurückgegeben.

Operator-Vorrang

In der folgenden Tabelle sind alle Google-Standard-SQL-Operatoren von der höchsten bis zur niedrigsten Priorität aufgeführt, d. h. in der Reihenfolge, in der sie innerhalb einer Anweisung ausgewertet werden.

Rangfolge Operator Datentypen der Eingabe Name Operator-Arität
1 Feldzugriffsoperator JSON
STRUCT
Feldzugriffsoperator Binär
  Array-Abo-Operator ARRAY Arrayposition. Muss mit OFFSET oder ORDINAL verwendet werden ­– siehe Arrayfunktionen. Binär
  JSON-Subscript-Operator JSON Feldname oder Arrayposition in JSON. Binär
2 + Alle numerischen Typen Unäres Plus Unär
  - Alle numerischen Typen Unäres Minus Unär
  ~ Ganzzahl oder BYTES Bitweises NOT Unär
3 * Alle numerischen Typen Multiplikation Binär
  / Alle numerischen Typen Division Binär
  || STRING, BYTES oder ARRAY<T> Verkettungsoperator Binär
4 + Alle numerischen Typen, DATE mit INT64, INTERVAL Addition Binär
  - Alle numerischen Typen, DATE mit INT64, INTERVAL Subtraktion Binär
5 << Ganzzahl oder BYTES Bitweise Linksverschiebung Binär
  >> Ganzzahl oder BYTES Bitweise Rechtsverschiebung Binär
6 & Ganzzahl oder BYTES Bitweises AND Binär
7 ^ Ganzzahl oder BYTES Bitweises XOR Binär
8 | Ganzzahl oder BYTES Bitweises OR Binär
9 (Vergleichsoperatoren) = Jeder vergleichbare Typ. Eine vollständige Liste finden Sie unter Datentypen. Gleich Binär
  < Jeder vergleichbare Typ. Eine vollständige Liste finden Sie unter Datentypen. Kleiner als Binär
  > Jeder vergleichbare Typ. Eine vollständige Liste finden Sie unter Datentypen. Größer als Binär
  <= Jeder vergleichbare Typ. Eine vollständige Liste finden Sie unter Datentypen. Kleiner als oder gleich Binär
  >= Jeder vergleichbare Typ. Eine vollständige Liste finden Sie unter Datentypen. Größer als oder gleich Binär
  !=, <> Jeder vergleichbare Typ. Eine vollständige Liste finden Sie unter Datentypen. Ungleich Binär
  [NOT] LIKE STRING und Byte Wert entspricht [nicht] dem angegebenen Muster Binär
  [NOT] BETWEEN Alle vergleichbaren Typen. Eine vollständige Liste finden Sie unter Datentypen. Wert ist [nicht] innerhalb des angegebenen Bereichs Binär
  [NOT] IN Alle vergleichbaren Typen. Eine vollständige Liste finden Sie unter Datentypen. Wert ist [nicht] in der Liste der angegebenen Werte Binär
  IS [NOT] NULL Alle Wert ist [nicht] NULL. Unär
  IS [NOT] TRUE BOOL Wert ist [nicht] TRUE. Unär
  IS [NOT] FALSE BOOL Wert ist [nicht] FALSE. Unär
10 NOT BOOL Logisches NOT Unär
11 AND BOOL Logisches AND Binär
12 OR BOOL Logisches OR Binär

Operatoren mit der gleichen Präzedenz sind links-assoziativ. Das heißt, dass diese Operatoren von links nach rechts gruppiert werden. Zum Beispiel wird der Ausdruck:

x AND y AND z

interpretiert als:

( ( x AND y ) AND z )

Der Ausdruck:

x * y / z

wird interpretiert als:

( ( x * y ) / z )

Alle Vergleichsoperatoren haben die gleiche Priorität. Vergleichsoperatoren sind jedoch nicht assoziativ. Daher sind Klammern erforderlich, um Mehrdeutigkeiten aufzulösen. Beispiel:

(x < y) IS FALSE

Feldzugriffsoperator

expression.fieldname[. ...]

Beschreibung

Ruft den Wert eines Feldes ab. Alternativ wird der Punktoperator genannt. Kann für den Zugriff auf verschachtelte Felder verwendet werden. z. B. expression.fieldname1.fieldname2.

Eingabetypen

  • STRUCT
  • JSON

Rückgabetyp

  • Für STRUCT: SQL-Datentyp von fieldname. Wenn in der Struktur kein Feld gefunden wird, wird ein Fehler ausgegeben.
  • Für JSON: JSON. Wenn in einem JSON-Wert kein Feld gefunden wird, wird ein SQL-NULL zurückgegeben.

Beispiel

Im folgenden Beispiel lautet der Ausdruck t.customer und die Feldzugriffsvorgänge sind .address und .country. Ein Vorgang ist eine Anwendung eines Operators (.) an bestimmte Operanden (in diesem Fall address und country oder genauer gesagt: t.customer und address für den ersten Vorgang sowie t.customer.address und country für den zweiten Vorgang).

WITH orders AS (
  SELECT STRUCT(STRUCT('Yonge Street' AS street, 'Canada' AS country) AS address) AS customer
)
SELECT t.customer.address.country FROM orders AS t;

+---------+
| country |
+---------+
| Canada  |
+---------+

Array-Abo-Operator

array_expression[array_subscript_specifier]

array_subscript_specifier:
  position_keyword(index)

position_keyword:
  { OFFSET | SAFE_OFFSET | ORDINAL | SAFE_ORDINAL }

Beschreibung

Ruft einen Wert aus einem Array an einem bestimmten Standort ab.

Eingabetypen

  • array_expression: Das Eingabearray.
  • position_keyword: Wo der Index für das Array beginnen soll und wie Indexe außerhalb des Bereichs verarbeitet werden. Zur Auswahl stehen:
    • OFFSET: Der Index beginnt bei null. Erzeugt einen Fehler, wenn der Index außerhalb des Bereichs liegt.
    • SAFE_OFFSET: Der Index beginnt bei null. Gibt NULL zurück, wenn der Index außerhalb des Bereichs liegt.
    • ORDINAL: Der Index beginnt bei Eins. Erzeugt einen Fehler, wenn der Index außerhalb des Bereichs liegt.
    • SAFE_ORDINAL: Der Index beginnt bei Eins. Gibt NULL zurück, wenn der Index außerhalb des Bereichs liegt.
  • index: Eine Ganzzahl, die eine bestimmte Position im Array darstellt.

Rückgabetyp

T, wobei array_expression = ARRAY<T>.

Beispiele

In diesem Beispiel wird der Array-Subscript-Operator dazu verwendet, Werte an bestimmten Positionen in item_array zurückzugeben. In diesem Beispiel wird auch gezeigt, was passiert, wenn Sie auf einen Index (6) in einem Array verweisen, das außerhalb des Bereichs liegt. Wenn das Präfix SAFE enthalten ist, wird NULL zurückgegeben. Andernfalls wird ein Fehler erzeugt.

WITH Items AS (SELECT ["coffee", "tea", "milk"] AS item_array)
SELECT
  item_array,
  item_array[OFFSET(1)] AS item_offset,
  item_array[ORDINAL(1)] AS item_ordinal,
  item_array[SAFE_OFFSET(6)] AS item_safe_offset,
FROM Items

+----------------------------------+--------------+--------------+------------------+
| item_array                       | item_offset  | item_ordinal | item_safe_offset |
+----------------------------------+--------------+--------------+------------------+
| [coffee, tea, milk]              | tea          | coffee       | NULL             |
+----------------------------------+--------------+--------------+------------------+

Wenn Sie im folgenden Beispiel einen Index in einem Array referenzieren, das außerhalb des Bereichs liegt und das Präfix SAFE nicht enthalten ist, wird ein Fehler erzeugt.

WITH Items AS (SELECT ["coffee", "tea", "milk"] AS item_array)
SELECT
  item_array[OFFSET(6)] AS item_offset
FROM Items

-- Error. OFFSET(6) is out of range.

JSON-Subscript-Operator

json_expression[array_element_id]
json_expression[field_name]

Beschreibung

Ruft einen Wert eines Arrayelements oder -felds in einem JSON-Ausdruck ab. Kann für den Zugriff auf verschachtelte Daten verwendet werden.

Eingabetypen

  • JSON expression: Der JSON-Ausdruck, der ein Arrayelement oder ein Arrayfeld enthält, das zurückgegeben werden soll.
  • [array_element_id]: Ein INT64-Ausdruck, der einen nullbasierten Index im Array darstellt. Wenn ein negativer Wert eingegeben wird oder der Wert größer oder gleich der Größe des Arrays ist oder der JSON-Ausdruck kein JSON-Array darstellt, wird ein SQL-NULL zurückgegeben.
  • [field_name]: Ein STRING-Ausdruck, der den Namen eines Felds in JSON darstellt. Wenn der Feldname nicht gefunden wird oder der JSON-Ausdruck kein JSON-Objekt ist, wird ein SQL-NULL zurückgegeben.

Rückgabetyp

JSON

Beispiel

Im folgenden Beispiel gilt:

  • json_value ist ein JSON-Ausdruck.
  • .class ist ein JSON-Feldzugriff.
  • .students ist ein JSON-Feldzugriff.
  • [0] ist ein JSON-Skriptausdruck mit einem Element-Offset, der auf das nullte Element eines Arrays im JSON-Wert zugreift.
  • ['name'] ist ein JSON-Skriptausdruck mit einem Feldnamen, der auf ein Feld zugreift.
SELECT json_value.class.students[0]['name'] AS first_student
FROM
  UNNEST(
    [
      JSON '{"class" : {"students" : [{"name" : "Jane"}]}}',
      JSON '{"class" : {"students" : []}}',
      JSON '{"class" : {"students" : [{"name" : "John"}, {"name": "Jamie"}]}}'])
    AS json_value;

+-----------------+
| first_student   |
+-----------------+
| "Jane"          |
| NULL            |
| "John"          |
+-----------------+

Arithmetischer Operator

Alle arithmetischen Operatoren akzeptieren die Eingabe des numerischen Typs T und der Ergebnistyp weist den Typ T auf, sofern in der nachfolgenden Beschreibung nichts anderes angegeben ist:

Name Syntax
Addition X + Y
Subtraktion X - Y
Multiplikation X * Y
Division X / Y
Unäres Plus + X
Unäres Minus - X

HINWEIS: Division durch Nulloperationen gibt einen Fehler zurück. Ziehen Sie die Funktion IEEE_DIVIDE oder SAFE_DIVIDE in Betracht, damit ein anderes Ergebnis zurückgegeben wird.

Ergebnistypen für Addition, Subtraktion und Multiplikation:

INPUTINT64NUMERICBIGNUMERICFLOAT64
INT64INT64NUMERICBIGNUMERICFLOAT64
NUMERICNUMERICNUMERICBIGNUMERICFLOAT64
BIGNUMERICBIGNUMERICBIGNUMERICBIGNUMERICFLOAT64
FLOAT64FLOAT64FLOAT64FLOAT64FLOAT64

Ergebnistypen für Division:

INPUTINT64NUMERICBIGNUMERICFLOAT64
INT64FLOAT64NUMERICBIGNUMERICFLOAT64
NUMERICNUMERICNUMERICBIGNUMERICFLOAT64
BIGNUMERICBIGNUMERICBIGNUMERICBIGNUMERICFLOAT64
FLOAT64FLOAT64FLOAT64FLOAT64FLOAT64

Ergebnistypen für unäres Plus:

INPUTINT64NUMERICBIGNUMERICFLOAT64
OUTPUTINT64NUMERICBIGNUMERICFLOAT64

Ergebnistypen für unäres Minus:

INPUTINT64NUMERICBIGNUMERICFLOAT64
OUTPUTINT64NUMERICBIGNUMERICFLOAT64

Operatoren für Datumsarithmetik

Die Operatoren „+“ und „-“ können für arithmetische Operationen an Datumsangaben verwendet werden.

date_expression + int64_expression
int64_expression + date_expression
date_expression - int64_expression

Beschreibung

Addiert oder subtrahiert int64_expression Tage zu bzw. von date_expression. Dies entspricht den Funktionen DATE_ADD und DATE_SUB, wenn der Zeitraum in Tagen angegeben wird.

Rückgabedatentyp

DATE

Beispiel

SELECT DATE "2020-09-22" + 1 AS day_later, DATE "2020-09-22" - 7 AS week_ago

+------------+------------+
| day_later  | week_ago   |
+------------+------------+
| 2020-09-23 | 2020-09-15 |
+------------+------------+

Datums-/Uhrzeits-Subtraktion

date_expression - date_expression
timestamp_expression - timestamp_expression
datetime_expression - datetime_expression

Beschreibung

Berechnet die Differenz zwischen zwei Datetime-Werten als Intervall.

Rückgabedatentyp

INTERVAL

Beispiel

SELECT
  DATE "2021-05-20" - DATE "2020-04-19" AS date_diff,
  TIMESTAMP "2021-06-01 12:34:56.789" - TIMESTAMP "2021-05-31 00:00:00" AS time_diff

+-------------------+------------------------+
| date_diff         | time_diff              |
+-------------------+------------------------+
| 0-0 396 0:0:0     | 0-0 0 36:34:56.789     |
+-------------------+------------------------+

Arithmetische Intervalloperatoren

Addition und Subtraktion

date_expression + interval_expression = DATETIME
date_expression - interval_expression = DATETIME
timestamp_expression + interval_expression = TIMESTAMP
timestamp_expression - interval_expression = TIMESTAMP
datetime_expression + interval_expression = DATETIME
datetime_expression - interval_expression = DATETIME

Beschreibung

Addiert ein Intervall zu einem Datetime-Wert oder subtrahiert ein Intervall von einem Datetime-Wert. Beispiel

SELECT
  DATE "2021-04-20" + INTERVAL 25 HOUR AS date_plus,
  TIMESTAMP "2021-05-02 00:01:02.345" - INTERVAL 10 SECOND AS time_minus;

+-------------------------+--------------------------------+
| date_plus               | time_minus                     |
+-------------------------+--------------------------------+
| 2021-04-21 01:00:00     | 2021-05-02 00:00:52.345+00     |
+-------------------------+--------------------------------+

Multiplikation und Division

interval_expression * integer_expression = INTERVAL
interval_expression / integer_expression = INTERVAL

Beschreibung

Multipliziert einen Intervallwert mit einer Ganzzahl oder teilt ihn durch eine Ganzzahl.

Beispiel

SELECT
  INTERVAL '1:2:3' HOUR TO SECOND * 10 AS mul1,
  INTERVAL 35 SECOND * 4 AS mul2,
  INTERVAL 10 YEAR / 3 AS div1,
  INTERVAL 1 MONTH / 12 AS div2

+----------------+--------------+-------------+--------------+
| mul1           | mul2         | div1        | div2         |
+----------------+--------------+-------------+--------------+
| 0-0 0 10:20:30 | 0-0 0 0:2:20 | 3-4 0 0:0:0 | 0-0 2 12:0:0 |
+----------------+--------------+-------------+--------------+

Bitweise Operatoren

Alle bitweisen Operatoren geben den gleichen Typ und die gleiche Länge wie der erste Operand zurück.

Name Syntax Datentyp der Eingabe Beschreibung
Bitweises NOT ~ X Ganzzahl oder BYTES Führt eine logische Negation auf jedem Bit durch und bildet das Einerkomplement des gegebenen Binärwerts.
Bitweises OR X | Y X: Ganzzahl oder BYTES
Y: gleicher Typ wie X
Nimmt zwei Bitmuster gleicher Länge und führt die logische inklusive OR-Operation bei jedem Paar der entsprechenden Bits durch. Dieser Operator gibt einen Fehler aus, wenn X- und Y-BYTES unterschiedlicher Länge sind.
Bitweises XOR X ^ Y X: Ganzzahl oder BYTES
Y: gleicher Typ wie X
Nimmt zwei Bitmuster gleicher Länge an und führt die logische exklusive OR-Operation bei jedem Paar der entsprechenden Bits durch. Dieser Operator gibt einen Fehler aus, wenn X- und Y-BYTES unterschiedlicher Länge sind.
Bitweises AND X & Y X: Ganzzahl oder BYTES
Y: gleicher Typ wie X
Nimmt zwei Bitmuster gleicher Länge und führt die logische AND-Operation bei jedem Paar der entsprechenden Bits durch. Dieser Operator gibt einen Fehler aus, wenn X- und Y-BYTES unterschiedlicher Länge sind.
Linksverschiebung X << Y X: Integer oder BYTES
Y: INT64
Verschiebt den ersten Operanden X nach links. Dieser Operator gibt 0 oder eine Bytesequenz von b'\x00' zurück, wenn der zweite Operand Y größer oder gleich der Bitlänge des ersten Operanden X ist (z. B. 64, wenn X den Typ INT64 hat). Dieser Operator gibt einen Fehler aus, wenn Y negativ ist.
Rechtsverschiebung X >> Y X: Integer oder BYTES
Y: INT64
Verschiebt den ersten Operanden X nach rechts. Dieser Operator führt keine Vorzeichenbit-Erweiterung bei einem Typ mit Vorzeichen durch (d. h. er füllt freie Bits auf der linken Seite mit 0). Dieser Operator gibt 0 oder eine Bytesequenz von b'\x00' zurück, wenn der zweite Operand Y größer oder gleich der Bitlänge des ersten Operanden X ist (z. B. 64, wenn X den Typ INT64 hat). Dieser Operator gibt einen Fehler aus, wenn Y negativ ist.

Logische Operatoren

Google-Standard-SQL unterstützt die logischen Operatoren AND, OR und NOT. Logische Operatoren erlauben nur Eingaben in Form von BOOL oder NULL und verwenden eine dreiwertige Logik, um ein Ergebnis zu erzeugen. Das Ergebnis kann TRUE, FALSE oder NULL sein:

x y x AND y x OR y
TRUE TRUE TRUE TRUE
TRUE FALSE FALSE TRUE
TRUE NULL NULL TRUE
FALSE TRUE FALSE TRUE
FALSE FALSE FALSE FALSE
FALSE NULL FALSE NULL
NULL TRUE NULL TRUE
NULL FALSE FALSE NULL
NULL NULL NULL NULL
x NOT x
TRUE FALSE
FALSE TRUE
NULL NULL

Beispiele

Die Beispiele in diesem Abschnitt beziehen sich auf eine Tabelle namens entry_table:

+-------+
| entry |
+-------+
| a     |
| b     |
| c     |
| NULL  |
+-------+
SELECT 'a' FROM entry_table WHERE entry = 'a'

-- a => 'a' = 'a' => TRUE
-- b => 'b' = 'a' => FALSE
-- NULL => NULL = 'a' => NULL

+-------+
| entry |
+-------+
| a     |
+-------+
SELECT entry FROM entry_table WHERE NOT (entry = 'a')

-- a => NOT('a' = 'a') => NOT(TRUE) => FALSE
-- b => NOT('b' = 'a') => NOT(FALSE) => TRUE
-- NULL => NOT(NULL = 'a') => NOT(NULL) => NULL

+-------+
| entry |
+-------+
| b     |
| c     |
+-------+
SELECT entry FROM entry_table WHERE entry IS NULL

-- a => 'a' IS NULL => FALSE
-- b => 'b' IS NULL => FALSE
-- NULL => NULL IS NULL => TRUE

+-------+
| entry |
+-------+
| NULL  |
+-------+

Vergleichsoperator

Vergleiche geben immer BOOL zurück. Im Allgemeinen müssen dafür beide Operanden vom gleichen Typ sein. Wenn die Operanden einen unterschiedlichen Typ haben und Google-Standard-SQL die Werte dieser Typen ohne Genauigkeitsverlust in einen allgemeinen Typ umwandeln kann, erzwingt Google-Standard-SQL in der Regel für den Vergleich eine Umwandlung in diesen allgemeinen Typ. Im Allgemeinen erzwingt Google-Standard-SQL die Umwandlung von Literalen in Nicht-Literale, sofern vorhanden. Vergleichbare Datentypen sind unter Datentypen definiert.

STRUCTs unterstützt nur vier Vergleichsoperatoren: gleich (=), ungleich (!= und <>) sowie IN.

Beim Vergleich dieser Datentypen gelten folgende Regeln:

  • FLOAT64: Alle Vergleiche mit NaN geben FALSE zurück, außer bei != und <>. Dafür wird TRUE zurückgegeben.
  • BOOL: FALSE ist kleiner als TRUE.
  • STRING: Strings werden von Codepunkt zu Codepunkt miteinander verglichen, d. h., der Vergleich kanonisch äquivalenter Strings wird nur dann zuverlässig als gleich ausgewertet, wenn sie zuerst normalisiert wurden.
  • NULL: Dafür gilt folgende Konvention: Jeder Vorgang mit einer NULL-Eingabe gibt NULL zurück.
Name Syntax Beschreibung
Kleiner als X < Y Gibt TRUE zurück, wenn X kleiner als Y ist. Dieser Operator unterstützt die Angabe der Sortierung.
Kleiner als oder gleich X <= Y Gibt TRUE zurück, wenn X kleiner oder gleich Y ist. Dieser Operator unterstützt die Angabe der Sortierung.
Größer als X > Y Gibt TRUE zurück, wenn X größer als Y ist. Dieser Operator unterstützt die Angabe der Sortierung.
Größer als oder gleich X >= Y Gibt TRUE zurück, wenn X größer oder gleich Y ist. Dieser Operator unterstützt die Angabe der Sortierung.
Gleich X = Y Gibt TRUE zurück, wenn X gleich Y ist. Dieser Operator unterstützt die Angabe der Sortierung.
Ungleich X != Y
X <> Y
Gibt TRUE zurück, wenn X ungleich Y ist. Dieser Operator unterstützt die Angabe der Sortierung.
BETWEEN X [NOT] BETWEEN Y AND Z

Gibt TRUE zurück, wenn X in dem angegebenen Bereich [nicht] vorhanden ist. Das Ergebnis von "X BETWEEN Y AND Z" ist äquivalent mit "Y <= X AND X <= Z", aber X wird nur einmal im Ersteren ausgewertet. Dieser Operator unterstützt die Angabe der Sortierung.

LIKE X [NOT] LIKE Y Überprüft, ob der STRING im ersten Operanden X mit einem vom zweiten Operanden Y angegebenen Muster übereinstimmt. Ausdrücke können diese Zeichen enthalten:
  • Ein Prozentzeichen "%" entspricht einer beliebigen Anzahl von Zeichen oder Byte
  • Ein Unterstrich "_" entspricht einem einzelnen Zeichen oder Byte
  • Sie können "\", "_" oder "%" mit zwei Backslashs maskieren. Beispiel: "\\%". Wenn Sie Rohstrings verwenden, ist nur ein einziger Backslash erforderlich. Beispiel: r"\%".
IN Mehrere – siehe unten Gibt FALSE zurück, wenn der rechte Operand leer ist. Gibt NULL zurück, wenn der linke Operand NULL ist. Gibt TRUE oder NULL, aber niemals FALSE zurück, wenn der rechte Operand NULL enthält. Argumente auf beiden Seiten von IN sind allgemeine Ausdrücke. Keiner der Operanden muss ein Literal sein, obwohl die Verwendung eines Literals auf der rechten Seite am häufigsten ist. X wird nur einmal ausgewertet. Dieser Operator unterstützt im Allgemeinen die Angabe der Sortierung.

Beim Testen von Werten auf Gleichheit, die einen STRUCT-Datentyp haben, ist es möglich, dass ein oder mehrere Felder NULL sind. In solchen Fällen:

  • Wenn alle Nicht-NULL-Feldwerte gleich sind, gibt der Vergleich NULL zurück.
  • Wenn alle Nicht-NULL-Feldwerte ungleich sind, gibt der Vergleich FALSE zurück.

Die folgende Tabelle zeigt, wie STRUCT-Datentypen verglichen werden, wenn sie Felder aufweisen, die mit NULL bewertet werden.

Struct1 Struct2 Struct1 = Struct2
STRUCT(1, NULL) STRUCT(1, NULL) NULL
STRUCT(1, NULL) STRUCT(2, NULL) FALSE
STRUCT(1,2) STRUCT(1, NULL) NULL

EXISTS-Operator

EXISTS ( subquery )

Beschreibung

Gibt TRUE zurück, wenn die Unterabfrage eine oder mehrere Zeilen erzeugt. Gibt FALSE zurück, wenn die Unterabfrage Nullzeilen erzeugt. Gibt niemals NULL zurück. Weitere Informationen zur Verwendung einer Unterabfrage mit EXISTS finden Sie unter EXISTS-Unterabfragen.

Beispiele

In diesem Beispiel gibt der Operator EXISTS das Ergebnis FALSE zurück, da es in Words keine Zeilen gibt, in denen die Richtung south ist:

WITH Words AS (
  SELECT 'Intend' as value, 'east' as direction UNION ALL
  SELECT 'Secure', 'north' UNION ALL
  SELECT 'Clarity', 'west'
 )
SELECT EXISTS ( SELECT value FROM Words WHERE direction = 'south' ) as result;

+--------+
| result |
+--------+
| FALSE  |
+--------+

Operator IN

Der Operator IN unterstützt die folgende Syntax:

search_value [NOT] IN value_set

value_set:
  {
    (expression[, ...])
    | (subquery)
    | UNNEST(array_expression)
  }

Beschreibung

Prüft auf einen gleichen Wert in einer Gruppe von Werten. Semantische Regeln gelten, aber im Allgemeinen gibt IN TRUE zurück, wenn ein gleicher Wert gefunden wird, FALSE, wenn ein gleicher Wert ausgeschlossen wird, andernfalls NULL. NOT IN gibt FALSE zurück, wenn ein gleicher Wert gefunden wird, TRUE, wenn ein gleicher Wert ausgeschlossen wird, andernfalls NULL.

  • search_value: Der Ausdruck, der mit einer Reihe von Werten verglichen wird.
  • value_set: Ein oder mehrere Werte, die mit einem Suchwert verglichen werden sollen.

    • (expression[, ...]): Eine Liste von Ausdrücken.
    • (subquery): Eine Unterabfrage, die eine einzelne Spalte zurückgibt. Die Werte in dieser Spalte sind die Werte. Wenn keine Zeilen erstellt werden, ist der Satz von Werten leer.
    • UNNEST(array_expression): Ein UNNEST-Operator, der eine Spalte mit Werten aus einem Array-Ausdruck zurückgibt. Dies entspricht:

      IN (SELECT element FROM UNNEST(array_expression) AS element)
      

Semantische Regeln

Bei Verwendung des IN-Operators gilt folgende Semantik in dieser Reihenfolge:

  • Gibt FALSE zurück, wenn value_set leer ist.
  • Gibt NULL zurück, wenn search_value NULL ist.
  • Gibt TRUE zurück, wenn value_set einen Wert enthält, der search_value entspricht.
  • Gibt NULL zurück, wenn value_set einen NULL-Wert enthält.
  • Gibt FALSE zurück.

Bei Verwendung des NOT IN-Operators gilt folgende Semantik in dieser Reihenfolge:

  • Gibt TRUE zurück, wenn value_set leer ist.
  • Gibt NULL zurück, wenn search_value NULL ist.
  • Gibt FALSE zurück, wenn value_set einen Wert enthält, der search_value entspricht.
  • Gibt NULL zurück, wenn value_set einen NULL-Wert enthält.
  • Gibt TRUE zurück.

Dieser Operator unterstützt im Allgemeinen die Sortierung. x [NOT] IN UNNEST wird jedoch nicht unterstützt.

Die Semantik von:

x IN (y, z, ...)

ist gleichbedeutend mit:

(x = y) OR (x = z) OR ...

und die Unterabfrage und Arrayformen sind in ähnlicher Weise definiert.

x NOT IN ...

entspricht:

NOT(x IN ...)

In der Form UNNEST wird ein Arrayscan wie UNNEST in der Klausel FROM behandelt:

x [NOT] IN UNNEST(<array expression>)

Diese Form wird häufig mit ARRAY-Parametern verwendet. Beispiel:

x IN UNNEST(@array_parameter)

Weitere Informationen zur Verwendung dieser Syntax finden Sie im Thema Arrays.

IN kann unter Verwendung der STRUCT-Konstruktorsyntax mit mehrteiligen Schlüsseln verwendet werden. Beispiel:

(Key1, Key2) IN ( (12,34), (56,78) )
(Key1, Key2) IN ( SELECT (table.a, table.b) FROM table )

Weitere Informationen finden Sie unter Struct-Typ.

Rückgabedatentyp

BOOL

Beispiele

Sie können diese WITH-Klauseln verwenden, um temporäre Tabellen für Words und Items in den folgenden Beispielen zu emulieren:

WITH Words AS (
  SELECT 'Intend' as value UNION ALL
  SELECT 'Secure' UNION ALL
  SELECT 'Clarity' UNION ALL
  SELECT 'Peace' UNION ALL
  SELECT 'Intend'
 )
SELECT * FROM Words;

+----------+
| value    |
+----------+
| Intend   |
| Secure   |
| Clarity  |
| Peace    |
| Intend   |
+----------+
WITH
  Items AS (
    SELECT STRUCT('blue' AS color, 'round' AS shape) AS info UNION ALL
    SELECT STRUCT('blue', 'square') UNION ALL
    SELECT STRUCT('red', 'round')
  )
SELECT * FROM Items;

+----------------------------+
| info                       |
+----------------------------+
| {blue color, round shape}  |
| {blue color, square shape} |
| {red color, round shape}   |
+----------------------------+

Beispiel mit IN und einem Ausdruck:

SELECT * FROM Words WHERE value IN ('Intend', 'Secure');

+----------+
| value    |
+----------+
| Intend   |
| Secure   |
| Intend   |
+----------+

Beispiel mit NOT IN und einem Ausdruck:

SELECT * FROM Words WHERE value NOT IN ('Intend');

+----------+
| value    |
+----------+
| Secure   |
| Clarity  |
| Peace    |
+----------+

Beispiel mit IN, einer skalaren Unterabfrage und einem Ausdruck:

SELECT * FROM Words WHERE value IN ((SELECT 'Intend'), 'Clarity');

+----------+
| value    |
+----------+
| Intend   |
| Clarity  |
| Intend   |
+----------+

Beispiel mit IN und einem UNNEST-Vorgang

SELECT * FROM Words WHERE value IN UNNEST(['Secure', 'Clarity']);

+----------+
| value    |
+----------+
| Secure   |
| Clarity  |
+----------+

Beispiel mit IN und STRUCT:

SELECT
  (SELECT AS STRUCT Items.info) as item
FROM
  Items
WHERE (info.shape, info.color) IN (('round', 'blue'));

+------------------------------------+
| item                               |
+------------------------------------+
| { {blue color, round shape} info } |
+------------------------------------+

IS-Operator

IS-Operatoren geben TRUE oder FALSE für die Bedingung zurück, die sie testen. Im Gegensatz zu den unter Mathematische Funktionen definierten Funktionen IS_INF und IS_NAN geben sie nie NULL zurück, auch nicht bei NULL-Eingaben. Wenn NOT vorhanden ist, wird der Ausgabewert BOOL invertiert.

Funktionssyntax Datentyp der Eingabe Datentyp des Ergebnisses Beschreibung

X IS TRUE
BOOL BOOL Wird als TRUE ausgewertet, wenn X als TRUE ausgewertet wird. Andernfalls wird er als FALSE ausgewertet.

X IS NOT TRUE
BOOL BOOL Wird als FALSE ausgewertet, wenn X als TRUE ausgewertet wird. Andernfalls wird er als TRUE ausgewertet.

X IS FALSE
BOOL BOOL Wird als TRUE ausgewertet, wenn X als FALSE ausgewertet wird. Andernfalls wird er als FALSE ausgewertet.

X IS NOT FALSE
BOOL BOOL Wird als FALSE ausgewertet, wenn X als FALSE ausgewertet wird. Andernfalls wird er als TRUE ausgewertet.

X IS NULL
Jeder Werttyp BOOL Wird als TRUE ausgewertet, wenn X als NULL ausgewertet wird. Andernfalls wird er als FALSE ausgewertet.

X IS NOT NULL
Jeder Werttyp BOOL Wird als FALSE ausgewertet, wenn X als NULL ausgewertet wird. Andernfalls wird er als TRUE ausgewertet.

X IS UNKNOWN
BOOL BOOL Wird als TRUE ausgewertet, wenn X als NULL ausgewertet wird. Andernfalls wird er als FALSE ausgewertet.

X IS NOT UNKNOWN
BOOL BOOL Wird als FALSE ausgewertet, wenn X als NULL ausgewertet wird. Andernfalls wird er als TRUE ausgewertet.

IS DISTINCT FROM-Operator

expression_1 IS [NOT] DISTINCT FROM expression_2

Beschreibung

IS DISTINCT FROM gibt TRUE zurück, wenn die Eingabewerte als voneinander unabhängig betrachtet werden,DISTINCT undGROUP BY Klauseln. Andernfalls wird FALSE zurückgegeben.

a IS DISTINCT FROM b gleich TRUE entspricht:

  • SELECT COUNT(DISTINCT x) FROM UNNEST([a,b]) x gibt 2 zurück.
  • SELECT * FROM UNNEST([a,b]) x GROUP BY x gibt zwei Zeilen zurück.

a IS DISTINCT FROM b entspricht NOT (a = b), außer in folgenden Fällen:

  • Dieser Operator gibt niemals NULL zurück, sodass NULL-Werte sich von Nicht-NULL-Werten unterscheiden, nicht von anderen NULL-Werten.
  • NaN-Werte werden von Nicht-NaN-Werten unterschieden, aber nicht von anderen NaN-Werten.

Sie können diesen Vorgang mit Feldern in einem komplexen Datentyp verwenden, jedoch nicht mit den komplexen Datentypen selbst. Diese komplexen Datentypen können nicht direkt verglichen werden:

  • STRUCT
  • ARRAY

Eingabetypen

  • expression_1: Der erste zu vergleichende Wert. Dies kann der gruppierbare Datentyp NULL oder NaN sein.
  • expression_2: Der zweite zu vergleichende Wert. Dies kann der gruppierbare Datentyp NULL oder NaN sein.
  • NOT: Wenn vorhanden, wird der Ausgabewert BOOL invertiert.

Rückgabetyp

BOOL

Beispiele

Diese geben TRUE zurück:

SELECT 1 IS DISTINCT FROM 2
SELECT 1 IS DISTINCT FROM NULL
SELECT 1 IS NOT DISTINCT FROM 1
SELECT NULL IS NOT DISTINCT FROM NULL

Diese geben FALSE zurück:

SELECT NULL IS DISTINCT FROM NULL
SELECT 1 IS DISTINCT FROM 1
SELECT 1 IS NOT DISTINCT FROM 2
SELECT 1 IS NOT DISTINCT FROM NULL

Verkettungsoperator

Der Verkettungsoperator kombiniert mehrere Werte zu einem einzigen Wert.

Funktionssyntax Datentyp der Eingabe Datentyp des Ergebnisses

STRING || STRING [ || ... ]
STRING STRING

BYTES || BYTES [ || ... ]
BYTES STRING

ARRAY<T> || ARRAY<T> [ || ... ]
ARRAY<T> ARRAY<T>