Administra tablas

En este documento, se describe cómo administrar tablas en BigQuery. Puedes administrar tus tablas de BigQuery de las siguientes maneras:

• Actualiza estas características de una tabla:
  • Fecha y hora de vencimiento
  • Descripción
  • Definición de esquema
  • Etiquetas
• Renombra (copia) una tabla.
• Copia una tabla
• Borra una tabla
• Restablece una tabla borrada

Para obtener más información sobre cómo crear y usar tablas, además de cómo obtener de información de las tablas, las listas de tablas y el control de acceso a los datos de estas, consulta Crea y usa tablas.

Actualiza las propiedades de las tablas

Puedes actualizar los siguientes elementos de una tabla:

• Descripción
• Hora de vencimiento
• Definición de esquema
• Etiquetas

Permisos necesarios

Como mínimo, para actualizar una tabla, debes tener los permisos bigquery.tables.update y bigquery.tables.get. En las siguientes funciones predefinidas de IAM, se incluyen los permisos bigquery.tables.update y bigquery.tables.get:

• bigquery.dataEditor
• bigquery.dataOwner
• bigquery.admin

Además, si un usuario tiene permisos bigquery.datasets.create, se le otorga el acceso bigquery.dataOwner cuando crea un conjunto de datos. El acceso bigquery.dataOwner otorga a los usuarios la capacidad de actualizar las propiedades de la tabla en los conjuntos de datos que crean.

Para obtener más información sobre las funciones y los permisos de IAM en BigQuery, consulta Funciones y permisos predefinidos.

Actualiza la descripción de una tabla

Puedes actualizar la descripción de una tabla de las siguientes maneras:

• Usa Cloud Console.
• Una declaración DDL ALTER TABLE
• Usa el comando bq de la herramienta de línea de comandos bq update
• Mediante una llamada al método de la API tables.patch
• Usa las bibliotecas cliente.

Para actualizar la descripción de una tabla, haz lo siguiente:

Console

Cuando creas una tabla mediante Cloud Console, no puedes agregar una descripción. Después de crear la tabla, puedes agregar una en la página de Detalles (Details).

1. En el panel Explorador, expande el proyecto y conjunto de datos y, luego, selecciona la tabla.

   Nota: La experiencia predeterminada es la vista previa de Cloud Console. Si hiciste clic en Hide preview features para ir a Cloud Console con disponibilidad general, realiza el siguiente paso: en la sección Recursos del panel de navegación, expande tu proyecto y la base de datos y, luego, haz clic en el nombre de la tabla.

2. En el panel de detalles, haz clic en Detalles.

3. En la sección Description (Descripción), haz clic en el ícono de lápiz para editar la descripción.

   

4. Ingresa una descripción en el cuadro y haz clic en Update (Actualizar) para guardarla.

SQL

Las declaraciones del lenguaje de definición de datos (DDL) te permiten crear y modificar tablas y vistas con la sintaxis de consulta de SQL estándar.

Para obtener más información, consulta cómo usar instrucciones del lenguaje de definición de datos.

Para actualizar la descripción de una tabla mediante una declaración DDL en Cloud Console, sigue estos pasos:

1. Haz clic en Redactar consulta nueva (Compose new query).

2. Escribe tu declaración del DDL en el área de texto Editor de consultas.

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

3. Haz clic en Ejecutar.

bq

Ejecuta el comando bq update con la marca --description. Si actualizas una tabla en un proyecto que no es tu proyecto predeterminado, debes agregar el ID del proyecto al nombre del conjunto de datos en el formato siguiente: project_id:dataset.

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

Reemplaza lo siguiente:

• description: Es el texto que describe la tabla entre comillas.
• project_id: Es el ID de tu proyecto.
• dataset: Es el nombre del conjunto de datos que contiene la tabla que estás actualizando.
• table: Es el nombre de la tabla que estás actualizando.

Ejemplos:

Ingresa el comando siguiente para cambiar la descripción de mytable en mydataset a “Descripción de mi tabla” (“Description of mytable”). mydataset está en tu proyecto predeterminado.

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

Ingresa el comando siguiente para cambiar la descripción de mytable en mydataset a “Descripción de mi tabla” (“Description of mytable”). mydataset está en myotherproject, no en tu proyecto predeterminado.

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

