Gestisci tabelle

Questo documento descrive come gestire le tabelle in BigQuery. Puoi gestire le tabelle BigQuery nei seguenti modi:

• Aggiorna le proprietà della tabella:
  • Data di scadenza
  • Descrizione
  • Definizione dello schema
  • Etichette
  • Modalità di arrotondamento predefinita
• Rinominare (copiare) una tabella
• Copiare una tabella
• Eliminare una tabella
• Ripristinare una tabella eliminata

Per ulteriori informazioni sulla creazione e sull'utilizzo delle tabelle, tra cui l'ottenimento di informazioni sulle tabelle, l'elenco delle tabelle e il controllo dell'accesso ai dati delle tabelle, consulta Creare e utilizzare le tabelle.

Prima di iniziare

Concedi i ruoli IAM (Identity and Access Management) che concedono agli utenti le autorizzazioni necessarie per eseguire ogni attività in questo documento. Le autorizzazioni necessarie per eseguire sono elencate nella sezione "Autorizzazioni obbligatorie" dell'attività.

Aggiorna le proprietà della tabella

Puoi aggiornare i seguenti elementi di una tabella:

• Descrizione
• Data di scadenza
• Definizione dello schema
• Etichette
• Nome tabella
• Tag

Autorizzazioni obbligatorie

Per ottenere le autorizzazioni necessarie per aggiornare le proprietà della tabella, chiedi all'amministratore di concederti Ruolo IAM Editor dati (roles/bigquery.dataEditor) in una tabella. Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso a progetti, cartelle e organizzazioni.

Questo ruolo predefinito contiene le autorizzazioni necessarie per aggiornare le proprietà della tabella. Per visualizzare le autorizzazioni esatte richieste, espandi la sezione Autorizzazioni richieste:

Autorizzazioni obbligatorie

Per aggiornare le proprietà della tabella sono necessarie le seguenti autorizzazioni:

• bigquery.tables.update
• bigquery.tables.get

Potresti anche riuscire a ottenere queste autorizzazioni con ruoli personalizzati altri ruoli predefiniti.

Inoltre, se disponi dell'autorizzazione bigquery.datasets.create, puoi Aggiornare le proprietà delle tabelle dei set di dati che crei.

Aggiorna la descrizione di una tabella

Puoi aggiornare la descrizione di una tabella nei seguenti modi:

• Utilizzo della console Google Cloud.
• Utilizzo di un'istruzione ALTER TABLE DDL (Data Definition Language).
• Viene utilizzato il comando bq update dello strumento a riga di comando bq.
• Chiamata a tables.patch API.
• Utilizzare le librerie client.

Per aggiornare la descrizione di una tabella:

Console

Non puoi aggiungere una descrizione quando crei una tabella utilizzando la console Google Cloud. Dopo aver creato la tabella, puoi aggiungere una descrizione nella pagina Dettagli.

1. Nel riquadro Explorer, espandi il progetto e il set di dati, quindi seleziona la tabella.

2. Nel riquadro dei dettagli, fai clic su Dettagli.

3. Nella sezione Descrizione, fai clic su sull'icona a forma di matita per modificare la descrizione.

   

4. Inserisci una descrizione nella casella e fai clic su Aggiorna per salvare.

SQL

Utilizza la ALTER TABLE SET OPTIONS. L'esempio seguente aggiorna la descrizione di una tabella denominata mytable:

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

   Vai a BigQuery

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

   ALTER TABLE mydataset.mytable
     SET OPTIONS (
       description = 'Description of mytable');

3. Fai clic su Esegui.

Per ulteriori informazioni su come eseguire le query, consulta Eseguire una query interattiva.

bq

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Esegui il comando bq update con il flag --description. Se aggiornare una tabella in un progetto diverso da quello predefinito, aggiungi al nome del set di dati nel seguente formato: project_id:dataset.

   bq update \
   --description "description" \
   project_id:dataset.table

   Sostituisci quanto segue:

   • description: il testo che descrive la tabella tra virgolette
   • project_id: il tuo ID progetto
   • dataset: il nome del set di dati che contiene la tabella che stai aggiornando
   • table: il nome della tabella che stai aggiornando

   Esempi:

   Per modificare la descrizione della tabella mytable nel set di dati mydataset in "Descrizione di mytable", inserisci il seguente comando. Il set di dati mydataset è in il progetto predefinito.

   bq update --description "Description of mytable" mydataset.mytable
   

   Per modificare la descrizione della tabella mytable nel set di dati mydataset in "Descrizione di mytable", inserisci il seguente comando. Il set di dati mydataset si trova nel progetto myotherproject, non nel progetto predefinito.

   bq update \
   --description "Description of mytable" \
   myotherproject:mydataset.mytable
   

API

Chiama il tables.patch e utilizza la proprietà description nella risorsa della tabella per aggiornare la descrizione della tabella. Poiché il metodo tables.update sostituisce l'intera risorsa della tabella, è preferibile il metodo tables.patch.

Vai

Prima di provare questo esempio, segui le istruzioni di configurazione Go riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta API Go BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

import (
	"context"
	"fmt"

	"cloud.google.com/go/bigquery"
)

// updateTableDescription demonstrates how to fetch a table's metadata and updates the Description metadata.
func updateTableDescription(projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// tableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	tableRef := client.Dataset(datasetID).Table(tableID)
	meta, err := tableRef.Metadata(ctx)
	if err != nil {
		return err
	}
	update := bigquery.TableMetadataToUpdate{
		Description: "Updated description.",
	}
	if _, err = tableRef.Update(ctx, update, meta.ETag); err != nil {
		return err
	}
	return nil
}

Java

Prima di provare questo esempio, segui le istruzioni di configurazione Java riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta API Java BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Table;

public class UpdateTableDescription {

  public static void runUpdateTableDescription() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String newDescription = "this is the new table description";
    updateTableDescription(datasetName, tableName, newDescription);
  }

  public static void updateTableDescription(
      String datasetName, String tableName, String newDescription) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      Table table = bigquery.getTable(datasetName, tableName);
      bigquery.update(table.toBuilder().setDescription(newDescription).build());
      System.out.println("Table description updated successfully to " + newDescription);
    } catch (BigQueryException e) {
      System.out.println("Table description was not updated \n" + e.toString());
    }
  }
}

Python

Prima di provare questo esempio, segui le istruzioni di configurazione Python riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Python.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

Configura Table.description e richiama Client.update_table() per inviare l'aggiornamento all'API.

# from google.cloud import bigquery
# client = bigquery.Client()
# project = client.project
# dataset_ref = bigquery.DatasetReference(project, dataset_id)
# table_ref = dataset_ref.table('my_table')
# table = client.get_table(table_ref)  # API request

assert table.description == "Original description."
table.description = "Updated description."

table = client.update_table(table, ["description"])  # API request

assert table.description == "Updated description."

Aggiornare la data e l'ora di scadenza di una tabella

Puoi impostare una scadenza predefinita per le tabelle a livello di set di dati oppure puoi impostare la scadenza di una tabella al momento della sua creazione. La data e l'ora di scadenza di una tabella spesso vengono indicate come "time to live" o TTL.

Quando una tabella scade, viene eliminata insieme a tutti i dati che contiene. Se necessario, puoi annullare l'eliminazione della tabella scaduta nella finestra di spostamento cronologico per il set di dati, consulta Ripristina le tabelle eliminate informazioni.

Se imposti la scadenza al momento della creazione della tabella, la tabella predefinita del set di dati la scadenza viene ignorata. Se non imposti una scadenza predefinita della tabella a livello di set di dati e non imposti una scadenza della tabella al momento della creazione, la tabella non scade mai e devi eliminarla manualmente.

In qualsiasi momento dopo la creazione della tabella, puoi aggiornarne la data di scadenza nel seguente modo:

• Utilizzo della console Google Cloud.
• Utilizzo di un'istruzione ALTER TABLE DDL (Data Definition Language).
• Utilizzo del comando bq update dello strumento a riga di comando bq.
• Chiamata al metodo dell'API tables.patch.
• Utilizzare le librerie client.

Nota: se imposti una scadenza già trascorsa, la tabella viene eliminati immediatamente.

Per aggiornare la data di scadenza di una tabella:

Console

Non puoi aggiungere una data di scadenza quando crei una tabella utilizzando la console Google Cloud. Dopo aver creato una tabella, puoi aggiungere o aggiornare scadenza nella pagina Dettagli tabella.

1. Nel riquadro Explorer, espandi il progetto e il set di dati, quindi seleziona nella tabella.

2. Nel riquadro dei dettagli, fai clic su Dettagli.

3. Fai clic sull'icona a forma di matita accanto a Informazioni tabella.

4. Per Scadenza tabella, seleziona Specifica data. Quindi seleziona data di scadenza usando il widget calendario.

5. Fai clic su Aggiorna per salvare. La data di scadenza aggiornata viene visualizzata nel Sezione Informazioni tabella.

