Benutzerdefinierte Standard-SQL-Funktionen

BigQuery unterstützt benutzerdefinierte Funktionen (UDFs). Mithilfe einer UDF können Sie unter Verwendung eines anderen SQL-Ausdrucks oder mit JavaScript Funktionen erstellen. Diese Funktionen akzeptieren Spalten als Eingabe und führen Aktionen aus. Das Ergebnis dieser Aktionen wird als Wert zurückgegeben. Weitere Informationen zu benutzerdefinierten Funktionen in Legacy-SQL finden Sie unter Benutzerdefinierte Funktionen in Legacy-SQL.

UDFs können entweder persistent oder temporär sein. Persistente UDFs können Sie für mehrere Abfragen verwenden, temporäre UDFs jedoch nur in einer einzigen Abfrage.

UDF-Syntax

Verwenden Sie die folgende Syntax, um eine persistente UDF zu erstellen:

CREATE [OR REPLACE] FUNCTION [IF NOT EXISTS]
    [[project_name.]dataset_name.]function_name
    ([named_parameter[, ...]])
  [RETURNS data_type]
  { sql_function_definition | javascript_function_definition }

Verwenden Sie die folgende Syntax, um eine temporäre UDF zu erstellen:

CREATE [OR REPLACE] {TEMPORARY | TEMP} FUNCTION [IF NOT EXISTS]
    function_name
    ([named_parameter[, ...]])
  [RETURNS data_type]
  { sql_function_definition | javascript_function_definition }

named_parameter:
  param_name param_type

sql_function_definition:
  AS (sql_expression)

javascript_function_definition:
  [determinism_specifier]
  LANGUAGE js
  [OPTIONS (library = library_array)]
  AS javascript_code

determinism_specifier:
  { DETERMINISTIC | NOT DETERMINISTIC }

