Stringfunktionen

Die hier dargestellten Stringfunktionen funktionieren mit zwei verschiedenen Datentypen: STRING und BYTES. STRING-Werte müssen korrekt in UTF-8 formatiert sein.

Funktionen, die Positionswerte wie STRPOS zurückgeben, codieren diese Positionen im Format INT64. Der Wert 1 bezieht sich auf das erste Zeichen (oder Byte), 2 bezieht sich auf das zweite Zeichen (oder Byte) und so weiter. Der Wert 0 gibt einen ungültigen Index an. Bei der Nutzung von Daten vom Typ STRING beziehen sich die zurückgegebenen Positionen auf Zeichenpositionen.

Alle Stringvergleiche werden von Byte zu Byte durchgeführt, ohne Rücksicht auf kanonische Äquivalenz von Unicode.

ASCII

ASCII(value)

Beschreibung

Gibt den ASCII-Code für das erste Zeichen oder Byte in value zurück. Gibt 0 zurück, wenn value leer ist oder der ASCII-Code für das erste Zeichen oder Byte 0 ist.

Rückgabetyp

INT64

Beispiele

SELECT ASCII('abcd') as A, ASCII('a') as B, ASCII('') as C, ASCII(NULL) as D;

+-------+-------+-------+-------+
| A     | B     | C     | D     |
+-------+-------+-------+-------+
| 97    | 97    | 0     | NULL  |
+-------+-------+-------+-------+

BYTE_LENGTH

BYTE_LENGTH(value)

Beschreibung

Gibt die Länge des STRING- oder BYTES-Werts in BYTES zurück, unabhängig davon, ob der Typ des Werts STRING oder BYTES ist.

Rückgabetyp

INT64

Beispiele

WITH example AS
  (SELECT 'абвгд' AS characters, b'абвгд' AS bytes)

SELECT
  characters,
  BYTE_LENGTH(characters) AS string_example,
  bytes,
  BYTE_LENGTH(bytes) AS bytes_example
FROM example;

+------------+----------------+-------+---------------+
| characters | string_example | bytes | bytes_example |
+------------+----------------+-------+---------------+
| абвгд      | 10             | абвгд | 10            |
+------------+----------------+-------+---------------+

CHAR_LENGTH

CHAR_LENGTH(value)

Beschreibung

Gibt die Länge von STRING in Zeichen zurück.

Rückgabetyp

INT64

Beispiele

WITH example AS
  (SELECT 'абвгд' AS characters)

SELECT
  characters,
  CHAR_LENGTH(characters) AS char_length_example
FROM example;

+------------+---------------------+
| characters | char_length_example |
+------------+---------------------+
| абвгд      |                   5 |
+------------+---------------------+

CHARACTER_LENGTH

CHARACTER_LENGTH(value)

Beschreibung

Synonym für CHAR_LENGTH.

Rückgabetyp

INT64

Beispiele

WITH example AS
  (SELECT 'абвгд' AS characters)

SELECT
  characters,
  CHARACTER_LENGTH(characters) AS char_length_example
FROM example;

+------------+---------------------+
| characters | char_length_example |
+------------+---------------------+
| абвгд      |                   5 |
+------------+---------------------+

CHR

CHR(value)

Beschreibung

Verwendet einen Unicode-Codepoint und gibt das Zeichen zurück, das mit dem Codepunkt übereinstimmt. Jeder gültige Codepoint sollte im Bereich von [0, 0xD7FF] und [0xE000, 0x10FFFF] liegen. Gibt einen leeren String zurück, wenn der Codepoint 0 ist. Wenn ein ungültiger Unicode-Codepoint angegeben wird, wird ein Fehler zurückgegeben.

Informationen zur Verwendung eines Arrays mit Unicode-Codepoints finden Sie unter CODE_POINTS_TO_STRING.

Rückgabetyp

STRING

Beispiele

SELECT CHR(65) AS A, CHR(255) AS B, CHR(513) AS C, CHR(1024)  AS D;

+-------+-------+-------+-------+
| A     | B     | C     | D     |
+-------+-------+-------+-------+
| A     | ÿ     | ȁ     | Ѐ     |
+-------+-------+-------+-------+
SELECT CHR(97) AS A, CHR(0xF9B5) AS B, CHR(0) AS C, CHR(NULL) AS D;

+-------+-------+-------+-------+
| A     | B     | C     | D     |
+-------+-------+-------+-------+
| a     | 例    |       | NULL  |
+-------+-------+-------+-------+

CODE_POINTS_TO_BYTES

CODE_POINTS_TO_BYTES(ascii_values)

Beschreibung

Gibt für ein Array von erweiterten ASCII-Codepunkten (ARRAY von INT64) BYTES zurück.

Informationen zum Umwandeln von BYTES in ein Array von Codepunkten finden Sie unter TO_CODE_POINTS.

Rückgabetyp

BYTES

Beispiele

Nachfolgend ein einfaches Beispiel mit CODE_POINTS_TO_BYTES.

SELECT CODE_POINTS_TO_BYTES([65, 98, 67, 100]) AS bytes;

-- Note that the result of CODE_POINTS_TO_BYTES is of type BYTES, displayed as a base64-encoded string.
-- In BYTES format, b'AbCd' is the result.
+----------+
| bytes    |
+----------+
| QWJDZA== |
+----------+

Im folgendem Beispiel wird ein String mit dem ROT13-Algorithmus (Rotiere um 13 Stellen) codiert.

SELECT CODE_POINTS_TO_BYTES(ARRAY_AGG(
  (SELECT
      CASE
        WHEN chr BETWEEN b'a' and b'z'
          THEN TO_CODE_POINTS(b'a')[offset(0)] +
            MOD(code+13-TO_CODE_POINTS(b'a')[offset(0)],26)
        WHEN chr BETWEEN b'A' and b'Z'
          THEN TO_CODE_POINTS(b'A')[offset(0)] +
            MOD(code+13-TO_CODE_POINTS(b'A')[offset(0)],26)
        ELSE code
      END
   FROM
     (SELECT code, CODE_POINTS_TO_BYTES([code]) chr)
  ) ORDER BY OFFSET)) AS encoded_string
FROM UNNEST(TO_CODE_POINTS(b'Test String!')) code WITH OFFSET;

-- Note that the result of CODE_POINTS_TO_BYTES is of type BYTES, displayed as a base64-encoded string.
-- In BYTES format, b'Grfg Fgevat!' is the result.
+------------------+
| encoded_string   |
+------------------+
| R3JmZyBGZ2V2YXQh |
+------------------+

CODE_POINTS_TO_STRING

CODE_POINTS_TO_STRING(value)

Beschreibung

Gibt für ein Array von Unicode-Codepunkten (ARRAY von INT64) einen STRING-Wert zurück. Wenn ein Codepunkt 0 ist, wird im STRING kein Zeichen dafür zurückgegeben.

Informationen zum Umwandeln eines Strings in ein Array von Codepunkten finden Sie unter TO_CODE_POINTS.

Rückgabetyp

STRING

Beispiele

Es folgen einfache Beispiele, in denen CODE_POINTS_TO_STRING verwendet wird.

SELECT CODE_POINTS_TO_STRING([65, 255, 513, 1024]) AS string;

+--------+
| string |
+--------+
| AÿȁЀ   |
+--------+
SELECT CODE_POINTS_TO_STRING([97, 0, 0xF9B5]) AS string;

+--------+
| string |
+--------+
| a例    |
+--------+
SELECT CODE_POINTS_TO_STRING([65, 255, NULL, 1024]) AS string;

+--------+
| string |
+--------+
| NULL   |
+--------+

Das folgende Beispiel berechnet die Häufigkeit der Buchstaben in einer Gruppe von Wörtern.

WITH Words AS (
  SELECT word
  FROM UNNEST(['foo', 'bar', 'baz', 'giraffe', 'llama']) AS word
)
SELECT
  CODE_POINTS_TO_STRING([code_point]) AS letter,
  COUNT(*) AS letter_count
FROM Words,
  UNNEST(TO_CODE_POINTS(word)) AS code_point
GROUP BY 1
ORDER BY 2 DESC;

+--------+--------------+
| letter | letter_count |
+--------+--------------+
| a      | 5            |
| f      | 3            |
| r      | 2            |
| b      | 2            |
| l      | 2            |
| o      | 2            |
| g      | 1            |
| z      | 1            |
| e      | 1            |
| m      | 1            |
| i      | 1            |
+--------+--------------+

CONCAT

CONCAT(value1[, ...])

Beschreibung

Verkettet einen oder mehrere Werte zu einem einzelnen Ergebnis. Alle Werte müssen BYTES oder Datentypen sein, die in STRING umgewandelt werden können.

Die Funktion gibt NULL zurück, wenn eines der Eingabeargumente NULL ist.

Rückgabetyp

STRING oder BYTES

Beispiele

SELECT CONCAT('T.P.', ' ', 'Bar') as author;

+---------------------+
| author              |
+---------------------+
| T.P. Bar            |
+---------------------+
SELECT CONCAT('Summer', ' ', 1923) as release_date;

+---------------------+
| release_date        |
+---------------------+
| Summer 1923         |
+---------------------+

With Employees AS
  (SELECT
    'John' AS first_name,
    'Doe' AS last_name
  UNION ALL
  SELECT
    'Jane' AS first_name,
    'Smith' AS last_name
  UNION ALL
  SELECT
    'Joe' AS first_name,
    'Jackson' AS last_name)

SELECT
  CONCAT(first_name, ' ', last_name)
  AS full_name
FROM Employees;

+---------------------+
| full_name           |
+---------------------+
| John Doe            |
| Jane Smith          |
| Joe Jackson         |
+---------------------+

CONTAINS_SUBSTR

CONTAINS_SUBSTR(expression, search_value_literal)

Beschreibung

Führt eine normalisierte Suche ohne Berücksichtigung der Groß-/Kleinschreibung durch, um zu prüfen, ob ein Wert in einem Ausdruck vorhanden ist. Gibt TRUE zurück, wenn der Wert vorhanden ist. Andernfalls wird FALSE zurückgegeben.

Der Suchwert muss ein STRING-Literal sein, aber nicht das Literal NULL.

Der Ausdruck kann ein Spalten- oder Tabellenverweis sein. Eine Tabellenreferenz wird als STRUCT ausgewertet, deren Felder die Spalten der Tabelle sind. Eine Spaltenreferenz wird als einer der folgenden Datentypen ausgewertet:

  • STRING
  • INT64
  • BOOL
  • NUMERIC
  • BIGNUMERIC
  • TIMESTAMP
  • TIME
  • DATE
  • DATETIME
  • ARRAY
  • STRUCT

Bei der Auswertung des Ausdrucks wird das Ergebnis in einen STRING umgewandelt und die Funktion sucht dann im Ergebnis nach dem Suchwert. Wenn der Suchwert NULL ist, wird ein Fehler ausgegeben. Wenn der Ausdruck NULL ist, ist der Rückgabewert NULL.

Sie können eine feldübergreifende Suche für einen Ausdruck machen, der als STRUCT oder ARRAY ausgewertet wird. Wird der Ausdruck als STRUCT ausgewertet, so ist die feldübergreifende Suche rekursiv und enthält alle Unterfelder innerhalb von STRUCT.

Bei einer feldübergreifenden Suche werden jedes Feld und Unterfeld einzeln in einen String konvertiert und nach dem Wert durchsucht. Die Funktion gibt TRUE zurück, wenn mindestens ein Feld den Suchwert enthält. Wenn mindestens ein Feld NULL ist, wird NULL zurückgegeben. Wenn der Suchwert nicht gefunden wird und alle Felder Nicht-NULL sind, wird FALSE zurückgegeben.

Bevor Werte verglichen werden, werden sie normalisiert und mit NFKC-Normalisierung wird die Groß-/Kleinschreibung vereinheitlicht. Suchanfragen mit Platzhaltern werden nicht unterstützt.

Rückgabetyp

BOOL

Beispiele

Die folgende Abfrage gibt TRUE zurück, da diese Übereinstimmung ohne Beachtung der Groß- und Kleinschreibung gefunden wurde: blue house und Blue house.

SELECT CONTAINS_SUBSTR('the blue house', 'Blue house') AS result;

+--------+
| result |
+--------+
| true   |
+--------+

Folgende Abfrage gibt FALSE zurück, da blue nicht in the red house gefunden wurde.

