Gestire le 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 richieste per eseguire un'attività (se presenti) sono elencate nella sezione "Autorizzazioni richieste" 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à delle tabelle, chiedi all'amministratore di concederti il ruolo IAM Editor di 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à delle tabelle. 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 ottenere queste autorizzazioni con ruoli personalizzati o altri ruoli predefiniti.

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

Aggiornare la descrizione di una tabella

Puoi aggiornare la descrizione di una tabella nei seguenti modi:

• Utilizzando la 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 del metodo dell'API tables.patch.
• Utilizzo delle 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 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 l'istruzione 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 di 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 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 stai aggiornando 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 \
   --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 da aggiornare

   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 si trova nel tuo 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 metodo tables.patch e utilizza la proprietà description nella risorsa tabella per aggiornare la descrizione della tabella. Poiché il metodo tables.update sostituisce l'intera risorsa 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 la documentazione di riferimento dell'API BigQuery Go.

Per autenticarti in 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"
)

// 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 la documentazione di riferimento dell'API BigQuery Java.

Per autenticarti in 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;

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 autenticarti in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

Configura la proprietà Table.description e chiama 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/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 "durata" o TTL.

Quando una tabella scade, viene eliminata insieme a tutti i dati in essa contenuti. Se necessario, puoi annullare l'eliminazione della tabella scaduta entro la finestra di viaggio nel tempo specificata per il set di dati. Per ulteriori informazioni, consulta Ripristinare le tabelle eliminate.

Se imposti la scadenza al momento della creazione della tabella, la scadenza predefinita della tabella del set di dati 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:

• Utilizzando la 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 del metodo dell'API tables.patch.
• Utilizzo delle librerie client.

Nota: se imposti una data e un'ora di scadenza che sono già trascorse, la tabella viene eliminata immediatamente.

Per aggiornare la data/ora 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 aggiornarne la scadenza nella pagina Dettagli tabella.

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. Fai clic sull'icona a forma di matita accanto a Informazioni tabella.

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

5. Fai clic su Aggiorna per salvare. L'ora di scadenza aggiornata viene visualizzata nella sezione Informazioni tabella.

SQL

Utilizza l'istruzione ALTER TABLE SET OPTIONS. L'esempio seguente aggiorna la data e l'ora di 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 stai aggiornando 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 la 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. Le tabelle senza scadenza devono essere eliminate 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 da aggiornare.

   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 si trova nel tuo 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 autenticarti in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare 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 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 in 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 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 in 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 autenticarti in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare 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 e l'ora di scadenza predefinite della partizione del set di dati:

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 in 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.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 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 autenticarti in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare 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
        )
    )

Aggiornare 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 su 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 impostata automaticamente su quella 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 l'istruzione ALTER TABLE RENAME TO. Nell'esempio seguente, mytable viene rinominato in mynewtable:

ALTER TABLE mydataset.mytable
RENAME TO mynewtable;

Limitazioni alla ridenominazione delle tabelle

• Se vuoi rinominare una tabella in cui vengono inseriti dati in streaming, devi interrompere lo streaming, eseguire il commit di eventuali stream in attesa e attendere che BigQuery indichi che lo streaming non è in uso.
• Sebbene in genere sia possibile rinominare una tabella 5 ore dopo l'ultima operazione di streaming, 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 contemporaneamente una tabella ed eseguire un'istruzione DML su quella tabella.
• La ridenominazione di una tabella rimuove tutti i tag del Catalogo di dati 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 copie di tabelle, consulta 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.
• Utilizza le librerie client.

Limitazioni relative alla 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 stesse convenzioni di denominazione utilizzate per creare una tabella.
• Le copie delle tabelle sono soggette ai limiti di BigQuery per i 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 dalla 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, come l'eliminazione o la ridenominazione delle colonne, possono causare schemi apparentemente identici, ma rappresentazioni interne diverse. Ciò potrebbe causare il fallimento di un job di copia della tabella con l'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 necessario a BigQuery per copiare le tabelle può variare notevolmente in base alle diverse esecuzioni perché lo spazio di archiviazione sottostante è gestito in modo dinamico.

• Non puoi copiare e accodare una tabella di origine a una tabella di destinazione con più colonne e le colonne aggiuntive hanno valori predefiniti. In alternativa, puoi eseguire INSERT destination_table SELECT * FROM source_table per copiare i dati.