API

Llama al método tables.patch y usa la propiedad description en el recurso de tabla para actualizar la descripción de la tabla. Debido a que se reemplaza todo el recurso de tabla usando el método tables.update, es preferible usar el método tables.patch.

Go

Antes de probar este ejemplo, sigue las instrucciones de configuración para Go que se encuentran en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de Go de BigQuery.

Ver en GitHubComentarios

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

Antes de probar este ejemplo, sigue las instrucciones de configuración para Java que se encuentran en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Java.

Ver en GitHubComentarios

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

Antes de probar esta muestra, sigue las instrucciones de configuración para Python incluidas en la Guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de Python de BigQuery.

Configura la propiedad Table.description y llama a Client.update_table() para enviar la actualización a la API.

Ver en GitHubComentarios

# 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."

Actualiza la fecha de vencimiento de una tabla

Puedes determinar una fecha de vencimiento de la tabla predeterminada a nivel de conjunto de datos o puedes configurarla cuando se crea la tabla. Se suele hablar de "tiempo de vida" o TTL para referirse a la fecha de vencimiento de una tabla.

Si configuras la fecha de vencimiento cuando se crea la tabla, se ignora el vencimiento predeterminado de la tabla del conjunto de datos. Si no estableces un vencimiento predeterminado de la tabla a nivel de conjunto de datos y no estableces un vencimiento de la tabla cuando la creas, la tabla nunca vencerá y deberás borrarla de forma manual.

En cualquier momento posterior a la creación de la tabla, puedes actualizar la fecha de vencimiento de la tabla de las siguientes maneras:

• Usa Cloud Console.
• Una declaración DDL ALTER TABLE
• Usa el comando bq de la herramienta de línea de comandos bq update
• Mediante una llamada al método de la API tables.patch
• Usa las bibliotecas cliente.

Nota: Si estableces una fecha de vencimiento que ya pasó, la tabla se borrará de inmediato.

Para actualizar la fecha de vencimiento de una tabla, haz lo siguiente:

Console

No puedes agregar una fecha de vencimiento cuando creas una tabla mediante Cloud Console. Después de crear una tabla, puedes agregar o actualizar su vencimiento en la página de Detalles de la tabla.

1. En el panel Explorador, expande el proyecto y conjunto de datos y, luego, selecciona la tabla.

   Nota: La experiencia predeterminada es la vista previa de Cloud Console. Si hiciste clic en Hide preview features para ir a Cloud Console con disponibilidad general, realiza el siguiente paso: en la sección Recursos del panel de navegación, expande tu proyecto y la base de datos y, luego, haz clic en el nombre de la tabla.

2. En el panel de detalles, haz clic en Detalles.

3. Haz clic en el ícono de lápiz junto a Información de tabla.

4. En Vencimiento de tabla, selecciona Especificar fecha. Luego, selecciona la fecha de vencimiento mediante el widget de calendario.

5. Haz clic en Actualizar para guardar. La fecha de vencimiento actualizada aparecerá en la sección Información de tabla (Table info).

SQL

Las declaraciones del lenguaje de definición de datos (DDL) te permiten crear y modificar tablas y vistas con la sintaxis de consulta de SQL estándar.

Para obtener más información, consulta cómo usar instrucciones del lenguaje de definición de datos.

Para actualizar la fecha de vencimiento mediante una instrucción DDL en Cloud Console, sigue estos pasos:

1. Haz clic en Redactar consulta nueva (Compose new query).

2. Escribe tu declaración del DDL en el área de texto Editor de consultas.

    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. Haz clic en Ejecutar.

bq

Ejecuta el comando bq update con la marca --expiration. Si actualizas una tabla en un proyecto que no es tu proyecto predeterminado, debes agregar el ID del proyecto al nombre del conjunto de datos en el formato siguiente: project_id:dataset.

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

Reemplaza lo siguiente:

• integer: Es el ciclo de vida predeterminado (en segundos) de la tabla. El valor mínimo es 3,600 segundos (una hora). La fecha de vencimiento se evalúa según la fecha actual más el valor del número entero. Si especificas 0, se quita el vencimiento y la tabla nunca se vence. Las tablas sin vencimiento deben borrarse de forma manual.
• project_id: Es el ID de tu proyecto.
• dataset: Es el nombre del conjunto de datos que contiene la tabla que estás actualizando.
• table: Es el nombre de la tabla que estás actualizando.

Ejemplos:

Ingresa el comando siguiente a fin de actualizar la fecha de vencimiento de mytable en mydataset a 5 días (432,000 segundos). mydataset está en tu proyecto predeterminado.

bq update --expiration 432000 mydataset.mytable

Ingresa el comando siguiente a fin de actualizar la fecha de vencimiento de mytable en mydataset a 5 días (432,000 segundos). mydataset está en myotherproject, no en tu proyecto predeterminado.

bq update --expiration 432000 myotherproject:mydataset.mytable

API

Llama al método tables.patch y usa la propiedad expirationTime en el recurso de tabla para actualizar el vencimiento de la tabla en milisegundos. Debido a que se reemplaza todo el recurso de tabla usando el método tables.update, es preferible usar el método tables.patch.

Go

Antes de probar este ejemplo, sigue las instrucciones de configuración para Go que se encuentran en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de Go de BigQuery.

Ver en GitHubComentarios

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

Antes de probar este ejemplo, sigue las instrucciones de configuración para Java que se encuentran en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Java.

Ver en GitHubComentarios

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

Antes de probar este ejemplo, sigue las instrucciones de configuración para Node.js que se encuentran en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la Documentación de referencia de la API de Node.js de BigQuery.

Ver en GitHubComentarios

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

Antes de probar esta muestra, sigue las instrucciones de configuración para Python incluidas en la Guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de Python de BigQuery.

Configura la propiedad Table.expires y llama a Client.update_table() para enviar la actualización a la API.

Ver en GitHubComentarios

import datetime
import pytz

# 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.expires is None

# set table to expire 5 days from now
expiration = datetime.datetime.now(pytz.utc) + datetime.timedelta(days=5)
table.expires = expiration
table = client.update_table(table, ["expires"])  # API request

# expiration is stored in milliseconds
margin = datetime.timedelta(microseconds=1000)
assert expiration - margin <= table.expires <= expiration + margin

Actualiza la definición de esquema de la tabla

Para obtener más información sobre cómo actualizar la definición de esquema de una tabla, consulta Modifica esquemas de tablas.

Renombra una tabla

Puedes cambiar el nombre de las tablas mediante las instrucciones del lenguaje de definición de datos. Para obtener más información, consulta la instrucción ALTER TABLE RENAME TO.

Copia una tabla

Puedes copiar una tabla de las maneras siguientes:

• Usa Cloud Console.
• Usa el comando bq de la herramienta de línea de comandos bq cp
• Llama al método jobs.insert de la API y configura un trabajo copy.
• Usa las bibliotecas cliente.

Permisos necesarios

Como mínimo, para copiar tablas y particiones, debes tener los siguientes permisos:

En el conjunto de datos de origen, debes tener los siguientes permisos:

• bigquery.tables.get
• bigquery.tables.getData

En el conjunto de datos de destino, debes tener los siguientes permisos:

• bigquery.tables.create para crear la copia de la tabla o partición en el conjunto de datos de destino

Las siguientes funciones predefinidas de IAM incluyen los permisos bigquery.tables.create, bigquery.tables.get y bigquery.tables.getData:

• bigquery.dataEditor
• bigquery.dataOwner
• bigquery.admin

Además, para ejecutar el trabajo de copia, debes tener los permisos bigquery.jobs.create.

En las siguientes funciones predefinidas de IAM, se incluyen los permisos bigquery.jobs.create:

• bigquery.user
• bigquery.jobUser
• bigquery.admin

Además, si un usuario tiene permisos bigquery.datasets.create, se le otorga el acceso bigquery.dataOwner cuando crea un conjunto de datos. El acceso a bigquery.dataOwner otorga al usuario la capacidad de copiar tablas y particiones en el conjunto de datos, pero se requiere acceso al conjunto de datos de destino, a menos que el usuario haya creado el conjunto de datos de destino.

Para obtener más información sobre las funciones y los permisos de IAM en BigQuery, consulta Funciones y permisos predefinidos.