SELECT CONTAINS_SUBSTR('the red house', 'blue') AS result;

+--------+
| result |
+--------+
| false  |
+--------+

Folgende Abfrage gibt TRUE zurück, da und IX denselben normalisierten Wert darstellen.

SELECT '\u2168 day' AS a, 'IX' AS b, CONTAINS_SUBSTR('\u2168', 'IX') AS result;

+----------------------+
| a      | b  | result |
+----------------------+
| Ⅸ day | IX | true   |
+----------------------+

Folgende Abfrage gibt TRUE zurück, da 35 in einem STRUCT-Feld gefunden wurde.

SELECT CONTAINS_SUBSTR((23, 35, 41), '35') AS result;

+--------+
| result |
+--------+
| true   |
+--------+

Die folgende Abfrage gibt TRUE zurück, da jk während einer rekursiven Suche in einem STRUCT gefunden wurde.

SELECT CONTAINS_SUBSTR(('abc', ['def', 'ghi', 'jkl'], 'mno'), 'jk');

+--------+
| result |
+--------+
| true   |
+--------+

Die folgende Abfrage gibt TRUE zurück, da NULL-Werte ignoriert werden, wenn eine Übereinstimmung innerhalb eines STRUCT oder ARRAY gefunden wird.

SELECT CONTAINS_SUBSTR((23, NULL, 41), '41') AS result;

+--------+
| result |
+--------+
| true   |
+--------+

Die folgende Abfrage gibt NULL zurück, da eine NULL in einem STRUCT vorhanden war, das nicht zu einer Übereinstimmung geführt hat.

SELECT CONTAINS_SUBSTR((23, NULL, 41), '35') AS result;

+--------+
| result |
+--------+
| null   |
+--------+

In der folgenden Abfrage wird ein Fehler ausgegeben, da der Suchwert kein NULL-Literal sein kann.

SELECT CONTAINS_SUBSTR('hello', NULL) AS result;
-- Throws an error

Die folgenden Beispiele verweisen auf eine Tabelle mit dem Namen Recipes, die Sie mit einer WITH-Klausel wie folgender emulieren können:

WITH Recipes AS
 (SELECT 'Blueberry pancakes' as Breakfast, 'Egg salad sandwich' as Lunch, 'Potato dumplings' as Dinner UNION ALL
  SELECT 'Potato pancakes', 'Toasted cheese sandwich', 'Beef stroganoff' UNION ALL
  SELECT 'Ham scramble', 'Steak avocado salad', 'Tomato pasta' UNION ALL
  SELECT 'Avocado toast', 'Tomato soup', 'Blueberry salmon' UNION ALL
  SELECT 'Corned beef hash', 'Lentil potato soup', 'Glazed ham')
SELECT * FROM Recipes;

+-------------------+-------------------------+------------------+
| Breakfast         | Lunch                   | Dinner           |
+-------------------+-------------------------+------------------+
| Bluberry pancakes | Egg salad sandwich      | Potato dumplings |
| Potato pancakes   | Toasted cheese sandwich | Beef stroganoff  |
| Ham scramble      | Steak avocado salad     | Tomato pasta     |
| Avocado toast     | Tomato soup             | Blueberry samon  |
| Corned beef hash  | Lentil potato soup      | Glazed ham       |
+-------------------+-------------------------+------------------+

Folgende Abfrage durchsucht alle Spalten der Tabelle Recipes nach dem Wert toast und gibt die Zeilen zurück, die diesen Wert enthalten.

SELECT * FROM Recipes WHERE CONTAINS_SUBSTR(Recipes, 'toast');

+-------------------+-------------------------+------------------+
| Breakfast         | Lunch                   | Dinner           |
+-------------------+-------------------------+------------------+
| Potato pancakes   | Toasted cheese sandwich | Beef stroganoff  |
| Avocado toast     | Tomato soup             | Blueberry samon  |
+-------------------+-------------------------+------------------+

Die folgende Abfrage durchsucht die Spalten Lunch und Dinner der Tabelle Recipe nach dem Wert potato und gibt die Zeile zurück, wenn eine der Spalten diesen Wert enthält.

SELECT * FROM Recipes WHERE CONTAINS_SUBSTR((Lunch, Dinner), 'potato');

+-------------------+-------------------------+------------------+
| Breakfast         | Lunch                   | Dinner           |
+-------------------+-------------------------+------------------+
| Bluberry pancakes | Egg salad sandwich      | Potato dumplings |
| Corned beef hash  | Lentil potato soup      | Glazed ham       |
+-------------------+-------------------------+------------------+

Die folgenden Abfragen suchen in allen Spalten der Tabelle Recipes mit Ausnahme der Spalten Lunch und Dinner. Sie geben die Zeilen aller Spalten außer Lunch oder Dinner zurück, die den Wert potato enthalten.

SELECT *
FROM Recipes
WHERE CONTAINS_SUBSTR(
  (SELECT AS STRUCT Recipes.* EXCEPT (Lunch, Dinner)),
  'potato'
);

+-------------------+-------------------------+------------------+
| Breakfast         | Lunch                   | Dinner           |
+-------------------+-------------------------+------------------+
| Potato pancakes   | Toasted cheese sandwich | Beef stroganoff  |
+-------------------+-------------------------+------------------+

ENDS_WITH

ENDS_WITH(value1, value2)

Beschreibung

Verwendet zwei STRING- oder BYTES-Werte. Gibt TRUE zurück, wenn der zweite Wert ein Suffix des ersten Werts ist.

Rückgabetyp

BOOL

Beispiele

WITH items AS
  (SELECT 'apple' as item
  UNION ALL
  SELECT 'banana' as item
  UNION ALL
  SELECT 'orange' as item)

SELECT
  ENDS_WITH(item, 'e') as example
FROM items;

+---------+
| example |
+---------+
|    True |
|   False |
|    True |
+---------+

FORMAT

FORMAT(format_string_expression, data_type_expression[, ...])

Beschreibung

FORMAT formatiert einen Datentypausdruck als String.

  • format_string_expression: Kann null oder mehrere Formatspezifizierer enthalten. Jeder Formatspezifizierer wird durch das %-Zeichen eingeführt und muss einem oder mehreren der übrigen Argumente zugeordnet werden. Im Allgemeinen ist dies eine Eins-zu-Eins-Zuordnung, außer wenn der *-Spezifizierer vorhanden ist. Zum Beispiel ist %.*i zwei Argumenten zugeordnet – einem Längenargument und einem signierten Ganzzahlenargument. Wenn die Anzahl der Argumente, die sich auf die Formatspezifizierer beziehen, nicht mit der Anzahl der Argumente übereinstimmt, tritt ein Fehler auf.
  • data_type_expression: Der Wert, der als String formatiert werden soll. Dies kann ein beliebiger BigQuery-Datentyp sein.

Rückgabetyp

STRING

Beispiele

Beschreibung Anweisung Ergebnis
Einfache Ganzzahl FORMAT('%d', 10) 10
Ganzzahl mit Leerzeichenausgleich links FORMAT('|%10d|', 11) |           11|
Ganzzahl mit aufgefüllten Nullen links FORMAT('+%010d+', 12) +0000000012+
Ganzzahl mit Kommas FORMAT("%'d", 123456789) 123,456,789
STRING FORMAT('-%s-', 'abcd efg') -abcd efg-
FLOAT64 FORMAT('%f %E', 1.1, 2.2) 1.100000 2.200000E+00
DATE FORMAT('%t', date '2015-09-01') 2015-09-01
TIMESTAMP FORMAT('%t', timestamp '2015-09-01 12:34:56 America/Los_Angeles') 2015‑09‑01 19:34:56+00

Die Funktion FORMAT() bietet weder eine vollständig anpassbare Formatierung für alle Typen und Werte noch eine sprachsensitive Formatierung.

Wenn eine benutzerdefinierte Formatierung für einen Typ erforderlich ist, müssen Sie ihn zuerst mit typspezifischen Formatfunktionen wie FORMAT_DATE() oder FORMAT_TIMESTAMP() formatieren. Beispiel:

SELECT FORMAT('date: %s!', FORMAT_DATE('%B %d, %Y', date '2015-01-02'));

Rückgabe:

date: January 02, 2015!

Unterstützte Formatspezifizierer

%[flags][width][.precision]specifier

Ein Formatspezifizierer fügt Formatierung hinzu, wenn ein Wert in einen String umgewandelt wird. Optional kann er diese Unterspezifizierer enthalten:

Weitere Informationen zu Formatspezifizierern:

Formatspezifizierer
Spezifizierer Beschreibung Beispiele Typen
d oder i Ganze Dezimalzahl 392 INT64
o Oktalzahl 610
INT64*
x Hexadezimale Ganzzahl 7fa
INT64*
X Hexadezimale Ganzzahl (Großbuchstaben) 7FA
INT64*
f Dezimalschreibweise: [-](Ganzzahl).(Bruchteil) für endliche Werte, in Kleinbuchstaben für nicht endliche Werte 392.650000
inf
nan
NUMERIC
BIGNUMERIC
FLOAT64
F Dezimalschreibweise: [-](Ganzzahl).(Bruchteil) für endliche Werte, in Großbuchstaben für nicht endliche Werte 392.650000
INF
NAN
NUMERIC
BIGNUMERIC
FLOAT64
e Exponentialschreibweise (Mantisse/Exponent), Kleinbuchstaben 3.926500e+02
inf
nan
NUMERIC
BIGNUMERIC
FLOAT64
E Exponentialschreibweise (Mantisse/Exponent), Großbuchstaben 3.926500E+02
INF
NAN
NUMERIC
BIGNUMERIC
FLOAT64
g Entweder Dezimalschreibweise oder wissenschaftliche Schreibweise, abhängig vom Exponenten des Eingabewerts und der angegebenen Genauigkeit. Kleinschreibung. Weitere Informationen finden Sie unter %g- und %G-Verhalten. 392.65
3.9265e+07
inf
nan
NUMERIC
BIGNUMERIC
FLOAT64
G Entweder Dezimalschreibweise oder wissenschaftliche Schreibweise, abhängig vom Exponenten des Eingabewerts und der angegebenen Genauigkeit. Großschreibung. Weitere Informationen finden Sie unter %g- und %G-Verhalten. 392.65
3.9265E+07
INF
NAN
NUMERIC
BIGNUMERIC
FLOAT64
s String Beispiel STRING
t Gibt einen druckbaren String zurück, der den Wert darstellt. Ähnelt häufig der Umwandlung des Arguments in STRING. Informationen dazu finden Sie unter %t- und %T-Verhalten. Beispiel
01.01.2014
<any>
T Erzeugt einen String, der eine gültige BigQuery-Konstante mit einem ähnlichen Typ zum Werttyp ist (vielleicht größer oder vielleicht ein String). Informationen dazu finden Sie unter %t- und %T-Verhalten. 'sample'
b'bytes sample'
1234
2.3
Datum '2014‑01‑01'
<any>
% '%%' erzeugt ein einziges '%' %

*Die Spezifizierer %o, %x und %X geben bei negativen Werten einen Fehler aus.

Der Formatspezifizierer kann optional die oben identifizierten Unterspezifizierer im Spezifiziererprototyp enthalten.

Diese Unterspezifizierer müssen folgenden Spezifikationen entsprechen.

Kennzeichnungen
Kennzeichnungen Beschreibung
- Linksbündig innerhalb der vorgegebenen Feldbreite; rechtsbündig ist die Voreinstellung (siehe Unterspezifizierer für die Breite).
+ Erzwingt, dass dem Ergebnis auch bei positiven Zahlen ein Plus- oder Minuszeichen (+ oder -) vorangestellt wird. Standardmäßig werden nur negative Zahlen mit dem Vorzeichen - versehen.
<Leerzeichen> Wird kein Vorzeichen geschrieben, wird vor dem Wert ein Leerzeichen eingefügt.
#
  • Bei "%o", "%x" und "%X" bedeutet dieses Flag, dass dem Wert 0, 0x bzw. 0X vorangestellt wird, wenn er nicht null ist.
  • Bei "%f", "%F", "%e" und "%E" bedeutet dieses Flag, dass das Dezimalzeichen auch dann hinzugefügt wird, wenn kein Bruchteil vorhanden ist, es sei denn, der Wert ist nicht endlich.
  • Bei "%g" und "%G" bedeutet dieses Flag, dass das Dezimalzeichen auch dann hinzugefügt wird, wenn kein Bruchteil vorhanden ist, es sei denn, der Wert ist nicht endlich. Die nachlaufenden Nullen nach dem Dezimalzeichen werden nie entfernt.