SQL

Utilizza l'istruzione ALTER TABLE SET OPTIONS. L'esempio seguente aggiorna la scadenza di una tabella denominata mytable:

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

   Vai a BigQuery

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

   ALTER TABLE mydataset.mytable
     SET OPTIONS (
       -- Sets table expiration to timestamp 2025-02-03 12:34:56
       expiration_timestamp = TIMESTAMP '2025-02-03 12:34:56');

3. Fai clic su Esegui.

Per ulteriori informazioni su come eseguire query, consulta Eseguire una query interattiva.

bq

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Esegui il comando bq update con il flag --expiration. Se aggiornare una tabella in un progetto diverso da quello predefinito, aggiungi l'ID progetto al nome del set di dati nel seguente formato: project_id:dataset.

   bq update \
   --expiration integer \
   project_id:dataset.table

   Sostituisci quanto segue:

   • integer: la durata predefinita (in secondi) per nella tabella. Il valore minimo è 3600 secondi (un'ora). La data di scadenza viene valutata come l'ora corrente più il valore intero. Se specifichi 0, la scadenza della tabella viene rimossa e la tabella non scade mai. Tabelle senza scadenza, devono essere eliminati manualmente.
   • project_id: il tuo ID progetto.
   • dataset: il nome del set di dati che contiene la tabella che stai aggiornando.
   • table: il nome della tabella che stai aggiornando.

   Esempi:

   Per aggiornare la data e l'ora di scadenza della tabella mytable nel set di dati mydataset su 5 giorni (432000 secondi), inserisci il seguente comando. Il set di dati mydataset è in progetto predefinito.

   bq update --expiration 432000 mydataset.mytable
   

   Per aggiornare la data e l'ora di scadenza della tabella mytable nel set di dati mydataset su 5 giorni (432000 secondi), inserisci il seguente comando. Il set di dati mydataset si trova nel progetto myotherproject, non nel progetto predefinito.

   bq update --expiration 432000 myotherproject:mydataset.mytable
   

API

Chiama il metodo tables.patch e utilizza la proprietà expirationTime nella risorsa tabella per aggiornare la scadenza della tabella in millisecondi. Poiché il metodo tables.update sostituisce l'intera risorsa tabella, è preferito il metodo tables.patch.

Vai

Prima di provare questo esempio, segui le istruzioni di configurazione Go riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Go.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

import (
	"context"
	"fmt"
	"time"

	"cloud.google.com/go/bigquery"
)

// updateTableExpiration demonstrates setting the table expiration of a table to a specific point in time
// in the future, at which time it will be deleted.
func updateTableExpiration(projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// tableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	tableRef := client.Dataset(datasetID).Table(tableID)
	meta, err := tableRef.Metadata(ctx)
	if err != nil {
		return err
	}
	update := bigquery.TableMetadataToUpdate{
		ExpirationTime: time.Now().Add(time.Duration(5*24) * time.Hour), // table expiration in 5 days.
	}
	if _, err = tableRef.Update(ctx, update, meta.ETag); err != nil {
		return err
	}
	return nil
}

Java

Prima di provare questo esempio, segui le istruzioni per la configurazione di Java nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Java BigQuery documentazione di riferimento.

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Table;
import java.util.concurrent.TimeUnit;

public class UpdateTableExpiration {

  public static void runUpdateTableExpiration() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    // Update table expiration to one day.
    Long newExpiration = TimeUnit.MILLISECONDS.convert(1, TimeUnit.DAYS);
    updateTableExpiration(datasetName, tableName, newExpiration);
  }

  public static void updateTableExpiration(
      String datasetName, String tableName, Long newExpiration) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      Table table = bigquery.getTable(datasetName, tableName);
      bigquery.update(table.toBuilder().setExpirationTime(newExpiration).build());

      System.out.println("Table expiration updated successfully to " + newExpiration);
    } catch (BigQueryException e) {
      System.out.println("Table expiration was not updated \n" + e.toString());
    }
  }
}

Node.js

Prima di provare questo esempio, segui le istruzioni per la configurazione di Node.js nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Node.js BigQuery documentazione di riferimento.

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

// Import the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function updateTableExpiration() {
  // Updates a table's expiration.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = 'my_dataset', // Existing dataset
  // const tableId = 'my_table', // Existing table
  // const expirationTime = Date.now() + 1000 * 60 * 60 * 24 * 5 // 5 days from current time in ms

  // Retreive current table metadata
  const table = bigquery.dataset(datasetId).table(tableId);
  const [metadata] = await table.getMetadata();

  // Set new table expiration to 5 days from current time
  metadata.expirationTime = expirationTime.toString();
  const [apiResponse] = await table.setMetadata(metadata);

  const newExpirationTime = apiResponse.expirationTime;
  console.log(`${tableId} expiration: ${newExpirationTime}`);
}

Python

Prima di provare questo esempio, segui le istruzioni di configurazione Python riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Python.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

Configura la proprietà Table.expires e chiama Client.update_table() per inviare l'aggiornamento all'API.

# Copyright 2022 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import datetime


def update_table_expiration(table_id, expiration):
    orig_table_id = table_id
    orig_expiration = expiration

    from google.cloud import bigquery

    client = bigquery.Client()

    # TODO(dev): Change table_id to the full name of the table you want to update.
    table_id = "your-project.your_dataset.your_table_name"

    # TODO(dev): Set table to expire for desired days days from now.
    expiration = datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(
        days=5
    )

    table_id = orig_table_id
    expiration = orig_expiration

    table = client.get_table(table_id)  # Make an API request.
    table.expires = expiration
    table = client.update_table(table, ["expires"])  # API request

    print(f"Updated {table_id}, expires {table.expires}.")

Per aggiornare la data di scadenza predefinita della partizione del set di dati:

Java

Prima di provare questo esempio, segui le istruzioni per la configurazione di Java nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Java.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Dataset;
import java.util.concurrent.TimeUnit;

// Sample to update partition expiration on a dataset.
public class UpdateDatasetPartitionExpiration {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    // Set the default partition expiration (applies to new tables, only) in
    // milliseconds. This example sets the default expiration to 90 days.
    Long newExpiration = TimeUnit.MILLISECONDS.convert(90, TimeUnit.DAYS);
    updateDatasetPartitionExpiration(datasetName, newExpiration);
  }

  public static void updateDatasetPartitionExpiration(String datasetName, Long newExpiration) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      Dataset dataset = bigquery.getDataset(datasetName);
      bigquery.update(dataset.toBuilder().setDefaultPartitionExpirationMs(newExpiration).build());
      System.out.println(
          "Dataset default partition expiration updated successfully to " + newExpiration);
    } catch (BigQueryException e) {
      System.out.println("Dataset partition expiration was not updated \n" + e.toString());
    }
  }
}

Python

Prima di provare questo esempio, segui le istruzioni per la configurazione di Python nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Python.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

# Copyright 2019 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.


def update_dataset_default_partition_expiration(dataset_id: str) -> None:

    from google.cloud import bigquery

    # Construct a BigQuery client object.
    client = bigquery.Client()

    # TODO(developer): Set dataset_id to the ID of the dataset to fetch.
    # dataset_id = 'your-project.your_dataset'

    dataset = client.get_dataset(dataset_id)  # Make an API request.

    # Set the default partition expiration (applies to new tables, only) in
    # milliseconds. This example sets the default expiration to 90 days.
    dataset.default_partition_expiration_ms = 90 * 24 * 60 * 60 * 1000

    dataset = client.update_dataset(
        dataset, ["default_partition_expiration_ms"]
    )  # Make an API request.

    print(
        "Updated dataset {}.{} with new default partition expiration {}".format(
            dataset.project, dataset.dataset_id, dataset.default_partition_expiration_ms
        )
    )

Aggiorna la modalità di arrotondamento di una tabella

Puoi aggiornare la modalità di arrotondamento predefinita di una tabella utilizzando l'istruzione DDL ALTER TABLE SET OPTIONS. L'esempio seguente aggiorna la modalità di arrotondamento predefinita per mytable in ROUND_HALF_EVEN:

ALTER TABLE mydataset.mytable
SET OPTIONS (
  default_rounding_mode = "ROUND_HALF_EVEN");

Quando aggiungi un campo NUMERIC o BIGNUMERIC a una tabella e non specifichi una modalità di arrotondamento, la modalità di arrotondamento viene impostato automaticamente sulla modalità di arrotondamento predefinita della tabella. La modifica della modalità di arrotondamento predefinita di una tabella non influisce sulla modalità di arrotondamento dei campi esistenti.

Aggiornare la definizione dello schema di una tabella

Per ulteriori informazioni sull'aggiornamento della definizione dello schema di una tabella, consulta Modificare gli schemi delle tabelle.

Rinominare una tabella

Puoi rinominare una tabella dopo averla creata utilizzando il metodo ALTER TABLE RENAME TO. L'esempio seguente rinomina mytable in mynewtable:

ALTER TABLE mydataset.mytable
RENAME TO mynewtable;

Limitazioni sulla ridenominazione delle tabelle

• Se vuoi rinominare una tabella contenente flussi di dati, devi interrompere del flusso di dati e attendere che BigQuery indichi che il flusso di dati non è in uso.
• In genere, una tabella può essere rinominata entro 72 ore dall'ultima operazione di streaming, ma potrebbe essere necessario più tempo.
• Gli ACL e i criteri di accesso alle righe esistenti vengono conservati, ma gli aggiornamenti degli ACL e dei criteri di accesso alle righe apportati durante la ridenominazione della tabella non vengono conservati.
• Non puoi rinominare una tabella ed eseguire un'istruzione DML contemporaneamente.
• La ridenominazione di una tabella rimuove tutti i Tag di Data Catalog attivati nella tabella.
• Non puoi rinominare le tabelle esterne.

Copiare una tabella

Questa sezione descrive come creare una copia completa di una tabella. Per informazioni su altri tipi di tabelle copie, vedi i cloni di tabelle e snapshot delle tabelle.

Puoi copiare una tabella nei seguenti modi:

• Utilizza la console Google Cloud.
• Utilizza il comando bq cp.
• Utilizza un'istruzione DDL (Data Definition Language) CREATE TABLE COPY.
• Chiama il metodo API jobs.insert e configura un job copy.
• Utilizzare le librerie client.

Limitazioni nella copia delle tabelle

I job di copia delle tabelle sono soggetti alle seguenti limitazioni:

• Quando copi una tabella, il nome della tabella di destinazione deve rispettare le le stesse convenzioni di denominazione usate per la creazione di una tabella.
• Le copie delle tabelle sono soggette a BigQuery limiti relativi ai job di copia.
• La console Google Cloud supporta la copia di una sola tabella alla volta. Non puoi sovrascrivere una tabella esistente nel set di dati di destinazione. La tabella deve avere un nome univoco nel set di dati di destinazione.
• La copia di più tabelle di origine in una tabella di destinazione non è supportata da la console Google Cloud.

• Quando copi più tabelle di origine in una tabella di destinazione utilizzando l'API, lo strumento a riga di comando bq o le librerie client, tutte le tabelle di origine devono avere schema identici, inclusi eventuali partizioni o raggruppamenti.

  Alcuni aggiornamenti dello schema delle tabelle, ad esempio l'eliminazione o la ridenominazione colonne, può fare sì che le tabelle abbiano schemi apparentemente identici ma rappresentazioni interne. Ciò potrebbe causare l'esito negativo di un job di copia della tabella con il errore Maximum limit on diverging physical schemas reached. In questo caso, puoi utilizzare l'istruzione CREATE TABLE LIKE per assicurarti che lo schema della tabella di origine corrisponda esattamente allo schema della tabella di destinazione.

• Il tempo impiegato da BigQuery per copiare le tabelle può variare in modo significativo in diverse esecuzioni perché lo spazio di archiviazione sottostante è gestito in modo dinamico.

• Non puoi copiare e aggiungere una tabella di origine a una tabella di destinazione che ha più rispetto alla tabella di origine e le colonne aggiuntive hanno valori predefiniti. Puoi invece eseguire INSERT destination_table SELECT * FROM source_table per copiare i dati.

• Se l'operazione di copia sovrascrive una tabella esistente, la tabella a livello di tabella per la tabella esistente sia mantenuto. I tag della tabella di origine non vengono copiati nella tabella sovrascritta.

• Se l'operazione di copia crea una nuova tabella, l'accesso a livello di tabella per nuova tabella è determinata dai criteri di accesso del set di dati in cui il nuovo viene creata la tabella. Inoltre, i tag vengono copiati dalla tabella di origine alla nuova.

• Quando copi più tabelle di origine in una tabella di destinazione, tutte le tabelle di origine devono avere tag identici.

Ruoli obbligatori

Per eseguire le attività in questo documento, devi disporre delle seguenti autorizzazioni.

Ruoli per copiare tabelle e partizioni

Per ottenere le autorizzazioni necessarie per copiare tabelle e partizioni, chiedi all'amministratore di concederti Ruolo IAM Editor dati (roles/bigquery.dataEditor) sui set di dati di origine e di destinazione. Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso a progetti, cartelle e organizzazioni.

Questo ruolo predefinito contiene le autorizzazioni necessarie per copiare tabelle e partizioni. Per vedere le autorizzazioni esatte obbligatorie, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

Per copiare tabelle e partizioni sono necessarie le seguenti autorizzazioni:

• bigquery.tables.getData nei set di dati di origine e di destinazione
• bigquery.tables.get nei set di dati di origine e di destinazione
• bigquery.tables.create nel set di dati di destinazione
• bigquery.tables.update nel set di dati di destinazione

Potresti anche riuscire a ottenere queste autorizzazioni con ruoli personalizzati altri ruoli predefiniti.

Autorizzazione per eseguire un job di copia

Per ottenere l'autorizzazione necessaria per eseguire un job di copia, chiedi all'amministratore di concederti il ruolo IAM Utente job (roles/bigquery.jobUser) nei set di dati di origine e di destinazione. Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso a progetti, cartelle e organizzazioni.

Questo ruolo predefinito contiene bigquery.jobs.create autorizzazione, che è obbligatorio di eseguire un job di copia.

Potresti anche riuscire a ottenere questa autorizzazione con ruoli personalizzati altri ruoli predefiniti.

Copiare una singola tabella di origine

Puoi copiare una singola tabella nei seguenti modi:

• Utilizzo della console Google Cloud.
• Viene utilizzato il comando bq cp dello strumento a riga di comando bq.
• Utilizzo di un'istruzione CREATE TABLE COPY DDL (Data Definition Language).
• Chiamare il metodo dell'API jobs.insert, configurare un job copy e specificare la proprietà sourceTable.
• Utilizzare le librerie client.

La console Google Cloud e l'istruzione CREATE TABLE COPY supportano solo una tabella di origine e una destinazione in un job di copia. Per copiare più file di origine in una tabella di destinazione, devi utilizzare lo strumento a riga di comando bq o l'API.

Per copiare una singola tabella di origine:

Console

1. Nel riquadro Explorer, espandi il progetto e il set di dati, quindi seleziona nella tabella.

2. Nel riquadro dei dettagli, fai clic su Copia tabella.

3. Nella finestra di dialogo Copia tabella, in Destinazione:

   • In Nome progetto, scegli il progetto in cui archiviare la tabella copiata.
   • In Nome set di dati, seleziona il set di dati in cui archiviare la tabella copiata. I set di dati di origine e di destinazione devono trovarsi nella stessa località.
   • In Nome tabella, inserisci un nome per la nuova tabella. Il nome deve univoco nel set di dati di destinazione. Non puoi sovrascrivere un modello esistente nel set di dati di destinazione utilizzando la console Google Cloud. Per ulteriori informazioni sui requisiti per i nomi delle tabelle, consulta Denominazione delle tabelle.

4. Fai clic su Copia per avviare il job di copia.

SQL

Utilizza l'istruzione CREATE TABLE COPY per copiare una tabella denominata table1 in una nuova tabella denominata table1copy:

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

   Vai a BigQuery

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

   CREATE TABLE myproject.mydataset.table1copy
   COPY myproject.mydataset.table1;

3. Fai clic su Esegui.

Per ulteriori informazioni su come eseguire query, consulta Eseguire una query interattiva.

