Funzioni definite dall'utente

Le funzioni definite dall'utente (UDF) in BigQuery consentono di incapsulare la logica di business personalizzata utilizzando espressioni SQL o codice JavaScript. La definizione di funzioni temporanee o permanenti personalizzate consente di estendere le funzionalità di BigQuery e riutilizzare calcoli complessi in più query.

Puoi definire le funzioni definite dall'utente come permanenti o temporanee. Puoi riutilizzare le funzioni definite dall'utente permanenti per più query, mentre le funzioni definite dall'utente temporanee scadono al termine della query. L'istruzione DROP FUNCTION è supportata solo per le funzioni definite dall'utente temporanee nelle query con più istruzioni e nelle procedure.

Per informazioni sulle funzioni definite dall'utente in SQL precedente, consulta Funzioni definite dall'utente in SQL precedente.

UDF SQL

L'esempio seguente crea una funzione definita dall'utente SQL temporanea denominata AddFourAndDivide e la chiama da un'istruzione SELECT:

CREATE TEMP FUNCTION AddFourAndDivide(x INT64, y INT64)
RETURNS FLOAT64
AS (
  (x + 4) / y
);

SELECT
  val, AddFourAndDivide(val, 2)
FROM
  UNNEST([2,3,5,8]) AS val;

Questo esempio produce il seguente output:

+-----+-----+
| val | f0_ |
+-----+-----+
|   2 | 3.0 |
|   3 | 3.5 |
|   5 | 4.5 |
|   8 | 6.0 |
+-----+-----+

L'esempio seguente crea la stessa funzione come funzione funzione definita dall'utente permanente:

CREATE FUNCTION mydataset.AddFourAndDivide(x INT64, y INT64)
RETURNS FLOAT64
AS (
  (x + 4) / y
);

Poiché questa funzione definita dall'utente è persistente, devi specificare un set di dati per la funzione (mydataset in questo esempio). Dopo aver eseguito l'istruzione CREATE FUNCTION, puoi chiamare la funzione da una query:

SELECT
  val, mydataset.AddFourAndDivide(val, 2)
FROM
  UNNEST([2,3,5,8,12]) AS val;

Parametri delle funzioni definite dall'utente SQL basate su modelli

Un parametro con un tipo uguale a ANY TYPE può corrispondere a più di un tipo di argomento quando viene chiamata la funzione.

  • Se più di un parametro ha il tipo ANY TYPE, BigQuery non applica alcuna relazione di tipo tra questi argomenti.
  • Il tipo restituito dalla funzione non può essere ANY TYPE. Deve essere omesso, il che significa che viene determinato automaticamente in base a sql_expression, o un tipo esplicito.
  • Il passaggio di argomenti della funzione di tipi incompatibili con la definizione della funzione genera un errore al momento della chiamata.

L'esempio seguente mostra una funzione definita dall'utente SQL che utilizza un parametro basato su un modello.

CREATE TEMP FUNCTION addFourAndDivideAny(x ANY TYPE, y ANY TYPE)
AS (
  (x + 4) / y
);

SELECT
  addFourAndDivideAny(3, 4) AS integer_input,
  addFourAndDivideAny(1.59, 3.14) AS floating_point_input;

Questo esempio produce il seguente output:

+----------------+-----------------------+
| integer_input  |  floating_point_input |
+----------------+-----------------------+
| 1.75           | 1.7802547770700636    |
+----------------+-----------------------+

L'esempio seguente utilizza un parametro basato su un modello per restituire l'ultimo elemento di un array di qualsiasi tipo:

CREATE TEMP FUNCTION lastArrayElement(arr ANY TYPE)
AS (
  arr[ORDINAL(ARRAY_LENGTH(arr))]
);

SELECT
  lastArrayElement(x) AS last_element
FROM (
  SELECT [2,3,5,8,13] AS x
);

Questo esempio produce il seguente output:

+--------------+
| last_element |
+--------------+
| 13           |
+--------------+

