Programmazione delle query

Le query pianificate di BigQuery ti consentono di automatizzare i workload GoogleSQL ricorrenti, incluse le istruzioni DDL (Data Definition Language) e DML (Data Manipulation Language). Per organizzare i risultati per data e ora, puoi parametrizzare sia la stringa di query sia la tabella di destinazione. Quando crei o aggiorni una pianificazione, BigQuery converte l'ora pianificata dall'ora locale in UTC, che non è interessata dall'ora legale.

Prima di iniziare

• Le query pianificate utilizzano le funzionalità di BigQuery Data Transfer Service. Verifica di aver completato tutte le azioni richieste in Attivazione di BigQuery Data Transfer Service.
• Concedi i ruoli IAM (Identity and Access Management) che forniscono agli utenti le autorizzazioni necessarie per eseguire ogni attività in questo documento.
• Se prevedi di specificare una chiave di crittografia gestita dal cliente (CMEK), assicurati che il tuo service account disponga delle autorizzazioni per criptare e decriptare e di avere l'ID risorsa della chiave Cloud KMS richiesto per utilizzare CMEK. Per informazioni su come funziona CMEK con BigQuery Data Transfer Service, consulta Specifica la chiave di crittografia con le query pianificate.

Limitazioni

• Le query pianificate eseguite esattamente all'ora (ad esempio alle 09:00) potrebbero essere attivate più volte, il che può causare risultati indesiderati come la duplicazione dei dati dalle operazioni INSERT. Per evitare questi risultati indesiderati, utilizza una pianificazione non all'ora esatta (ad esempio, 08:58 o 09:03).

Autorizzazioni obbligatorie

Per pianificare una query, devi disporre delle seguenti autorizzazioni IAM:

• Per creare il trasferimento, devi disporre delle autorizzazioni bigquery.transfers.update e bigquery.datasets.get o delle autorizzazioni bigquery.jobs.create, bigquery.transfers.get e bigquery.datasets.get.

  Nota: se utilizzi la console Google Cloud o lo strumento a riga di comando bq per pianificare una query, devi disporre dell'autorizzazione bigquery.transfers.get.

• Per eseguire una query pianificata, devi disporre di:

  • Autorizzazione bigquery.datasets.get sul set di dati di destinazione.
  • Autorizzazione bigquery.jobs.create sul progetto.

Per modificare o eliminare una query pianificata, devi disporre di uno dei seguenti elementi:

• Le autorizzazioni bigquery.transfers.update e bigquery.transfers.get sul progetto.
• Se esegui una query pianificata utilizzando le credenziali utente, l'utente deve essere proprietario della query pianificata e tu devi disporre dell'autorizzazione bigquery.jobs.create per il progetto.
• Se esegui una query pianificata come account di servizio, l'utente che chiama la query pianificata deve disporre delle autorizzazioni bigquery.transfers.update e bigquery.transfers.get sul progetto. La concessione del ruolo Utente account di servizio IAM (iam.serviceAccountUser) consente a un utente di eseguire job come service account, ma non concede autorizzazioni di gestione sulla configurazione delle query pianificate.

Il ruolo IAM predefinito Amministratore BigQuery (roles/bigquery.admin) include le autorizzazioni necessarie per pianificare o modificare una query.

Per saperne di più sui ruoli IAM in BigQuery, consulta Ruoli e autorizzazioni predefiniti.

Per creare o aggiornare le query pianificate eseguite da un account di servizio, devi disporre dell'accesso a quel account di servizio. Per saperne di più sulla concessione agli utenti del ruolo di account di servizio, consulta Ruolo Service Account User. Per selezionare un account di servizio nella UI delle query pianificate della consoleGoogle Cloud , devi disporre delle seguenti autorizzazioni IAM:

• iam.serviceAccounts.list per elencare i tuoi service account.
• iam.serviceAccountUser per assegnare un account di servizio a una query pianificata.

Nota: se utilizzi lo strumento a riga di comando bq, utilizza il flag --service_account_name anziché eseguire l'autenticazione come service account.

Opzioni di configurazione

Le sezioni seguenti descrivono le opzioni di configurazione.

Stringa di query

La stringa di query deve essere valida e scritta in GoogleSQL. Ogni esecuzione di una query pianificata può ricevere i seguenti parametri di query.

Per testare manualmente una stringa di query con i parametri @run_time e @run_date prima di pianificare una query, utilizza lo strumento a riga di comando bq.

Parametri disponibili

Parametro	Tipo GoogleSQL	Valore
@run_time	TIMESTAMP	Rappresentata nel fuso orario UTC. Per le query pianificate regolarmente, run_time rappresenta l'ora di esecuzione prevista. Ad esempio, se la query pianificata è impostata su "ogni 24 ore", la differenza run_time tra due query consecutive è esattamente di 24 ore, anche se il tempo di esecuzione effettivo potrebbe variare leggermente.
@run_date	DATE	Rappresenta una data di calendario logica.

Esempio

Il parametro @run_time fa parte della stringa di query in questo esempio, che esegue una query su un set di dati pubblico denominato hacker_news.stories.

SELECT @run_time AS time,
  title,
  author,
  text
FROM `bigquery-public-data.hacker_news.stories`
LIMIT
  1000

Tabella di destinazione

Se la tabella di destinazione per i risultati non esiste quando configuri la query pianificata, BigQuery tenta di crearla.

Se utilizzi una query DDL o DML, nella console Google Cloud scegli la località di elaborazione o la regione. La località di elaborazione è obbligatoria per le query DDL o DML che creano la tabella di destinazione.

Se la tabella di destinazione esiste e utilizzi la WRITE_APPEND preferenza di scrittura, BigQuery aggiunge i dati alla tabella di destinazione e tenta di mappare lo schema. BigQuery consente automaticamente l'aggiunta e il riordinamento dei campi e gestisce i campi facoltativi mancanti. Se lo schema della tabella cambia così tanto tra un'esecuzione e l'altra che BigQuery non può elaborare le modifiche automaticamente, la query pianificata non va a buon fine.

Le query possono fare riferimento a tabelle di progetti e set di dati diversi. Quando configuri la query pianificata, non è necessario includere il set di dati di destinazione nel nome della tabella. Il set di dati di destinazione viene specificato separatamente.

Il set di dati e la tabella di destinazione di una query pianificata devono trovarsi nello stesso progetto della query pianificata.

Preferenza di scrittura

La preferenza di scrittura selezionata determina il modo in cui i risultati della query vengono scritti in una tabella di destinazione esistente.

• WRITE_TRUNCATE: se la tabella esiste, BigQuery sovrascrive i dati della tabella.
• WRITE_APPEND: se la tabella esiste, BigQuery aggiunge i dati alla tabella.