Limitaciones sobre la copia de tablas

Los trabajos de copia de tablas están sujetos a las limitaciones siguientes:

• Cuando copias una tabla, el nombre de la tabla de destino debe respetar las mismas convenciones que cuando creas una tabla.
• Las copias de tablas están sujetas a las políticas de cuota de BigQuery de trabajos de copia.
• Cuando usas Cloud Console para copiar una tabla, no puedes reemplazar una tabla existente en el conjunto de datos de destino. La tabla debe tener un nombre único en el conjunto de datos de destino.
• Cuando copias tablas, el conjunto de datos de destino debe residir en la misma ubicación que el conjunto de datos que contiene la tabla que quieres copiar. Por ejemplo, no puedes copiar una tabla de un conjunto de datos de la UE y escribirlo en un conjunto de datos de EE.UU.
• Cloud Console no admite la copia de múltiples tablas de origen en una tabla de destino.
• Cuando copias varias tablas de origen a una de destino con la API o la herramienta de línea de comandos de bq, todas las tablas de origen deben tener esquemas idénticos.
• El tiempo que tarda BigQuery en copiar tablas puede variar significativamente en las diferentes ejecuciones, porque el almacenamiento subyacente se administra de forma dinámica.

Copia una sola tabla fuente

Puedes copiar una única tabla de las siguientes maneras:

• Usa Cloud Console.
• Usa el comando bq de la herramienta de línea de comandos bq cp
• Mediante una llamada al método de API jobs.insert, la configuración de un trabajo copy y la especificación de la propiedad sourceTable.
• Usa las bibliotecas cliente.

Cloud Console solo admite una tabla de origen y una tabla de destino en un trabajo de copia. Para copiar múltiples archivos fuente a una tabla de destino, debes usar la herramienta de línea de comandos de bq o la API.

Para copiar una sola tabla fuente, haz lo siguiente:

Console

1. En el panel Explorador, expande el proyecto y conjunto de datos y, luego, selecciona la tabla.

   Nota: La experiencia predeterminada es la vista previa de Cloud Console. Si hiciste clic en Hide preview features para ir a Cloud Console con disponibilidad general, realiza el siguiente paso: en la sección Recursos del panel de navegación, expande tu proyecto y la base de datos y, luego, haz clic en el nombre de la tabla.

2. En el panel de detalles, haz clic en Crear tabla (Create table).

3. En el cuadro de diálogo Copiar tabla, en Destino, haz lo siguiente:

   • En Nombre del proyecto (Project name), elige el proyecto que almacenará la tabla copiada.
   • En Nombre del conjunto de datos (Dataset name), selecciona el conjunto de datos en el que deseas almacenar la tabla copiada. Los conjuntos de datos de origen y de destino deben estar en la misma ubicación.
   • En Nombre de tabla, ingresa un nombre para la tabla nueva. El nombre debe ser único en el conjunto de datos de destino. No puedes reemplazar una tabla existente en el conjunto de datos de destino mediante Cloud Console. Para obtener más información sobre los requisitos de los nombres de tablas, consulta Nombres de las tablas.

4. Haz clic en Copiar para iniciar el trabajo de copia.

bq

Ejecuta el comando bq cp. Se pueden usar marcas opcionales a fin de controlar la disposición de escritura de la tabla de destino:

• -a o --append_table anexan los datos de la tabla de origen a una tabla existente en el conjunto de datos de destino.
• -f o --force reemplazan una tabla existente en el conjunto de datos de destino sin solicitar confirmación.
• -n o --no_clobber muestran el siguiente mensaje de error si la tabla ya existe en el conjunto de datos de destino: Table 'project_id:dataset.table' already exists, skipping. Si no se especifica -n, el comportamiento predeterminado es solicitarte confirmación para reemplazar la tabla de destino.
• --destination_kms_key es la clave de Cloud KMS administrada por el cliente que se usa para encriptar la tabla de destino.

--destination_kms_key no se muestra aquí. Consulta la página sobre protección de datos con claves de Cloud Key Management Service para obtener más información.

Si el conjunto de datos de origen o de destino se encuentra en un proyecto que no es el predeterminado, debes agregar el ID del proyecto a los nombres de los conjuntos de datos con el siguiente formato: project_id:dataset.