Subquery scalari

Una funzione definita dall'utente SQL può restituire il valore di una subquery scalare. Una sottoquery scalare deve selezionare una singola colonna.

L'esempio seguente mostra una funzione definita dall'utente SQL che utilizza una subquery scalare per conteggiare il numero di utenti con una determinata età in una tabella utente:

CREATE TEMP TABLE users
AS (
  SELECT
    1 AS id, 10 AS age
  UNION ALL
  SELECT
    2 AS id, 30 AS age
  UNION ALL
  SELECT
    3 AS id, 10 AS age
);

CREATE TEMP FUNCTION countUserByAge(userAge INT64)
AS (
  (SELECT COUNT(1) FROM users WHERE age = userAge)
);

SELECT
  countUserByAge(10) AS count_user_age_10,
  countUserByAge(20) AS count_user_age_20,
  countUserByAge(30) AS count_user_age_30;

Questo esempio produce il seguente output:

+-------------------+-------------------+-------------------+
| count_user_age_10 | count_user_age_20 | count_user_age_30 |
+-------------------+-------------------+-------------------+
|                 2 |                 0 |                 1 |
+-------------------+-------------------+-------------------+

Progetto predefinito nelle espressioni SQL

Nel corpo di una funzione definita dall'utente SQL, tutti i riferimenti alle entità BigQuery, come tabelle o viste, devono includere l'ID progetto, a meno che l'entità non si trovi nello stesso progetto che contiene la funzione definita dall'utente.

Ad esempio, prendi in esame la seguente affermazione:

CREATE FUNCTION project1.mydataset.myfunction()
AS (
  (SELECT COUNT(*) FROM mydataset.mytable)
);

Se esegui questa istruzione da project1 e mydataset.mytable esiste in project1, l'istruzione ha esito positivo. Tuttavia, se esegui questa istruzione da un altro progetto, l'istruzione non va a buon fine. Per correggere l'errore, includi l'ID progetto nel riferimento alla tabella:

CREATE FUNCTION project1.mydataset.myfunction()
AS (
  (SELECT COUNT(*) FROM project1.mydataset.mytable)
);

Puoi anche fare riferimento a un'entità in un progetto o set di dati diverso da quello in cui crei la funzione:

CREATE FUNCTION project1.mydataset.myfunction()
AS (
  (SELECT COUNT(*) FROM project2.another_dataset.another_table)
);

Utilizza le variabili di sistema con le funzioni definite dall'utente SQL

Le variabili di sistema @@session_id e @@location sono supportate con le funzioni definite dall'utente SQL. Puoi includere queste variabili di sistema in qualsiasi punto dell'istruzione di creazione della funzione per restituire l'ID sessione o la località della query corrente. Tutte le altre variabili di sistema non sono supportate.

UDF JavaScript

Una funzione definita dall'utente JavaScript consente di chiamare il codice scritto in JavaScript da una query SQL. Le funzioni definite dall'utente JavaScript in genere consumano più risorse slot rispetto alle query SQL standard, riducendo le prestazioni dei job. Se la funzione può essere espressa in SQL, spesso è più ottimale eseguire il codice come un job di query SQL standard.

L'esempio seguente mostra una funzione definita dall'utente JavaScript. Il codice JavaScript è racchiuso tra virgolette all'interno di una stringa non elaborata.

CREATE TEMP FUNCTION multiplyInputs(x FLOAT64, y FLOAT64)
RETURNS FLOAT64
LANGUAGE js
AS r"""
  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;

Questo esempio produce il seguente output:

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

L'esempio successivo somma i valori di tutti i campi denominati foo nella stringa JSON specificata.

CREATE TEMP FUNCTION SumFieldsNamedFoo(json_row STRING)
RETURNS FLOAT64
LANGUAGE js
AS r"""
  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;

L'esempio produce il seguente output:

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

Tipi di dati delle funzioni definite dall'utente JavaScript supportati