0 Füllt die Zahl von links mit Nullen (0) statt mit Leerzeichen auf, wenn das Auffüllen spezifiziert ist (siehe Unterspezifizierer für die Breite).
'

Formatiert Ganzzahlen mit dem passenden Gruppierungszeichen. Beispiel:

  • FORMAT("%'d", 12345678) gibt 12,345,678 zurück
  • FORMAT("%'x", 12345678) gibt bc:614e zurück
  • FORMAT("%'o", 55555) gibt 15,4403 zurück
  • Dieses Flag spielt nur für Dezimal-, Hexadezimal- und Oktalwerte eine Rolle.

Flags können in beliebiger Reihenfolge angegeben werden. Doppelte Flags sind kein Fehler. Wenn Flags für einen Elementtyp nicht relevant sind, werden sie ignoriert.

Breite
Breite Beschreibung
<Anzahl> Mindestanzahl der zu druckenden Zeichen. Wenn der Wert, der ausgegeben werden soll, kürzer als diese Zahl ist, wird das Ergebnis mit Leerzeichen aufgefüllt. Der Wert wird nicht abgeschnitten, auch wenn das Ergebnis größer ist.
* Die Breite wird nicht im Formatstring angegeben, sondern als zusätzliches Ganzzahlargument vor dem Argument, das formatiert werden muss, vorangestellt.
Precision
Precision Beschreibung
.<Anzahl>
  • Für die Ganzzahlspezifizierer "%d", "%i", "%o", "%u", "%x" und "%X": Die Genauigkeit gibt die Mindestanzahl der zu schreibenden Ziffern an. Wenn der zu schreibende Wert kürzer als diese Zahl ist, wird das Ergebnis mit nachlaufenden Nullen aufgefüllt. Der Wert wird nicht abgeschnitten, auch wenn das Ergebnis länger ist. Eine Genauigkeit von 0 bedeutet, dass kein Zeichen für den Wert 0 geschrieben wird.
  • Für die Spezifizierer "%a", "%A", "%e", "%E", "%f" und "%F" ist dies die Anzahl an Ziffern, die nach dem Dezimalzeichen ausgegeben werden sollen. Der Standardwert ist 6.
  • Für die Spezifizierer "%g" und "%G" ist dies die Anzahl an signifikanten Ziffern, die ausgegeben werden sollen, bevor die Nullen nach dem Dezimalzeichen entfernt werden. Der Standardwert ist 6.
.* Die Präzision wird im Formatstring nicht angegeben, sondern als zusätzliches Ganzzahlwertargument dem Argument vorangestellt, das formatiert werden muss.
Verhalten von %g und %G

Die Formatspezifizierer %g und %G wenden entweder die Dezimalschreibweise (z. B. %f und %F) oder die wissenschaftliche Schreibweise (z. B. %e und %E) an. Dies ist abhängig vom Exponenten des Eingabewerts und der angegebenen Präzision.

Übernehmen Sie p für die angegebene Genauigkeit. Der Standardwert ist 6, und 1, wenn die angegebene Genauigkeit kleiner als 1 ist. Der Eingabewert wird zuerst in die wissenschaftliche Schreibweise mit der Präzision = (p - 1) umgewandelt. Wenn der resultierende Exponentenanteil x kleiner als -4 oder nicht kleiner als p ist, wird die wissenschaftliche Schreibweise mit der Präzision = (p - 1) verwendet. Andernfalls wird die Dezimalschreibweise mit der Präzision = (p - 1 - x) verwendet.

Sofern kein #-Flag vorhanden ist, werden die nachlaufenden Nullen nach dem Dezimalzeichen entfernt. Das Dezimalzeichen wird ebenfalls entfernt, wenn ihm keine Ziffer folgt.

%t- und %T-Verhalten

Die Formatspezifizierer %t und %T werden für alle Typen definiert. Die Breite, Präzision und Flags funktionieren wie bei %s: Die Breite ist die Mindestbreite und der STRING wird auf diese Größe aufgefüllt. Die Präzision ist die maximale Breite des zu zeigenden Inhalts und der STRING wird vor dem Auffüllen auf die Breite auf diese Größe gekürzt.

Der Spezifizierer %t ist immer eine lesbare Form des Werts.

Der Spezifizierer %T ist immer ein gültiges SQL-Literal eines ähnlichen Typs, z. B. ein breiterer numerischer Typ. Das Literal enthält keine Umwandlungen und keinen Typnamen, mit Ausnahme des Sonderfalls von nicht endlichen Gleitkommazahlenwerten.

Der STRING ist in folgender Weise formatiert:

Typ %t %T
NULL eines beliebigen Typs NULL NULL
INT64
123 123
NUMERIC 123,0 (immer mit ,0) NUMERIC "123,0"
FLOAT64 123,0 (immer mit ,0)
123e+10
inf
-inf
NaN
123,0 (immer mit ,0)
123e+10
CAST("inf" AS <Typ>)
CAST("-inf" AS <Typ>)
CAST("nan" AS <Typ>)
STRING Stringwert ohne Anführungszeichen String-Literal mit Anführungszeichen
BYTES Escape-Byte ohne Anführungszeichen
z. B. abc\x01\x02
Byte-Literal mit Anführungszeichen
z. B. b"abc\x01\x02"
DATE 03.02.2011 DATE "03.02.2011"
TIMESTAMP 03.02.2011 04:05:06+00 TIMESTAMP "03.02.2011 04:05:06+00"
INTERVAL 1-2 3 4:5:6.789 INTERVAL "1-2 3 4:5:6.789" YEAR TO SECOND
ARRAY [Wert, Wert, ...]
wobei Werte mit %t formatiert sind
[Wert, Wert, ...]
wobei Werte mit %T formatiert sind
STRUCT (Wert, Wert, ...)
wobei Felder mit %t formatiert sind
(Wert, Wert, ...)
wobei Felder mit %T formatiert sind

Sonderfälle:
Nullfelder: STRUCT()
Ein Feld: STRUCT(Wert)
Fehlerbedingungen

Wenn ein Formatspezifizierer ungültig ist oder nicht mit dem zugehörigen Argumenttyp kompatibel ist oder die falsche Nummer oder die falschen Argumente bereitgestellt werden, wird ein Fehler erzeugt. Die folgenden <format_string>-Ausdrücke sind beispielsweise ungültig:

FORMAT('%s', 1)
FORMAT('%')
NULL-Argument-Behandlung

Ein NULL-Formatstring führt zu einem Ausgabe-STRING von NULL. Alle anderen Argumente werden in diesem Fall ignoriert.

Die Funktion erzeugt generell einen NULL-Wert, wenn ein NULL-Argument vorhanden ist. Beispielsweise generiert FORMAT('%i', NULL_expression) einen NULL STRING als Ausgabe.

Allerdings gibt es dafür Ausnahmen. Wenn der Formatspezifizierer %t oder %T ist (beide generieren STRINGs, die effektiv mit CAST und der Literalwertsemantik übereinstimmen), generiert ein STRING-Wert den String "NULL" (ohne Anführungszeichen) im Ergebnis-NULL. Ein Beispiel dafür ist die folgende Funktion:

FORMAT('00-%t-00', NULL_expression);

Rückgabe:

00-NULL-00
Zusätzliche semantische Regeln

FLOAT64-Werte können +/-inf oder NaN sein. Wenn ein Argument einen dieser Werte aufweist, ist das Ergebnis der Formatspezifizierer %f, %F, %e, %E, %g, %G und %t gleich inf, -inf oder nan (in Klein- oder Großbuchstaben), soweit zutreffend. Dies entspricht der Art und Weise, wie BigQuery diese Werte in den Typ STRING umwandelt. Für %T gibt BigQuery Strings in Anführungszeichen für FLOAT64-Werte zurück, die keine Nicht-String-Literaldarstellungen haben.

FROM_BASE32

FROM_BASE32(string_expr)

Beschreibung

Wandelt den base32-codierten Eingabe-string_expr in das BYTES-Format um. Zum Umwandeln von BYTES in einen base32-codierten STRING verwenden Sie TO_BASE32.

Rückgabetyp

BYTES

Beispiel

SELECT FROM_BASE32('MFRGGZDF74======') AS byte_data;

-- Note that the result of FROM_BASE32 is of type BYTES, displayed as a base64-encoded string.
+-----------+
| byte_data |
+-----------+
| YWJjZGX/  |
+-----------+

FROM_BASE64

FROM_BASE64(string_expr)

Beschreibung

Wandelt den base64-codierten Eingabe-string_expr in das BYTES-Format um. Zum Umwandeln von BYTES in einen base64-codierten STRING verwenden Sie TO_BASE64.

Es gibt mehrere gängige base64-Codierungen, die sich darin unterscheiden, mit welchem Alphabet aus 65 ASCII-Zeichen die 64 Ziffern und das Auffüllen codiert werden. Weitere Informationen finden Sie unter RFC 4648. Diese Funktion erwartet das Alphabet [A-Za-z0-9+/=].

Rückgabetyp

BYTES

Beispiel

SELECT FROM_BASE64('/+A=') AS byte_data;

-- Note that the result of FROM_BASE64 is of type BYTES, displayed as a base64-encoded string.
+-----------+
| byte_data |
+-----------+
| /+A=      |
+-----------+

Wenn Sie mit einer Codierung mit einem anderen base64-Standard arbeiten möchten, müssen Sie unter Umständen FROM_BASE64 mit der Funktion REPLACE erstellen. Die URL-sichere und dateinamen-sichere base64url-Codierung, die häufig von Webprogrammierern verwendet wird, verwendet -_= statt +/= als letzte Zeichen. Um einen base64url-codierten String zu decodieren, ersetzen Sie - und _ durch + bzw. /.

SELECT FROM_BASE64(REPLACE(REPLACE('_-A=', '-', '+'), '_', '/')) AS binary;

-- Note that the result of FROM_BASE64 is of type BYTES, displayed as a base64-encoded string.
+--------+
| binary |
+--------+
| /+A=   |
+--------+

FROM_HEX

FROM_HEX(string)

Beschreibung

Wandelt einen hexadezimal codierten STRING in das BYTES-Format um. Gibt einen Fehler zurück, wenn der Eingabe-STRING Zeichen außerhalb des Bereichs (0..9, A..F, a..f) enthält. Die Groß-/Kleinschreibung der Zeichen spielt keine Rolle. Wenn der Eingabe-STRING eine ungerade Anzahl an Zeichen enthält, verhält sich die Funktion so, als würde die Eingabe eine zusätzliche führende 0 enthalten. Zum Umwandeln von BYTES in einen hexadezimal codierten STRING verwenden Sie TO_HEX.

Rückgabetyp

BYTES

Beispiel

WITH Input AS (
  SELECT '00010203aaeeefff' AS hex_str UNION ALL
  SELECT '0AF' UNION ALL
  SELECT '666f6f626172'
)
SELECT hex_str, FROM_HEX(hex_str) AS bytes_str
FROM Input;

-- Note that the result of FROM_HEX is of type BYTES, displayed as a base64-encoded string.
+------------------+--------------+
| hex_str          | bytes_str    |
+------------------+--------------+
| 0AF              | AAECA6ru7/8= |
| 00010203aaeeefff | AK8=         |
| 666f6f626172     | Zm9vYmFy     |
+------------------+--------------+

INITCAP

INITCAP(value[, delimiters])

Beschreibung

Verwendet einen STRING und gibt ihn mit dem ersten Zeichen in jedem Wort in Großbuchstaben und allen anderen Zeichen in Kleinbuchstaben zurück. Nichtalphabetische Zeichen bleiben gleich.

delimiters ist ein optionales Stringargument, mit dem der Standardsatz von Zeichen überschrieben wird, die zum Trennen von Wörtern verwendet werden. Wenn delimiters nicht angegeben wird, werden standardmäßig die folgenden Zeichen verwendet:
<whitespace> [ ] ( ) { } / | \ < > ! ? @ " ^ # $ & ~ _ , . : ; * % + -

Wenn value oder delimiters den Wert NULL hat, gibt die Funktion NULL zurück.