Opcional: Proporciona la marca --location y configura el valor en tu ubicación.

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

Reemplaza lo siguiente:

• location: El nombre de tu ubicación. La marca --location es opcional. Por ejemplo, si usas BigQuery en la región de Tokio, puedes establecer el valor de la marca en asia-northeast1. Puedes establecer un valor predeterminado para la ubicación con el archivo .bigqueryrc.
• project_id: el ID de tu proyecto
• dataset: Es el nombre del conjunto de datos de origen o de destino.
• source_table: Es la tabla que estás copiando.
• destination_table: Es el nombre de la tabla en el conjunto de datos de destino.

Ejemplos:

Ingresa el comando siguiente para copiar mydataset.mytable a mydataset2.mytable2. Ambos conjuntos de datos se encuentran en tu proyecto predeterminado.

bq cp mydataset.mytable mydataset2.mytable2

Ingresa el comando siguiente para copiar mydataset.mytable y reemplazar una tabla de destino con el mismo nombre. El conjunto de datos fuente se encuentra en tu proyecto predeterminado. El conjunto de datos de destino se encuentra en myotherproject. Se usa el acceso directo -f para reemplazar la tabla de destino sin confirmación.

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

Ingresa el siguiente comando para copiar mydataset.mytable y mostrar un error si el conjunto de datos de destino contiene una tabla con el mismo nombre. El conjunto de datos fuente se encuentra en tu proyecto predeterminado. El conjunto de datos de destino se encuentra en myotherproject. Se usa el acceso directo -n para evitar reemplazar una tabla con el mismo nombre.

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

Ingresa el comando siguiente para copiar mydataset.mytable y anexar los datos a una tabla de destino con el mismo nombre. El conjunto de datos fuente se encuentra en tu proyecto predeterminado. El conjunto de datos de destino se encuentra en myotherproject. Se usa el acceso directo - a para anexar los datos a la tabla de destino.

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

API

Puedes copiar una tabla existente mediante la API si llamas al método bigquery.jobs.insert y configuras un trabajo copy. Especifica tu ubicación en la propiedad location en la sección jobReference del recurso de trabajo.

Debes especificar los valores siguientes en tu configuración de trabajo:

"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
    },

Aquí, sourceTable proporciona información sobre la tabla que se copiará, destinationTable proporciona información sobre la tabla nueva, createDisposition especifica si se debe crear la tabla en caso de que no exista y writeDisposition especifica si se debe reemplazar una tabla existente o anexar a ella.

C#

Antes de probar este ejemplo, sigue las instrucciones de configuración para C# incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de C# de BigQuery.

Ver en GitHubComentarios

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.
        // Retrieve destination table
        BigQueryTable destinationTable = client.GetTable(destinationTableRef);
        Console.WriteLine(
            $"Copied {destinationTable.Resource.NumRows} rows from table "
            + $"{sourceTableRef.DatasetId}.{sourceTableRef.TableId} "
            + $"to {destinationTable.FullyQualifiedId}."
        );
    }
}

Comienza a usarlo

Antes de probar este ejemplo, sigue las instrucciones de configuración para Go que se encuentran en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de Go de BigQuery.

Ver en GitHubComentarios

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

Antes de probar este ejemplo, sigue las instrucciones de configuración para Java que se encuentran en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Java.

Ver en GitHubComentarios

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

Antes de probar este ejemplo, sigue las instrucciones de configuración para Node.js que se encuentran en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la Documentación de referencia de la API de Node.js de BigQuery.

Ver en GitHubComentarios

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

Antes de probar este ejemplo, sigue las instrucciones de configuración para PHP incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de PHP de BigQuery.

Ver en GitHubComentarios

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

Antes de probar esta muestra, sigue las instrucciones de configuración para Python incluidas en la Guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de Python de BigQuery.

Ver en GitHubComentarios

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.")

Copia múltiples tablas fuente

Puedes copiar varias tablas de origen en una tabla de destino de las maneras siguientes:

• Usa el comando bq de la herramienta de línea de comandos bq cp
• Mediante una llamada al método jobs.insert, la configuración de un trabajo copy y la especificación de la propiedad sourceTables.
• Usa las bibliotecas cliente.