bq

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Esegui il comando bq cp. È possibile utilizzare flag facoltativi per controllare la disposizione della scrittura della tabella di destinazione:

   • -a o --append_table aggiunge i dati della tabella di origine a una tabella esistente nel set di dati di destinazione.
   • -f o --force sovrascrive una tabella esistente nel set di dati di destinazione e non richiede una conferma.
   • -n o --no_clobber restituisce il seguente messaggio di errore se la tabella esiste nel set di dati di destinazione: Table 'project_id:dataset.table' already exists, skipping. Se non viene specificato -n, il comportamento predefinito è chiederti di scegliere se sostituire la tabella di destinazione.
   • --destination_kms_key è la chiave Cloud KMS gestita dal cliente utilizzata per criptare la tabella di destinazione.

   --destination_kms_key non è stata dimostrata qui. Consulta: Protezione dei dati con le chiavi di Cloud Key Management Service per ulteriori informazioni.

   Se il set di dati di origine o di destinazione si trova in un progetto diverso da quello predefinito aggiungi l'ID progetto ai nomi del set di dati nel seguente formato: project_id:dataset.

   (Facoltativo) Fornisci il flag --location e imposta il valore sulla tua posizione.

   bq --location=location cp \
   -a -f -n \
   project_id:dataset.source_table \
   project_id:dataset.destination_table

   Sostituisci quanto segue:

   • location: il nome del luogo in cui ti trovi. Il flag --location è facoltativo. Ad esempio, se utilizzi BigQuery Regione di Tokyo, puoi impostare il valore del flag su asia-northeast1. Puoi imposta un valore predefinito per la località utilizzando File .bigqueryrc.
   • project_id: il tuo ID progetto.
   • dataset: il nome dell'origine o della destinazione del set di dati.
   • source_table: la tabella che stai copiando.
   • destination_table: il nome della tabella nel set di dati di destinazione.

   Esempi:

   Per copiare la tabella mydataset.mytable nella tabella mydataset2.mytable2, inserisci il seguente comando. Entrambi i set di dati si trovano nel tuo progetto predefinito.

   bq cp mydataset.mytable mydataset2.mytable2
   

   Per copiare la tabella mydataset.mytable e sovrascrivere una tabella di destinazione con lo stesso nome, inserisci questo comando. Il set di dati di origine si trova nel tuo progetto predefinito. Il set di dati di destinazione si trova nel progetto myotherproject. La scorciatoia -f viene utilizzata per sovrascrivere la tabella di destinazione senza un prompt.

   bq cp -f \
   mydataset.mytable \
   myotherproject:myotherdataset.mytable

   Per copiare la tabella mydataset.mytable e restituire un errore se il set di dati di destinazione contiene una tabella con lo stesso nome, inserisci il seguente comando. Il set di dati di origine si trova nel progetto predefinito. La destinazione il set di dati si trova nel progetto myotherproject. La scorciatoia -n viene utilizzata per evitare di sovrascrivere una tabella con lo stesso nome.

   bq cp -n \
   mydataset.mytable \
   myotherproject:myotherdataset.mytable

   Per copiare la tabella mydataset.mytable e aggiungere i dati a una di destinazione con lo stesso nome, inserisci il comando seguente. Il set di dati di origine si trovi nel tuo progetto predefinito. Il set di dati di destinazione si trova nel progetto myotherproject. La scorciatoia - a viene utilizzata per aggiungere elementi a tabella di destinazione.

   bq cp -a mydataset.mytable myotherproject:myotherdataset.mytable
   

API

Puoi copiare una tabella esistente tramite l'API chiamando il metodo bigquery.jobs.insert e configurare un job copy. Specifica la tua località in la proprietà location nella sezione jobReference di risorse di lavoro.

Devi specificare i seguenti valori nella configurazione del job:

"copy": {
      "sourceTable": {       // Required
        "projectId": string, // Required
        "datasetId": string, // Required
        "tableId": string    // Required
      },
      "destinationTable": {  // Required
        "projectId": string, // Required
        "datasetId": string, // Required
        "tableId": string    // Required
      },
      "createDisposition": string,  // Optional
      "writeDisposition": string,   // Optional
    },

Dove sourceTable fornisce informazioni sulla tabella da utilizzare copiato, destinationTable fornisce informazioni sul nuovo tabella, createDisposition specifica se creare se non esiste e writeDisposition specifica se sovrascrivere o aggiungere a una tabella esistente.

C#

Prima di provare questo esempio, segui le istruzioni per la configurazione di C# nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery C#.

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

using Google.Apis.Bigquery.v2.Data;
using Google.Cloud.BigQuery.V2;
using System;

public class BigQueryCopyTable
{
    public void CopyTable(
        string projectId = "your-project-id",
        string destinationDatasetId = "your_dataset_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        TableReference sourceTableRef = new TableReference()
        {
            TableId = "shakespeare",
            DatasetId = "samples",
            ProjectId = "bigquery-public-data"
        };
        TableReference destinationTableRef = client.GetTableReference(
            destinationDatasetId, "destination_table");
        BigQueryJob job = client.CreateCopyJob(
            sourceTableRef, destinationTableRef)
            .PollUntilCompleted() // Wait for the job to complete.
            .ThrowOnAnyError();

        // Retrieve destination table
        BigQueryTable destinationTable = client.GetTable(destinationTableRef);
        Console.WriteLine(
            $"Copied {destinationTable.Resource.NumRows} rows from table "
            + $"{sourceTableRef.DatasetId}.{sourceTableRef.TableId} "
            + $"to {destinationTable.FullyQualifiedId}."
        );
    }
}

Vai

Prima di provare questo esempio, segui le istruzioni per la configurazione di Go nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Go.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

import (
	"context"
	"fmt"

	"cloud.google.com/go/bigquery"
)

// copyTable demonstrates copying a table from a source to a destination, and
// allowing the copy to overwrite existing data by using truncation.
func copyTable(projectID, datasetID, srcID, dstID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// srcID := "sourcetable"
	// dstID := "destinationtable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	dataset := client.Dataset(datasetID)
	copier := dataset.Table(dstID).CopierFrom(dataset.Table(srcID))
	copier.WriteDisposition = bigquery.WriteTruncate
	job, err := copier.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}
	if err := status.Err(); err != nil {
		return err
	}
	return nil
}

Java

Prima di provare questo esempio, segui le istruzioni di configurazione Java riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Java.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.CopyJobConfiguration;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.TableId;

public class CopyTable {

  public static void runCopyTable() {
    // TODO(developer): Replace these variables before running the sample.
    String destinationDatasetName = "MY_DESTINATION_DATASET_NAME";
    String destinationTableId = "MY_DESTINATION_TABLE_NAME";
    String sourceDatasetName = "MY_SOURCE_DATASET_NAME";
    String sourceTableId = "MY_SOURCE_TABLE_NAME";

    copyTable(sourceDatasetName, sourceTableId, destinationDatasetName, destinationTableId);
  }

  public static void copyTable(
      String sourceDatasetName,
      String sourceTableId,
      String destinationDatasetName,
      String destinationTableId) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      TableId sourceTable = TableId.of(sourceDatasetName, sourceTableId);
      TableId destinationTable = TableId.of(destinationDatasetName, destinationTableId);

      // For more information on CopyJobConfiguration see:
      // https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/bigquery/JobConfiguration.html
      CopyJobConfiguration configuration =
          CopyJobConfiguration.newBuilder(destinationTable, sourceTable).build();

      // For more information on Job see:
      // https://googleapis.dev/java/google-cloud-clients/latest/index.html?com/google/cloud/bigquery/package-summary.html
      Job job = bigquery.create(JobInfo.of(configuration));

      // Blocks until this job completes its execution, either failing or succeeding.
      Job completedJob = job.waitFor();
      if (completedJob == null) {
        System.out.println("Job not executed since it no longer exists.");
        return;
      } else if (completedJob.getStatus().getError() != null) {
        System.out.println(
            "BigQuery was unable to copy table due to an error: \n" + job.getStatus().getError());
        return;
      }
      System.out.println("Table copied successfully.");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Table copying job was interrupted. \n" + e.toString());
    }
  }
}

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione Node.js riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta API Node.js BigQuery documentazione di riferimento.

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

// Import the Google Cloud client library and create a client
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function copyTable() {
  // Copies src_dataset:src_table to dest_dataset:dest_table.

  /**
   * TODO(developer): Uncomment the following lines before running the sample
   */
  // const srcDatasetId = "my_src_dataset";
  // const srcTableId = "my_src_table";
  // const destDatasetId = "my_dest_dataset";
  // const destTableId = "my_dest_table";

  // Copy the table contents into another table
  const [job] = await bigquery
    .dataset(srcDatasetId)
    .table(srcTableId)
    .copy(bigquery.dataset(destDatasetId).table(destTableId));

  console.log(`Job ${job.id} completed.`);

  // Check the job's status for errors
  const errors = job.status.errors;
  if (errors && errors.length > 0) {
    throw errors;
  }
}

PHP

Prima di provare questo esempio, segui le istruzioni per la configurazione di PHP nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API PHP BigQuery documentazione di riferimento.

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

use Google\Cloud\BigQuery\BigQueryClient;
use Google\Cloud\Core\ExponentialBackoff;

/** Uncomment and populate these variables in your code */
// $projectId = 'The Google project ID';
// $datasetId = 'The BigQuery dataset ID';
// $sourceTableId   = 'The BigQuery table ID to copy from';
// $destinationTableId = 'The BigQuery table ID to copy to';

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$sourceTable = $dataset->table($sourceTableId);
$destinationTable = $dataset->table($destinationTableId);
$copyConfig = $sourceTable->copy($destinationTable);
$job = $sourceTable->runJob($copyConfig);

// poll the job until it is complete
$backoff = new ExponentialBackoff(10);
$backoff->execute(function () use ($job) {
    print('Waiting for job to complete' . PHP_EOL);
    $job->reload();
    if (!$job->isComplete()) {
        throw new Exception('Job has not yet completed', 500);
    }
});
// check if the job has errors
if (isset($job->info()['status']['errorResult'])) {
    $error = $job->info()['status']['errorResult']['message'];
    printf('Error running job: %s' . PHP_EOL, $error);
} else {
    print('Table copied successfully' . PHP_EOL);
}

Python