Rückgabetyp

STRING

Beispiele

WITH example AS
(
  SELECT 'Hello World-everyone!' AS value UNION ALL
  SELECT 'tHe dog BARKS loudly+friendly' AS value UNION ALL
  SELECT 'apples&oranges;&pears' AS value UNION ALL
  SELECT 'καθίσματα ταινιών' AS value
)
SELECT value, INITCAP(value) AS initcap_value FROM example

+-------------------------------+-------------------------------+
| value                         | initcap_value                 |
+-------------------------------+-------------------------------+
| Hello World-everyone!         | Hello World-Everyone!         |
| tHe dog BARKS loudly+friendly | The Dog Barks Loudly+Friendly |
| apples&oranges;&pears         | Apples&Oranges;&Pears         |
| καθίσματα ταινιών             | Καθίσματα Ταινιών             |
+-------------------------------+-------------------------------+

WITH example AS
(
  SELECT 'hello WORLD!' AS value, '' AS delimiters UNION ALL
  SELECT 'καθίσματα ταιντιώ@ν' AS value, 'τ@' AS delimiters UNION ALL
  SELECT 'Apples1oranges2pears' AS value, '12' AS delimiters UNION ALL
  SELECT 'tHisEisEaESentence' AS value, 'E' AS delimiters
)
SELECT value, delimiters, INITCAP(value, delimiters) AS initcap_value FROM example;

+----------------------+------------+----------------------+
| value                | delimiters | initcap_value        |
+----------------------+------------+----------------------+
| hello WORLD!         |            | Hello world!         |
| καθίσματα ταιντιώ@ν  | τ@         | ΚαθίσματΑ τΑιντΙώ@Ν  |
| Apples1oranges2pears | 12         | Apples1Oranges2Pears |
| tHisEisEaESentence   | E          | ThisEIsEAESentence   |
+----------------------+------------+----------------------+

INSTR

INSTR(source_value, search_value[, position[, occurrence]])

Beschreibung

Gibt den niedrigsten auf eins basierenden Index von search_value in source_value zurück. 0 wird zurückgegeben, wenn keine Übereinstimmung gefunden wird. source_value und search_value müssen vom gleichen Typ sein, entweder STRING oder BYTES.

Wenn position angegeben wird, beginnt die Suche an dieser Position in source_value, andernfalls am Anfang von source_value. Wenn position negativ ist, sucht die Funktion ab dem Ende von source_value rückwärts, wobei -1 das letzte Zeichen angibt. position darf nicht 0 sein.

Wenn occurrence angegeben wird, gibt die Suche die Position einer bestimmten Instanz von search_value in source_value zurück. Andernfalls wird der Index des ersten Vorkommens zurückgegeben. Wenn occurrence größer als die Anzahl der gefundenen Übereinstimmungen ist, wird 0 zurückgegeben. Ist occurrence > 1, sucht die Funktion nach überschneidenden Vorkommen. Die Funktion sucht also nach zusätzlichen Vorkommen, beginnend mit dem zweiten Zeichen im vorherigen Vorkommen. occurrence darf nicht 0 oder negativ sein.

Rückgabetyp

INT64

Beispiele

WITH example AS
(SELECT 'banana' as source_value, 'an' as search_value, 1 as position, 1 as
occurrence UNION ALL
SELECT 'banana' as source_value, 'an' as search_value, 1 as position, 2 as
occurrence UNION ALL
SELECT 'banana' as source_value, 'an' as search_value, 1 as position, 3 as
occurrence UNION ALL
SELECT 'banana' as source_value, 'an' as search_value, 3 as position, 1 as
occurrence UNION ALL
SELECT 'banana' as source_value, 'an' as search_value, -1 as position, 1 as
occurrence UNION ALL
SELECT 'banana' as source_value, 'an' as search_value, -3 as position, 1 as
occurrence UNION ALL
SELECT 'banana' as source_value, 'ann' as search_value, 1 as position, 1 as
occurrence UNION ALL
SELECT 'helloooo' as source_value, 'oo' as search_value, 1 as position, 1 as
occurrence UNION ALL
SELECT 'helloooo' as source_value, 'oo' as search_value, 1 as position, 2 as
occurrence
)
SELECT source_value, search_value, position, occurrence, INSTR(source_value,
search_value, position, occurrence) AS instr
FROM example;

+--------------+--------------+----------+------------+-------+
| source_value | search_value | position | occurrence | instr |
+--------------+--------------+----------+------------+-------+
| banana       | an           | 1        | 1          | 2     |
| banana       | an           | 1        | 2          | 4     |
| banana       | an           | 1        | 3          | 0     |
| banana       | an           | 3        | 1          | 4     |
| banana       | an           | -1       | 1          | 4     |
| banana       | an           | -3       | 1          | 4     |
| banana       | ann          | 1        | 1          | 0     |
| helloooo     | oo           | 1        | 1          | 5     |
| helloooo     | oo           | 1        | 2          | 6     |
+--------------+--------------+----------+------------+-------+

LEFT

LEFT(value, length)

Beschreibung

Gibt einen STRING- oder BYTES-Wert zurück, der aus der angegebenen Anzahl von ganz links in value stehenden Zeichen oder Byte besteht. Die length ist ein INT64-Wert, der die Länge des zurückgegebenen Werts angibt. Wenn value vom Typ BYTES ist, ist length die Anzahl der ganz links stehenden Byte, die zurückgegeben werden sollen. Wenn value den Wert STRING hat, ist length die Anzahl der ganz links stehenden Zeichen, die zurückgegeben werden sollen.

Wenn length 0 ist, wird ein leerer STRING- oder BYTES-Wert zurückgegeben. Wenn length negativ ist, wird ein Fehler zurückgegeben. Wenn length die Anzahl der Zeichen oder Byte von value überschreitet, wird der ursprüngliche value zurückgegeben.

Rückgabetyp

STRING oder BYTES

Beispiele

WITH examples AS
(SELECT 'apple' as example
UNION ALL
SELECT 'banana' as example
UNION ALL
SELECT 'абвгд' as example
)
SELECT example, LEFT(example, 3) AS left_example
FROM examples;

+---------+--------------+
| example | left_example |
+---------+--------------+
| apple   | app          |
| banana  | ban          |
| абвгд   | абв          |
+---------+--------------+
WITH examples AS
(SELECT b'apple' as example
UNION ALL
SELECT b'banana' as example
UNION ALL
SELECT b'\xab\xcd\xef\xaa\xbb' as example
)
SELECT example, LEFT(example, 3) AS left_example
FROM examples;

-- Note that the result of LEFT is of type BYTES, displayed as a base64-encoded string.
+----------+--------------+
| example  | left_example |
+----------+--------------+
| YXBwbGU= | YXBw         |
| YmFuYW5h | YmFu         |
| q83vqrs= | q83v         |
+----------+--------------+

LENGTH

LENGTH(value)

Beschreibung

Gibt die Länge des STRING- oder BYTES-Werts zurück. Der Wert wird für STRING-Argumente in Zeichen und für das BYTES-Argument in Byte zurückgegeben.

Rückgabetyp

INT64

Beispiele


WITH example AS
  (SELECT 'абвгд' AS characters)

SELECT
  characters,
  LENGTH(characters) AS string_example,
  LENGTH(CAST(characters AS BYTES)) AS bytes_example
FROM example;

+------------+----------------+---------------+
| characters | string_example | bytes_example |
+------------+----------------+---------------+
| абвгд      |              5 |            10 |
+------------+----------------+---------------+

LPAD

LPAD(original_value, return_length[, pattern])

Beschreibung

Gibt einen STRING- oder BYTES-Wert zurück, der aus original_value mit vorangestelltem pattern besteht. Die return_length ist ein INT64-Wert, der die Länge des zurückgegebenen Werts angibt. Wenn original_value vom Typ BYTES ist, dann stellt return_length die Anzahl der Byte dar. Wenn original_value vom Typ STRING ist, dann gibt return_length die Anzahl der Zeichen wieder.

Der Standardwert von pattern ist ein Leerzeichen.

original_value und pattern müssen denselben Datentyp haben.

Wenn return_length kleiner oder gleich der Länge von original_value ist, gibt diese Funktion den Wert von original_value zurück, gekürzt auf den Wert von return_length. Beispiel: LPAD('hello world', 7); gibt 'hello w' zurück.

Wenn original_value, return_length oder pattern den Wert NULL hat, gibt diese Funktion NULL zurück.

Diese Funktion gibt einen Fehler zurück, wenn:

  • return_length negativ ist
  • pattern leer ist

Rückgabetyp

STRING oder BYTES

Beispiele

SELECT t, len, FORMAT('%T', LPAD(t, len)) AS LPAD FROM UNNEST([
  STRUCT('abc' AS t, 5 AS len),
  ('abc', 2),
  ('例子', 4)
]);

+------+-----+----------+
| t    | len | LPAD     |
|------|-----|----------|
| abc  | 5   | "  abc"  |
| abc  | 2   | "ab"     |
| 例子  | 4   | "  例子" |
+------+-----+----------+
SELECT t, len, pattern, FORMAT('%T', LPAD(t, len, pattern)) AS LPAD FROM UNNEST([
  STRUCT('abc' AS t, 8 AS len, 'def' AS pattern),
  ('abc', 5, '-'),
  ('例子', 5, '中文')
]);

+------+-----+---------+--------------+
| t    | len | pattern | LPAD         |
|------|-----|---------|--------------|
| abc  | 8   | def     | "defdeabc"   |
| abc  | 5   | -       | "--abc"      |
| 例子  | 5   | 中文    | "中文中例子"   |
+------+-----+---------+--------------+
SELECT FORMAT('%T', t) AS t, len, FORMAT('%T', LPAD(t, len)) AS LPAD FROM UNNEST([
  STRUCT(b'abc' AS t, 5 AS len),
  (b'abc', 2),
  (b'\xab\xcd\xef', 4)
]);

+-----------------+-----+------------------+
| t               | len | LPAD             |
|-----------------|-----|------------------|
| b"abc"          | 5   | b"  abc"         |
| b"abc"          | 2   | b"ab"            |
| b"\xab\xcd\xef" | 4   | b" \xab\xcd\xef" |
+-----------------+-----+------------------+
SELECT
  FORMAT('%T', t) AS t,
  len,
  FORMAT('%T', pattern) AS pattern,
  FORMAT('%T', LPAD(t, len, pattern)) AS LPAD
FROM UNNEST([
  STRUCT(b'abc' AS t, 8 AS len, b'def' AS pattern),
  (b'abc', 5, b'-'),
  (b'\xab\xcd\xef', 5, b'\x00')
]);

+-----------------+-----+---------+-------------------------+
| t               | len | pattern | LPAD                    |
|-----------------|-----|---------|-------------------------|
| b"abc"          | 8   | b"def"  | b"defdeabc"             |
| b"abc"          | 5   | b"-"    | b"--abc"                |
| b"\xab\xcd\xef" | 5   | b"\x00" | b"\x00\x00\xab\xcd\xef" |
+-----------------+-----+---------+-------------------------+

LOWER

LOWER(value)

Beschreibung

Bei STRING-Argumenten wird der Originalstring mit allen alphabetischen Zeichen in Kleinbuchstaben zurückgegeben. Die Zuordnung zwischen Klein- und Großbuchstaben erfolgt nach der Unicode-Zeichendatenbank, ohne dabei sprachspezifische Zuordnungen zu berücksichtigen.

BYTES-Argumente werden als ASCII-Text behandelt, wobei alle Byte größer als 127 intakt bleiben.

Rückgabetyp

STRING oder BYTES

Beispiele


WITH items AS
  (SELECT
    'FOO' as item
  UNION ALL
  SELECT
    'BAR' as item
  UNION ALL
  SELECT
    'BAZ' as item)

SELECT
  LOWER(item) AS example
FROM items;

+---------+
| example |
+---------+
| foo     |
| bar     |
| baz     |
+---------+

LTRIM

LTRIM(value1[, value2])

Beschreibung

Identisch mit TRIM, es werden jedoch nur vorangestellte Zeichen entfernt.

Rückgabetyp

STRING oder BYTES

Beispiele

WITH items AS
  (SELECT '   apple   ' as item
  UNION ALL
  SELECT '   banana   ' as item
  UNION ALL
  SELECT '   orange   ' as item)