Se utilizzi una query DDL o DML, non puoi utilizzare l'opzione di preferenza di scrittura.

La creazione, il troncamento o l'aggiunta di una tabella di destinazione avviene solo se BigQuery è in grado di completare correttamente la query. Le azioni di creazione, troncamento o aggiunta vengono eseguite come un unico aggiornamento atomico al completamento del job.

Clustering

Le query pianificate possono creare il clustering solo su nuove tabelle, quando la tabella viene creata con un'istruzione DDL CREATE TABLE AS SELECT. Consulta Creazione di una tabella in cluster dal risultato di una query nella pagina Utilizzo delle istruzioni del linguaggio di definizione dei dati.

Opzioni di partizionamento

Le query pianificate possono creare tabelle di destinazione partizionate o non partizionate. Il partizionamento è disponibile nei metodi di configurazione della console Google Cloud , dello strumento a riga di comando bq e dell'API. Se utilizzi una query DDL o DML con partizionamento, lascia vuoto il campo di partizionamento della tabella di destinazione.

In BigQuery puoi utilizzare i seguenti tipi di partizionamento delle tabelle:

• Partizionamento per intervalli di numeri interi: tabelle partizionate in base a intervalli di valori in una colonna INTEGER specifica.
• Partizionamento delle colonne per unità di tempo: tabelle partizionate in base a una colonna TIMESTAMP, DATE o DATETIME.
• Partizionamento per data di importazione: tabelle partizionate in base alla data di importazione. BigQuery assegna automaticamente le righe alle partizioni in base al momento in cui BigQuery acquisisce i dati.

Per creare una tabella partizionata utilizzando una query programmata nella consoleGoogle Cloud , utilizza le seguenti opzioni:

• Per utilizzare il partizionamento per intervallo di numeri interi, lascia vuoto il campo di partizionamento della tabella di destinazione.

• Per utilizzare il partizionamento delle colonne per unità di tempo, specifica il nome della colonna nel campo Partizionamento della tabella di destinazione quando configuri una query pianificata.

• Per utilizzare il partizionamento in base al tempo di importazione, lascia vuoto il campo di partizionamento della tabella di destinazione e indica il partizionamento per data nel nome della tabella di destinazione. Ad esempio, mytable${run_date}. Per saperne di più, consulta Sintassi dei modelli di parametri.

Parametri disponibili

Quando configuri la query pianificata, puoi specificare come vuoi partizionare la tabella di destinazione con i parametri di runtime.

Parametro	Tipo di template	Valore
run_time	Timestamp formattato	Nel fuso orario UTC, in base alla pianificazione. Per le query pianificate regolarmente, run_time rappresenta l'ora di esecuzione prevista. Ad esempio, se la query pianificata è impostata su "ogni 24 ore", la differenza di run_time tra due query consecutive è esattamente di 24 ore, anche se il tempo di esecuzione effettivo può variare leggermente. Consulta TransferRun.runTime.
run_date	Stringa di data	La data del parametro run_time nel seguente formato: %Y-%m-%d; ad esempio, 2018-01-01. Questo formato è compatibile con le tabelle partizionate per data di acquisizione.

Sistema di modelli

Le query pianificate supportano i parametri di runtime nel nome della tabella di destinazione con una sintassi di creazione dei modelli.

Sintassi dei modelli dei parametri

La sintassi dei modelli supporta la creazione di modelli di stringhe di base e l'offset temporale. I parametri sono indicati nei seguenti formati:

• {run_date}
• {run_time[+\-offset]|"time_format"}

Parametro	Purpose
run_date	Questo parametro viene sostituito dalla data nel formato YYYYMMDD.
run_time	Questo parametro supporta le seguenti proprietà: offset Offset temporale espresso in ore (h), minuti (m) e secondi (s) in quest'ordine. I giorni (g) non sono supportati. Sono consentiti i decimali, ad esempio: 1.5h. time_format Una stringa di formattazione. I parametri di formattazione più comuni sono anni (%Y), mesi (%m) e giorni (%d). Per le tabelle partizionate, AAAAMMGG è il suffisso obbligatorio, che equivale a "%Y%m%d". Scopri di più sulla formattazione degli elementi datetime.

Note sull'utilizzo:

• Non sono consentiti spazi vuoti tra run_time, offset e formato dell'ora.
• Per includere parentesi graffe letterali nella stringa, puoi utilizzare il carattere di escape '\{' and '\}'.
• Per includere virgolette letterali o una barra verticale nel time_format, ad esempio "YYYY|MM|DD", puoi eseguirne l'escape nella stringa di formato come: '\"' o '\|'.

Esempi di modelli di parametri

Questi esempi mostrano come specificare i nomi delle tabelle di destinazione con formati di ora diversi e come compensare il tempo di esecuzione.

run_time (UTC)	Parametro basato su modello	Nome tabella di destinazione di output
2018-02-15 00:01:00	mytable	mytable
2018-02-15 00:01:00	mytable_{run_time|"%Y%m%d"}	mytable_20180215
2018-02-15 00:01:00	mytable_{run_time+25h|"%Y%m%d"}	mytable_20180216
2018-02-15 00:01:00	mytable_{run_time-1h|"%Y%m%d"}	mytable_20180214
2018-02-15 00:01:00	mytable_{run_time+1.5h|"%Y%m%d%H"} o mytable_{run_time+90m|"%Y%m%d%H"}	mytable_2018021501
2018-02-15 00:01:00	{run_time+97s|"%Y%m%d"}_mytable_{run_time+97s|"%H%M%S"}	20180215_mytable_000237

Nota: quando utilizzi i parametri di data o ora per creare tabelle con nomi che terminano con un formato di data come YYYYMMDD, BigQuery raggruppa queste tabelle. Nella console Google Cloud , queste tabelle raggruppate potrebbero essere visualizzate con un nome come mytable_(1), che rappresenta la raccolta di tabelle con sharding.

utilizza un service account

Puoi configurare una query pianificata per l'autenticazione come account di servizio. Un account di servizio è un account speciale associato al tuo progetto Google Cloud . Il account di servizio può eseguire job, come query pianificate o pipeline di elaborazione batch, con le proprie credenziali di servizio anziché con quelle di un utente finale.

Scopri di più sull'autenticazione con i service account in Introduzione all'autenticazione.

• Puoi configurare la query pianificata con un service account. Se hai eseguito l'accesso con un'identità federata, è necessario un account di servizio per creare un trasferimento. Se hai eseguito l'accesso con un Account Google, il account di servizio per il trasferimento è facoltativo.

• Puoi aggiornare una query pianificata esistente con le credenziali di un service account con lo strumento a riga di comando bq o la console Google Cloud . Per saperne di più, consulta Aggiorna le credenziali delle query pianificate.

Specifica la chiave di crittografia con le query pianificate