Prima di provare questo esempio, segui le istruzioni di configurazione Python riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta API Python BigQuery documentazione di riferimento.

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Set source_table_id to the ID of the original table.
# source_table_id = "your-project.source_dataset.source_table"

# TODO(developer): Set destination_table_id to the ID of the destination table.
# destination_table_id = "your-project.destination_dataset.destination_table"

job = client.copy_table(source_table_id, destination_table_id)
job.result()  # Wait for the job to complete.

print("A copy of the table created.")

Copiare più tabelle di origine

Puoi copiare più tabelle di origine in una tabella di destinazione nei seguenti modi:

• Utilizzo del comando bq cp dello strumento a riga di comando bq.
• Chiamare il metodo jobs.insert, configurare un job copy e specificare la proprietà sourceTables.
• Utilizzo delle librerie client.

Tutte le tabelle di origine devono avere schemi e tag identici, ed è consentita una sola tabella di destinazione.

Le tabelle di origine devono essere specificate come elenco separato da virgole. Non puoi utilizzare gli asterischi quando copi più tabelle di origine.

Per copiare più tabelle di origine, seleziona una delle seguenti opzioni:

bq

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Esegui il comando bq cp e includi più tabelle di origine come elenco separato da virgole. È possibile usare flag facoltativi per controllare la scrittura della tabella di destinazione:

   • -a o --append_table aggiunge i dati delle tabelle di origine a una tabella esistente nel set di dati di destinazione.
   • -f o --force sovrascrive una tabella di destinazione esistente nel set di dati di destinazione e non richiede conferma.
   • -n o --no_clobber restituisce il seguente messaggio di errore se la tabella esiste nel set di dati di destinazione: Table 'project_id:dataset.table' already exists, skipping. Se -n non è specificato, il valore predefinito di scegliere se sostituire o meno la destinazione tabella.
   • --destination_kms_key è la chiave Cloud Key Management Service gestita dal cliente utilizzata per criptare la tabella di destinazione.

   --destination_kms_key non è stata dimostrata qui. Per ulteriori informazioni, consulta Proteggere i dati con le chiavi di Cloud Key Management Service.

   Se il set di dati di origine o di destinazione si trova in un progetto diverso da quello predefinito aggiungi l'ID progetto ai nomi del set di dati nel seguente formato: project_id:dataset.

   (Facoltativo) Fornisci il flag --location e imposta il valore sulla tua posizione.

   bq --location=location cp \
   -a -f -n \
   project_id:dataset.source_table,project_id:dataset.source_table \
   project_id:dataset.destination_table

   Sostituisci quanto segue:

   • location: il nome del luogo in cui ti trovi. Il flag --location è facoltativo. Ad esempio, se utilizzi BigQuery nella regione di Tokyo, puoi impostare il valore del flag su asia-northeast1. Puoi impostare un valore predefinito per la posizione utilizzando il file .bigqueryrc.
   • project_id: il tuo ID progetto.
   • dataset: il nome dell'origine o della destinazione del set di dati.
   • source_table: la tabella che stai copiando.
   • destination_table: il nome della tabella nella set di dati di destinazione.

   Esempi:

   Per copiare la tabella mydataset.mytable e la tabella mydataset.mytable2 nella tabella mydataset2.tablecopy, inserisci il seguente comando. Tutti i set di dati si trovano nel progetto predefinito.

   bq cp \
   mydataset.mytable,mydataset.mytable2 \
   mydataset2.tablecopy

   Per copiare la tabella mydataset.mytable e la tabella mydataset.mytable2 nella tabella myotherdataset.mytable e sovrascrivere una tabella di destinazione con lo stesso nome, inserisci il seguente comando. Il set di dati di destinazione si trova myotherproject, non il progetto predefinito. La scorciatoia -f è utilizzato per sovrascrivere la tabella di destinazione senza un prompt.

   bq cp -f \
   mydataset.mytable,mydataset.mytable2 \
   myotherproject:myotherdataset.mytable

   Per copiare la tabella myproject:mydataset.mytable e la tabella myproject:mydataset.mytable2 e restituire un errore se il set di dati di destinazione contiene una tabella con lo stesso nome, inserisci il seguente comando. Il set di dati di destinazione si trova nel progetto myotherproject. La La scorciatoia -n viene utilizzata per impedire la sovrascrittura di una tabella con lo stesso nome.

   bq cp -n \
   myproject:mydataset.mytable,myproject:mydataset.mytable2 \
   myotherproject:myotherdataset.mytable

   Per copiare la tabella mydataset.mytable e la tabella mydataset.mytable2 e per aggiungere i dati a una tabella di destinazione con lo stesso nome, inserisci . Il set di dati di origine si trova nel progetto predefinito. La il set di dati di destinazione si trova nel progetto myotherproject. La scorciatoia -a viene utilizzata per accodare alla tabella di destinazione.

   bq cp -a \
   mydataset.mytable,mydataset.mytable2 \
   myotherproject:myotherdataset.mytable

API

Per copiare più tabelle utilizzando l'API, chiama il metodo jobs.insert , configura un job copy della tabella e specifica la proprietà sourceTables.

Specifica la tua regione nella proprietà location nella sezione jobReference della risorsa job.

Vai

Prima di provare questo esempio, segui le istruzioni di configurazione Go riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta API Go BigQuery documentazione di riferimento.

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

import (
	"context"
	"fmt"

	"cloud.google.com/go/bigquery"
)

// copyMultiTable demonstrates using a copy job to copy multiple source tables into a single destination table.
func copyMultiTable(projectID, srcDatasetID string, srcTableIDs []string, dstDatasetID, dstTableID string) error {
	// projectID := "my-project-id"
	// srcDatasetID := "sourcedataset"
	// srcTableIDs := []string{"table1","table2"}
	// dstDatasetID = "destinationdataset"
	// dstTableID = "destinationtable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	srcDataset := client.Dataset(srcDatasetID)
	dstDataset := client.Dataset(dstDatasetID)
	var tableRefs []*bigquery.Table
	for _, v := range srcTableIDs {
		tableRefs = append(tableRefs, srcDataset.Table(v))
	}
	copier := dstDataset.Table(dstTableID).CopierFrom(tableRefs...)
	copier.WriteDisposition = bigquery.WriteTruncate
	job, err := copier.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}
	if err := status.Err(); err != nil {
		return err
	}
	return nil
}

Java

Prima di provare questo esempio, segui le istruzioni di configurazione Java riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Java.

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.CopyJobConfiguration;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.TableId;
import java.util.Arrays;

public class CopyMultipleTables {

  public static void runCopyMultipleTables() {
    // TODO(developer): Replace these variables before running the sample.
    String destinationDatasetName = "MY_DATASET_NAME";
    String destinationTableId = "MY_TABLE_NAME";
    copyMultipleTables(destinationDatasetName, destinationTableId);
  }

  public static void copyMultipleTables(String destinationDatasetName, String destinationTableId) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      TableId destinationTable = TableId.of(destinationDatasetName, destinationTableId);

      // For more information on CopyJobConfiguration see:
      // https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/bigquery/JobConfiguration.html
      CopyJobConfiguration configuration =
          CopyJobConfiguration.newBuilder(
                  destinationTable,
                  Arrays.asList(
                      TableId.of(destinationDatasetName, "table1"),
                      TableId.of(destinationDatasetName, "table2")))
              .build();

      // For more information on Job see:
      // https://googleapis.dev/java/google-cloud-clients/latest/index.html?com/google/cloud/bigquery/package-summary.html
      Job job = bigquery.create(JobInfo.of(configuration));

      // Blocks until this job completes its execution, either failing or succeeding.
      Job completedJob = job.waitFor();
      if (completedJob == null) {
        System.out.println("Job not executed since it no longer exists.");
        return;
      } else if (completedJob.getStatus().getError() != null) {
        System.out.println(
            "BigQuery was unable to copy tables due to an error: \n" + job.getStatus().getError());
        return;
      }
      System.out.println("Table copied successfully.");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Table copying job was interrupted. \n" + e.toString());
    }
  }
}

Node.js

Prima di provare questo esempio, segui le istruzioni per la configurazione di Node.js nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Node.js BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

// Import the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function copyTableMultipleSource() {
  // Copy multiple source tables to a given destination.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = "my_dataset";
  // sourceTable = 'my_table';
  // destinationTable = 'testing';

  // Create a client
  const dataset = bigquery.dataset(datasetId);

  const metadata = {
    createDisposition: 'CREATE_NEVER',
    writeDisposition: 'WRITE_TRUNCATE',
  };

  // Create table references
  const table = dataset.table(sourceTable);
  const yourTable = dataset.table(destinationTable);

  // Copy table
  const [apiResponse] = await table.copy(yourTable, metadata);
  console.log(apiResponse.configuration.copy);
}

Python

Prima di provare questo esempio, segui le istruzioni di configurazione Python riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Python.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Set dest_table_id to the ID of the destination table.
# dest_table_id = "your-project.your_dataset.your_table_name"