• Se l'operazione di copia sovrascrive una tabella esistente, l'accesso a livello di tabella per la tabella esistente viene mantenuto. I tag della tabella di origine non vengono copiati nella tabella sovrascritta, mentre i tag della tabella esistente vengono mantenuti. Tuttavia, quando copi le tabelle tra regioni, i tag nella tabella esistente vengono rimossi.

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

• 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à descritte 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 il ruolo IAM Editor di dati (roles/bigquery.dataEditor) 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 le autorizzazioni necessarie per copiare tabelle e partizioni. Per visualizzare le autorizzazioni esatte richieste, espandi la sezione Autorizzazioni richieste:

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 ottenere queste autorizzazioni con ruoli personalizzati o 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) per i 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 l'autorizzazione bigquery.jobs.create necessaria per eseguire un job di copia.

Potresti anche ottenere questa autorizzazione con ruoli personalizzati o altri ruoli predefiniti.

Copiare una singola tabella di origine

Puoi copiare una singola tabella nei seguenti modi:

• Utilizzando la console Google Cloud.
• Utilizzo del 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.
• Utilizzo delle librerie client.

La console Google Cloud e l'istruzione CREATE TABLE COPY supportano solo una tabella di origine e una tabella di 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 la 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.
   • Per Nome set di dati, seleziona il set di dati in cui vuoi archiviare la tabella copiata. I set di dati di origine e di destinazione devono trovarsi nella stessa posizione.
   • In Nome tabella, inserisci un nome per la nuova tabella. Il nome deve essere univoco nel set di dati di destinazione. Non puoi sovrascrivere una tabella esistente nel set di dati di destinazione utilizzando la console Google Cloud. Per ulteriori informazioni sui requisiti per i nomi delle tabelle, consulta Denominatione 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 di 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 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 è dimostrato qui. Per saperne di più, 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 dei 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 della tua località. 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 del set di dati di origine o di destinazione.
   • 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 il seguente 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. Il set di dati di destinazione si trova nel progetto myotherproject. La scorciatoia -n viene utilizzata per impedire la sovrascrittura di una tabella con lo stesso nome.

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

   Per copiare la tabella mydataset.mytable e accodare i dati a una tabella di destinazione con lo stesso nome, inserisci il seguente 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 - a viene utilizzata per accodare alla 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 configurando un job copy. Specifica la tua posizione nella proprietà location nella sezione jobReference della risorsa job.

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 copiare, destinationTable fornisce informazioni sulla nuova tabella, createDisposition specifica se creare la tabella se non esiste e writeDisposition specifica se sovrascrivere o accodare una tabella esistente.

C#

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

Per autenticarti in BigQuery, configura le 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 la documentazione di riferimento dell'API BigQuery Go.

Per autenticarti in 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"
)

// 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 in 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.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 in 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 di configurazione PHP riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery PHP.

Per autenticarti in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare 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 la documentazione di riferimento dell'API BigQuery Python.

Per autenticarti in 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 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 e è consentita una sola tabella di destinazione.

Le tabelle di origine devono essere specificate come elenco separato da virgole. Non puoi utilizzare i caratteri jolly 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 utilizzare flag facoltativi per controllare la disposizione della 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 non è specificato -n, il comportamento predefinito è chiederti di scegliere se sostituire la tabella di destinazione.
   • --destination_kms_key è la chiave Cloud Key Management Service gestita dal cliente utilizzata per criptare la tabella di destinazione.

   --destination_kms_key non è dimostrato qui. Per saperne di più, 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 dei 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 della tua località. 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 del set di dati di origine o di destinazione.
   • 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 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 nel progetto myotherproject, non nel progetto predefinito. La scorciatoia -f viene utilizzata 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 scorciatoia -n viene utilizzata per impedire l'overwriting 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 aggiungere i dati a una tabella di destinazione con lo stesso nome, inserisci il seguente comando. Il set di dati di origine si trova nel progetto predefinito. 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 la documentazione di riferimento dell'API BigQuery Go.

Per autenticarti in 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 in 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.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 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 in 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 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 autenticarti in 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 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 un clone della tabella da una regione BigQuery o multiregione a un'altra. Sono incluse tutte le tabelle a cui è stato applicato Cloud KMS (CMEK) gestito dal cliente. In questo modo, si incorrono in costi aggiuntivi in base ai prezzi di BigQuery.

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, 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 nel 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 tuo 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 il 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 configura un job copy della tabella.

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