Puoi specificare chiavi di crittografia gestite dal cliente (CMEK) per criptare i dati per un'esecuzione del trasferimento. Puoi utilizzare una CMEK per supportare i trasferimenti da query pianificate.

Quando specifichi una CMEK con un trasferimento, BigQuery Data Transfer Service applica la CMEK a qualsiasi cache del disco intermedia dei dati importati, in modo che l'intero flusso di lavoro di trasferimento dei dati sia conforme alla CMEK.

Non puoi aggiornare un trasferimento esistente per aggiungere una CMEK se il trasferimento non è stato creato originariamente con una CMEK. Ad esempio, non puoi modificare una tabella di destinazione che era originariamente criptata per impostazione predefinita in modo che ora sia criptata con CMEK. Allo stesso modo, non puoi modificare una tabella di destinazione criptata con CMEK per applicare un tipo di crittografia diverso.

Puoi aggiornare una CMEK per un trasferimento se la configurazione del trasferimento è stata creata originariamente con una crittografia CMEK. Quando aggiorni una CMEK per una configurazione di trasferimento, BigQuery Data Transfer Service la propaga alle tabelle di destinazione alla successiva esecuzione del trasferimento, durante la quale BigQuery Data Transfer Service sostituisce le CMEK obsolete con la nuova CMEK. Per saperne di più, consulta Aggiorna un trasferimento.

Puoi anche utilizzare le chiavi predefinite del progetto. Quando specifichi una chiave predefinita del progetto con un trasferimento, BigQuery Data Transfer Service utilizza la chiave predefinita del progetto come chiave predefinita per tutte le nuove configurazioni di trasferimento.

Configura le query pianificate con un account di servizio

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Java.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

import com.google.api.gax.rpc.ApiException;
import com.google.cloud.bigquery.datatransfer.v1.CreateTransferConfigRequest;
import com.google.cloud.bigquery.datatransfer.v1.DataTransferServiceClient;
import com.google.cloud.bigquery.datatransfer.v1.ProjectName;
import com.google.cloud.bigquery.datatransfer.v1.TransferConfig;
import com.google.protobuf.Struct;
import com.google.protobuf.Value;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

// Sample to create a scheduled query with service account
public class CreateScheduledQueryWithServiceAccount {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    final String projectId = "MY_PROJECT_ID";
    final String datasetId = "MY_DATASET_ID";
    final String serviceAccount = "MY_SERVICE_ACCOUNT";
    final String query =
        "SELECT CURRENT_TIMESTAMP() as current_time, @run_time as intended_run_time, "
            + "@run_date as intended_run_date, 17 as some_integer";
    Map<String, Value> params = new HashMap<>();
    params.put("query", Value.newBuilder().setStringValue(query).build());
    params.put(
        "destination_table_name_template",
        Value.newBuilder().setStringValue("my_destination_table_{run_date}").build());
    params.put("write_disposition", Value.newBuilder().setStringValue("WRITE_TRUNCATE").build());
    params.put("partitioning_field", Value.newBuilder().build());
    TransferConfig transferConfig =
        TransferConfig.newBuilder()
            .setDestinationDatasetId(datasetId)
            .setDisplayName("Your Scheduled Query Name")
            .setDataSourceId("scheduled_query")
            .setParams(Struct.newBuilder().putAllFields(params).build())
            .setSchedule("every 24 hours")
            .build();
    createScheduledQueryWithServiceAccount(projectId, transferConfig, serviceAccount);
  }

  public static void createScheduledQueryWithServiceAccount(
      String projectId, TransferConfig transferConfig, String serviceAccount) throws IOException {
    try (DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.create()) {
      ProjectName parent = ProjectName.of(projectId);
      CreateTransferConfigRequest request =
          CreateTransferConfigRequest.newBuilder()
              .setParent(parent.toString())
              .setTransferConfig(transferConfig)
              .setServiceAccountName(serviceAccount)
              .build();
      TransferConfig config = dataTransferServiceClient.createTransferConfig(request);
      System.out.println(
          "\nScheduled query with service account created successfully :" + config.getName());
    } catch (ApiException ex) {
      System.out.print("\nScheduled query with service account was not created." + ex.toString());
    }
  }
}

Python

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Python.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

from google.cloud import bigquery_datatransfer

transfer_client = bigquery_datatransfer.DataTransferServiceClient()

# The project where the query job runs is the same as the project
# containing the destination dataset.
project_id = "your-project-id"
dataset_id = "your_dataset_id"

# This service account will be used to execute the scheduled queries. Omit
# this request parameter to run the query as the user with the credentials
# associated with this client.
service_account_name = "[e-mail]"

# Use standard SQL syntax for the query.
query_string = """
SELECT
  CURRENT_TIMESTAMP() as current_time,
  @run_time as intended_run_time,
  @run_date as intended_run_date,
  17 as some_integer
"""

parent = transfer_client.common_project_path(project_id)

transfer_config = bigquery_datatransfer.TransferConfig(
    destination_dataset_id=dataset_id,
    display_name="Your Scheduled Query Name",
    data_source_id="scheduled_query",
    params={
        "query": query_string,
        "destination_table_name_template": "your_table_{run_date}",
        "write_disposition": "WRITE_TRUNCATE",
        "partitioning_field": "",
    },
    schedule="every 24 hours",
)

transfer_config = transfer_client.create_transfer_config(
    bigquery_datatransfer.CreateTransferConfigRequest(
        parent=parent,
        transfer_config=transfer_config,
        service_account_name=service_account_name,
    )
)

print("Created scheduled query '{}'".format(transfer_config.name))

Visualizza lo stato delle query programmate

Console

Per visualizzare lo stato delle query pianificate, nel menu di navigazione, fai clic su Pianificazione e filtra per Query pianificata. Fai clic su una query pianificata per visualizzarne i dettagli.

bq

Le query pianificate sono un tipo di trasferimento. Per visualizzare i dettagli di una query pianificata, puoi prima utilizzare lo strumento a riga di comando bq per elencare le configurazioni di trasferimento.

Inserisci il comando bq ls e fornisci il flag di trasferimento --transfer_config. Sono richiesti anche i seguenti flag:

• --transfer_location

Ad esempio:

bq ls \
--transfer_config \
--transfer_location=us

Per visualizzare i dettagli di una singola query pianificata, inserisci il comando bq show e fornisci il transfer_path per la query pianificata o la configurazione del trasferimento.

Ad esempio:

bq show \
--transfer_config \
projects/862514376110/locations/us/transferConfigs/5dd12f26-0000-262f-bc38-089e0820fe38

API

Utilizza il metodo projects.locations.transferConfigs.list e fornisci un'istanza della risorsa TransferConfig.

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Java.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