# TODO(developer): Set table_ids to the list of the IDs of the original tables.
# table_ids = ["your-project.your_dataset.your_table_name", ...]

job = client.copy_table(table_ids, dest_table_id)  # Make an API request.
job.result()  # Wait for the job to complete.

print("The tables {} have been appended to {}".format(table_ids, dest_table_id))

Copiare le tabelle tra regioni

Anteprima

Questo prodotto o funzionalità è soggetto ai "Termini delle Offerte pre-GA" nella sezione Termini generali del servizio dei Termini specifici del servizio. I prodotti e le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per saperne di più, consulta le descrizioni della fase di lancio.

Puoi copiare una tabella, uno snapshot della tabella o clone di tabelle da una singola BigQuery regione o più regioni a un'altra. Sono incluse tutte le tabelle a cui è stato applicato Cloud KMS (CMEK) gestito dal cliente. In questo modo comporta costi aggiuntivi secondo BigQuery prezzi.

Per copiare una tabella tra regioni, seleziona una delle seguenti opzioni:

bq

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Esegui il comando bq cp:

   bq cp \
   -f -n \
   SOURCE_PROJECT:SOURCE_DATASET.SOURCE_TABLE \
   DESTINATION_PROJECT:DESTINATION_DATASET.DESTINATION_TABLE
   

Sostituisci quanto segue:

• SOURCE_PROJECT: ID progetto di origine. Se il set di dati di origine si trova in un progetto diverso da quello predefinito progetto, aggiungi l'ID progetto al nome del set di dati di origine.

• DESTINATION_PROJECT: l'ID progetto di destinazione. Se il set di dati di destinazione si trova in un progetto diverso da quello predefinito, aggiungi l'ID progetto al nome del set di dati di destinazione.

• SOURCE_DATASET: il nome del set di dati di origine.

• DESTINATION_DATASET: il nome del set di dati di destinazione.

• SOURCE_TABLE: la tabella che stai copiando.

• DESTINATION_TABLE: il nome della tabella in il set di dati di destinazione.

  Esempi:

  Per copiare la tabella mydataset_us.mytable dalla località con più regioni us alla tabella mydataset_eu.mytable2 nella località con più regioni eu, inserisci il seguente comando. Entrambi i set di dati si trovano nel progetto predefinito.

  bq cp --sync=false mydataset_us.mytable mydataset_eu.mytable2
  

  Per copiare una tabella con CMEK abilitato, puoi creare una chiave utilizzando Cloud KMS e specificarla nel comando bq cp oppure utilizzare un set di dati di destinazione con CMEK predefinito configurato. L'esempio seguente specifica la CMEK di destinazione nel comando bq cp.

  bq cp --destination_kms_key=projects/testing/locations/us/keyRings/us_key/cryptoKeys/eu_key mydataset_us.mytable mydataset_eu.mytable2
  

API

Per copiare una tabella tra regioni utilizzando l'API, chiama il metodo jobs.insert e configurare un job copy della tabella.

Specifica la tua regione nella proprietà location nel Sezione jobReference della risorsa job.

C#

Prima di provare questo esempio, segui le istruzioni per la configurazione di C# nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API C# BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

using Google.Apis.Bigquery.v2.Data;
using Google.Cloud.BigQuery.V2;
using System;

public class BigQueryCopyTable
{
    public void CopyTable(
        string projectId = "your-project-id",
        string destinationDatasetId = "your_dataset_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        TableReference sourceTableRef = new TableReference()
        {
            TableId = "shakespeare",
            DatasetId = "samples",
            ProjectId = "bigquery-public-data"
        };
        TableReference destinationTableRef = client.GetTableReference(
            destinationDatasetId, "destination_table");
        BigQueryJob job = client.CreateCopyJob(
            sourceTableRef, destinationTableRef)
            .PollUntilCompleted() // Wait for the job to complete.
            .ThrowOnAnyError();

        // Retrieve destination table
        BigQueryTable destinationTable = client.GetTable(destinationTableRef);
        Console.WriteLine(
            $"Copied {destinationTable.Resource.NumRows} rows from table "
            + $"{sourceTableRef.DatasetId}.{sourceTableRef.TableId} "
            + $"to {destinationTable.FullyQualifiedId}."
        );
    }
}

Vai

Prima di provare questo esempio, segui le istruzioni di configurazione Go riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta API Go BigQuery documentazione di riferimento.

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

import (
	"context"
	"fmt"

	"cloud.google.com/go/bigquery"
)

// copyTable demonstrates copying a table from a source to a destination, and
// allowing the copy to overwrite existing data by using truncation.
func copyTable(projectID, datasetID, srcID, dstID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// srcID := "sourcetable"
	// dstID := "destinationtable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	dataset := client.Dataset(datasetID)
	copier := dataset.Table(dstID).CopierFrom(dataset.Table(srcID))
	copier.WriteDisposition = bigquery.WriteTruncate
	job, err := copier.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}
	if err := status.Err(); err != nil {
		return err
	}
	return nil
}

Java

Prima di provare questo esempio, segui le istruzioni di configurazione Java riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Java.

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.CopyJobConfiguration;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.TableId;

public class CopyTable {

  public static void runCopyTable() {
    // TODO(developer): Replace these variables before running the sample.
    String destinationDatasetName = "MY_DESTINATION_DATASET_NAME";
    String destinationTableId = "MY_DESTINATION_TABLE_NAME";
    String sourceDatasetName = "MY_SOURCE_DATASET_NAME";
    String sourceTableId = "MY_SOURCE_TABLE_NAME";

    copyTable(sourceDatasetName, sourceTableId, destinationDatasetName, destinationTableId);
  }

  public static void copyTable(
      String sourceDatasetName,
      String sourceTableId,
      String destinationDatasetName,
      String destinationTableId) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      TableId sourceTable = TableId.of(sourceDatasetName, sourceTableId);
      TableId destinationTable = TableId.of(destinationDatasetName, destinationTableId);

      // For more information on CopyJobConfiguration see:
      // https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/bigquery/JobConfiguration.html
      CopyJobConfiguration configuration =
          CopyJobConfiguration.newBuilder(destinationTable, sourceTable).build();

      // For more information on Job see:
      // https://googleapis.dev/java/google-cloud-clients/latest/index.html?com/google/cloud/bigquery/package-summary.html
      Job job = bigquery.create(JobInfo.of(configuration));

      // Blocks until this job completes its execution, either failing or succeeding.
      Job completedJob = job.waitFor();
      if (completedJob == null) {
        System.out.println("Job not executed since it no longer exists.");
        return;
      } else if (completedJob.getStatus().getError() != null) {
        System.out.println(
            "BigQuery was unable to copy table due to an error: \n" + job.getStatus().getError());
        return;
      }
      System.out.println("Table copied successfully.");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Table copying job was interrupted. \n" + e.toString());
    }
  }
}

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione Node.js riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Node.js.

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

// Import the Google Cloud client library and create a client
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function copyTable() {
  // Copies src_dataset:src_table to dest_dataset:dest_table.

  /**
   * TODO(developer): Uncomment the following lines before running the sample
   */
  // const srcDatasetId = "my_src_dataset";
  // const srcTableId = "my_src_table";
  // const destDatasetId = "my_dest_dataset";
  // const destTableId = "my_dest_table";

  // Copy the table contents into another table
  const [job] = await bigquery
    .dataset(srcDatasetId)
    .table(srcTableId)
    .copy(bigquery.dataset(destDatasetId).table(destTableId));

  console.log(`Job ${job.id} completed.`);

  // Check the job's status for errors
  const errors = job.status.errors;
  if (errors && errors.length > 0) {
    throw errors;
  }
}

PHP

Prima di provare questo esempio, segui le istruzioni per la configurazione di PHP nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API PHP BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

use Google\Cloud\BigQuery\BigQueryClient;
use Google\Cloud\Core\ExponentialBackoff;

/** Uncomment and populate these variables in your code */
// $projectId = 'The Google project ID';
// $datasetId = 'The BigQuery dataset ID';
// $sourceTableId   = 'The BigQuery table ID to copy from';
// $destinationTableId = 'The BigQuery table ID to copy to';

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$sourceTable = $dataset->table($sourceTableId);
$destinationTable = $dataset->table($destinationTableId);
$copyConfig = $sourceTable->copy($destinationTable);
$job = $sourceTable->runJob($copyConfig);

// poll the job until it is complete
$backoff = new ExponentialBackoff(10);
$backoff->execute(function () use ($job) {
    print('Waiting for job to complete' . PHP_EOL);
    $job->reload();
    if (!$job->isComplete()) {
        throw new Exception('Job has not yet completed', 500);
    }
});
// check if the job has errors
if (isset($job->info()['status']['errorResult'])) {
    $error = $job->info()['status']['errorResult']['message'];
    printf('Error running job: %s' . PHP_EOL, $error);
} else {
    print('Table copied successfully' . PHP_EOL);
}

Python