Diese Syntax besteht aus den folgenden Komponenten:

  • CREATE { FUNCTION | OR REPLACE FUNCTION | FUNCTION IF NOT EXISTS }: Erstellt oder aktualisiert eine Funktion. Zum Ersetzen einer vorhandenen gleichnamigen Funktion verwenden Sie das Schlüsselwort OR REPLACE. Wenn eine Abfrage als erfolgreich behandelt werden, aber keine Aktion auslösen soll, falls bereits eine gleichnamige Funktion vorhanden ist, verwenden Sie die Klausel IF NOT EXISTS.

  • project_name ist der Name des Projekts, in dem Sie die Funktion erstellen. Die Standardeinstellung ist das Projekt, das diese DDL-Abfrage ausführt. Wenn der Projektname Sonderzeichen wie Doppelpunkte enthält, sollte er in Backticks (`) gesetzt werden (Beispiel: `google.com:my_project`).

  • dataset_name ist der Name des Datasets, in dem Sie die Funktion erstellen. Die Standardeinstellung ist defaultDataset in der Anfrage.

  • named_parameter: Besteht aus durch Kommas getrennten Paaren aus param_name und param_type. Der Wert von param_type ist ein BigQuery-Datentyp. Bei einer SQL-UDF kann der Wert von param_type auch ANY TYPE sein.

  • determinism_specifier. Gilt nur für benutzerdefinierte JavaScript-Funktionen. Weist BigQuery darauf hin, ob das Abfrageergebnis im Cache speicherbar ist. Kann einer der folgenden Werte sein:

    • DETERMINISTIC: Die Funktion gibt immer dasselbe Ergebnis zurück, wenn dieselben Argumente übergeben werden. Das Abfrageergebnis sind potenziell im Cache speicherbar. Wenn die Funktion add_one(i) beispielsweise immer i + 1 zurückgibt, ist die Funktion deterministisch.

    • NOT DETERMINISTIC: Die Funktion gibt nicht immer dasselbe Ergebnis zurück, wenn dieselben Argumente übergeben werden, und ist daher nicht im Cache speicherbar. Wenn add_random(i) zum Beispiel i + rand() zurückgibt, ist die Funktion nicht deterministisch und BigQuery verwendet keine im Cache gespeicherten Ergebnisse.

      Wenn alle aufgerufenen Funktionen DETERMINISTISCH sind, versucht BigQuery, das Ergebnis im Cache zu speichern, außer die Ergebnisse sind aus anderen Gründen nicht im Cache speicherbar. Weitere Informationen finden Sie unter Im Cache gespeicherte Abfrageergebnisse verwenden.

  • [RETURNS data_type]: Gibt den Datentyp an, der von der Funktion zurückgegeben wird.

    • Wenn die Funktion in SQL definiert ist, ist die Klausel RETURNS optional. Wenn die Klausel RETURNS nicht angegeben wird und die Funktion von einer Abfrage aufgerufen wird, leitet BigQuery den Ergebnistyp der Funktion aus dem SQL-Funktionsrumpf ab.
    • Wenn die Funktion in JavaScript definiert ist, muss die Klausel RETURNS verwendet werden. Weitere Informationen zu zulässigen Werten für data_type finden Sie unter Von JavaScript-UDFs unterstützte Datentypen.
  • AS (sql_expression). Gibt den SQL-Ausdruck an, der die Funktion definiert.

  • [OPTIONS (library = library_array)]: Definiert für eine JavaScript-UDF ein Array von JavaScript-Bibliotheken, die in die Funktionsdefinition aufgenommen werden sollen.

  • AS javascript_code. Gibt die Definition einer JavaScript-Funktion an. javascript_code ist ein Stringliteral.

Verwenden Sie die folgende Syntax, um eine persistente benutzerdefinierte Funktion zu löschen:

DROP FUNCTION [IF EXISTS] [[project_name.]dataset_name.]function_name

Temporäre UDFs laufen sofort nach Beendigung der Abfrage ab, daher werden DROP FUNCTION-Anweisungen nur für temporäre UDFs in Skripts und Verfahren unterstützt.

SQL-UDFs

Erstellen Sie SQL-UDFs mit der folgenden Syntax:

CREATE [OR REPLACE] [TEMPORARY | TEMP] FUNCTION [IF NOT EXISTS]
    [[`project_name`.]dataset_name.]function_name
    ([named_parameter[, ...]])
  [RETURNS data_type]
  AS (sql_expression)

named_parameter:
  param_name param_type

Vorlagen für SQL-UDF-Parameter

Ein Vorlagenparameter mit param_type = ANY TYPE kann bei einem Funktionsaufruf mit mehr als einem Argumenttyp übereinstimmen.

  • Wenn mehr als ein Parameter den Typ ANY TYPE hat, erzwingt BigQuery keine Typbeziehung zwischen diesen Argumenten.
  • Der Rückgabetyp der Funktion darf nicht ANY TYPE sein. Er muss entweder ausgelassen werden, d. h. automatisch anhand von sql_expression ermittelt werden, oder ein expliziter Typ sein.
  • Werden der Funktion Argumente mit Typen übergeben, die nicht mit der Funktionsdefinition kompatibel sind, wird zum Aufrufzeitpunkt ein Fehler ausgelöst.

SQL-UDF-Beispiele

Das folgende Beispiel zeigt eine UDF, die sich einer SQL-Funktion bedient.

CREATE TEMP FUNCTION addFourAndDivide(x INT64, y INT64) AS ((x + 4) / y);
WITH numbers AS
  (SELECT 1 as val
  UNION ALL
  SELECT 3 as val
  UNION ALL
  SELECT 4 as val
  UNION ALL
  SELECT 5 as val)
SELECT val, addFourAndDivide(val, 2) AS result
FROM numbers;

+-----+--------+
| val | result |
+-----+--------+
| 1   | 2.5    |
| 3   | 3.5    |
| 4   | 4      |
| 5   | 4.5    |
+-----+--------+

Das folgende Beispiel zeigt eine SQL-UDF, die einen Vorlagenparameter verwendet. Die daraus resultierende Funktion akzeptiert Argumente verschiedener Typen.

CREATE TEMP FUNCTION addFourAndDivideAny(x ANY TYPE, y ANY TYPE) AS (
  (x + 4) / y
);
SELECT addFourAndDivideAny(3, 4) AS integer_output,
       addFourAndDivideAny(1.59, 3.14) AS floating_point_output;

+----------------+-----------------------+
| integer_output | floating_point_output |
+----------------+-----------------------+
| 1.75           | 1.7802547770700636    |
+----------------+-----------------------+

Das folgende Beispiel zeigt eine SQL-UDF, die einen Vorlagenparameter verwendet, um das letzte Element eines Arrays eines beliebigen Typs zurückzugeben.

CREATE TEMP FUNCTION lastArrayElement(arr ANY TYPE) AS (
  arr[ORDINAL(ARRAY_LENGTH(arr))]
);
SELECT
  names[OFFSET(0)] AS first_name,
  lastArrayElement(names) AS last_name
FROM (
  SELECT ['Fred', 'McFeely', 'Rogers'] AS names UNION ALL
  SELECT ['Marie', 'Skłodowska', 'Curie']
);

+------------+-----------+
| first_name | last_name |
+------------+-----------+
| Fred       | Rogers    |
| Marie      | Curie     |
+------------+-----------+

JavaScript-UDFs

JavaScript-UDFs werden mit der folgenden Struktur erstellt.

CREATE [OR REPLACE] [TEMPORARY | TEMP] FUNCTION [IF NOT EXISTS]
    [[`project_name`.]dataset_name.]function_name
    ([named_parameter[, ...]])
  RETURNS data_type
  [DETERMINISTIC | NOT DETERMINISTIC]
  LANGUAGE js
  [OPTIONS (library = library_array)]
  AS javascript_code

Von JavaScript-UDFs unterstützte Datentypen

Einige SQL-Typen haben eine direkte Zuordnung zu JavaScript-Typen, andere dagegen nicht. BigQuery stellt Typen auf folgende Weise dar:

BigQuery-Datentyp JavaScript-Datentyp
ARRAY ARRAY
BOOL BOOLEAN
BYTES STRING mit Base64-Codierung
FLOAT64 NUMBER
NUMERIC Wenn ein NUMERIC-Wert genau als IEEE 754-Gleitkommawert dargestellt werden kann und keinen Bruchteil hat, wird er als Zahl codiert. Diese Werte liegen im Bereich [-253, 253]. Andernfalls werden sie als String codiert.
STRING STRING
STRUCT OBJECT, wobei jedes STRUCT-Feld einen Namen hat
TIMESTAMP DATE mit einem Mikrosekundenfeld, das den microsecond-Bruchteil des Zeitstempels enthält
DATE DATE

Da JavaScript keine 64-Bit-Ganzzahlen unterstützt, wird INT64 als Eingabetyp für JavaScript-UDFs nicht unterstützt. Verwenden Sie stattdessen FLOAT64, um Ganzzahlwerte als Zahl darzustellen, oder STRING, um Ganzzahlwerte als String darzustellen.

BigQuery unterstützt INT64 als Rückgabetyp in JavaScript-UDFs. In diesem Fall gibt der JavaScript-Funktionsrumpf entweder eine JavaScript-Zahl oder einen JavaScript-String zurück. BigQuery konvertiert diese Typen in INT64.

Wenn der Rückgabewert der JavaScript-UDF ein Promise ist, wartet BigQuery auf das Promise, bis es erfüllt ist. Wenn sich das Promise in einem erfüllten Zustand befindet, gibt BigQuery das Ergebnis zurück. Wenn sich das Promise in einem abgelehnten Status befindet, gibt BigQuery einen Fehler zurück.

Regeln für Anführungszeichen

Der JavaScript-Code muss in Anführungszeichen gesetzt werden. Für einfache, einzeilige Code-Snippets können Sie einen Standardstring in Anführungszeichen verwenden:

CREATE TEMP FUNCTION plusOne(x FLOAT64)
RETURNS FLOAT64
LANGUAGE js
AS "return x+1;";
SELECT val, plusOne(val) AS result
FROM UNNEST([1, 2, 3, 4, 5]) AS val;

+-----------+-----------+
| val       | result    |
+-----------+-----------+
| 1         | 2         |
| 2         | 3         |
| 3         | 4         |
| 4         | 5         |
| 5         | 6         |
+-----------+-----------+

In Fällen, in denen das Snippet Anführungszeichen enthält oder aus mehreren Zeilen besteht, verwenden Sie Blocks mit dreifachen Anführungszeichen:

CREATE TEMP FUNCTION customGreeting(a STRING)
RETURNS STRING
LANGUAGE js AS """
  var d = new Date();
  if (d.getHours() < 12) {
    return 'Good Morning, ' + a + '!';
  } else {
    return 'Good Evening, ' + a + '!';
  }
  """;
SELECT customGreeting(names) as everyone
FROM UNNEST(["Hannah", "Max", "Jakob"]) AS names;
+-----------------------+
| everyone              |
+-----------------------+
| Good Morning, Hannah! |
| Good Morning, Max!    |
| Good Morning, Jakob!  |
+-----------------------+

JavaScript-Bibliotheken einbeziehen

Sie können JavaScript-UDFs über den Bereich OPTIONS erweitern. In diesem Abschnitt können Sie externe Codebibliotheken für die UDF angeben.

CREATE TEMP FUNCTION myFunc(a FLOAT64, b STRING)
  RETURNS STRING
  LANGUAGE js
  OPTIONS (
    library=["gs://my-bucket/path/to/lib1.js", "gs://my-bucket/path/to/lib2.js"]
  )
  AS
"""
    // Assumes 'doInterestingStuff' is defined in one of the library files.
    return doInterestingStuff(a, b);
""";

SELECT myFunc(3.14, 'foo');

Im vorherigen Beispiel ist der Code in lib1.js und lib2.js für jeden Code im Bereich [external_code] der UDF verfügbar.

Beispiele für JavaScript-UDFs

CREATE TEMP FUNCTION multiplyInputs(x FLOAT64, y FLOAT64)
RETURNS FLOAT64
LANGUAGE js AS """
  return x*y;
""";
WITH numbers AS
  (SELECT 1 AS x, 5 as y
  UNION ALL
  SELECT 2 AS x, 10 as y
  UNION ALL
  SELECT 3 as x, 15 as y)
SELECT x, y, multiplyInputs(x, y) as product
FROM numbers;

+-----+-----+--------------+
| x   | y   | product      |
+-----+-----+--------------+
| 1   | 5   | 5            |
| 2   | 10  | 20           |
| 3   | 15  | 45           |
+-----+-----+--------------+

Sie können das Ergebnis einer UDF als Eingabe an eine andere UDF übergeben. Beispiel:

CREATE TEMP FUNCTION multiplyInputs(x FLOAT64, y FLOAT64)
RETURNS FLOAT64
LANGUAGE js AS """
  return x*y;
""";
CREATE TEMP FUNCTION divideByTwo(x FLOAT64)
RETURNS FLOAT64
LANGUAGE js AS """
  return x/2;
""";
WITH numbers AS
  (SELECT 1 AS x, 5 as y
  UNION ALL
  SELECT 2 AS x, 10 as y
  UNION ALL
  SELECT 3 as x, 15 as y)
SELECT x,
  y,
  multiplyInputs(divideByTwo(x), divideByTwo(y)) as half_product
FROM numbers;

+-----+-----+--------------+
| x   | y   | half_product |
+-----+-----+--------------+
| 1   | 5   | 1.25         |
| 2   | 10  | 5            |
| 3   | 15  | 11.25        |
+-----+-----+--------------+

Im folgenden Beispiel werden die Werte aller Felder namens foo im angegebenen JSON-String summiert.

CREATE TEMP FUNCTION SumFieldsNamedFoo(json_row STRING)
  RETURNS FLOAT64
  LANGUAGE js AS """
function SumFoo(obj) {
  var sum = 0;
  for (var field in obj) {
    if (obj.hasOwnProperty(field) && obj[field] != null) {
      if (typeof obj[field] == "object") {
        sum += SumFoo(obj[field]);
      } else if (field == "foo") {
        sum += obj[field];
      }
    }
  }
  return sum;
}
var row = JSON.parse(json_row);
return SumFoo(row);
""";

WITH Input AS (
  SELECT STRUCT(1 AS foo, 2 AS bar, STRUCT('foo' AS x, 3.14 AS foo) AS baz) AS s, 10 AS foo UNION ALL
  SELECT NULL, 4 AS foo UNION ALL
  SELECT STRUCT(NULL, 2 AS bar, STRUCT('fizz' AS x, 1.59 AS foo) AS baz) AS s, NULL AS foo
)
SELECT
  TO_JSON_STRING(t) AS json_row,
  SumFieldsNamedFoo(TO_JSON_STRING(t)) AS foo_sum
FROM Input AS t;
+---------------------------------------------------------------------+---------+
| json_row                                                            | foo_sum |
+---------------------------------------------------------------------+---------+
| {"s":{"foo":1,"bar":2,"baz":{"x":"foo","foo":3.14}},"foo":10}       | 14.14   |
| {"s":null,"foo":4}                                                  | 4       |
| {"s":{"foo":null,"bar":2,"baz":{"x":"fizz","foo":1.59}},"foo":null} | 1.59    |
+---------------------------------------------------------------------+---------+

Weitere Informationen zur Zuordnung von BigQuery-Datentypen zu JavaScript-Typen finden Sie unter Von JavaScript-UDFs unterstützte Datentypen.

Best Practices für JavaScript-UDFs

Eingabe vorfiltern

Wenn Ihre Eingabe einfach gefiltert werden kann, bevor sie an eine JavaScript-UDF übergeben wird, kann die Abfrage wahrscheinlich schneller und günstiger ausgeführt werden.

Persistenten änderbaren Status vermeiden

Speichern oder rufen Sie keinen änderbaren Status über JavaScript-UDF-Aufrufe hinweg auf.

Speicher effizient nutzen

Die JavaScript-Verarbeitungsumgebung verfügt nur über wenig Speicher pro Abfrage. JavaScript-UDF-Abfragen, die zu viel lokalen Status ansammeln, können aufgrund von Speicherausschöpfung fehlschlagen.

Abfrage mit einer UDF ausführen

Mit der Cloud Console

Sie können über die Cloud Console Abfragen mit einer oder mehreren UDFs ausführen.

  1. Klicken Sie auf Neue Abfrage erstellen.
  2. Geben Sie die UDF-Anweisung im Bereich Abfrageeditor ein. Beispiel:

    CREATE TEMPORARY FUNCTION timesTwo(x FLOAT64)
    RETURNS FLOAT64
      LANGUAGE js AS """
      return x*2;
    """;
  3. Geben Sie unterhalb der UDF-Anweisung die SQL-Abfrage ein. Beispiel:

    SELECT timesTwo(numbers) AS doubles
    FROM UNNEST([1, 2, 3, 4, 5]) AS numbers;
  4. Klicken Sie auf Abfrage ausführen. Die Abfrageergebnisse werden unterhalb der Schaltflächen angezeigt.

bq-Befehlszeilentool verwenden

Über das bq-Befehlszeilentool im Cloud SDK können Sie eine Abfrage mit einer oder mehreren UDFs ausführen.

Verwenden Sie die folgende Syntax zum Ausführen einer Abfrage mit einer UDF:

bq query <statement_with_udf_and_query>

Autorisierte UDFs

Eine autorisierte UDF ist eine UDF, die für den Zugriff auf ein bestimmtes Dataset autorisiert ist. Die UDF kann auch dann Tabellen im Dataset abfragen, wenn der Nutzer, der die UDF aufruft, keinen Zugriff auf diese Tabellen hat.

Mit autorisierten UDFs können Sie Abfrageergebnisse für bestimmte Nutzer oder Gruppen freigeben, ohne diesen Nutzern oder Gruppen Zugriff auf die zugrunde liegenden Tabellen zu gewähren. Beispielsweise kann eine autorisierte UDF eine Aggregation von Daten berechnen oder einen Tabellenwert abrufen und diesen Wert in einer Berechnung verwenden.

Zum Autorisieren einer UDF können Sie die Google Cloud Console, die REST API oder das bq-Befehlszeilentool verwenden:

Console

  1. Rufen Sie in der Cloud Console die Seite „BigQuery“ auf.

    BigQuery aufrufen

  2. Maximieren Sie im Navigationsbereich im Abschnitt Ressourcen Ihr Projekt und wählen Sie ein Dataset aus.

  3. Klicken Sie im Detailbereich auf Routinen autorisieren.

  4. Wählen Sie auf der Seite Autorisierte Routinen im Abschnitt Routine autorisieren die Projekt-ID, die Dataset-ID und die Routine-ID für die UDF aus, die Sie autorisieren möchten.

  5. Klicken Sie auf Autorisierung hinzufügen.

API

  1. Rufen Sie die Methode datasets.get auf, um das Dataset abzurufen, auf das die UDF zugreifen soll. Der Antworttext enthält eine Darstellung der Dataset-Ressource.

  2. Fügen Sie dem access-Array in der Dataset-Ressource das folgende JSON-Objekt hinzu:

    {
     "routine": {
       "datasetId": "DATASET_NAME",
       "projectId": "PROJECT_ID",
       "routineId": "ROUTINE_NAME"
     }
    }
    

    Dabei gilt:

    • DATASET_NAME ist der Name des Datasets, das die UDF enthält.
    • PROJECT_ID ist die Projekt-ID des Projekts, das die UDF enthält.
    • ROUTINE_NAME ist der Name der UDF.
  3. Rufen Sie die Methode dataset.update mit der geänderten Dataset-Darstellung auf.

bq

  1. Verwenden Sie den Befehl bq show, um die JSON-Darstellung des Datasets abzurufen, auf das die UDF zugreifen soll. Die Ausgabe des Befehls ist eine JSON-Darstellung der Dataset-Ressource. Speichern Sie das Ergebnis in einer lokalen Datei.

    bq show --format=prettyjson TARGET_DATASET > dataset.json
    

    Ersetzen Sie TARGET_DATASET durch den Namen des Datasets, auf das die UDF zugreifen soll.

  2. Bearbeiten Sie die Datei, um dem access-Array in der Dataset-Ressource das folgende JSON-Objekt hinzuzufügen:

    {
     "routine": {
       "datasetId": "DATASET_NAME",
       "projectId": "PROJECT_ID",
       "routineId": "ROUTINE_NAME"
     }
    }
    

    Dabei gilt:

    • DATASET_NAME ist der Name des Datasets, das die UDF enthält.
    • PROJECT_ID ist die Projekt-ID des Projekts, das die UDF enthält.
    • ROUTINE_NAME ist der Name der UDF.
  3. Aktualisieren Sie das Dataset mit dem Befehl bq update.

    bq update --source dataset.json TARGET_DATASET
    

Beispiel für eine autorisierte UDF

Im Folgenden finden Sie ein End-to-End-Beispiel für das Erstellen und Verwenden einer autorisierten UDF.

  1. Erstellen Sie zwei Datasets mit den Namen private_dataset und public_dataset. Weitere Informationen zum Erstellen eines Datasets finden Sie unter Dataset erstellen.

  2. Führen Sie die folgende Anweisung aus, um eine Tabelle mit dem Namen private_table in private_dataset zu erstellen:

    CREATE OR REPLACE TABLE private_dataset.private_table
    AS SELECT key FROM UNNEST(['key1', 'key1','key2','key3']) key;
    
  3. Führen Sie die folgende Anweisung aus, um eine UDF mit dem Namen count_key in public_dataset zu erstellen. Die UDF enthält eine SELECT-Anweisung für private_table.

    CREATE OR REPLACE FUNCTION public_dataset.count_key(input_key STRING)
    RETURNS INT64
    AS
    ((SELECT COUNT(1) FROM private_dataset.private_table t WHERE t.key = input_key));
    
  4. Weisen Sie einem Nutzer des Datasets public_dataset die Rolle bigquery.dataViewer zu. Diese Rolle enthält die Berechtigung bigquery.routines.get, mit der der Nutzer die Funktion aufrufen kann. Weitere Informationen zum Zuweisen von Zugriffssteuerungen für Datasets finden Sie unter Zugriff auf Datasets steuern.

  5. An diesem Punkt hat der Nutzer die Berechtigung, die Funktion count_key aufzurufen, kann jedoch nicht auf die Tabelle in private_dataset zugreifen. Wenn der Nutzer versucht, die Funktion aufzurufen, erhält er eine Fehlermeldung ähnlich der folgenden:

    Access Denied: Table myproject:private_dataset.private_table: User does
    not have permission to query table myproject:private_dataset.private_table.
    
  6. Führen Sie mit dem bq-Befehlszeilentool den Befehl show so aus:

    bq show --format=prettyjson private_dataset > dataset.json
    

    Die Ausgabe wird in einer lokalen Datei mit dem Namen dataset.json gespeichert.

  7. Bearbeiten Sie dataset.json, um dem access-Array das folgende JSON-Objekt hinzuzufügen:

    {
     "routine": {
       "datasetId": "public_dataset",
       "projectId": "PROJECT_ID",
       "routineId": "count_key"
     }
    }
    

    Ersetzen Sie PROJECT_ID durch die Projekt-ID für public_dataset.

  8. Führen Sie mit dem bq-Befehlszeilentool den Befehl update so aus:

    bq update --source dataset.json private_dataset
    
  9. Der Nutzer kann die folgende Abfrage ausführen, um zu prüfen, ob die UDF Zugriff auf private_dataset hat:

    SELECT public_dataset.count_key('key1');
    

Beschreibungen zu UDFs hinzufügen

So fügen Sie einer UDF eine Beschreibung hinzu:

Console

  1. Rufen Sie in der Cloud Console die Seite „BigQuery“ auf.

    BigQuery aufrufen

  2. Wählen Sie im Bereich Ressourcen die Funktion aus.

  3. Klicken Sie im Bereich Details auf das Stiftsymbol neben Beschreibung, um den Beschreibungstext zu bearbeiten.

  4. Geben Sie im Dialogfeld eine Beschreibung in das Feld ein oder bearbeiten Sie die vorhandene Beschreibung. Klicken Sie auf Aktualisieren, um den neuen Beschreibungstext zu speichern.

Alternativ können Sie die Beschreibung mithilfe einer Standard-SQL-Abfrage mit dem Parameter description des Felds OPTIONS aktualisieren. Geben Sie im Feld Abfrageeditor Ihre Funktionsdefinition ein und fügen Sie die folgende Zeile hinzu:

OPTIONS (description="DESCRIPTION") AS """

Ersetzen Sie DESCRIPTION durch die Beschreibung, die Sie hinzufügen möchten.

bq

Mithilfe der bq query-Syntax aus UDFs und dem bq-Befehlszeilentool können Sie die Beschreibung einer Funktion über die Befehlszeile bearbeiten. Geben Sie die Standard-SQL mit dem Flag --nouse_legacy_sql oder -- use_legacy_sql=false an und geben Sie dann Ihre Funktionsdefinition ein. Fügen Sie Ihrer Definition die folgende Zeile hinzu, um den Parameter description im Feld OPTIONS festzulegen:

OPTIONS (description="DESCRIPTION") AS """

Ersetzen Sie DESCRIPTION durch die Beschreibung, die Sie hinzufügen möchten.

Beschränkungen

Für temporäre und persistente benutzerdefinierte Funktionen gelten die folgenden Beschränkungen:

  • Die DOM-Objekte Window, Document und Node sowie die Funktionen, die diese Objekte erfordern, werden nicht unterstützt.
  • JavaScript-Funktionen, die nativen Code benötigen, werden nicht unterstützt.
  • Bei einer JavaScript-UDF kann es zu einer Zeitüberschreitung kommen, die ein Abschließen Ihrer Abfrage verhindert. Zeitüberschreitungen können bereits nach nur fünf Minuten auftreten, hängen aber von mehreren Faktoren ab, z. B. auch davon, wie viel Nutzer-CPU-Zeit die Funktion verbraucht und wie groß die Eingaben an die JavaSript-Funktion und ihre Ausgaben sind.
  • Bitweise Vorgänge in JavaScript verarbeiten nur die wichtigsten 32 Bit
  • Für UDFs gelten bestimmte Ratenbegrenzungen und Kontingentlimits. Weitere Informationen finden Sie unter UDF-Limits.

Für persistente benutzerdefinierte Funktionen gelten die folgenden Beschränkungen:

  • Ein Dataset kann jeweils nur eine persistente UDF mit demselben Namen enthalten. Sie können jedoch eine UDF mit dem gleichen Namen einer Tabelle in demselben Dataset erstellen.
  • Wenn Sie von einer persistenten UDF auf eine andere oder von einer logischen Ansicht auf eine persistente UDF verweisen, müssen Sie den Namen mit dem Dataset qualifizieren. Beispiel:
    CREATE FUNCTION mydataset.referringFunction() AS (mydataset.referencedFunction());

Für temporäre benutzerdefinierte Funktionen gelten die folgenden Beschränkungen:

  • Beim Erstellen einer temporären UDF darf function_name keine Punkte enthalten.
  • Ansichten und persistente UDFs können nicht auf temporäre UDFs verweisen.