import com.google.api.gax.rpc.ApiException;
import com.google.cloud.bigquery.datatransfer.v1.DataTransferServiceClient;
import com.google.cloud.bigquery.datatransfer.v1.ListTransferConfigsRequest;
import com.google.cloud.bigquery.datatransfer.v1.ProjectName;
import java.io.IOException;

// Sample to get list of transfer config
public class ListTransferConfigs {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    final String projectId = "MY_PROJECT_ID";
    listTransferConfigs(projectId);
  }

  public static void listTransferConfigs(String projectId) throws IOException {
    try (DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.create()) {
      ProjectName parent = ProjectName.of(projectId);
      ListTransferConfigsRequest request =
          ListTransferConfigsRequest.newBuilder().setParent(parent.toString()).build();
      dataTransferServiceClient
          .listTransferConfigs(request)
          .iterateAll()
          .forEach(config -> System.out.print("Success! Config ID :" + config.getName() + "\n"));
    } catch (ApiException ex) {
      System.out.println("Config list not found due to error." + ex.toString());
    }
  }
}

Python

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Python.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

import google.api_core.exceptions
from google.cloud import bigquery_datatransfer_v1

client = bigquery_datatransfer_v1.DataTransferServiceClient()


def list_transfer_configs(project_id: str, location: str) -> None:
    """Lists transfer configurations in a given project.

    This sample demonstrates how to list all transfer configurations in a project.

    Args:
        project_id: The Google Cloud project ID.
        location: The geographic location of the transfer config, for example "us-central1"
    """

    parent = client.common_location_path(project_id, location)

    try:
        for config in client.list_transfer_configs(parent=parent):
            print(f"Name: {config.name}")
            print(f"Display Name: {config.display_name}")
            print(f"Data source: {config.data_source_id}")
            print(f"Destination dataset: {config.destination_dataset_id}")
            if "time_based_schedule" in config.schedule_options_v2:
                print(
                    f"Schedule: {config.schedule_options_v2.time_based_schedule.schedule}"
                )
            else:
                print("Schedule: None")
            print("---")
    except google.api_core.exceptions.NotFound:
        print(
            f"Error: Project '{project_id}' not found or contains no transfer configs."
        )
    except google.api_core.exceptions.PermissionDenied:
        print(
            f"Error: Permission denied for project '{project_id}'. Please ensure you have the correct permissions."
        )

Aggiorna le query pianificate

Console

Per aggiornare una query pianificata:

1. Nel menu di navigazione, fai clic su Query pianificate o Pianificazione.
2. Nell'elenco delle query pianificate, fai clic sul nome della query che vuoi modificare.
3. Nella pagina Dettagli query pianificata che si apre, fai clic su Modifica.
4. (Facoltativo) Modifica il testo della query nel riquadro dell'editor di query.
5. Fai clic su Query pianificata e poi seleziona Aggiorna query pianificata.
6. (Facoltativo) Modifica le altre opzioni di pianificazione per la query.
7. Fai clic su Aggiorna.

bq

Le query pianificate sono un tipo di trasferimento. Per aggiornare una query pianificata, puoi utilizzare lo strumento a riga di comando bq per creare una configurazione del trasferimento.

Inserisci il comando bq update con il flag --transfer_config obbligatorio.

Flag facoltativi:

• --project_id è l'ID progetto. Se --project_id non è specificato, viene utilizzato il progetto predefinito.

• --schedule è la frequenza con cui vuoi eseguire la query. Se --schedule non è specificato, il valore predefinito è "ogni 24 ore" in base all'ora di creazione.

• --service_account_name ha effetto solo se è impostato anche --update_credentials. Per saperne di più, consulta Aggiorna le credenziali delle query pianificate.

• --target_dataset (facoltativo per le query DDL e DML) è un modo alternativo per assegnare un nome al set di dati di destinazione per i risultati della query, se utilizzato con le query DDL e DML.

• --display_name è il nome della query pianificata.

• --params i parametri per la configurazione del trasferimento creata in formato JSON. Ad esempio: --params='{"param":"param_value"}'.

• --destination_kms_key specifica l'ID risorsa della chiave per la chiave Cloud KMS se utilizzi una chiave di crittografia gestita dal cliente (CMEK) per questo trasferimento. Per informazioni su come funzionano le chiavi di crittografia gestite dal cliente (CMEK) con BigQuery Data Transfer Service, consulta Specifica la chiave di crittografia con le query pianificate.

bq update \
--target_dataset=dataset \
--display_name=name \
--params='parameters'
--transfer_config \
RESOURCE_NAME

Sostituisci quanto segue:

• dataset: il set di dati di destinazione per la configurazione del trasferimento. Questo parametro è facoltativo per le query DDL e DML. È obbligatorio per tutte le altre query.
• name: il nome visualizzato della configurazione del trasferimento. Il nome visualizzato può essere qualsiasi valore che puoi identificare in un secondo momento se devi modificare la query.
• parameters: contiene i parametri per la configurazione del trasferimento creata in formato JSON. Ad esempio: --params='{"param":"param_value"}'.
  • Per una query pianificata, devi fornire il parametro query.
  • Il parametro destination_table_name_template è il nome della tabella di destinazione. Questo parametro è facoltativo per le query DDL e DML. È obbligatorio per tutte le altre query.
  • Per il parametro write_disposition, puoi scegliere WRITE_TRUNCATE per troncare (sovrascrivere) la tabella di destinazione o WRITE_APPEND per aggiungere i risultati della query alla tabella di destinazione. Questo parametro è facoltativo per le query DDL e DML. È obbligatorio per tutte le altre query.
• (Facoltativo) --destination_kms_key specifica l'ID risorsa della chiave per la chiave Cloud KMS, ad esempio projects/project_name/locations/us/keyRings/key_ring_name/cryptoKeys/key_name.
• RESOURCE_NAME: il nome della risorsa del trasferimento (noto anche come configurazione del trasferimento). Se non conosci il nome della risorsa del trasferimento, trovalo con: bq ls --transfer_config --transfer_location=location.

Nota: per scrivere i risultati in una tabella partizionata per data di importazione, consulta le istruzioni in Tabella di destinazione. Una query pianificata non va a buon fine se crei una configurazione del trasferimento con il parametro destination_table_name_template impostato su una tabella partizionata per data di acquisizione, mentre viene restituito un errore se imposti il parametro partitioning_field su una tabella partizionata per data di acquisizione.

Nota: non puoi configurare le notifiche utilizzando lo strumento a riga di comando.

Ad esempio, il seguente comando aggiorna una configurazione del trasferimento delle query pianificate denominata My Scheduled Query utilizzando la query SELECT 1 from mydataset.test. La tabella di destinazione mytable viene troncata per ogni scrittura e il set di dati di destinazione è mydataset:

bq update \
--target_dataset=mydataset \
--display_name='My Scheduled Query' \
--params='{"query":"SELECT 1 from mydataset.test","destination_table_name_template":"mytable","write_disposition":"WRITE_TRUNCATE"}'
--transfer_config \
projects/myproject/locations/us/transferConfigs/1234a123-1234-1a23-1be9-12ab3c456de7

API

Utilizza il metodo projects.transferConfigs.patch e fornisci il nome della risorsa del trasferimento utilizzando il parametro transferConfig.name. Se non conosci il nome della risorsa del trasferimento, utilizza il comando bq ls --transfer_config --transfer_location=location per elencare tutti i trasferimenti o chiama il metodo projects.locations.transferConfigs.list e fornisci l'ID progetto utilizzando il parametro parent.

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Java.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

import com.google.api.gax.rpc.ApiException;
import com.google.cloud.bigquery.datatransfer.v1.DataTransferServiceClient;
import com.google.cloud.bigquery.datatransfer.v1.TransferConfig;
import com.google.cloud.bigquery.datatransfer.v1.UpdateTransferConfigRequest;
import com.google.protobuf.FieldMask;
import com.google.protobuf.util.FieldMaskUtil;
import java.io.IOException;

// Sample to update transfer config.
public class UpdateTransferConfig {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String configId = "MY_CONFIG_ID";
    TransferConfig transferConfig =
        TransferConfig.newBuilder()
            .setName(configId)
            .setDisplayName("UPDATED_DISPLAY_NAME")
            .build();
    FieldMask updateMask = FieldMaskUtil.fromString("display_name");
    updateTransferConfig(transferConfig, updateMask);
  }

  public static void updateTransferConfig(TransferConfig transferConfig, FieldMask updateMask)
      throws IOException {
    try (DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.create()) {
      UpdateTransferConfigRequest request =
          UpdateTransferConfigRequest.newBuilder()
              .setTransferConfig(transferConfig)
              .setUpdateMask(updateMask)
              .build();
      TransferConfig updateConfig = dataTransferServiceClient.updateTransferConfig(request);
      System.out.println("Transfer config updated successfully :" + updateConfig.getDisplayName());
    } catch (ApiException ex) {
      System.out.print("Transfer config was not updated." + ex.toString());
    }
  }
}

Python

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Python.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

import google.api_core.exceptions
from google.cloud import bigquery_datatransfer_v1
from google.protobuf import field_mask_pb2


client = bigquery_datatransfer_v1.DataTransferServiceClient()


def update_transfer_config(
    project_id: str,
    location: str,
    transfer_config_id: str,
) -> None:
    """Updates a data transfer configuration.

    This sample shows how to update the display name for a transfer
    configuration.

    Args:
        project_id: The Google Cloud project ID.
        location: The geographic location of the transfer config, for example "us-central1"
        transfer_config_id: The transfer configuration ID
    """
    transfer_config_name = client.transfer_config_path(
        project=f"{project_id}/locations/{location}",
        transfer_config=transfer_config_id,
    )

    transfer_config = bigquery_datatransfer_v1.types.TransferConfig(
        name=transfer_config_name,
        display_name="My New Transfer Config display name",
    )
    update_mask = field_mask_pb2.FieldMask(paths=["display_name"])

    try:
        response = client.update_transfer_config(
            transfer_config=transfer_config,
            update_mask=update_mask,
        )

        print(f"Updated transfer config: {response.name}")
        print(f"New display name: {response.display_name}")
    except google.api_core.exceptions.NotFound:
        print(f"Error: Transfer config '{transfer_config_name}' not found.")

Nota: non puoi aggiornare la località di una query pianificata. Se sposti un set di dati di origine o di destinazione utilizzato in una query pianificata, devi creare una nuova query pianificata nella nuova località.

Aggiorna le query pianificate con limitazioni di proprietà

Se provi ad aggiornare una query pianificata di cui non sei proprietario, l'aggiornamento potrebbe non riuscire e generare il seguente messaggio di errore:

Cannot modify restricted parameters without taking ownership of the transfer configuration.

Il proprietario di una query pianificata è l'identità le cui credenziali vengono utilizzate per eseguirla:

• Credenziali utente: se la query viene eseguita come utente, l'utente è il proprietario.
• Credenziali del service account: se la query viene eseguita come account di servizio, il account di servizio è il proprietario.

Importante: se la query pianificata è configurata per l'esecuzione come account di servizio, il account di servizio è proprietario della query, ma non può gestire la configurazione della query pianificata. Per gestire o eliminare la query pianificata, devi disporre dell'autorizzazione bigquery.transfers.update per il progetto.

L'utente associato può essere visualizzato nei dettagli di configurazione della query pianificata. Per informazioni su come aggiornare la query pianificata per assumerne la proprietà, consulta Aggiorna le credenziali delle query pianificate. Per concedere agli utenti l'accesso a un account di servizio, devi disporre del ruolo Utente service account.

I parametri limitati dal proprietario per le query pianificate sono:

• Il testo della query
• Il set di dati di destinazione
• Il modello del nome della tabella di destinazione

Aggiorna le credenziali delle query pianificate

Se stai pianificando una query esistente, potresti dover aggiornare le credenziali utente nella query. Le credenziali vengono aggiornate automaticamente per le nuove query pianificate.

Attenzione: l'aggiornamento delle credenziali esegue la query con la tua identità e le tue autorizzazioni. Verifica che la query non sia stata modificata da altri per accedere a risorse che solo tu puoi visualizzare, il che potrebbe comportare un accesso non autorizzato a dati sensibili.

Ecco altre situazioni che potrebbero richiedere l'aggiornamento delle credenziali:

• Vuoi eseguire query sui dati di Google Drive in una query pianificata.

• Ricevi un errore INVALID_USER quando tenti di pianificare la query:

  Error code 5 : Authentication failure: User Id not found. Error code: INVALID_USERID

• Quando provi ad aggiornare la query, ricevi il seguente errore relativo ai parametri limitati:

  Cannot modify restricted parameters without taking ownership of the transfer configuration.

Nota: se non sei il proprietario della query pianificata, devi disporre dell'autorizzazione bigquery.transfers.update sul tuo progetto Google Cloud per aggiornare le credenziali della query pianificata. Per ulteriori informazioni, consulta Autorizzazioni richieste.

Console

Per aggiornare le credenziali esistenti in una query pianificata:

1. Trova e visualizza lo stato di una query pianificata.

2. Fai clic sul pulsante ALTRO e seleziona Aggiorna credenziali.

   

3. Attendi da 10 a 20 minuti affinché la modifica diventi effettiva. Potresti dover svuotare la cache del browser.

Attenzione: la modifica delle credenziali utilizzate in una query pianificata in un service account non è supportata nella console Google Cloud .