Prima di provare questo esempio, segui le istruzioni di configurazione Python riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta API Python BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Set source_table_id to the ID of the original table.
# source_table_id = "your-project.source_dataset.source_table"

# TODO(developer): Set destination_table_id to the ID of the destination table.
# destination_table_id = "your-project.destination_dataset.destination_table"

job = client.copy_table(source_table_id, destination_table_id)
job.result()  # Wait for the job to complete.

print("A copy of the table created.")

Limitazioni

La copia di una tabella tra regioni è soggetta alle seguenti limitazioni:

• Non puoi copiare una tabella utilizzando la console Google Cloud o la TABLE COPY DDL l'Informativa.
• Non puoi copiare una tabella se nella tabella di origine sono presenti tag di criteri.
• Non puoi copiare i criteri IAM associati alle tabelle. Puoi applicare gli stessi criteri alla destinazione al termine della copia.
• Non puoi copiare più tabelle di origine in un'unica tabella di destinazione.
• Non puoi copiare le tabelle in modalità di aggiunta.
• Le informazioni relative al viaggio nel tempo non vengono copiate nella regione di destinazione.
• I cloni delle tabelle vengono convertiti in una copia completa nella regione di destinazione.

Visualizzare l'utilizzo attuale delle quote

Puoi visualizzare l'utilizzo corrente dei job di query, caricamento, estrazione o copia eseguendo una query INFORMATION_SCHEMA per visualizzare i metadati dei job eseguiti in un periodo di tempo specificato. Puoi confrontare il tuo utilizzo attuale con la quota per determinare l'utilizzo della quota per un particolare tipo di job. Le seguenti query di esempio utilizza la vista INFORMATION_SCHEMA.JOBS per elencare il numero esegui query, carica, estrai e copia i job in base al progetto:

SELECT
  sum(case  when job_type="QUERY" then 1 else 0 end) as QRY_CNT,
  sum(case  when job_type="LOAD" then 1 else 0 end) as LOAD_CNT,
  sum(case  when job_type="EXTRACT" then 1 else 0 end) as EXT_CNT,
  sum(case  when job_type="COPY" then 1 else 0 end) as CPY_CNT
FROM `region-eu`.INFORMATION_SCHEMA.JOBS_BY_PROJECT
WHERE date(creation_time)= CURRENT_DATE()

Nota: la visualizzazione INFORMATION_SCHEMA non mostra i job di copia tra regioni.

Per visualizzare i limiti di quota per i job di copia, consulta Quote e limiti - Job di copia.

Elimina tabelle

Puoi eliminare una tabella nei seguenti modi:

• Utilizzo della console Google Cloud.
• Utilizzo di un'istruzione DROP TABLE DDL (Data Definition Language).
• Utilizzo dello strumento a riga di comando bq bq rm.
• Chiamata al metodo dell'API tables.delete.
• Utilizzo delle librerie client.

Per eliminare tutte le tabelle nel set di dati, elimina il set di dati.

Quando elimini una tabella, vengono eliminati anche tutti i dati al suo interno. Per eliminare automaticamente le tabelle dopo un determinato periodo di tempo, imposta la scadenza predefinita della tabella per il set di dati o imposta la data e l'ora di scadenza quando crei la tabella.

Se elimini una tabella, vengono eliminate anche le eventuali autorizzazioni associate. Quando devi ricreare una tabella eliminata, devi anche riconfigurare manualmente le eventuali autorizzazioni di accesso associate in precedenza.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per eliminare una tabella, chiedi all'amministratore di concederti Ruolo IAM Editor dati (roles/bigquery.dataEditor) nel set di dati. Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso a progetti, cartelle e organizzazioni.

Questo ruolo predefinito contiene le autorizzazioni necessarie per eliminare una tabella. Per visualizzare le autorizzazioni esatte richieste, espandi la sezione Autorizzazioni richieste:

Autorizzazioni obbligatorie

Per eliminare una tabella sono necessarie le seguenti autorizzazioni:

• bigquery.tables.delete
• bigquery.tables.get

Potresti anche ottenere queste autorizzazioni con ruoli personalizzati o altri ruoli predefiniti.

Eliminazione di una tabella

Per eliminare una tabella:

Console

1. Nel riquadro Explorer, espandi il progetto e il set di dati, quindi seleziona la tabella.

2. Nel riquadro dei dettagli, fai clic su Elimina tabella.

3. Digita "delete" nella finestra di dialogo, quindi fai clic su Elimina per confermare.

SQL

Utilizza l'istruzione DROP TABLE. L'esempio seguente elimina una tabella denominata mytable:

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

   Vai a BigQuery

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

   DROP TABLE mydataset.mytable;

3. Fai clic su Esegui.

Per ulteriori informazioni su come eseguire query, consulta Eseguire una query interattiva.

bq

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Utilizza il comando bq rm con il flag --table (o la scorciatoia -t) per eliminare una tabella. Quando utilizzi lo strumento a riga di comando bq per rimuovere una tabella, devi confermare un'azione. Puoi utilizzare il flag --force (o la scorciatoia -f) per saltare la conferma.

   Se la tabella si trova in un set di dati di un progetto diverso da quello predefinito aggiungi l'ID progetto al nome del set di dati nel seguente formato: project_id:dataset.

   bq rm \
   -f \
   -t \
   project_id:dataset.table

   Sostituisci quanto segue:

   • project_id: il tuo ID progetto
   • dataset: il nome del set di dati che contiene la tabella
   • table: il nome della tabella che stai eliminando

   Esempi:

   Per eliminare la tabella mytable dal set di dati mydataset, inserisci il comando seguente. Il set di dati mydataset si trova nel tuo progetto predefinito.

   bq rm -t mydataset.mytable
   

   Per eliminare la tabella mytable dal set di dati mydataset, inserisci il comando seguente. Il set di dati mydataset si trova in myotherproject progetto predefinito, non quello predefinito.

   bq rm -t myotherproject:mydataset.mytable
   

   Per eliminare la tabella mytable dal set di dati mydataset, inserisci il comando seguente. Il set di dati mydataset è nel progetto predefinito. La usa la scorciatoia -f per bypassare la conferma.

   bq rm -f -t mydataset.mytable
   

   Nota: puoi inserire il valore bq ls dataset nello strumento a riga di comando bq per confermare che una tabella è stata rimossa da un set di dati.

API

Chiama il tables.delete API e specifica la tabella da eliminare utilizzando il parametro tableId.

C#

Prima di provare questo esempio, segui le istruzioni per la configurazione di C# nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery C#.

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

using Google.Cloud.BigQuery.V2;
using System;

public class BigQueryDeleteTable
{
    public void DeleteTable(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id",
        string tableId = "your_table_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        client.DeleteTable(datasetId, tableId);
        Console.WriteLine($"Table {tableId} deleted.");
    }
}

Vai

Prima di provare questo esempio, segui le istruzioni di configurazione Go riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Go.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

import (
	"context"
	"fmt"

	"cloud.google.com/go/bigquery"
)

// deleteTable demonstrates deletion of a BigQuery table.
func deleteTable(projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// tableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	table := client.Dataset(datasetID).Table(tableID)
	if err := table.Delete(ctx); err != nil {
		return err
	}
	return nil
}

Java

Prima di provare questo esempio, segui le istruzioni per la configurazione di Java nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Java BigQuery documentazione di riferimento.

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.TableId;

public class DeleteTable {

  public static void runDeleteTable() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    deleteTable(datasetName, tableName);
  }

  public static void deleteTable(String datasetName, String tableName) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();
      boolean success = bigquery.delete(TableId.of(datasetName, tableName));
      if (success) {
        System.out.println("Table deleted successfully");
      } else {
        System.out.println("Table was not found");
      }
    } catch (BigQueryException e) {
      System.out.println("Table was not deleted. \n" + e.toString());
    }
  }
}

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione Node.js riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta API Node.js BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

// Import the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function deleteTable() {
  // Deletes "my_table" from "my_dataset".

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = "my_dataset";
  // const tableId = "my_table";

  // Delete the table
  await bigquery
    .dataset(datasetId)
    .table(tableId)
    .delete();

  console.log(`Table ${tableId} deleted.`);
}

PHP

Prima di provare questo esempio, segui le istruzioni di configurazione PHP riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta API PHP BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

use Google\Cloud\BigQuery\BigQueryClient;

/** Uncomment and populate these variables in your code */
// $projectId = 'The Google project ID';
// $datasetId = 'The BigQuery dataset ID';
// $tableId = 'The BigQuery table ID';

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$table = $dataset->table($tableId);
$table->delete();
printf('Deleted table %s.%s' . PHP_EOL, $datasetId, $tableId);

Python

Prima di provare questo esempio, segui le istruzioni di configurazione Python riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta API Python BigQuery documentazione di riferimento.

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Set table_id to the ID of the table to fetch.
# table_id = 'your-project.your_dataset.your_table'