SELECT
  CONCAT('#', LTRIM(item), '#') as example
FROM items;

+-------------+
| example     |
+-------------+
| #apple   #  |
| #banana   # |
| #orange   # |
+-------------+
WITH items AS
  (SELECT '***apple***' as item
  UNION ALL
  SELECT '***banana***' as item
  UNION ALL
  SELECT '***orange***' as item)

SELECT
  LTRIM(item, '*') as example
FROM items;

+-----------+
| example   |
+-----------+
| apple***  |
| banana*** |
| orange*** |
+-----------+
WITH items AS
  (SELECT 'xxxapplexxx' as item
  UNION ALL
  SELECT 'yyybananayyy' as item
  UNION ALL
  SELECT 'zzzorangezzz' as item
  UNION ALL
  SELECT 'xyzpearxyz' as item)
SELECT
  LTRIM(item, 'xyz') as example
FROM items;

+-----------+
| example   |
+-----------+
| applexxx  |
| bananayyy |
| orangezzz |
| pearxyz   |
+-----------+

NORMALIZE

NORMALIZE(value[, normalization_mode])

Beschreibung

Gibt einen Stringwert als normalisierten String zurück. Wenn Sie keinen Normalisierungsmodus bereitstellen, wird NFC verwendet.

Normalisierung wird verwendet, damit zwei Strings einander entsprechen. Normalisierung wird oft in Situationen verwendet, in denen zwei Strings dasselbe auf dem Bildschirm rendern, aber unterschiedliche Unicode-Codepunkte haben.

NORMALIZE unterstützt vier optionale Normalisierungsmodi:

Wert Name Beschreibung
NFC Normalisierungsform Kanonische Komposition Zerlegt Zeichen und setzt sie nach kanonischer Äquivalenz wieder zusammen.
NFKC Normalisierungsform Kompatibilitätskomposition Zerlegt Zeichen nach Kompatibilität und setzt sie nach kanonischer Äquivalenz wieder zusammen.
NFD Normalisierungsform Kanonische Zerlegung Zerlegt Zeichen nach kanonischer Äquivalenz und mehrere Kombinationszeichen werden in einer bestimmten Reihenfolge angeordnet.
NFKD Normalisierungsform Kompatibilitätszerlegung Zerlegt Zeichen nach Kompatibilität und mehrere Kombinationszeichen werden in einer bestimmten Reihenfolge angeordnet.

Rückgabetyp

STRING

Beispiele

SELECT a, b, a = b as normalized
FROM (SELECT NORMALIZE('\u00ea') as a, NORMALIZE('\u0065\u0302') as b);

+---+---+------------+
| a | b | normalized |
+---+---+------------+
| ê | ê | true       |
+---+---+------------+

Verschiedene Leerzeichen normalisieren:

WITH EquivalentNames AS (
  SELECT name
  FROM UNNEST([
      'Jane\u2004Doe',
      'John\u2004Smith',
      'Jane\u2005Doe',
      'Jane\u2006Doe',
      'John Smith']) AS name
)
SELECT
  NORMALIZE(name, NFKC) AS normalized_name,
  COUNT(*) AS name_count
FROM EquivalentNames
GROUP BY 1;

+-----------------+------------+
| normalized_name | name_count |
+-----------------+------------+
| John Smith      | 2          |
| Jane Doe        | 3          |
+-----------------+------------+

NORMALIZE_AND_CASEFOLD

NORMALIZE_AND_CASEFOLD(value[, normalization_mode])

Beschreibung

Nimmt einen Stringwert und gibt ihn als normalisierten String zurück.

Normalisierung wird verwendet, damit zwei Strings einander entsprechen. Normalisierung wird oft in Situationen verwendet, in denen zwei Strings dasselbe auf dem Bildschirm rendern, aber unterschiedliche Unicode-Codepunkte haben.

Umwandlung in einheitliche Groß- oder Kleinschreibung wird für den Vergleich von Strings ohne Berücksichtigung der Groß- und Kleinschreibung verwendet. Wenn Sie Strings vergleichen müssen und die Groß- und Kleinschreibung nicht berücksichtigt werden soll, verwenden Sie NORMALIZE_AND_CASEFOLD. Andernfalls verwenden Sie NORMALIZE.

NORMALIZE_AND_CASEFOLD unterstützt vier optionale Normalisierungsmodi:

Wert Name Beschreibung
NFC Normalisierungsform Kanonische Komposition Zerlegt Zeichen und setzt sie nach kanonischer Äquivalenz wieder zusammen.
NFKC Normalisierungsform Kompatibilitätskomposition Zerlegt Zeichen nach Kompatibilität und setzt sie nach kanonischer Äquivalenz wieder zusammen.
NFD Normalisierungsform Kanonische Zerlegung Zerlegt Zeichen nach kanonischer Äquivalenz und mehrere Kombinationszeichen werden in einer bestimmten Reihenfolge angeordnet.
NFKD Normalisierungsform Kompatibilitätszerlegung Zerlegt Zeichen nach Kompatibilität und mehrere Kombinationszeichen werden in einer bestimmten Reihenfolge angeordnet.

Rückgabetyp

STRING

Beispiele

SELECT
  a, b,
  NORMALIZE(a) = NORMALIZE(b) as normalized,
  NORMALIZE_AND_CASEFOLD(a) = NORMALIZE_AND_CASEFOLD(b) as normalized_with_case_folding
FROM (SELECT 'The red barn' AS a, 'The Red Barn' AS b);

+--------------+--------------+------------+------------------------------+
| a            | b            | normalized | normalized_with_case_folding |
+--------------+--------------+------------+------------------------------+
| The red barn | The Red Barn | false      | true                         |
+--------------+--------------+------------+------------------------------+
WITH Strings AS (
  SELECT '\u2168' AS a, 'IX' AS b UNION ALL
  SELECT '\u0041\u030A', '\u00C5'
)
SELECT a, b,
  NORMALIZE_AND_CASEFOLD(a, NFD)=NORMALIZE_AND_CASEFOLD(b, NFD) AS nfd,
  NORMALIZE_AND_CASEFOLD(a, NFC)=NORMALIZE_AND_CASEFOLD(b, NFC) AS nfc,
  NORMALIZE_AND_CASEFOLD(a, NFKD)=NORMALIZE_AND_CASEFOLD(b, NFKD) AS nkfd,
  NORMALIZE_AND_CASEFOLD(a, NFKC)=NORMALIZE_AND_CASEFOLD(b, NFKC) AS nkfc
FROM Strings;

+---+----+-------+-------+------+------+
| a | b  | nfd   | nfc   | nkfd | nkfc |
+---+----+-------+-------+------+------+
| Ⅸ | IX | false | false | true | true |
| Å | Å  | true  | true  | true | true |
+---+----+-------+-------+------+------+

OCTET_LENGTH

OCTET_LENGTH(value)

Alias für BYTE_LENGTH.

REGEXP_CONTAINS

REGEXP_CONTAINS(value, regexp)

Beschreibung

Gibt TRUE zurück, wenn value partiell mit dem regulären regexp-Ausdruck übereinstimmt.

Wenn das Argument regexp ungültig ist, gibt die Funktion einen Fehler zurück.

Sie können auch nach einer vollständigen Übereinstimmung suchen. Dazu verwenden Sie ^ (Anfang des Textes) und $ (Ende des Textes). Aufgrund der Rangfolge der Operatoren für reguläre Ausdrücke empfehlen sich Klammern um alles zwischen ^ und $.

Rückgabetyp

BOOL

Beispiele

SELECT
  email,
  REGEXP_CONTAINS(email, r'@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+') AS is_valid
FROM
  (SELECT
    ['foo@example.com', 'bar@example.org', 'www.example.net']
    AS addresses),
  UNNEST(addresses) AS email;

+-----------------+----------+
| email           | is_valid |
+-----------------+----------+
| foo@example.com | true     |
| bar@example.org | true     |
| www.example.net | false    |
+-----------------+----------+

-- Performs a full match, using ^ and $. Due to regular expression operator
-- precedence, it is good practice to use parentheses around everything between ^
-- and $.
SELECT
  email,
  REGEXP_CONTAINS(email, r'^([\w.+-]+@foo\.com|[\w.+-]+@bar\.org)$')
    AS valid_email_address,
  REGEXP_CONTAINS(email, r'^[\w.+-]+@foo\.com|[\w.+-]+@bar\.org$')
    AS without_parentheses
FROM
  (SELECT
    ['a@foo.com', 'a@foo.computer', 'b@bar.org', '!b@bar.org', 'c@buz.net']
    AS addresses),
  UNNEST(addresses) AS email;

+----------------+---------------------+---------------------+
| email          | valid_email_address | without_parentheses |
+----------------+---------------------+---------------------+
| a@foo.com      | true                | true                |
| a@foo.computer | false               | true                |
| b@bar.org      | true                | true                |
| !b@bar.org     | false               | true                |
| c@buz.net      | false               | false               |
+----------------+---------------------+---------------------+

REGEXP_EXTRACT

REGEXP_EXTRACT(value, regexp[, position[, occurrence]])

Beschreibung

Gibt den Teilstring in value zurück, der mit dem regulären Ausdruck regexp übereinstimmt. Gibt NULL zurück, wenn es keine Übereinstimmung gibt.

Wenn der reguläre Ausdruck eine Erfassungsgruppe enthält, gibt die Funktion den Teilstring zurück, der mit dieser Erfassungsgruppe übereinstimmt. Wenn der Ausdruck keine Erfassungsgruppe enthält, gibt die Funktion den gesamten übereinstimmenden Teilstring zurück.

Wenn position angegeben wird, beginnt die Suche an dieser Position in value, andernfalls am Anfang von value. Die position muss eine positive Ganzzahl sein und darf nicht 0 sein. Wenn position größer als die Länge von value ist, wird NULL zurückgegeben.

Wenn occurrence angegeben wird, gibt die Suche ein bestimmtes Vorkommen von regexp in value zurück. Andernfalls wird die erste Übereinstimmung zurückgegeben. Wenn occurrence größer als die Anzahl der gefundenen Übereinstimmungen ist, wird NULL zurückgegeben. Ist occurrence > 1, sucht die Funktion nach zusätzlichen Vorkommen, beginnend mit dem Zeichen nach dem vorherigen Vorkommen.

Gibt einen Fehler zurück, wenn:

  • Der reguläre Ausdruck ungültig ist
  • Der reguläre Ausdruck mehr als eine Erfassungsgruppe aufweist
  • position keine positive Ganzzahl ist
  • occurrence keine positive Ganzzahl ist

Rückgabetyp

STRING oder BYTES

Beispiele

WITH email_addresses AS
  (SELECT 'foo@example.com' as email
  UNION ALL
  SELECT 'bar@example.org' as email
  UNION ALL
  SELECT 'baz@example.net' as email)

SELECT
  REGEXP_EXTRACT(email, r'^[a-zA-Z0-9_.+-]+')
  AS user_name
FROM email_addresses;

+-----------+
| user_name |
+-----------+
| foo       |
| bar       |
| baz       |
+-----------+
WITH email_addresses AS
  (SELECT 'foo@example.com' as email
  UNION ALL
  SELECT 'bar@example.org' as email
  UNION ALL
  SELECT 'baz@example.net' as email)

SELECT
  REGEXP_EXTRACT(email, r'^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.([a-zA-Z0-9-.]+$)')
  AS top_level_domain
FROM email_addresses;

+------------------+
| top_level_domain |
+------------------+
| com              |
| org              |
| net              |
+------------------+
WITH example AS
(SELECT 'Hello Helloo and Hellooo' AS value, 'H?ello+' AS regex, 1 as position,
1 AS occurrence UNION ALL
SELECT 'Hello Helloo and Hellooo', 'H?ello+', 1, 2 UNION ALL
SELECT 'Hello Helloo and Hellooo', 'H?ello+', 1, 3 UNION ALL
SELECT 'Hello Helloo and Hellooo', 'H?ello+', 1, 4 UNION ALL
SELECT 'Hello Helloo and Hellooo', 'H?ello+', 2, 1 UNION ALL
SELECT 'Hello Helloo and Hellooo', 'H?ello+', 3, 1 UNION ALL
SELECT 'Hello Helloo and Hellooo', 'H?ello+', 3, 2 UNION ALL
SELECT 'Hello Helloo and Hellooo', 'H?ello+', 3, 3 UNION ALL
SELECT 'Hello Helloo and Hellooo', 'H?ello+', 20, 1 UNION ALL
SELECT 'cats&dogs&rabbits' ,'\\w+&', 1, 2 UNION ALL
SELECT 'cats&dogs&rabbits', '\\w+&', 2, 3
)
SELECT value, regex, position, occurrence, REGEXP_EXTRACT(value, regex,
position, occurrence) AS regexp_value FROM example;