Todas las tablas de origen deben tener esquemas idénticos y solo se permite una tabla de destino.

Las tablas fuente deben especificarse en una lista separada por comas. No puedes usar comodines cuando copias múltiples tablas fuente.

Para copiar múltiples tablas fuente, sigue estos pasos:

Console

En la actualidad, Cloud Console no admite la copia de múltiples tablas.

bq

Ejecuta el comando bq cp con varias tablas de origen en una lista separada por comas. Se pueden usar marcas opcionales a fin de controlar la disposición de escritura de la tabla de destino:

• -a o --append_table anexan los datos de las tablas de origen a una tabla existente en el conjunto de datos de destino.
• -f o --force reemplazan una tabla de destino existente en el conjunto de datos de destino y no te solicitan confirmación.
• -n o --no_clobber muestran el siguiente mensaje de error si la tabla ya existe en el conjunto de datos de destino: Table 'project_id:dataset.table' already exists, skipping. Si no se especifica -n, el comportamiento predeterminado es solicitarte confirmación para reemplazar la tabla de destino.
• --destination_kms_key es la clave Cloud Key Management Service administrada por el cliente que se usa para encriptar la tabla de destino.

--destination_kms_key no se muestra aquí. Consulta la página sobre protección de datos con claves de Cloud Key Management Service para obtener más información.

Si el conjunto de datos de origen o de destino se encuentra en un proyecto que no es el predeterminado, debes agregar el ID del proyecto a los nombres de los conjuntos de datos con el siguiente formato: project_id:dataset.

Opcional: Proporciona la marca --location y configura el valor en tu ubicación.

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

Reemplaza lo siguiente:

• location: El nombre de tu ubicación. La marca --location es opcional. Por ejemplo, si usas BigQuery en la región de Tokio, puedes establecer el valor de la marca en asia-northeast1. Puedes establecer un valor predeterminado para la ubicación con el archivo .bigqueryrc.
• project_id: el ID de tu proyecto
• dataset: Es el nombre del conjunto de datos de origen o de destino.
• source_table: es la tabla que copiarás.
• destination_table: Es el nombre de la tabla en el conjunto de datos de destino.

Ejemplos:

Ingresa el siguiente comando para copiar mydataset.mytable y mydataset.mytable2 a mydataset2.tablecopy. Todos los conjuntos de datos se encuentran en tu proyecto predeterminado.

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

Ingresa el siguiente comando para copiar mydataset.mytable y mydataset.mytable2 a myotherdataset.mytable y reemplazar una tabla de destino con el mismo nombre. El conjunto de datos de destino se encuentra en myotherproject, no en tu proyecto predeterminado. Se usa el acceso directo -f para reemplazar la tabla de destino sin confirmación.

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

Ingresa el siguiente comando para copiar myproject:mydataset.mytable y myproject:mydataset.mytable2, y mostrar un error si el conjunto de datos de destino contiene una tabla con el mismo nombre. El conjunto de datos de destino se encuentra en myotherproject. Se usa el acceso directo -n para evitar reemplazar una tabla con el mismo nombre.

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

Ingresa el siguiente comando para copiar mydataset.mytable y mydataset.mytable2, y anexar los datos a una tabla de destino con el mismo nombre. El conjunto de datos fuente se encuentra en tu proyecto predeterminado. El conjunto de datos de destino se encuentra en myotherproject. Se usa el acceso directo -a para anexar los datos a la tabla de destino.

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

API

Para copiar varias tablas con la API, llama al método jobs.insert, configura un trabajo copy de tabla y especifica la propiedad sourceTables.

Especifica tu región en la propiedad location en la sección jobReference del recurso de trabajo.

Go

Antes de probar este ejemplo, sigue las instrucciones de configuración para Go que se encuentran en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de Go de BigQuery.

Ver en GitHubComentarios

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

Antes de probar este ejemplo, sigue las instrucciones de configuración para Java que se encuentran en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Java.

Ver en GitHubComentarios

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

Antes de probar este ejemplo, sigue las instrucciones de configuración para Node.js que se encuentran en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la Documentación de referencia de la API de Node.js de BigQuery.