# If the table does not exist, delete_table raises
# google.api_core.exceptions.NotFound unless not_found_ok is True.
client.delete_table(table_id, not_found_ok=True)  # Make an API request.
print("Deleted table '{}'.".format(table_id))

Ruby

Prima di provare questo esempio, segui le istruzioni di configurazione Ruby riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Ruby.

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

require "google/cloud/bigquery"

def delete_table dataset_id = "my_dataset_id", table_id = "my_table_id"
  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id
  table    = dataset.table table_id

  table.delete

  puts "Table #{table_id} deleted."
end

Ripristinare le tabelle eliminate

Puoi annullare l'eliminazione di una tabella nella finestra di spostamento cronologico specificata per incluse le eliminazioni esplicite e implicite dovute a la scadenza della tabella. Hai la possibilità di per configurare la finestra di spostamento cronologico. Per annullare l'eliminazione di un intero set di dati, consulta Annulla l'eliminazione dei set di dati.

La finestra di spostamento cronologico può avere una durata compresa tra due e sette giorni. Una volta trascorsa la finestra di viaggio nel tempo, non è possibile annullare l'eliminazione di una tabella utilizzando alcun metodo, inclusa l'apertura di un ticket dell'assistenza.

Quando ripristini una tabella dai dati storici, i tag della tabella di origine non vengono copiati nella tabella di destinazione.

Puoi ripristinare una tabella che è stata eliminata, ma che si trova ancora nel periodo di tempo selezionato, copiandola in una nuova tabella utilizzando il decoratore di tempo @<time>. Per copiare la tabella, puoi utilizzare lo strumento a riga di comando bq o le librerie client:

Console

Non puoi annullare l'eliminazione di una tabella utilizzando la console Google Cloud.

bq

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Per ripristinare una tabella, devi prima determinare un timestamp UNIX della data e dell'esistenza della tabella (in millisecondi). Puoi utilizzare il comando date di Linux per generare il timestamp Unix da un valore timestamp normale:

   date -d '2023-08-04 16:00:34.456789Z' +%s000
   

3. Quindi, utilizza il comando bq copy con il decoratore di viaggio nel tempo @<time> per eseguire l'operazione di copia della tabella.

   Ad esempio, inserisci il seguente comando per copiare tabella mydataset.mytable nel momento 1418864998000 in una nuova tabella mydataset.newtable.

   bq cp mydataset.mytable@1418864998000 mydataset.newtable
   

   (Facoltativo) Fornisci il flag --location e imposta il valore sulla tua posizione.

   Puoi anche specificare un offset relativo. L'esempio seguente copia versione di una tabella di un'ora fa:

   bq cp mydataset.mytable@-3600000 mydataset.newtable
   

   Per ulteriori informazioni, consulta Ripristinare una tabella da un determinato punto nel tempo.

Vai

Prima di provare questo esempio, segui le istruzioni per la configurazione di Go nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Go BigQuery documentazione di riferimento.

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

import (
	"context"
	"fmt"
	"time"

	"cloud.google.com/go/bigquery"
)

// deleteAndUndeleteTable demonstrates how to recover a deleted table by copying it from a point in time
// that predates the deletion event.
func deleteAndUndeleteTable(projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// tableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	ds := client.Dataset(datasetID)
	if _, err := ds.Table(tableID).Metadata(ctx); err != nil {
		return err
	}
	// Record the current time.  We'll use this as the snapshot time
	// for recovering the table.
	snapTime := time.Now()

	// "Accidentally" delete the table.
	if err := client.Dataset(datasetID).Table(tableID).Delete(ctx); err != nil {
		return err
	}

	// Construct the restore-from tableID using a snapshot decorator.
	snapshotTableID := fmt.Sprintf("%s@%d", tableID, snapTime.UnixNano()/1e6)
	// Choose a new table ID for the recovered table data.
	recoverTableID := fmt.Sprintf("%s_recovered", tableID)

	// Construct and run a copy job.
	copier := ds.Table(recoverTableID).CopierFrom(ds.Table(snapshotTableID))
	copier.WriteDisposition = bigquery.WriteTruncate
	job, err := copier.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}
	if err := status.Err(); err != nil {
		return err
	}

	ds.Table(recoverTableID).Delete(ctx)
	return nil
}

Java

Prima di provare questo esempio, segui le istruzioni di configurazione Java riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta API Java BigQuery documentazione di riferimento.

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.CopyJobConfiguration;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.TableId;

// Sample to undeleting a table
public class UndeleteTable {

  public static void runUndeleteTable() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_TABLE";
    String recoverTableName = "MY_RECOVER_TABLE_TABLE";
    undeleteTable(datasetName, tableName, recoverTableName);
  }

  public static void undeleteTable(String datasetName, String tableName, String recoverTableName) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      // "Accidentally" delete the table.
      bigquery.delete(TableId.of(datasetName, tableName));

      // Record the current time.  We'll use this as the snapshot time
      // for recovering the table.
      long snapTime = System.currentTimeMillis();

      // Construct the restore-from tableID using a snapshot decorator.
      String snapshotTableId = String.format("%s@%d", tableName, snapTime);

      // Construct and run a copy job.
      CopyJobConfiguration configuration =
          CopyJobConfiguration.newBuilder(
                  // Choose a new table ID for the recovered table data.
                  TableId.of(datasetName, recoverTableName),
                  TableId.of(datasetName, snapshotTableId))
              .build();

      Job job = bigquery.create(JobInfo.of(configuration));
      job = job.waitFor();
      if (job.isDone() && job.getStatus().getError() == null) {
        System.out.println("Undelete table recovered successfully.");
      } else {
        System.out.println(
            "BigQuery was unable to copy the table due to an error: \n"
                + job.getStatus().getError());
        return;
      }
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Table not found. \n" + e.toString());
    }
  }
}

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione Node.js riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta API Node.js BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

// Import the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function undeleteTable() {
  // Undeletes "my_table_to_undelete" from "my_dataset".

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = "my_dataset";
  // const tableId = "my_table_to_undelete";
  // const recoveredTableId = "my_recovered_table";

  /**
   * TODO(developer): Choose an appropriate snapshot point as epoch milliseconds.
   * For this example, we choose the current time as we're about to delete the
   * table immediately afterwards.
   */
  const snapshotEpoch = Date.now();

  // Delete the table
  await bigquery
    .dataset(datasetId)
    .table(tableId)
    .delete();

  console.log(`Table ${tableId} deleted.`);

  // Construct the restore-from table ID using a snapshot decorator.
  const snapshotTableId = `${tableId}@${snapshotEpoch}`;

  // Construct and run a copy job.
  await bigquery
    .dataset(datasetId)
    .table(snapshotTableId)
    .copy(bigquery.dataset(datasetId).table(recoveredTableId));

  console.log(
    `Copied data from deleted table ${tableId} to ${recoveredTableId}`
  );
}

Python

Prima di provare questo esempio, segui le istruzioni di configurazione Python riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Python.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

import time

from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Choose a table to recover.
# table_id = "your-project.your_dataset.your_table"

# TODO(developer): Choose a new table ID for the recovered table data.
# recovered_table_id = "your-project.your_dataset.your_table_recovered"

# TODO(developer): Choose an appropriate snapshot point as epoch
# milliseconds. For this example, we choose the current time as we're about
# to delete the table immediately afterwards.
snapshot_epoch = int(time.time() * 1000)

# ...

# "Accidentally" delete the table.
client.delete_table(table_id)  # Make an API request.

# Construct the restore-from table ID using a snapshot decorator.
snapshot_table_id = "{}@{}".format(table_id, snapshot_epoch)

# Construct and run a copy job.
job = client.copy_table(
    snapshot_table_id,
    recovered_table_id,
    # Must match the source and destination tables location.
    location="US",
)  # Make an API request.

job.result()  # Wait for the job to complete.

print(
    "Copied data from deleted table {} to {}".format(table_id, recovered_table_id)
)

Se prevedi di voler ripristinare una tabella in un momento successivo a quello consentito dalla finestra di viaggio nel tempo, crea uno snapshot della tabella. Per ulteriori informazioni, consulta Snapshot delle tabelle.

Sicurezza delle tabelle

Per controllare l'accesso alle tabelle in BigQuery, consulta Introduzione ai controlli di accesso alle tabelle.

Passaggi successivi

• Per saperne di più sulla creazione e sull'utilizzo delle tabelle, consulta Creare e utilizzare le tabelle.
• Per ulteriori informazioni sulla gestione dei dati, consulta Utilizzare i dati delle tabelle.
• Per ulteriori informazioni su come specificare gli schemi delle tabelle, consulta la sezione Specifica di uno schema.
• Per saperne di più sulla modifica degli schemi delle tabelle, consulta Modifica degli schemi delle tabelle.
• Per saperne di più sui set di dati, consulta Introduzione ai set di dati.
• Per ulteriori informazioni sulle viste, consulta Introduzione alle viste.