C#

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

Per autenticarti in BigQuery, configura le 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 la documentazione di riferimento dell'API BigQuery Go.

Per autenticarti in 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"
)

// 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 in 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.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 in 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 di configurazione PHP riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery PHP.

Per autenticarti in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare 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 la documentazione di riferimento dell'API BigQuery Python.

Per autenticarti in 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 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 l'istruzione TABLE COPY DDL.
• Non puoi copiare una tabella se nella tabella di origine sono presenti tag di criteri.
• Non puoi copiare una tabella se la tabella di origine è più grande di 20 TiB fisici. Per informazioni sulle dimensioni fisiche della tabella di origine, consulta Ottenere informazioni sulle tabelle.
• Non puoi copiare i criteri IAM associati alle tabelle. Puoi applicare gli stessi criteri alla destinazione al termine della copia.
• Se l'operazione di copia sovrascrive una tabella esistente, i tag nella tabella esistente vengono rimossi.
• Non puoi copiare più tabelle di origine in un'unica tabella di destinazione.
• Non puoi copiare le tabelle in modalità di accodamento.
• 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 l'utilizzo corrente con il limite di quota per determinare l'utilizzo della quota per un determinato tipo di job. La seguente query di esempio utilizza la vista INFORMATION_SCHEMA.JOBS per elencare il numero di job di query, caricamento, estrazione e copia per 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.

Eliminare le tabelle

Puoi eliminare una tabella nei seguenti modi:

• Utilizzando la console Google Cloud.
• Utilizzo di un'istruzione DROP TABLE DDL (Data Definition Language).
• Utilizzo del comando bq rm dello strumento a riga di comando bq.
• Chiamata del 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 la data e l'ora di scadenza quando crei la tabella.

L'eliminazione di una tabella comporta anche l'eliminazione di eventuali autorizzazioni associate. Quando riesegui la creazione di una tabella eliminata, devi anche riconfigurare manualmente le autorizzazioni di accesso precedentemente associate.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per eliminare una tabella, chiedi all'amministratore di concederti il ruolo IAM Editor di 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 l'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 da eliminare

   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 nel progetto myotherproject, non nel progetto 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 si trova nel tuo progetto predefinito. Il comando utilizza la scorciatoia -f per bypassare la conferma.

   bq rm -f -t mydataset.mytable
   

   Nota: puoi inserire il comando 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 metodo API tables.delete e specifica la tabella da eliminare utilizzando il parametro tableId.

C#

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

Per autenticarti in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare 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 autenticarti in 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"
)

// 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 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 in 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 la documentazione di riferimento dell'API BigQuery Node.js.

Per autenticarti in 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 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 la documentazione di riferimento dell'API BigQuery PHP.

Per autenticarti in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare 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 la documentazione di riferimento dell'API BigQuery Python.

Per autenticarti in 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 in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare 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 all'interno del periodo di viaggio nel tempo specificato per il set di dati, incluse le eliminazioni esplicite e implicite dovute alla scadenza della tabella. Puoi configurare la finestra di spostamento cronologico. Per annullare l'eliminazione di un intero set di dati, consulta Annullare l'eliminazione dei set di dati.

La finestra di spostamento nel tempo può avere una durata compresa tra due e sette giorni. Una volta trascorsa la finestra di viaggio nel tempo, BigQuery fornisce un periodo di sicurezza in cui i dati eliminati vengono conservati automaticamente per altri sette giorni. Una volta trascorso il periodo di sicurezza, non è possibile annullare l'eliminazione di una tabella utilizzando alcun metodo, incluso l'apertura di un ticket di 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 del 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'ora in cui la tabella esisteva (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 la tabella mydataset.mytable al 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 la 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 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 autenticarti in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare 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 la documentazione di riferimento dell'API BigQuery Java.

Per autenticarti in 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.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 la documentazione di riferimento dell'API BigQuery Node.js.

Per autenticarti in 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 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 autenticarti in BigQuery, configura le 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 della tabella

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 Specificare uno schema.
• Per ulteriori informazioni sulla modifica degli schemi delle tabelle, consulta Modificare gli 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.