Ver en GitHubComentarios

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

Antes de probar esta muestra, sigue las instrucciones de configuración para Python incluidas en la Guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de Python de BigQuery.

Ver en GitHubComentarios

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

Borra tablas

Puedes borrar una tabla de las maneras siguientes:

• Usa Cloud Console.
• Usa el comando bq rm de la herramienta de línea de comandos de bq.
• Mediante una llamada al método de la API tables.delete.
• Usa las bibliotecas cliente.

Por ahora, solo puedes borrar una tabla a la vez.

Cuando borras una tabla, también se borra cualquier dato en ella. Para borrar las tablas de forma automática después de un tiempo determinado, debes establecer el vencimiento predeterminado de la tabla para el conjunto de datos o configurar la fecha de vencimiento cuando creas la tabla.

Permisos necesarios

Como mínimo, para borrar una tabla, debes tener los permisos bigquery.tables.delete y bigquery.tables.get. En las siguientes funciones predefinidas de IAM, se incluyen los permisos bigquery.tables.delete y bigquery.tables.get:

• bigquery.dataOwner
• bigquery.dataEditor
• bigquery.admin

Además, si un usuario tiene permisos bigquery.datasets.create, se le otorga el acceso bigquery.dataOwner cuando crea un conjunto de datos. El acceso bigquery.dataOwner permite al usuario borrar tablas en el conjunto de datos.

Para obtener más información sobre las funciones y los permisos de IAM en BigQuery, consulta Funciones y permisos predefinidos.

Borra una tabla

Para borrar una tabla, sigue estos pasos:

Console

1. En el panel Explorador, expande el proyecto y conjunto de datos y, luego, selecciona la tabla.

   Nota: La experiencia predeterminada es la vista previa de Cloud Console. Si hiciste clic en Hide preview features para ir a Cloud Console con disponibilidad general, realiza el siguiente paso: en la sección Recursos del panel de navegación, expande tu proyecto y la base de datos y, luego, haz clic en el nombre de la tabla.

2. En el panel de detalles*, haz clic en Borrar tabla.

3. Escribe el nombre de la tabla en el cuadro de diálogo y haz clic en Borrar para confirmar.

SQL

Las declaraciones del lenguaje de definición de datos (DDL) te permiten borrar tablas mediante la sintaxis de consultas SQL estándar.

Para obtener más información, consulta cómo usar instrucciones del lenguaje de definición de datos.

Para borrar una tabla existente mediante una declaración DDL en Cloud Console, sigue estos pasos:

1. Haz clic en Redactar consulta nueva.

2. Escribe tu declaración de DDL en el campo Editor de consultas.

    DROP TABLE mydataset.mytable
    

3. Haga clic en Ejecutar.

bq

Usa el comando bq rm con la marca --table (o el acceso directo -t) para borrar una tabla. Cuando usas la herramienta de línea de comandos de bq para quitar una tabla, debes confirmar la acción. Puedes usar la marca --force (o el acceso directo -f) para que no se solicite confirmación.

Si la tabla se encuentra en un conjunto de datos en un proyecto que no es el predeterminado, debes agregar el ID del proyecto al nombre del conjunto de datos con el formato siguiente: project_id:dataset.

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

Reemplaza lo siguiente:

• project_id: Es el ID de tu proyecto
• dataset: Es el nombre del conjunto de datos que contiene la tabla.
• table: Es el nombre de la tabla que borrarás

Ejemplos:

Ingresa el siguiente comando para borrar mytable de mydataset. mydataset está en tu proyecto predeterminado.

bq rm -t mydataset.mytable

Ingresa el siguiente comando para borrar mytable de mydataset. mydataset está en myotherproject, no en tu proyecto predeterminado.

bq rm -t myotherproject:mydataset.mytable

Ingresa el siguiente comando para borrar mytable de mydataset. mydataset está en tu proyecto predeterminado. El comando usa el acceso directo -f para omitir la confirmación.

bq rm -f -t mydataset.mytable

Nota: Puedes ingresar el comando bq ls dataset en la herramienta de línea de comandos bq para confirmar que una tabla que se quitó de un conjunto de datos.

API