+--------------------------+---------+----------+------------+--------------+
| value                    | regex   | position | occurrence | regexp_value |
+--------------------------+---------+----------+------------+--------------+
| Hello Helloo and Hellooo | H?ello+ | 1        | 1          | Hello        |
| Hello Helloo and Hellooo | H?ello+ | 1        | 2          | Helloo       |
| Hello Helloo and Hellooo | H?ello+ | 1        | 3          | Hellooo      |
| Hello Helloo and Hellooo | H?ello+ | 1        | 4          | NULL         |
| Hello Helloo and Hellooo | H?ello+ | 2        | 1          | ello         |
| Hello Helloo and Hellooo | H?ello+ | 3        | 1          | Helloo       |
| Hello Helloo and Hellooo | H?ello+ | 3        | 2          | Hellooo      |
| Hello Helloo and Hellooo | H?ello+ | 3        | 3          | NULL         |
| Hello Helloo and Hellooo | H?ello+ | 20       | 1          | NULL         |
| cats&dogs&rabbits        | \w+&    | 1        | 2          | dogs&        |
| cats&dogs&rabbits        | \w+&    | 2        | 3          | NULL         |
+--------------------------+---------+----------+------------+--------------+

REGEXP_EXTRACT_ALL

REGEXP_EXTRACT_ALL(value, regexp)

Beschreibung

Gibt ein Array aller Teilstrings von value zurück, die mit dem regulären Ausdruck regexp übereinstimmen.

Die Funktion REGEXP_EXTRACT_ALL gibt ausschließlich nicht überlappende Übereinstimmungen zurück. Wenn Sie beispielsweise diese Funktion verwenden, um ana aus banana zu extrahieren, wird nur ein Teilstring zurückgegeben, nicht zwei.

Rückgabetyp

Ein ARRAY entweder aus STRINGs oder BYTES.

Beispiele

WITH code_markdown AS
  (SELECT 'Try `function(x)` or `function(y)`' as code)

SELECT
  REGEXP_EXTRACT_ALL(code, '`(.+?)`') AS example
FROM code_markdown;

+----------------------------+
| example                    |
+----------------------------+
| [function(x), function(y)] |
+----------------------------+

REGEXP_INSTR

REGEXP_INSTR(source_value, regexp [, position[, occurrence, [occurrence_position]]])

Beschreibung

Gibt den niedrigsten 1-basierten Index eines regulären Ausdrucks regexp in source_value zurück. Gibt 0 zurück, wenn keine Übereinstimmung gefunden wurde oder der reguläre Ausdruck leer ist. Gibt einen Fehler zurück, wenn der reguläre Ausdruck ungültig ist oder mehr als eine Erfassungsgruppe hat. source_value und regexp müssen vom gleichen Typ sein, entweder STRING oder BYTES.

Wenn position angegeben wird, beginnt die Suche an dieser Position in source_value, andernfalls am Anfang von source_value. Wenn position negativ ist, sucht die Funktion ab dem Ende von source_value rückwärts, wobei -1 das letzte Zeichen angibt. position darf nicht 0 sein.

Wenn occurrence angegeben wird, gibt die Suche die Position einer bestimmten Instanz von regexp in source_value zurück. Andernfalls wird der Index des ersten Vorkommens zurückgegeben. Wenn occurrence größer als die Anzahl der gefundenen Übereinstimmungen ist, wird 0 zurückgegeben. Ist occurrence > 1, sucht die Funktion nach überschneidenden Vorkommen. Die Funktion sucht also nach zusätzlichen Vorkommen, beginnend mit dem zweiten Zeichen im vorherigen Vorkommen. occurrence darf nicht 0 oder negativ sein.

Optional können Sie mit occurrence_position angeben, wo eine Position in Bezug auf occurrence beginnt. Sie haben folgende Auswahlmöglichkeiten: + 0: gibt die Anfangsposition des Vorkommens zurück. + 1: gibt die erste Position nach dem Ende des Vorkommens zurück. Wenn das Ende des Vorkommens auch das Ende der Eingabe ist, wird ein Ende des Vorkommens zurückgegeben. Beispiel: Länge eines Strings + 1.

Rückgabetyp

INT64

Beispiele

WITH example AS (
  SELECT 'ab@gmail.com' AS source_value, '@[^.]*' AS regexp UNION ALL
  SELECT 'ab@mail.com', '@[^.]*' UNION ALL
  SELECT 'abc@gmail.com', '@[^.]*' UNION ALL
  SELECT 'abc.com', '@[^.]*')
SELECT source_value, regexp, REGEXP_INSTR(source_value, regexp) AS instr
FROM example;

+---------------+--------+-------+
| source_value  | regexp | instr |
+---------------+--------+-------+
| ab@gmail.com  | @[^.]* | 3     |
| ab@mail.com   | @[^.]* | 3     |
| abc@gmail.com | @[^.]* | 4     |
| abc.com       | @[^.]* | 0     |
+---------------+--------+-------+
WITH example AS (
  SELECT 'a@gmail.com b@gmail.com' AS source_value, '@[^.]*' AS regexp, 1 AS position UNION ALL
  SELECT 'a@gmail.com b@gmail.com', '@[^.]*', 2 UNION ALL
  SELECT 'a@gmail.com b@gmail.com', '@[^.]*', 3 UNION ALL
  SELECT 'a@gmail.com b@gmail.com', '@[^.]*', 4)
SELECT
  source_value, regexp, position,
  REGEXP_INSTR(source_value, regexp, position) AS instr
FROM example;

+-------------------------+--------+----------+-------+
| source_value            | regexp | position | instr |
+-------------------------+--------+----------+-------+
| a@gmail.com b@gmail.com | @[^.]* | 1        | 2     |
| a@gmail.com b@gmail.com | @[^.]* | 2        | 2     |
| a@gmail.com b@gmail.com | @[^.]* | 3        | 14    |
| a@gmail.com b@gmail.com | @[^.]* | 4        | 14    |
+-------------------------+--------+----------+-------+
WITH example AS (
  SELECT 'a@gmail.com b@gmail.com c@gmail.com' AS source_value,
         '@[^.]*' AS regexp, 1 AS position, 1 AS occurrence UNION ALL
  SELECT 'a@gmail.com b@gmail.com c@gmail.com', '@[^.]*', 1, 2 UNION ALL
  SELECT 'a@gmail.com b@gmail.com c@gmail.com', '@[^.]*', 1, 3)
SELECT
  source_value, regexp, position, occurrence,
  REGEXP_INSTR(source_value, regexp, position, occurrence) AS instr
FROM example;

+-------------------------------------+--------+----------+------------+-------+
| source_value                        | regexp | position | occurrence | instr |
+-------------------------------------+--------+----------+------------+-------+
| a@gmail.com b@gmail.com c@gmail.com | @[^.]* | 1        | 1          | 2     |
| a@gmail.com b@gmail.com c@gmail.com | @[^.]* | 1        | 2          | 14    |
| a@gmail.com b@gmail.com c@gmail.com | @[^.]* | 1        | 3          | 26    |
+-------------------------------------+--------+----------+------------+-------+
WITH example AS (
  SELECT 'a@gmail.com' AS source_value, '@[^.]*' AS regexp,
         1 AS position, 1 AS occurrence, 0 AS o_position UNION ALL
  SELECT 'a@gmail.com', '@[^.]*', 1, 1, 1)
SELECT
  source_value, regexp, position, occurrence, o_position,
  REGEXP_INSTR(source_value, regexp, position, occurrence, o_position) AS instr
FROM example;

+--------------+--------+----------+------------+------------+-------+
| source_value | regexp | position | occurrence | o_position | instr |
+--------------+--------+----------+------------+------------+-------+
| a@gmail.com  | @[^.]* | 1        | 1          | 0          | 2     |
| a@gmail.com  | @[^.]* | 1        | 1          | 1          | 8     |
+--------------+--------+----------+------------+------------+-------+

REGEXP_REPLACE

REGEXP_REPLACE(value, regexp, replacement)

Beschreibung

Gibt einen STRING zurück, in dem alle Teilstrings von value, die mit dem regulären regexp-Ausdruck übereinstimmen, durch replacement ersetzt werden.

Sie können innerhalb des Arguments replacement Escape-Ziffern mit Backslash (\1 bis \9) verwenden, um Text einzufügen, der mit der entsprechenden Klammergruppe im regexp-Muster übereinstimmt. Verwenden Sie \0, um auf den gesamten übereinstimmenden Text zu verweisen.

Wenn Sie dem regulären Ausdruck einen umgekehrten Schrägstrich (Backslash) hinzufügen möchten, müssen Sie ein Escapezeichen voranstellen. Beispiel: SELECT REGEXP_REPLACE('abc', 'b(.)', 'X\\1'); gibt aXc zurück. Sie können auch Rohstrings verwenden, um eine Escape-Ebene zu entfernen, zum Beispiel SELECT REGEXP_REPLACE('abc', 'b(.)', r'X\1');.

Durch die Funktion REGEXP_REPLACE werden ausschließlich nicht überlappende Übereinstimmungen ersetzt. Beispielsweise führt das Ersetzen von ana in banana zu nur einer Ersetzung, nicht zwei.

Wenn das Argument regexp kein gültiger regulärer Ausdruck ist, gibt diese Funktion einen Fehler zurück.

Rückgabetyp

STRING oder BYTES

Beispiele

WITH markdown AS
  (SELECT '# Heading' as heading
  UNION ALL
  SELECT '# Another heading' as heading)

SELECT
  REGEXP_REPLACE(heading, r'^# ([a-zA-Z0-9\s]+$)', '<h1>\\1</h1>')
  AS html
FROM markdown;

+--------------------------+
| html                     |
+--------------------------+
| <h1>Heading</h1>         |
| <h1>Another heading</h1> |
+--------------------------+

REGEXP_SUBSTR

REGEXP_SUBSTR(value, regexp[, position[, occurrence]])

Beschreibung

Synonym für REGEXP_EXTRACT.

Rückgabetyp

STRING oder BYTES

Beispiele

WITH example AS
(SELECT 'Hello World Helloo' AS value, 'H?ello+' AS regex, 1 AS position, 1 AS
occurrence
)
SELECT value, regex, position, occurrence, REGEXP_SUBSTR(value, regex,
position, occurrence) AS regexp_value FROM example;

+--------------------+---------+----------+------------+--------------+
| value              | regex   | position | occurrence | regexp_value |
+--------------------+---------+----------+------------+--------------+
| Hello World Helloo | H?ello+ | 1        | 1          | Hello        |
+--------------------+---------+----------+------------+--------------+

REPLACE

REPLACE(original_value, from_value, to_value)

Beschreibung

Ersetzt alle Vorkommen von from_value durch to_value in original_value. Wenn from_value leer ist, wird keine Ersetzung vorgenommen.

Rückgabetyp

STRING oder BYTES

Beispiele

WITH desserts AS
  (SELECT 'apple pie' as dessert
  UNION ALL
  SELECT 'blackberry pie' as dessert
  UNION ALL
  SELECT 'cherry pie' as dessert)

SELECT
  REPLACE (dessert, 'pie', 'cobbler') as example
FROM desserts;

+--------------------+
| example            |
+--------------------+
| apple cobbler      |
| blackberry cobbler |
| cherry cobbler     |
+--------------------+

REPEAT

REPEAT(original_value, repetitions)

Beschreibung

Gibt einen STRING- oder BYTES-Wert zurück, der aus Wiederholungen von original_value besteht. Der Parameter repetitions gibt die Anzahl der Wiederholungen von original_value an. Gibt NULL zurück, wenn entweder original_value oder repetitions gleich NULL ist.

Diese Funktion gibt einen Fehler zurück, wenn der Wert von repetitions negativ ist.

Rückgabetyp

STRING oder BYTES

Beispiele