bq

Le query pianificate sono un tipo di trasferimento. Per aggiornare le credenziali di una query pianificata, puoi utilizzare lo strumento a riga di comando bq per aggiornare la configurazione del trasferimento.

Inserisci il comando bq update e fornisci il flag di trasferimento --transfer_config. Sono richiesti anche i seguenti flag:

• --update_credentials

Flag facoltativo:

• --service_account_name serve per autenticare la query pianificata con un account di servizio anziché con il tuo account utente individuale.

Ad esempio, il seguente comando aggiorna una configurazione del trasferimento delle query pianificate per l'autenticazione come account di servizio:

bq update \
--update_credentials \
--service_account_name=abcdef-test-sa@abcdef-test. \
--transfer_config \
projects/myproject/locations/us/transferConfigs/1234a123-1234-1a23-1be9-12ab3c456de7

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Java.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

import com.google.api.gax.rpc.ApiException;
import com.google.cloud.bigquery.datatransfer.v1.DataTransferServiceClient;
import com.google.cloud.bigquery.datatransfer.v1.TransferConfig;
import com.google.cloud.bigquery.datatransfer.v1.UpdateTransferConfigRequest;
import com.google.protobuf.FieldMask;
import com.google.protobuf.util.FieldMaskUtil;
import java.io.IOException;

// Sample to update credentials in transfer config.
public class UpdateCredentials {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String configId = "MY_CONFIG_ID";
    String serviceAccount = "MY_SERVICE_ACCOUNT";
    TransferConfig transferConfig = TransferConfig.newBuilder().setName(configId).build();
    FieldMask updateMask = FieldMaskUtil.fromString("service_account_name");
    updateCredentials(transferConfig, serviceAccount, updateMask);
  }

  public static void updateCredentials(
      TransferConfig transferConfig, String serviceAccount, FieldMask updateMask)
      throws IOException {
    try (DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.create()) {
      UpdateTransferConfigRequest request =
          UpdateTransferConfigRequest.newBuilder()
              .setTransferConfig(transferConfig)
              .setUpdateMask(updateMask)
              .setServiceAccountName(serviceAccount)
              .build();
      dataTransferServiceClient.updateTransferConfig(request);
      System.out.println("Credentials updated successfully");
    } catch (ApiException ex) {
      System.out.print("Credentials was not updated." + ex.toString());
    }
  }
}

Python

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Python.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

from google.cloud import bigquery_datatransfer
from google.protobuf import field_mask_pb2

transfer_client = bigquery_datatransfer.DataTransferServiceClient()

service_account_name = "[e-mail]"
transfer_config_name = "projects/1234/locations/us/transferConfigs/abcd"

transfer_config = bigquery_datatransfer.TransferConfig(name=transfer_config_name)

transfer_config = transfer_client.update_transfer_config(
    {
        "transfer_config": transfer_config,
        "update_mask": field_mask_pb2.FieldMask(paths=["service_account_name"]),
        "service_account_name": service_account_name,
    }
)

print("Updated config: '{}'".format(transfer_config.name))

Configura un'esecuzione manuale per le date storiche

Oltre a pianificare l'esecuzione di una query in un secondo momento, puoi anche attivare manualmente le esecuzioni immediate. L'attivazione di un'esecuzione immediata è necessaria se la query utilizza il parametro run_date e si sono verificati problemi durante un'esecuzione precedente.

Ad esempio, ogni giorno alle 09:00 esegui una query su una tabella di origine per trovare le righe che corrispondono alla data corrente. Tuttavia, scopri che i dati non sono stati aggiunti alla tabella di origine negli ultimi tre giorni. In questo caso, puoi impostare la query in modo che venga eseguita su dati storici all'interno di un intervallo di date specificato. La query viene eseguita utilizzando combinazioni di parametri run_date e run_time che corrispondono alle date configurate nella query pianificata.

Dopo aver configurato una query pianificata, ecco come puoi eseguirla utilizzando un intervallo di date storiche:

Console

Dopo aver fatto clic su Pianifica per salvare la query pianificata, puoi fare clic sul pulsante Query pianificate per visualizzare l'elenco delle query pianificate. Fai clic su un nome visualizzato per visualizzare i dettagli della pianificazione delle query. In alto a destra nella pagina, fai clic su Pianifica backfill per specificare un intervallo di date storiche.

I runtime scelti rientrano tutti nell'intervallo selezionato, inclusa la prima data ed esclusa l'ultima.

Avviso: gli intervalli di date forniti sono in formato UTC, ma la pianificazione della query viene visualizzata nel fuso orario locale (consulta l'Esempio 2 per risolvere questo problema).

Esempio 1

La query pianificata è impostata per l'esecuzione alle ore every day 09:00 (fuso orario del Pacifico). Mancano i dati del 1°, 2 e 3 gennaio. Scegli il seguente intervallo di date storiche:

Start Time = 1/1/19
End Time = 1/4/19

La query viene eseguita utilizzando i parametri run_date e run_time che corrispondono ai seguenti orari:

• 1/1/19 09:00 fuso orario del Pacifico
• 2/1/19 09:00 fuso orario del Pacifico
• 3/1/19 09:00 fuso orario del Pacifico

Esempio 2

La query pianificata è impostata per l'esecuzione alle ore every day 23:00 (fuso orario del Pacifico). Mancano i dati del 1°, 2 e 3 gennaio. Scegli i seguenti intervalli di date storiche (le date successive vengono scelte perché l'ora UTC ha una data diversa alle 23:00 ora del Pacifico):

Start Time = 1/2/19
End Time = 1/5/19

La query viene eseguita utilizzando i parametri run_date e run_time che corrispondono ai seguenti orari:

• 2 gennaio 2019 alle 06:00 UTC o 1° gennaio 2019 alle 23:00 fuso orario del Pacifico
• 3 gennaio 2019 alle 06:00 UTC o 2 gennaio 2019 alle 23:00 fuso orario del Pacifico
• 4/1/19 06:00 UTC o 3/1/2019 23:00 fuso orario del Pacifico

Dopo aver configurato le esecuzioni manuali, aggiorna la pagina per visualizzarle nell'elenco delle esecuzioni.

bq

Per eseguire manualmente la query su un intervallo di date storico:

Inserisci il comando bq mk e fornisci il flag di esecuzione del trasferimento --transfer_run. Sono richiesti anche i seguenti flag:

• --start_time
• --end_time

bq mk \
--transfer_run \
--start_time='start_time' \
--end_time='end_time' \
resource_name

Sostituisci quanto segue:

• start_time e end_time. Timestamp che terminano con Z o contengono un offset del fuso orario valido. Esempi:
  • 2017-08-19T12:11:35.00Z
  • 2017-05-25T00:00:00+00:00