Llama al método de API tables.delete y especifica la tabla que deseas borrar con el parámetro tableId.

C#

Antes de probar este ejemplo, sigue las instrucciones de configuración para C# incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de C# de BigQuery.

Ver en GitHubComentarios

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.");
    }
}

Comienza a usarlo

Antes de probar este ejemplo, sigue las instrucciones de configuración para Go que se encuentran en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de Go de BigQuery.

Ver en GitHubComentarios

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

Antes de probar este ejemplo, sigue las instrucciones de configuración para Java que se encuentran en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Java.

Ver en GitHubComentarios

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

Antes de probar este ejemplo, sigue las instrucciones de configuración para Node.js que se encuentran en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la Documentación de referencia de la API de Node.js de BigQuery.

Ver en GitHubComentarios

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

Antes de probar este ejemplo, sigue las instrucciones de configuración para PHP incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de PHP de BigQuery.

Ver en GitHubComentarios

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

Antes de probar esta muestra, sigue las instrucciones de configuración para Python incluidas en la Guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de Python de BigQuery.

Ver en GitHubComentarios

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

Antes de probar este ejemplo, sigue las instrucciones de configuración para Ruby incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. A fin de obtener más información, consulta la documentación de referencia de la API de BigQuery para Ruby.

Ver en GitHubComentarios

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

Restablece tablas borradas

Puedes recuperar una tabla durante los 7 días posteriores a la eliminación, incluidas las eliminaciones explícitas y a las implícitas debido al vencimiento de la tabla. Después de siete días, no es posible recuperar una tabla con algún método, incluido abrir un ticket de asistencia.

Puedes restablecer una tabla borrada de las siguientes maneras:

• Usa el decorador de instantáneas @<time> en la herramienta de línea de comandos de bq.
• Usa bibliotecas cliente.

Console

No puedes recuperar una tabla mediante Cloud Console.

bq

Para restablecer una tabla, usa una operación de copia de tabla con el decorador de instantáneas @<time>. Primero, determina una marca de tiempo UNIX de cuando existió la tabla (en milisegundos). Luego, usa el comando bq copy con el decorador de instantáneas.

Por ejemplo, ingresa el siguiente comando para copiar mydataset.mytable en el momento 1418864998000 en una nueva tabla mydataset.newtable.

bq cp mydataset.mytable@1418864998000 mydataset.newtable

Opcional: Proporciona la marca --location y configura el valor en tu ubicación.

También puedes especificar un desplazamiento relativo. En el siguiente ejemplo, se copia la versión de una tabla de hace una hora atrás:

bq cp mydataset.mytable@-3600000 mydataset.newtable

Para obtener más información, consulta Cómo restablecer una tabla a partir de un momento determinado.

Go

Ver en GitHub

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

Antes de probar este ejemplo, sigue las instrucciones de configuración para Java que se encuentran en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Java.

Ver en GitHubComentarios

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

Antes de probar este ejemplo, sigue las instrucciones de configuración para Node.js que se encuentran en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la Documentación de referencia de la API de Node.js de BigQuery.

Ver en GitHubComentarios

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

Antes de probar esta muestra, sigue las instrucciones de configuración para Python incluidas en la Guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de Python de BigQuery.

Ver en GitHubComentarios

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.
# recovery_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)
)

Si tienes previsto restablecer una tabla más de siete días después de que se borró o venció, debes crear una instantánea de tabla de la tabla. Para obtener más información, consulta Instantáneas de tabla.

Seguridad de las tablas

Para controlar el acceso a las tablas en BigQuery, consulta Introducción a los controles de acceso a las tablas.

Próximos pasos

• Si deseas obtener más información sobre cómo crear y usar tablas, consulta Crea y usa tablas.
• Para obtener más información sobre cómo manejar datos, consulta cómo trabajar con datos de tablas.
• Si quieres obtener más información acerca de cómo especificar esquemas de tablas, consulta Especifica un esquema.
• Para obtener más información sobre cómo modificar los esquemas de las tablas, consulta Modifica esquemas de tablas.
• Para obtener más información sobre conjuntos de datos, consulta Introducción a los conjuntos de datos.
• Para obtener más información sobre las vistas, consulta Introducción a las vistas.