SELECT t, n, REPEAT(t, n) AS REPEAT FROM UNNEST([
  STRUCT('abc' AS t, 3 AS n),
  ('例子', 2),
  ('abc', null),
  (null, 3)
]);

+------+------+-----------+
| t    | n    | REPEAT    |
|------|------|-----------|
| abc  | 3    | abcabcabc |
| 例子 | 2    | 例子例子  |
| abc  | NULL | NULL      |
| NULL | 3    | NULL      |
+------+------+-----------+

REVERSE

REVERSE(value)

Beschreibung

Gibt den umgekehrten Wert der STRING- oder BYTES-Eingabe zurück.

Rückgabetyp

STRING oder BYTES

Beispiele

WITH example AS (
  SELECT 'foo' AS sample_string, b'bar' AS sample_bytes UNION ALL
  SELECT 'абвгд' AS sample_string, b'123' AS sample_bytes
)
SELECT
  sample_string,
  REVERSE(sample_string) AS reverse_string,
  sample_bytes,
  REVERSE(sample_bytes) AS reverse_bytes
FROM example;

+---------------+----------------+--------------+---------------+
| sample_string | reverse_string | sample_bytes | reverse_bytes |
+---------------+----------------+--------------+---------------+
| foo           | oof            | bar          | rab           |
| абвгд         | дгвба          | 123          | 321           |
+---------------+----------------+--------------+---------------+
RIGHT(value, length)

Beschreibung

Gibt einen STRING- oder BYTES-Wert zurück, der aus der angegebenen Anzahl der ganz rechts neben value stehenden Zeichen oder Byte besteht. Die length ist ein INT64-Wert, der die Länge des zurückgegebenen Werts angibt. Wenn value vom Typ BYTES ist, ist length die Anzahl der ganz rechts stehenden Bytes, die zurückgegeben werden sollen. Wenn value den Wert STRING hat, ist length die Anzahl der ganz rechts stehenden Zeichen, die zurückgegeben werden sollen.

Wenn length 0 ist, wird ein leerer STRING- oder BYTES-Wert zurückgegeben. Wenn length negativ ist, wird ein Fehler zurückgegeben. Wenn length die Anzahl der Zeichen oder Byte von value überschreitet, wird der ursprüngliche value zurückgegeben.

Rückgabetyp

STRING oder BYTES

Beispiele

WITH examples AS
(SELECT 'apple' as example
UNION ALL
SELECT 'banana' as example
UNION ALL
SELECT 'абвгд' as example
)
SELECT example, RIGHT(example, 3) AS right_example
FROM examples;

+---------+---------------+
| example | right_example |
+---------+---------------+
| apple   | ple           |
| banana  | ana           |
| абвгд   | вгд           |
+---------+---------------+
WITH examples AS
(SELECT b'apple' as example
UNION ALL
SELECT b'banana' as example
UNION ALL
SELECT b'\xab\xcd\xef\xaa\xbb' as example
)
SELECT example, RIGHT(example, 3) AS right_example
FROM examples;

-- Note that the result of RIGHT is of type BYTES, displayed as a base64-encoded string.
+----------+---------------+
| example  | right_example |
+----------+---------------+
| YXBwbGU= | cGxl          |
| YmFuYW5h | YW5h          |
| q83vqrs= | 76q7          |
+----------+---------------+

RPAD

RPAD(original_value, return_length[, pattern])

Beschreibung

Gibt einen STRING- oder BYTES-Wert zurück, der aus dem original_value mit angehängtem pattern besteht. Der Parameter return_length ist ein INT64-Wert, der die Länge des zurückgegebenen Werts angibt. Wenn für original_value der Typ BYTES gilt, dann ist return_length die Anzahl der Byte. Wenn für original_value der Typ STRING gilt, dann ist return_length die Anzahl der Zeichen.

Der Standardwert von pattern ist ein Leerzeichen.

original_value und pattern müssen denselben Datentyp haben.

Wenn return_length kleiner oder gleich der Länge von original_value ist, gibt diese Funktion den Wert von original_value zurück, gekürzt auf den Wert von return_length. Beispiel: RPAD('hello world', 7); gibt 'hello w' zurück.

Wenn original_value, return_length oder pattern den Wert NULL hat, gibt diese Funktion NULL zurück.

Diese Funktion gibt einen Fehler zurück, wenn:

  • return_length negativ ist
  • pattern leer ist

Rückgabetyp

STRING oder BYTES

Beispiele

SELECT t, len, FORMAT('%T', RPAD(t, len)) AS RPAD FROM UNNEST([
  STRUCT('abc' AS t, 5 AS len),
  ('abc', 2),
  ('例子', 4)
]);

+------+-----+----------+
| t    | len | RPAD     |
|------|-----|----------|
| abc  | 5   | "abc  "  |
| abc  | 2   | "ab"     |
| 例子  | 4   | "例子  " |
+------+-----+----------+
SELECT t, len, pattern, FORMAT('%T', RPAD(t, len, pattern)) AS RPAD FROM UNNEST([
  STRUCT('abc' AS t, 8 AS len, 'def' AS pattern),
  ('abc', 5, '-'),
  ('例子', 5, '中文')
]);

+------+-----+---------+--------------+
| t    | len | pattern | RPAD         |
|------|-----|---------|--------------|
| abc  | 8   | def     | "abcdefde"   |
| abc  | 5   | -       | "abc--"      |
| 例子  | 5   | 中文     | "例子中文中"  |
+------+-----+---------+--------------+
SELECT FORMAT('%T', t) AS t, len, FORMAT('%T', RPAD(t, len)) AS RPAD FROM UNNEST([
  STRUCT(b'abc' AS t, 5 AS len),
  (b'abc', 2),
  (b'\xab\xcd\xef', 4)
]);

+-----------------+-----+------------------+
| t               | len | RPAD             |
|-----------------|-----|------------------|
| b"abc"          | 5   | b"abc  "         |
| b"abc"          | 2   | b"ab"            |
| b"\xab\xcd\xef" | 4   | b"\xab\xcd\xef " |
+-----------------+-----+------------------+
SELECT
  FORMAT('%T', t) AS t,
  len,
  FORMAT('%T', pattern) AS pattern,
  FORMAT('%T', RPAD(t, len, pattern)) AS RPAD
FROM UNNEST([
  STRUCT(b'abc' AS t, 8 AS len, b'def' AS pattern),
  (b'abc', 5, b'-'),
  (b'\xab\xcd\xef', 5, b'\x00')
]);

+-----------------+-----+---------+-------------------------+
| t               | len | pattern | RPAD                    |
|-----------------|-----|---------|-------------------------|
| b"abc"          | 8   | b"def"  | b"abcdefde"             |
| b"abc"          | 5   | b"-"    | b"abc--"                |
| b"\xab\xcd\xef" | 5   | b"\x00" | b"\xab\xcd\xef\x00\x00" |
+-----------------+-----+---------+-------------------------+

RTRIM

RTRIM(value1[, value2])

Beschreibung

Identisch mit TRIM, es werden jedoch nur nachgestellte Zeichen entfernt.

Rückgabetyp

STRING oder BYTES

Beispiele

WITH items AS
  (SELECT '***apple***' as item
  UNION ALL
  SELECT '***banana***' as item
  UNION ALL
  SELECT '***orange***' as item)

SELECT
  RTRIM(item, '*') as example
FROM items;

+-----------+
| example   |
+-----------+
| ***apple  |
| ***banana |
| ***orange |
+-----------+
WITH items AS
  (SELECT 'applexxx' as item
  UNION ALL
  SELECT 'bananayyy' as item
  UNION ALL
  SELECT 'orangezzz' as item
  UNION ALL
  SELECT 'pearxyz' as item)

SELECT
  RTRIM(item, 'xyz') as example
FROM items;

+---------+
| example |
+---------+
| apple   |
| banana  |
| orange  |
| pear    |
+---------+

SAFE_CONVERT_BYTES_TO_STRING

SAFE_CONVERT_BYTES_TO_STRING(value)

Beschreibung

Wandelt eine BYTES-Sequenz in STRING um. Alle ungültigen UTF-8-Zeichen werden durch das Unicode-Ersatzzeichen U+FFFD ersetzt.

Rückgabetyp

STRING

Beispiele

Diese Anweisung gibt das Unicode-Ersetzungszeichen „�“ zurück:

SELECT SAFE_CONVERT_BYTES_TO_STRING(b'\xc2') as safe_convert;

SOUNDEX

SOUNDEX(value)

Beschreibung

Gibt einen STRING zurück, der den Soundex-Code für value darstellt.

SOUNDEX erzeugt eine phonetische Darstellung eines Strings. Er indexiert Wörter nach ihrem Klang bei englischer Aussprache. Er wird normalerweise verwendet, um festzustellen, ob zwei Strings, z. B. die Nachnamen Levine und Lavine oder die englischen Wörterto und too eine ähnliche Aussprache haben.

Das Ergebnis von SOUNDEX besteht aus einem Buchstaben gefolgt von 3 Ziffern. Nicht lateinische Zeichen werden ignoriert. Wenn der verbleibende String nach dem Entfernen nicht lateinischer Zeichen leer ist, wird ein leerer STRING zurückgegeben.

Rückgabetyp

STRING

Beispiele

WITH example AS (
  SELECT 'Ashcraft' AS value UNION ALL
  SELECT 'Raven' AS value UNION ALL
  SELECT 'Ribbon' AS value UNION ALL
  SELECT 'apple' AS value UNION ALL
  SELECT 'Hello world!' AS value UNION ALL
  SELECT '  H3##!@llo w00orld!' AS value UNION ALL
  SELECT '#1' AS value UNION ALL
  SELECT NULL AS value
)
SELECT value, SOUNDEX(value) AS soundex
FROM example;

+----------------------+---------+
| value                | soundex |
+----------------------+---------+
| Ashcraft             | A261    |
| Raven                | R150    |
| Ribbon               | R150    |
| apple                | a140    |
| Hello world!         | H464    |
|   H3##!@llo w00orld! | H464    |
| #1                   |         |
| NULL                 | NULL    |
+----------------------+---------+

SPLIT

SPLIT(value[, delimiter])

Beschreibung

Teilt value mithilfe des Arguments delimiter.

Für STRING ist das Standardtrennzeichen das Komma (,).

Für BYTES müssen Sie ein Trennzeichen angeben.

Das Aufteilen mit einem leeren Trennzeichen generiert ein Array von UTF-8-Zeichen für STRING-Werte und ein Array von BYTES für BYTES-Werte.

Das Aufteilen eines leeren STRING gibt ein ARRAY aus einem einzelnen leeren STRING zurück.

Rückgabetyp

ARRAY vom Typ STRING oder ARRAY vom Typ BYTES.

Beispiele

WITH letters AS
  (SELECT '' as letter_group
  UNION ALL
  SELECT 'a' as letter_group
  UNION ALL
  SELECT 'b c d' as letter_group)

SELECT SPLIT(letter_group, ' ') as example
FROM letters;

+----------------------+
| example              |
+----------------------+
| []                   |
| [a]                  |
| [b, c, d]            |
+----------------------+

STARTS_WITH

STARTS_WITH(value1, value2)

Beschreibung

Verwendet zwei STRING- oder BYTES-Werte. Gibt TRUE zurück, wenn der zweite Wert ein Präfix des ersten Werts ist.

Rückgabetyp

BOOL

Beispiele

WITH items AS
  (SELECT 'foo' as item
  UNION ALL
  SELECT 'bar' as item
  UNION ALL
  SELECT 'baz' as item)

SELECT
  STARTS_WITH(item, 'b') as example
FROM items;

+---------+
| example |
+---------+
|   False |
|    True |
|    True |
+---------+

STRPOS

STRPOS(value1, value2)

Beschreibung

Verwendet zwei STRING- oder BYTES-Werte. Gibt den 1-basierten Index des ersten Vorkommens von value2 innerhalb von value1 zurück. Gibt 0 zurück, wenn value2 nicht gefunden wird.

Rückgabetyp

INT64

Beispiele

WITH email_addresses AS
  (SELECT
    'foo@example.com' AS email_address
  UNION ALL
  SELECT
    'foobar@example.com' AS email_address
  UNION ALL
  SELECT
    'foobarbaz@example.com' AS email_address
  UNION ALL
  SELECT
    'quxexample.com' AS email_address)

SELECT
  STRPOS(email_address, '@') AS example
FROM email_addresses;