• resource_name: il nome risorsa della query pianificata (o del trasferimento). Il nome della risorsa è noto anche come configurazione del trasferimento.

Ad esempio, il seguente comando pianifica un backfill per la risorsa di query pianificata (o configurazione del trasferimento): projects/myproject/locations/us/transferConfigs/1234a123-1234-1a23-1be9-12ab3c456de7.

  bq mk \
  --transfer_run \
  --start_time 2017-05-25T00:00:00Z \
  --end_time 2017-05-25T00:00:00Z \
  projects/myproject/locations/us/transferConfigs/1234a123-1234-1a23-1be9-12ab3c456de7

Per saperne di più, consulta bq mk --transfer_run.

API

Utilizza il metodo projects.locations.transferConfigs.scheduleRun e fornisci un percorso della risorsa TransferConfig.

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Java.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

import com.google.api.gax.rpc.ApiException;
import com.google.cloud.bigquery.datatransfer.v1.DataTransferServiceClient;
import com.google.cloud.bigquery.datatransfer.v1.ScheduleTransferRunsRequest;
import com.google.cloud.bigquery.datatransfer.v1.ScheduleTransferRunsResponse;
import com.google.protobuf.Timestamp;
import java.io.IOException;
import org.threeten.bp.Clock;
import org.threeten.bp.Instant;
import org.threeten.bp.temporal.ChronoUnit;

// Sample to run schedule back fill for transfer config
public class ScheduleBackFill {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String configId = "MY_CONFIG_ID";
    Clock clock = Clock.systemDefaultZone();
    Instant instant = clock.instant();
    Timestamp startTime =
        Timestamp.newBuilder()
            .setSeconds(instant.minus(5, ChronoUnit.DAYS).getEpochSecond())
            .setNanos(instant.minus(5, ChronoUnit.DAYS).getNano())
            .build();
    Timestamp endTime =
        Timestamp.newBuilder()
            .setSeconds(instant.minus(2, ChronoUnit.DAYS).getEpochSecond())
            .setNanos(instant.minus(2, ChronoUnit.DAYS).getNano())
            .build();
    scheduleBackFill(configId, startTime, endTime);
  }

  public static void scheduleBackFill(String configId, Timestamp startTime, Timestamp endTime)
      throws IOException {
    try (DataTransferServiceClient client = DataTransferServiceClient.create()) {
      ScheduleTransferRunsRequest request =
          ScheduleTransferRunsRequest.newBuilder()
              .setParent(configId)
              .setStartTime(startTime)
              .setEndTime(endTime)
              .build();
      ScheduleTransferRunsResponse response = client.scheduleTransferRuns(request);
      System.out.println("Schedule backfill run successfully :" + response.getRunsCount());
    } catch (ApiException ex) {
      System.out.print("Schedule backfill was not run." + ex.toString());
    }
  }
}

Python

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Python.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

import datetime

from google.cloud.bigquery_datatransfer_v1 import (
    DataTransferServiceClient,
    StartManualTransferRunsRequest,
)

# Create a client object
client = DataTransferServiceClient()

# Replace with your transfer configuration name
transfer_config_name = "projects/1234/locations/us/transferConfigs/abcd"
now = datetime.datetime.now(datetime.timezone.utc)
start_time = now - datetime.timedelta(days=5)
end_time = now - datetime.timedelta(days=2)

# Some data sources, such as scheduled_query only support daily run.
# Truncate start_time and end_time to midnight time (00:00AM UTC).
start_time = datetime.datetime(
    start_time.year, start_time.month, start_time.day, tzinfo=datetime.timezone.utc
)
end_time = datetime.datetime(
    end_time.year, end_time.month, end_time.day, tzinfo=datetime.timezone.utc
)

requested_time_range = StartManualTransferRunsRequest.TimeRange(
    start_time=start_time,
    end_time=end_time,
)

# Initialize request argument(s)
request = StartManualTransferRunsRequest(
    parent=transfer_config_name,
    requested_time_range=requested_time_range,
)

# Make the request
response = client.start_manual_transfer_runs(request=request)

# Handle the response
print("Started manual transfer runs:")
for run in response.runs:
    print(f"backfill: {run.run_time} run: {run.name}")

Configura gli avvisi per le query pianificate

Puoi configurare policy di avviso per le query pianificate in base alle metriche del conteggio delle righe. Per saperne di più, consulta Configura gli avvisi con query pianificate.

Elimina query pianificate

Console

Per eliminare una query programmata nella pagina Query programmate della console Google Cloud , segui questi passaggi:

1. Nel menu di navigazione, fai clic su Query pianificate.
2. Nell'elenco delle query pianificate, fai clic sul nome della query pianificata che vuoi eliminare.

3. Nella pagina Dettagli query pianificata, fai clic su Elimina.

   

In alternativa, puoi eliminare una query pianificata nella pagina Pianificazione della console Google Cloud :

1. Nel menu di navigazione, fai clic su Pianificazione.
2. Nell'elenco delle query pianificate, fai clic sul menu Azioni per la query pianificata che vuoi eliminare.

3. Seleziona Elimina.

   

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Java.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

import com.google.api.gax.rpc.ApiException;
import com.google.cloud.bigquery.datatransfer.v1.DataTransferServiceClient;
import com.google.cloud.bigquery.datatransfer.v1.DeleteTransferConfigRequest;
import java.io.IOException;

// Sample to delete a transfer config
public class DeleteTransferConfig {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // i.e projects/{project_id}/transferConfigs/{config_id}` or
    // `projects/{project_id}/locations/{location_id}/transferConfigs/{config_id}`
    String configId = "MY_CONFIG_ID";
    deleteTransferConfig(configId);
  }

  public static void deleteTransferConfig(String configId) throws IOException {
    try (DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.create()) {
      DeleteTransferConfigRequest request =
          DeleteTransferConfigRequest.newBuilder().setName(configId).build();
      dataTransferServiceClient.deleteTransferConfig(request);
      System.out.println("Transfer config deleted successfully");
    } catch (ApiException ex) {
      System.out.println("Transfer config was not deleted." + ex.toString());
    }
  }
}

Python

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Python.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

import google.api_core.exceptions
from google.cloud import bigquery_datatransfer_v1

client = bigquery_datatransfer_v1.DataTransferServiceClient()


def delete_transfer_config(
    project_id: str, location: str, transfer_config_id: str
) -> None:
    """Deletes a data transfer configuration, including any associated transfer runs and logs.

    Args:
        project_id: The Google Cloud project ID.
        location: The geographic location of the transfer configuration, for example, "us-central1".
        transfer_config_id: The transfer configuration ID, for example, "1234a-5678-90b1-2c3d-4e5f67890g12".
    """

    name = client.transfer_config_path(
        project=f"{project_id}/locations/{location}",
        transfer_config=transfer_config_id,
    )
    request = bigquery_datatransfer_v1.DeleteTransferConfigRequest(name=name)

    try:
        client.delete_transfer_config(request=request)
        print(f"Deleted transfer config {name}")
    except google.api_core.exceptions.NotFound:
        print(f"Error: Transfer config '{name}' not found.")