Alcuni tipi SQL hanno una mappatura diretta ai tipi JavaScript, altri no. BigQuery rappresenta i tipi nel seguente modo:

Tipo di dati BigQuery Tipo di dati JavaScript
ARRAY ARRAY
BOOL BOOLEANO
BYTES STRING codificata in base64
FLOAT64 NUMERO
NUMERIC, BIGNUMERIC Se un valore NUMERIC o BIGNUMERIC può essere rappresentato esattamente come una rappresentazione in virgola mobile IEEE 754 e non ha una parte frazionaria, il valore viene codificato come numero. Questi valori sono compresi nell'intervallo [-253, 253]. In caso contrario, il valore viene codificato come stringa.
STRING STRING
STRUCT OBJECT in cui ogni campo STRUCT è un campo denominato
TIMESTAMP DATE con un campo di microsecondi contenente la frazione microsecond del timestamp
DATA DATA
JSON

OGGETTI, ARRAY e VALORI JSON vengono convertiti in OGGETTI, ARRAY e VALORI JavaScript equivalenti.

JavaScript non supporta i valori INT64. Solo i numeri JSON nell'intervallo [-253, 253] vengono convertiti esattamente. In caso contrario, il valore numerico viene arrotondato, il che potrebbe comportare una perdita di precisione.

Poiché JavaScript non supporta un tipo di numero intero a 64 bit, INT64 non è supportato come tipo di input per le funzioni definite dall'utente JavaScript. Utilizza invece FLOAT64 per rappresentare i valori interi come numero o STRING per rappresentare i valori interi come stringa.

BigQuery supporta INT64 come tipo restituito nelle funzioni definite dall'utente JavaScript. In questo caso, il corpo della funzione JavaScript può restituire un numero o una stringa JavaScript. BigQuery converte quindi uno di questi tipi in INT64.

Se il valore restituito dalla funzione definita dall'utente JavaScript è un Promise, BigQuery attende la Promise finché Promise non viene stabilita. Se la Promise si stabilizza in uno stato di completamento, BigQuery restituisce il risultato. Se Promise si stabilizza in uno stato rifiutato, BigQuery restituisce un errore.

Regole per i preventivi

Il codice JavaScript deve essere racchiuso tra virgolette. Per gli snippet di codice di una riga, puoi utilizzare una stringa tra virgolette standard:

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;

Questo esempio produce il seguente output:

+-----------+-----------+
| val       | result    |
+-----------+-----------+
| 1         | 2.0       |
| 2         | 3.0       |
| 3         | 4.0       |
| 4         | 5.0       |
| 5         | 6.0       |
+-----------+-----------+

Nei casi in cui lo snippet contiene virgolette o è composto da più righe, utilizza blocchi con virgolette triple:

CREATE TEMP FUNCTION customGreeting(a STRING)
RETURNS STRING
LANGUAGE js
AS r"""
  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;

Questo esempio produce il seguente output:

+-----------------------+
| everyone              |
+-----------------------+
| Good Morning, Hannah! |
| Good Morning, Max!    |
| Good Morning, Jakob!  |
+-----------------------+

Includi librerie JavaScript

Puoi estendere le tue funzioni definite dall'utente JavaScript utilizzando la sezione OPTIONS. Questa sezione consente di specificare librerie di codice esterne per la funzione definita dall'utente.

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 r"""
  // Assumes 'doInterestingStuff' is defined in one of the library files.
  return doInterestingStuff(a, b);
""";

SELECT myFunc(3.14, 'foo');

Nell'esempio precedente, il codice in lib1.js e lib2.js è disponibile per qualsiasi codice nella sezione [external_code] della funzione definita dall'utente.

Best practice per le funzioni definite dall'utente JavaScript

Prefiltra l'input

Se l'input può essere filtrato prima di essere passato a una funzione definita dall'utente JavaScript, la query potrebbe essere più rapida ed economica.

Evita lo stato mutabile persistente

Non archiviare o accedere a uno stato modificabile tra le chiamate delle funzioni JavaScript definite dall'utente. Ad esempio, evita il seguente formato:

-- Avoid this pattern
CREATE FUNCTION temp.mutable()
RETURNS INT64
LANGUAGE js
AS r"""
  var i = 0; // Mutable state
  function dontDoThis() {
    return ++i;
  }
  return dontDoThis()