+---------+
| example |
+---------+
|       4 |
|       7 |
|      10 |
|       0 |
+---------+

SUBSTR

SUBSTR(value, position[, length])

Beschreibung

Gibt einen Teilstring des angegebenen STRING- oder BYTES-Werts zurück. Das Argument position ist eine Ganzzahl, die die Startposition des Teilstrings angibt, wobei Position = 1 das erste Zeichen oder Byte festlegt. Das Argument length ist die maximale Anzahl an Zeichen für STRING-Argumente oder an Byte für BYTES-Argumente.

Wenn position negativ ist, zählt die Funktion ab dem Ende von value, wobei -1 das letzte Zeichen angibt.

Ist position eine Position vom linken Ende des STRING (position = 0 oder position < -LENGTH(value)), startet die Funktion ab Position = 1. Wenn length die Länge von value überschreitet, gibt die Funktion weniger als die Anzahl der length-Zeichen zurück.

Ist length kleiner als 0, gibt die Funktion einen Fehler zurück.

Rückgabetyp

STRING oder BYTES

Beispiele

WITH items AS
  (SELECT 'apple' as item
  UNION ALL
  SELECT 'banana' as item
  UNION ALL
  SELECT 'orange' as item)

SELECT
  SUBSTR(item, 2) as example
FROM items;

+---------+
| example |
+---------+
| pple    |
| anana   |
| range   |
+---------+
WITH items AS
  (SELECT 'apple' as item
  UNION ALL
  SELECT 'banana' as item
  UNION ALL
  SELECT 'orange' as item)

SELECT
  SUBSTR(item, 2, 2) as example
FROM items;

+---------+
| example |
+---------+
| pp      |
| an      |
| ra      |
+---------+
WITH items AS
  (SELECT 'apple' as item
  UNION ALL
  SELECT 'banana' as item
  UNION ALL
  SELECT 'orange' as item)

SELECT
  SUBSTR(item, -2) as example
FROM items;

+---------+
| example |
+---------+
| le      |
| na      |
| ge      |
+---------+

SUBSTRING

SUBSTRING(value, position[, length])

Alias für SUBSTR.

TO_BASE32

TO_BASE32(bytes_expr)

Beschreibung

Wandelt eine Sequenz aus BYTES in einen base32-codierten STRING um. Zum Konvertieren eines base32-codierten STRING in BYTES verwenden Sie FROM_BASE32.

Rückgabetyp

STRING

Beispiel

SELECT TO_BASE32(b'abcde\xFF') AS base32_string;

+------------------+
| base32_string    |
+------------------+
| MFRGGZDF74====== |
+------------------+

TO_BASE64

TO_BASE64(bytes_expr)

Beschreibung

Wandelt eine Sequenz aus BYTES in einen base64-codierten STRING um. Zum Konvertieren eines base64-codierten STRING in BYTES verwenden Sie FROM_BASE64.

Es gibt mehrere gängige base64-Codierungen, die sich darin unterscheiden, mit welchem Alphabet aus 65 ASCII-Zeichen die 64 Ziffern und das Auffüllen codiert werden. Weitere Informationen finden Sie unter RFC 4648. Diese Funktion fügt einen Abstand hinzu und verwendet das Alphabet [A-Za-z0-9+/=].

Rückgabetyp

STRING

Beispiel

SELECT TO_BASE64(b'\377\340') AS base64_string;

+---------------+
| base64_string |
+---------------+
| /+A=          |
+---------------+

Wenn Sie mit einer Codierung mit einem anderen base64-Standard arbeiten möchten, müssen Sie unter Umständen TO_BASE64 mit der Funktion REPLACE erstellen. Die URL-sichere und dateinamen-sichere base64url-Codierung, die häufig von Webprogrammierern verwendet wird, verwendet -_= statt +/= als letzte Zeichen. Um einen base64url-codierten String zu codieren, ersetzen Sie + und / durch - bzw. _.

SELECT REPLACE(REPLACE(TO_BASE64(b'\377\340'), '+', '-'), '/', '_') as websafe_base64;

+----------------+
| websafe_base64 |
+----------------+
| _-A=           |
+----------------+

TO_CODE_POINTS

TO_CODE_POINTS(value)

Beschreibung

Gibt für einen Wert ein INT64-Array zurück.

  • Wenn value ein STRING ist, stellt jedes Element im zurückgegebenen Array einen Codepunkt dar. Jeder Codepunkt liegt im Bereich von [0, 0xD7FF] und [0xE000, 0x10FFFF].
  • Wenn value ein BYTES-Wert ist, stellt jedes Element im Array einen erweiterten ASCII-Zeichenwert im Bereich von [0, 255] dar.

Informationen zur Umwandlung eines Arrays von Codepunkten in STRING oder BYTES finden Sie unter CODE_POINTS_TO_STRING bzw. CODE_POINTS_TO_BYTES.

Rückgabetyp

ARRAY von INT64

Beispiele

Das folgende Beispiel ruft die Codepunkte für jedes Element in einem Array von Wörtern ab.

SELECT word, TO_CODE_POINTS(word) AS code_points
FROM UNNEST(['foo', 'bar', 'baz', 'giraffe', 'llama']) AS word;

+---------+------------------------------------+
| word    | code_points                        |
+---------+------------------------------------+
| foo     | [102, 111, 111]                    |
| bar     | [98, 97, 114]                      |
| baz     | [98, 97, 122]                      |
| giraffe | [103, 105, 114, 97, 102, 102, 101] |
| llama   | [108, 108, 97, 109, 97]            |
+---------+------------------------------------+

Das folgende Beispiel wandelt ganzzahlige Darstellungen von BYTES in ihre entsprechenden ASCII-Zeichenwerte um.

SELECT word, TO_CODE_POINTS(word) AS bytes_value_as_integer
FROM UNNEST([b'\x00\x01\x10\xff', b'\x66\x6f\x6f']) AS word;

+------------------+------------------------+
| word             | bytes_value_as_integer |
+------------------+------------------------+
| \x00\x01\x10\xff | [0, 1, 16, 255]        |
| foo              | [102, 111, 111]        |
+------------------+------------------------+

Im folgenden Beispiel wird der Unterschied zwischen einem BYTES-Ergebnis und einem STRING-Ergebnis veranschaulicht.

SELECT TO_CODE_POINTS(b'Ā') AS b_result, TO_CODE_POINTS('Ā') AS s_result;

+------------+----------+
| b_result   | s_result |
+------------+----------+
| [196, 128] | [256]    |
+------------+----------+

Beachten Sie, dass das Zeichen "Ā" als 2-Byte-Unicode-Sequenz dargestellt wird. Deshalb gibt die BYTES-Version von TO_CODE_POINTS ein Array von zwei Elementen zurück, während die STRING-Version ein Array aus einem einzelnen Element zurückgibt.

TO_HEX

TO_HEX(bytes)

Beschreibung

Wandelt eine Sequenz von BYTES in einen hexadezimalen STRING um. Wandelt jedes Byte im STRING in zwei hexadezimale Zeichen im Bereich (0..9, a..f) um. Zum Konvertieren eines hexadezimal codierten STRING in BYTES verwenden Sie FROM_HEX.

Rückgabetyp

STRING

Beispiel

WITH Input AS (
  SELECT b'\x00\x01\x02\x03\xAA\xEE\xEF\xFF' AS byte_str UNION ALL
  SELECT b'foobar'
)
SELECT byte_str, TO_HEX(byte_str) AS hex_str
FROM Input;

+----------------------------------+------------------+
| byte_string                      | hex_string       |
+----------------------------------+------------------+
| \x00\x01\x02\x03\xaa\xee\xef\xff | 00010203aaeeefff |
| foobar                           | 666f6f626172     |
+----------------------------------+------------------+

TRANSLATE

TRANSLATE(expression, source_characters, target_characters)

Beschreibung

In expression wird damit jedes Zeichen in source_characters durch das entsprechende Zeichen in target_characters ersetzt. Alle Eingaben müssen vom gleichen Typ sein, entweder STRING oder BYTES.

  • Jedes Zeichen in expression wird höchstens einmal übersetzt.
  • Ein Zeichen in expression, das in source_characters nicht vorhanden ist, bleibt in expression unverändert.
  • Ein Zeichen in source_characters ohne ein entsprechendes Zeichen in target_characters wird im Ergebnis weggelassen.
  • Ein doppeltes Zeichen in source_characters führt zu einem Fehler.

Rückgabetyp

STRING oder BYTES

Beispiele

WITH example AS (
  SELECT 'This is a cookie' AS expression, 'sco' AS source_characters, 'zku' AS
  target_characters UNION ALL
  SELECT 'A coaster' AS expression, 'co' AS source_characters, 'k' as
  target_characters
)
SELECT expression, source_characters, target_characters, TRANSLATE(expression,
source_characters, target_characters) AS translate
FROM example;

+------------------+-------------------+-------------------+------------------+
| expression       | source_characters | target_characters | translate        |
+------------------+-------------------+-------------------+------------------+
| This is a cookie | sco               | zku               | Thiz iz a kuukie |
| A coaster        | co                | k                 | A kaster         |
+------------------+-------------------+-------------------+------------------+

TRIM

TRIM(value1[, value2])

Beschreibung

Entfernt alle voran- und nachgestellten Zeichen, die mit value2 übereinstimmen. Wenn value2 nicht angegeben ist, werden alle voran- und nachgestellten Leerzeichen (wie nach Unicode-Standard definiert) entfernt. Wenn das erste Argument vom Typ BYTES ist, ist das zweite Argument erforderlich.

Wenn value2 mehr als ein Zeichen oder Byte enthält, entfernt die Funktion alle voran- oder nachgestellten Zeichen oder Byte, die in value2 enthalten sind.

Rückgabetyp

STRING oder BYTES

Beispiele

WITH items AS
  (SELECT '   apple   ' as item
  UNION ALL
  SELECT '   banana   ' as item
  UNION ALL
  SELECT '   orange   ' as item)

SELECT
  CONCAT('#', TRIM(item), '#') as example
FROM items;

+----------+
| example  |
+----------+
| #apple#  |
| #banana# |
| #orange# |
+----------+
WITH items AS
  (SELECT '***apple***' as item
  UNION ALL
  SELECT '***banana***' as item
  UNION ALL
  SELECT '***orange***' as item)

SELECT
  TRIM(item, '*') as example
FROM items;

+---------+
| example |
+---------+
| apple   |
| banana  |
| orange  |
+---------+
WITH items AS
  (SELECT 'xxxapplexxx' as item
  UNION ALL
  SELECT 'yyybananayyy' as item
  UNION ALL
  SELECT 'zzzorangezzz' as item
  UNION ALL
  SELECT 'xyzpearxyz' as item)

SELECT
  TRIM(item, 'xyz') as example
FROM items;

+---------+
| example |
+---------+
| apple   |
| banana  |
| orange  |
| pear    |
+---------+

UNICODE

UNICODE(value)

Beschreibung

Gibt den Unicode-Codepoint für das erste Zeichen in value zurück. Gibt 0 zurück, wenn value leer ist oder der resultierende Unicode-Codepoint 0 ist.

Rückgabetyp

INT64

Beispiele

SELECT UNICODE('âbcd') as A, UNICODE('â') as B, UNICODE('') as C, UNICODE(NULL) as D;

+-------+-------+-------+-------+
| A     | B     | C     | D     |
+-------+-------+-------+-------+
| 226   | 226   | 0     | NULL  |
+-------+-------+-------+-------+

UPPER

UPPER(value)

Beschreibung

Bei STRING-Argumenten wird der ursprüngliche String mit allen alphabetischen Zeichen in Großbuchstaben zurückgegeben. Die Zuordnung zwischen Groß- und Kleinbuchstaben erfolgt nach der Unicode-Zeichendatenbank, ohne dabei sprachspezifische Zuordnungen zu berücksichtigen.

BYTES-Argumente werden als ASCII-Text behandelt, wobei alle Byte größer als 127 intakt bleiben.

Rückgabetyp

STRING oder BYTES

Beispiele

WITH items AS
  (SELECT
    'foo' as item
  UNION ALL
  SELECT
    'bar' as item
  UNION ALL
  SELECT
    'baz' as item)

SELECT
  UPPER(item) AS example
FROM items;

+---------+
| example |
+---------+
| FOO     |
| BAR     |
| BAZ     |
+---------+