Disattiva o attiva le query pianificate

Per mettere in pausa le esecuzioni pianificate di una query selezionata senza eliminare la pianificazione, puoi disattivare la pianificazione.

Per disattivare una pianificazione per una query selezionata:

1. Nel menu di navigazione della console Google Cloud , fai clic su Pianificazione.
2. Nell'elenco delle query pianificate, fai clic sul menu Azioni per la query pianificata che vuoi disattivare.

3. Seleziona Disable (Disattiva).

   

Per attivare una query pianificata disattivata, fai clic sul menu Azioni per la query pianificata che vuoi attivare e seleziona Abilita.

Quote

Le query pianificate vengono sempre eseguite come job di query batch e sono soggette alle stesse quote e limitazioni di BigQuery delle query manuali.

Sebbene le query pianificate utilizzino le funzionalità di BigQuery Data Transfer Service, non sono trasferimenti e non sono soggette alla quota dei job di caricamento.

L'identità utilizzata per eseguire la query determina le quote applicate. Questo dipende dalla configurazione della query pianificata:

• Credenziali del creator (predefinito): se non specifichi un account di servizio, la query pianificata viene eseguita utilizzando le credenziali dell'utente che l'ha creata. Il job di query viene fatturato al progetto del creator ed è soggetto alle quote dell'utente e del progetto.

• Credenziali dell'account di servizio: se configuri la query pianificata in modo che utilizzi un service account, l'esecuzione avviene utilizzando le credenziali del service account. In questo caso, il job viene comunque fatturato al progetto contenente la query pianificata, ma l'esecuzione è soggetta alle quote del account di servizio specificato.

Prezzi

Le query pianificate hanno lo stesso prezzo delle query BigQuery manuali.

Aree geografiche supportate

Attenzione: le query tra regioni non sono supportate. La tabella di destinazione della query programmata deve trovarsi nella stessa regione dei dati su cui viene eseguita la query. Anche la località selezionata per la query pianificata deve essere la stessa regione dei dati su cui viene eseguita la query.

Le query pianificate sono supportate nelle seguenti località.

Regioni

La tabella seguente elenca le regioni delle Americhe in cui è disponibile BigQuery.

Descrizione della regione	Nome della regione	Dettagli
Columbus, Ohio	us-east5
Dallas	us-south1	Bassi livelli di CO2
Iowa	us-central1	Bassi livelli di CO2
Los Angeles	us-west2
Las Vegas	us-west4
Messico	northamerica-south1
Montréal	northamerica-northeast1	Bassi livelli di CO2
Virginia del Nord	us-east4
Oklahoma	us-central2	Bassi livelli di CO2
Oregon	us-west1	Bassi livelli di CO2
Salt Lake City	us-west3
San Paolo	southamerica-east1	Bassi livelli di CO2
Santiago	southamerica-west1	Bassi livelli di CO2
Carolina del Sud	us-east1
Toronto	northamerica-northeast2	Bassi livelli di CO2

La tabella seguente elenca le regioni dell'Asia Pacifico in cui è disponibile BigQuery.

Descrizione della regione	Nome della regione	Dettagli
Bangkok	asia-southeast3
Delhi	asia-south2
Hong Kong	asia-east2
Giacarta	asia-southeast2
Melbourne	australia-southeast2
Mumbai	asia-south1
Osaka	asia-northeast2
Seul	asia-northeast3
Singapore	asia-southeast1
Sydney	australia-southeast1
Taiwan	asia-east1
Tokyo	asia-northeast1

La tabella seguente elenca le regioni in Europa in cui è disponibile BigQuery.

Descrizione della regione	Nome della regione	Dettagli
Belgio	europe-west1	Bassi livelli di CO2
Berlino	europe-west10
Finlandia	europe-north1	Bassi livelli di CO2
Francoforte	europe-west3
Londra	europe-west2	Bassi livelli di CO2
Madrid	europe-southwest1	Bassi livelli di CO2
Milano	europe-west8
Paesi Bassi	europe-west4	Bassi livelli di CO2
Parigi	europe-west9	Bassi livelli di CO2
Stoccolma	europe-north2	Bassi livelli di CO2
Torino	europe-west12	Bassi livelli di CO2
Varsavia	europe-central2	Bassi livelli di CO2
Zurigo	europe-west6	Bassi livelli di CO2

La tabella seguente elenca le regioni del Medio Oriente in cui è disponibile BigQuery.

Descrizione della regione	Nome della regione	Dettagli
Dammam	me-central2
Doha	me-central1
Tel Aviv	me-west1

La tabella seguente elenca le regioni in Africa in cui è disponibile BigQuery.

Descrizione della regione	Nome della regione	Dettagli
Johannesburg	africa-south1

Multi-regioni

Nota: Entro la fine dell'anno, BigQuery smetterà di usare il termine multi-region. I nomi delle regioni US e EU verranno invece inclusi nell'elenco delle singole regioni e verranno collocati rispettivamente nelle regioni us-central1 e europe-west4. La residenza dei dati esistente non cambia.

La tabella seguente elenca le multi-regioni in cui è disponibile BigQuery. Quando selezioni una località multiregionale, consenti a BigQuery di selezionare una singola regione all'interno della località multiregionale in cui i dati vengono archiviati ed elaborati.

Descrizione multiregionale	Nome della multi-regione
Data center negli stati membri dell'Unione Europea^1	EU
Data center negli Stati Uniti^2	US

Nota: la selezione di una località multiregionale non fornisce la replica tra regioni o la ridondanza regionale, pertanto non aumenta la disponibilità del set di dati in caso di interruzione del servizio a livello di regione. I dati vengono archiviati in una singola regione all'interno della posizione geografica.

¹ I dati che si trovano nella multi-regione EU vengono archiviati solo in una delle seguenti località: europe-west1 (Belgio) o europe-west4 (Paesi Bassi). La località esatta in cui i dati vengono archiviati ed elaborati viene determinata automaticamente da BigQuery.

² I dati che si trovano nella multi-regione US vengono archiviati solo in una delle seguenti località: us-central1 (Iowa), us-west1 (Oregon) o us-central2 (Oklahoma). La località esatta in cui i dati vengono archiviati ed elaborati viene determinata automaticamente da BigQuery.

Passaggi successivi

• Per un esempio di query pianificata che utilizza un account di servizio e include i parametri @run_date e @run_time, consulta Creazione di snapshot delle tabelle con una query pianificata.