""";

Utilizza la memoria in modo efficiente

L'ambiente di elaborazione JavaScript ha una memoria limitata disponibile per query. Le query delle funzioni definite dall'utente JavaScript che accumulano troppi stati locali potrebbero non riuscire a causa dell'esaurimento della memoria.

Autorizza routine

Puoi autorizzare le funzioni definite dall'utente come routine. Le routine autorizzate ti consentono di condividere i risultati delle query con utenti o gruppi specifici senza concedere l'accesso diretto alle tabelle sottostanti. Ad esempio, una routine può calcolare aggregazioni o cercare un valore di tabella e utilizzarlo in un calcolo. Per saperne di più, consulta Routine autorizzate.

Aggiungi descrizioni alle funzioni definite dall'utente

Per aggiungere una descrizione a una funzione definita dall'utente:

Console

  1. Vai alla pagina BigQuery nella console Google Cloud .

    Vai a BigQuery

  2. Nel riquadro a sinistra, fai clic su Spazio di esplorazione:

    Pulsante evidenziato per il riquadro Spazio di esplorazione.

    Se non vedi il riquadro a sinistra, fai clic su Espandi riquadro sinistro per aprirlo.

  3. Nel riquadro Explorer, espandi il progetto e fai clic su Set di dati.

  4. Fai clic sul tuo set di dati. Puoi anche utilizzare la funzionalità di ricerca o i filtri per trovare il tuo set di dati.

  5. Fai clic sulla scheda Routine, quindi seleziona la funzione.

  6. Nel riquadro dei dettagli, fai clic su Modifica dettagli routine per modificare il testo della descrizione.

  7. Nella finestra di dialogo, inserisci una descrizione nella casella o modifica quella esistente. Fai clic su Salva per salvare il nuovo testo della descrizione.

SQL

Per aggiornare la descrizione di una funzione, ricreala utilizzando l'istruzione DDL CREATE FUNCTION e imposta il campo description nell'elenco OPTIONS:

  1. Nella console Google Cloud , vai alla pagina BigQuery.

    Vai a BigQuery

  2. Nell'editor di query, inserisci la seguente istruzione:

    CREATE OR REPLACE FUNCTION mydataset.my_function(...)
AS (
  ...
) OPTIONS (
  description = 'DESCRIPTION'
);

  3. Fai clic su Esegui.

Per saperne di più su come eseguire le query, consulta Esegui una query interattiva.

Crea routine di mascheramento personalizzate

Puoi creare funzioni definite dall'utente da utilizzare con le routine di mascheramento personalizzate. Devi creare set di dati dedicati e configurare le autorizzazioni IAM appropriate per la gestione delle funzioni definite dall'utente di mascheramento. Le routine di mascheramento personalizzate devono soddisfare i seguenti requisiti:

  • La routine di mascheramento personalizzata deve essere una funzione definita dall'utente SQL.
  • Nella funzione OPTIONS, l'opzione data_governance_type deve essere impostata su DATA_MASKING.
  • Le routine di mascheramento personalizzate supportano le seguenti funzioni:
  • Le routine di mascheramento personalizzate non possono accettare input o un input all'interno dei tipi di dati BigQuery, ad eccezione di GEOGRAPHY e STRUCT. GEOGRAPHY e STRUCT non sono supportati per le routine di mascheramento personalizzate.
  • I parametri delle funzioni definite dall'utente SQL basate su modelli non sono supportati.
  • Quando viene fornito un input, i tipi di dati di input e output devono essere gli stessi.
  • È necessario specificare un tipo di output.
  • Nel corpo della definizione non è possibile fare riferimento ad altre funzioni definite dall'utente, sottoquery, tabelle o viste.
  • Dopo aver creato una routine di mascheramento, questa non può essere modificata in una funzione standard. Ciò significa che se l'opzione data_governance_type è impostata su DATA_MASKING, non puoi modificare data_governance_type utilizzando istruzioni DDL o chiamate API.
  • Le routine di mascheramento personalizzate supportano le istruzioni CASE e CASE expr. I seguenti operatori possono essere utilizzati con le istruzioni CASE e CASE expr:

Ad esempio, una routine di mascheramento che sostituisce il codice fiscale di un utente con XXX-XX-XXXX potrebbe avere il seguente aspetto:

  CREATE OR REPLACE FUNCTION SSN_Mask(ssn STRING) RETURNS STRING
  OPTIONS (data_governance_type="DATA_MASKING") AS (
  SAFE.REGEXP_REPLACE(ssn, '[0-9]', 'X') # 123-45-6789 -> XXX-XX-XXXX
  );

L'esempio seguente esegue l'hashing con il salt fornito dall'utente, utilizzando la funzione SHA256:

CREATE OR REPLACE FUNCTION `project.dataset.masking_routine1`(
  ssn STRING)
RETURNS STRING OPTIONS (data_governance_type = 'DATA_MASKING')
AS (
  CAST(SHA256(CONCAT(ssn, 'salt')) AS STRING format 'HEX')
);

L'esempio seguente maschera una colonna DATETIME con un valore costante:

CREATE OR REPLACE FUNCTION `project.dataset.masking_routine2`(
  column DATETIME)
RETURNS DATETIME OPTIONS (data_governance_type = 'DATA_MASKING')
AS (
  SAFE_CAST('2023-09-07' AS DATETIME)
);

SAFE

Dopo aver creato la routine di mascheramento personalizzata, questa è disponibile come regola di mascheramento in Crea policy dati.

Funzioni fornite dalla community

Le funzioni definite dall'utente fornite dalla community sono disponibili nel set di dati pubblico bigquery-public-data.persistent_udfs e nel repository GitHub bigquery-utils open source. Puoi visualizzare tutte le funzioni definite dall'utente della community nella console Google Cloud aggiungendo a Speciali il progetto bigquery-public-data nel riquadro Explorer, quindi espandendo il set di dati persistent_udfs nidificato all'interno del progetto.

Consenti l'accesso alle funzioni create dalla community all'interno di un perimetro dei Controlli di servizio VPC

Per i progetti in cui sono abilitati i Controlli di servizio VPC e BigQuery è un servizio protetto, devi definire una regola in uscita per il progetto bigquery-public-data (ID progetto: 1057666841514).

Questa regola deve abilitare le seguenti operazioni:

  • bigquery.routines.get (per l'utilizzo delle routine)
  • bigquery.tables.getData (per eseguire query sulle tabelle BigQuery)

Il codice seguente mostra un esempio di configurazione YAML:

  - egressFrom:
      identityType: ANY_IDENTITY
    egressTo:
      operations:
      - serviceName: 'bigquery.googleapis.com'
        methodSelectors:
        - permission: 'bigquery.routines.get'
        - permission: 'bigquery.tables.getData'
      resources:
      - projects/1057666841514 # bigquery-public-data

Se vuoi contribuire alle funzioni definite dall'utente in questo repository, consulta Contribuire alle funzioni definite dall'utente per istruzioni.

Accesso unificato alle routine in più regioni

Per utilizzare le UDF nelle query in più regioni, l'UDF deve essere disponibile in ogni regione in cui viene eseguita una query contenente l'UDF. Pertanto, devi creare e gestire le UDF in qualsiasi regione in cui potresti utilizzarle in una query. Anche se le tabelle sono identiche, devi mantenere due versioni della funzione. Ad esempio, se archivi i dati di vendita nelle località multiregionali EU e US, devi mantenere una versione della funzione in ogni regione. Ad esempio:

Una query nella località multi-regione EU: 

  SELECT
    id,
    europe_dataset.my_function(value)
  FROM
    sales;

Una query nella località multi-regione US: 

  SELECT
    id,
    us_dataset.my_function(value)
  FROM
    sales;

Inoltre, quando la definizione della funzione cambia, devi aggiornarla in tutte le regioni.

Per rendere le tue funzioni definite dall'utente indipendenti dalla regione, puoi utilizzare la replica dei set di dati tra regioni:

  1. Crea un nuovo set di dati dedicato, ad esempio my_utils, per archiviare tutte le funzioni definite dall'utente necessarie. Ricorda che tutte le tabelle aggiunte a questo set di dati verranno replicate, il che aumenterà i costi. Tuttavia, la replica di UDF e procedure non comporta costi aggiuntivi.
  2. Aggiungi tutte le tue funzioni definite dall'utente al nuovo set di dati. Possono essere incluse anche funzioni definite dall'utente della community, come bqutil copiate da GitHub.
  3. Abilita la replica del set di dati. Configura questo set di dati in modo che venga replicato in tutte le regioni in cui devi eseguire query che chiamano queste funzioni definite dall'utente. Le tue funzioni verranno copiate in queste regioni e mantenute sincronizzate.

Quando esegui una query, BigQuery utilizza automaticamente la versione locale della funzione definita dall'utente dalla replica del set di dati locale senza che tu debba specificare la regione in cui è definita la funzione, rendendo le query portabili in diverse località. Ad esempio:

  SELECT
    id,
    my_utils.my_function(value)
  FROM
    sales;

Limitazioni

Alle funzioni definite dall'utente temporanee e permanenti si applicano le seguenti limitazioni:

  • Gli oggetti DOM Window, Document e Node e le funzioni che li richiedono non sono supportati.
  • Le funzioni JavaScript operano all'interno di un ambiente sandbox e quelle che si basano sul codice di sistema sottostante potrebbero non riuscire a causa di chiamate di sistema limitate.
  • Una funzione definita dall'utente JavaScript può scadere e impedire il completamento della query. I timeout possono essere di soli 5 minuti, ma possono variare in base a diversi fattori, tra cui il tempo di CPU utente utilizzato dalla funzione e le dimensioni degli input e degli output della funzione JavaScript.
  • Le operazioni bit per bit in JavaScript gestiscono solo i 32 bit più significativi.
  • Le funzioni definite dall'utente sono soggette a determinati limiti di frequenza e di quota. Per saperne di più, consulta Limiti delle funzioni definite dall'utente.

Le seguenti limitazioni si applicano alle funzioni definite dall'utente permanenti:

  • Ogni set di dati può contenere una sola funzione definita dall'utente permanente con lo stesso nome. Tuttavia, puoi creare una funzione definita dall'utente con lo stesso nome di una tabella nello stesso set di dati.
  • Quando fai riferimento a una funzione definita dall'utente permanente dall'utente permanente da un'altra funzione definita dall'funzione definita dall'utente permanente o da una vista logica, devi qualificare il nome con il set di dati. Ad esempio:
    CREATE FUNCTION mydataset.referringFunction() AS (mydataset.referencedFunction());
  • Le funzioni definite dall'utente permanenti possono essere chiamate in sicurezza quando vengono condivise tra i proprietari. Le funzioni definite dall'utente non possono modificare i dati, comunicare con sistemi esterni o inviare log a Google Cloud Observability o ad applicazioni simili.

Le seguenti limitazioni si applicano alle funzioni definite dall'utente temporanee.

  • Quando crei una funzione definita dall'utente temporanea, function_name non può contenere punti.
  • Le viste e le funzioni definite dall'utente permanenti non possono fare riferimento a funzioni definite dall'utente temporanee.