Esta página se ha traducido con Cloud Translation API.

Gestionar vistas lógicas

En este documento se describe cómo gestionar las vistas en BigQuery. Puedes gestionar tus vistas de BigQuery de las siguientes formas:

Actualizar una vista
Copiar una vista
Cambiar el nombre de una vista
Eliminar una vista

Antes de empezar

Concede roles de gestión de identidades y accesos (IAM) que proporcionen a los usuarios los permisos necesarios para realizar cada tarea de este documento. Los permisos necesarios para realizar una tarea (si los hay) se indican en la sección "Permisos necesarios" de la tarea.

Actualizar una vista

Una vez que haya creado una vista, podrá actualizar las siguientes propiedades:

Consulta SQL
Hora de vencimiento
Descripción
Etiquetas

Permisos obligatorios

Para actualizar una vista, necesitas los siguientes permisos de gestión de identidades y accesos:

bigquery.tables.update
bigquery.tables.get

Cada uno de los siguientes roles de gestión de identidades y accesos predefinidos incluye los permisos que necesitas para actualizar una vista:

roles/bigquery.dataEditor
roles/bigquery.dataOwner
roles/bigquery.admin

Además, si tienes el permiso bigquery.datasets.create, puedes actualizar las tablas y las vistas de los conjuntos de datos que crees.

Para actualizar la consulta de SQL de una vista, también debe tener permisos para consultar cualquier tabla a la que haga referencia la consulta de SQL de la vista.

Para obtener más información sobre los roles y permisos de IAM en BigQuery, consulta el artículo sobre funciones y permisos predefinidos.

Actualizar la consulta de SQL de una vista

Para actualizar la consulta de SQL que se usa para definir una vista, puedes hacer lo siguiente:

Usar la Google Cloud consola
Usar el comando bq update de la herramienta de línea de comandos bq
Llamar al método de API tables.patch
Usar las bibliotecas de cliente

Puedes cambiar el dialecto de SQL de Legacy SQL a GoogleSQL en la API o en la herramienta de línea de comandos bq. No puedes actualizar una vista de SQL antiguo a GoogleSQL en la consolaGoogle Cloud .

Para actualizar la consulta SQL de una vista, sigue estos pasos:

Consola

En el panel Explorador, expande tu proyecto y tu conjunto de datos, y selecciona la vista.
Haga clic en la pestaña Detalles.
Encima del cuadro Consulta, haz clic en el botón Editar consulta. En el cuadro de diálogo que aparece, haz clic en Abrir.
Edita la consulta de SQL en el cuadro Editor de consultas y, a continuación, haz clic en Guardar vista.
Comprueba que todos los campos del cuadro de diálogo Guardar vista sean correctos y, a continuación, haz clic en Guardar.

bq

Ejecuta el comando bq update con la marca --view. Para usar GoogleSQL o actualizar el dialecto de la consulta de SQL antiguo a GoogleSQL, incluye la marca --use_legacy_sql y asígnale el valor false.

Si tu consulta hace referencia a recursos de funciones definidas por el usuario externas almacenadas en Cloud Storage o en archivos locales, usa la marca --view_udf_resource para especificar esos recursos. Aquí no se muestra la marca --view_udf_resource. Para obtener más información sobre cómo usar las funciones definidas por el usuario, consulta el artículo Funciones definidas por el usuario de GoogleSQL.

Si vas a actualizar una vista en un proyecto que no sea el predeterminado, añade el ID del proyecto al nombre del conjunto de datos con el siguiente formato: project_id:dataset.

bq update \
    --use_legacy_sql=false \
    --view_udf_resource=path_to_file \
    --view='query' \
    project_id:dataset.view

Haz los cambios siguientes:

path_to_file: el URI o la ruta del sistema de archivos local a un archivo de código que se va a cargar y evaluar inmediatamente como un recurso de función definida por el usuario que usa la vista. Repite la marca para especificar varios archivos.
query: una consulta de GoogleSQL válida
project_id: tu ID de proyecto
dataset: el nombre del conjunto de datos que contiene la vista que estás actualizando
view: el nombre de la vista que quieres actualizar

Ejemplos

Introduce el siguiente comando para actualizar la consulta de SQL de una vista llamada myview en mydataset. mydataset está en tu proyecto predeterminado. La consulta de ejemplo que se ha usado para actualizar la vista consulta datos del conjunto de datos público USA Name Data.

bq update \
    --use_legacy_sql=false \
    --view \
    'SELECT
      name,
      number
    FROM
      `bigquery-public-data.usa_names.usa_1910_current`
    WHERE
      gender = "M"
    ORDER BY
      number DESC;' \
    mydataset.myview

Introduce el siguiente comando para actualizar la consulta de SQL de una vista llamada myview en mydataset. mydataset está en myotherproject, no en tu proyecto predeterminado. La consulta de ejemplo que se usa para actualizar la vista consulta datos del conjunto de datos público USA Name Data.

bq update \
    --use_legacy_sql=false \
    --view \
    'SELECT
      name,
      number
    FROM
      `bigquery-public-data.usa_names.usa_1910_current`
    WHERE
      gender = "M"
    ORDER BY
      number DESC;' \
    myotherproject:mydataset.myview

API

Para actualizar una vista, llama al método tables.patch con un recurso de tabla que contenga una propiedad view actualizada. Como el método tables.update sustituye todo el recurso de la tabla, se recomienda usar el método tables.patch.

Go

Antes de probar este ejemplo, sigue las Goinstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Go de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

import (
	"context"
	"fmt"

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

// updateView demonstrates updating the query metadata that defines a logical view.
func updateView(projectID, datasetID, viewID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// viewID := "myview"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	view := client.Dataset(datasetID).Table(viewID)
	meta, err := view.Metadata(ctx)
	if err != nil {
		return err
	}

	newMeta := bigquery.TableMetadataToUpdate{
		// This example updates a view into the shakespeare dataset to exclude works named after kings.
		ViewQuery: "SELECT word, word_count, corpus, corpus_date FROM `bigquery-public-data.samples.shakespeare` WHERE corpus NOT LIKE '%king%'",
	}

	if _, err := view.Update(ctx, newMeta, meta.ETag); err != nil {
		return err
	}
	return nil
}

Java

Antes de probar este ejemplo, sigue las Javainstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Java de BigQuery.

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

// Sample to update query on a view
public class UpdateViewQuery {

  public static void runUpdateViewQuery() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String viewName = "MY_VIEW_NAME";
    String updateQuery =
        String.format("SELECT TimestampField, StringField FROM %s.%s", datasetName, tableName);
    updateViewQuery(datasetName, viewName, updateQuery);
  }

  public static void updateViewQuery(String datasetName, String viewName, String query) {
    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();

      // Retrieve existing view metadata
      TableInfo viewMetadata = bigquery.getTable(TableId.of(datasetName, viewName));

      // Update view query
      ViewDefinition viewDefinition = viewMetadata.getDefinition();
      viewDefinition.toBuilder().setQuery(query).build();

      // Set metadata
      bigquery.update(viewMetadata.toBuilder().setDefinition(viewDefinition).build());

      System.out.println("View query updated successfully");
    } catch (BigQueryException e) {
      System.out.println("View query was not updated. \n" + e.toString());
    }
  }
}

Node.js

Antes de probar este ejemplo, sigue las Node.jsinstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Node.js de BigQuery.

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

async function updateViewQuery() {
  // Updates a view named "my_existing_view" in "my_dataset".

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = "my_existing_dataset"
  // const tableId = "my_existing_table"
  const dataset = await bigquery.dataset(datasetId);

  // This example updates a view into the USA names dataset to include state.
  const newViewQuery = `SELECT name, state 
  FROM \`bigquery-public-data.usa_names.usa_1910_current\`
  LIMIT 10`;

  // Retrieve existing view
  const [view] = await dataset.table(tableId).get();

  // Retrieve existing view metadata
  const [metadata] = await view.getMetadata();

  // Update view query
  metadata.view = newViewQuery;

  // Set metadata
  await view.setMetadata(metadata);

  console.log(`View ${tableId} updated.`);
}

Python

Antes de probar este ejemplo, sigue las Pythoninstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Python de BigQuery.

from google.cloud import bigquery

client = bigquery.Client()

view_id = "my-project.my_dataset.my_view"
source_id = "my-project.my_dataset.my_table"
view = bigquery.Table(view_id)

# The source table in this example is created from a CSV file in Google
# Cloud Storage located at
# `gs://cloud-samples-data/bigquery/us-states/us-states.csv`. It contains
# 50 US states, while the view returns only those states with names
# starting with the letter 'M'.
view.view_query = f"SELECT name, post_abbr FROM `{source_id}` WHERE name LIKE 'M%'"

# Make an API request to update the query property of the view.
view = client.update_table(view, ["view_query"])
print(f"Updated {view.table_type}: {str(view.reference)}")

Actualizar la fecha de vencimiento de una vista

Puedes definir una fecha de vencimiento predeterminada para las tablas a nivel del conjunto de datos (lo que afecta tanto a las tablas como a las vistas) o puedes definir la fecha de vencimiento de una vista cuando se crea. Si define la fecha de vencimiento al crear la vista, se ignorará la fecha de vencimiento predeterminada de la tabla del conjunto de datos. Si no define una caducidad de tabla predeterminada a nivel del conjunto de datos y no define una caducidad al crear la vista, la vista nunca caducará y deberá eliminarla manualmente.

En cualquier momento después de crear la vista, puede actualizar su tiempo de vencimiento de las siguientes formas:

Usar la Google Cloud consola
Usar una instrucción del lenguaje de definición de datos (DDL) escrita con la sintaxis de GoogleSQL
Usar el comando bq update de la herramienta de línea de comandos bq
Llamar al método de API tables.patch
Usar las bibliotecas de cliente

Para actualizar el tiempo de vencimiento de una vista, sigue estos pasos:

Consola

En el panel de navegación, selecciona la vista que quieras.
En la página Ver detalles, haga clic en la pestaña Detalles.
A la derecha de Ver información, haz clic en el icono de edición (lápiz).
En el cuadro de diálogo Ver información, en Caducidad de la vista, haz clic en Especificar fecha.
En el selector de fecha, introduce la fecha y la hora de vencimiento y, a continuación, haz clic en Aceptar.
Haz clic en Actualizar. La hora de vencimiento actualizada aparece en la sección Ver información.

SQL

Usa la ALTER VIEW SET OPTIONSdeclaración de DDL:

En la Google Cloud consola, ve a la página BigQuery.

Ir a BigQuery
En el editor de consultas, introduce la siguiente instrucción:
```
 ALTER VIEW DATASET_ID.MY_VIEW
 SET OPTIONS (
  expiration_timestamp = TIMESTAMP('NEW_TIMESTAMP'));
```
Haz los cambios siguientes:
- DATASET_ID: el ID del conjunto de datos que contiene la vista
- MY_VIEW: el nombre de la vista que se va a actualizar
- NEW_TIMESTAMP: un valor TIMESTAMP
Haz clic en Ejecutar.

Para obtener más información sobre cómo ejecutar consultas, consulta Ejecutar una consulta interactiva.

bq

Ejecuta el comando bq update con la marca --expiration. Si vas a actualizar una vista en un proyecto que no sea el predeterminado, añade el ID del proyecto al nombre del conjunto de datos con el siguiente formato: project_id:dataset.

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

Sustituye lo siguiente:

integer: el tiempo de vida predeterminado (en segundos) de la tabla. El valor mínimo es de 3600 segundos (una hora). La hora de vencimiento se calcula como la hora actual más el valor entero.
project_id: tu ID de proyecto
dataset: el nombre del conjunto de datos que contiene la vista que quieres actualizar
view: el nombre de la vista que quieres actualizar

Ejemplos

Introduce el siguiente comando para actualizar el tiempo de vencimiento de myview en mydataset a 5 días (432.000 segundos). mydataset está en tu proyecto predeterminado.

bq update \
    --expiration 432000 \
    mydataset.myview

Introduce el siguiente comando para actualizar el tiempo de vencimiento de myview en mydataset a 5 días (432.000 segundos). mydataset está en myotherproject, no en tu proyecto predeterminado.

bq update \
    --expiration 432000 \
    myotherproject:mydataset.myview

API

Llama al método tables.patch y usa la propiedad expirationTime en el recurso de tabla. Como el método tables.update sustituye todo el recurso de la tabla, se recomienda usar el método tables.patch. Cuando usas la API REST, el vencimiento de la vista se expresa en milisegundos.

Go

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

Table beforeTable = bigquery.getTable(datasetName, tableName);

// Set table to expire 5 days from now.
long expirationMillis = DateTime.now().plusDays(5).getMillis();
TableInfo tableInfo = beforeTable.toBuilder()
        .setExpirationTime(expirationMillis)
        .build();
Table afterTable = bigquery.update(tableInfo);

Node.js

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

El proceso para actualizar la fecha de vencimiento de una vista es el mismo que el de una tabla.

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

Actualizar la descripción de una vista

Para actualizar la descripción de una vista, sigue estos pasos:

Usar la Google Cloud consola
Usar una instrucción del lenguaje de definición de datos (DDL) escrita con la sintaxis de GoogleSQL
Usar el comando bq update de la herramienta de línea de comandos bq
Llamar al método de API tables.patch
Usar las bibliotecas de cliente

Para actualizar la descripción de una vista, sigue estos pasos:

Consola

No puedes añadir una descripción cuando creas una vista con la consola Google Cloud . Una vez creada la vista, puede añadir una descripción en la página Detalles.

En el panel Explorador, expande tu proyecto y tu conjunto de datos, y selecciona la vista.
Haga clic en la pestaña Detalles.
Haz clic en el icono de lápiz situado junto a Descripción.
Escribe una descripción en el cuadro de diálogo. Haz clic en Actualizar para guardar la nueva descripción.

SQL

Usa la ALTER VIEW SET OPTIONSdeclaración de DDL:

En la Google Cloud consola, ve a la página BigQuery.

Ir a BigQuery
En el editor de consultas, introduce la siguiente instrucción:
```
 ALTER VIEW DATASET_ID.MY_VIEW
 SET OPTIONS (
  description = 'NEW_DESCRIPTION');
```
Haz los cambios siguientes:
- DATASET_ID: el ID del conjunto de datos que contiene la vista
- MY_VIEW: el nombre de la vista que se va a actualizar
- NEW_DESCRIPTION: la nueva descripción de la vista
Haz clic en Ejecutar.

Para obtener más información sobre cómo ejecutar consultas, consulta Ejecutar una consulta interactiva.

bq

Ejecuta el comando bq update con la marca --description. Si vas a actualizar una vista en un proyecto que no sea el predeterminado, añade el ID del proyecto al nombre del conjunto de datos con el siguiente formato: [PROJECT_ID]:[DATASET].

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

Haz los cambios siguientes:

description: el texto que describe la vista entre comillas
project_id: tu ID de proyecto.
dataset: el nombre del conjunto de datos que contiene la vista que quieres actualizar
view: el nombre de la vista que quieres actualizar

Ejemplos

Introduce el siguiente comando para cambiar la descripción de myview en mydataset a "Descripción de myview". mydataset está en tu proyecto predeterminado.

bq update \
    --description "Description of myview" \
    mydataset.myview

Introduce el siguiente comando para cambiar la descripción de myview en mydataset a "Descripción de myview". mydataset está en myotherproject, no en tu proyecto predeterminado.

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

API

Llama al método tables.patch y usa la propiedad description para actualizar la descripción de la vista en el recurso de tabla. Como el método tables.update sustituye todo el recurso de tabla, se recomienda usar el método tables.patch.

Go

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

El proceso para actualizar la descripción de una vista es el mismo que para actualizar la descripción de una tabla.

// String datasetName = "my_dataset_name";
// String tableName = "my_table_name";
// String newDescription = "new_description";

Table beforeTable = bigquery.getTable(datasetName, tableName);
TableInfo tableInfo = beforeTable.toBuilder()
    .setDescription(newDescription)
    .build();
Table afterTable = bigquery.update(tableInfo);

Node.js

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

async function updateTableDescription() {
  // Updates a table's description.

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

  // Set new table description
  const description = 'New table description.';
  metadata.description = description;
  const [apiResponse] = await table.setMetadata(metadata);
  const newDescription = apiResponse.description;

  console.log(`${tableId} description: ${newDescription}`);
}

Python

El proceso para actualizar la descripción de una vista es el mismo que para actualizar la descripción de una tabla.

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

Copiar vistas

Puedes copiar una vista con la Google Cloud consola.

No puedes copiar una vista con la herramienta de línea de comandos bq, la API REST o las bibliotecas de cliente, pero sí puedes copiar una vista en el conjunto de datos de destino.

Permisos obligatorios

Para copiar una vista en la consola de Google Cloud , necesitas permisos de gestión de identidades y accesos en los conjuntos de datos de origen y de destino.

En el conjunto de datos de origen, necesitas lo siguiente:
- bigquery.tables.get
- bigquery.tables.getData (obligatorio para acceder a las tablas a las que hace referencia la consulta de SQL de la vista)
En el conjunto de datos de destino, necesitas lo siguiente:
- bigquery.tables.create (te permite crear una copia de la vista en el conjunto de datos de destino)

Cada uno de los siguientes roles de gestión de identidades y accesos predefinidos incluye los permisos que necesita para copiar una vista:

roles/bigquery.dataEditor
roles/bigquery.dataOwner
roles/bigquery.admin

Además, si tienes el permiso bigquery.datasets.create, puedes copiar vistas en los conjuntos de datos que crees. También debe tener acceso al conjunto de datos de destino, a menos que lo haya creado usted.

Para obtener más información sobre los roles y permisos de IAM en BigQuery, consulta el artículo sobre funciones y permisos predefinidos.

Copiar una vista

Para copiar una vista, siga estos pasos:

En el panel Explorador, expande tu proyecto y tu conjunto de datos, y selecciona la vista.
En el panel de detalles, haga clic en Copiar vista.
En el cuadro de diálogo Copiar vista, haga lo siguiente:
- En la sección Fuente, comprueba que el Nombre del proyecto, el Nombre del conjunto de datos y el Nombre de la tabla sean correctos.
- En la sección Destino:
  - En Nombre del proyecto, elige el proyecto al que quieras copiar la vista.
  - En Nombre del conjunto de datos, elija el conjunto de datos que contendrá la vista copiada.
  - En Nombre de la tabla, introduzca el nombre de la vista. Para cambiar el nombre de la vista, escribe uno nuevo en el cuadro. Si introduce un nombre nuevo, debe seguir las reglas de nomenclatura de las vistas.
- Haz clic en Copiar.

Se aplican límites a las tareas de copia. Para obtener más información, consulta Cuotas y límites.

Cambiar el nombre de una vista

Actualmente, solo puedes cambiar el nombre de una vista cuando usas la Google Cloud consola para copiarla. Para obtener instrucciones sobre cómo cambiar el nombre de una vista al copiarla, consulta Copiar una vista.

No puedes cambiar el nombre de una vista con la herramienta de línea de comandos bq, la API ni las bibliotecas de cliente. En su lugar, debe volver a crear la vista con el nuevo nombre.

Eliminar vistas

Para eliminar una vista, sigue estos pasos:

Usar la Google Cloud consola
Usar el comando bq rm de la herramienta de línea de comandos bq
Llamar al método de la API tables.delete

Actualmente, solo puede eliminar una vista a la vez con cualquiera de los métodos disponibles.

Para eliminar automáticamente las vistas después de un periodo específico, define el tiempo de vencimiento predeterminado a nivel del conjunto de datos o define el tiempo de vencimiento cuando crees la vista.

Cuando eliminas una vista autorizada, puede tardar hasta 24 horas en quitarse de la lista de vistas autorizadas del conjunto de datos de origen.

Si eliminas una vista, también se eliminarán los permisos asociados a ella. Cuando vuelvas a crear una vista eliminada, también debes volver a configurar manualmente los permisos de acceso que estuvieran asociados a ella.

Permisos obligatorios

Para eliminar una vista, necesitas los siguientes permisos de gestión de identidades y accesos:

bigquery.tables.delete

Cada uno de los siguientes roles de gestión de identidades y accesos predefinidos incluye los permisos que necesitas para eliminar una vista:

roles/bigquery.dataOwner
roles/bigquery.dataEditor
roles/bigquery.admin

Además, si tienes el permiso bigquery.datasets.create, puedes eliminar vistas de los conjuntos de datos que crees.

Para obtener más información sobre los roles y permisos de IAM en BigQuery, consulta el artículo sobre funciones y permisos predefinidos.

Eliminar una vista

Para eliminar una vista, sigue estos pasos:

Consola

En la Google Cloud consola, ve a la página BigQuery.

Ir a BigQuery
En el panel Explorador, expande tu proyecto y tu conjunto de datos, y selecciona la vista.
En el panel de detalles, haz clic en Eliminar vista.
Escribe "delete" en el cuadro de diálogo y haz clic en Eliminar para confirmar la acción.

SQL

Usa la DROP VIEWdeclaración de DDL:

En la Google Cloud consola, ve a la página BigQuery.

Ir a BigQuery
En el editor de consultas, introduce la siguiente instrucción:
```
DROP VIEW mydataset.myview;
```
Haz los cambios siguientes:
- DATASET_ID: el ID del conjunto de datos que contiene la vista
- MY_VIEW: el nombre de la vista que se va a actualizar
- NEW_DESCRIPTION: la nueva descripción de la vista
Haz clic en Ejecutar.

Para obtener más información sobre cómo ejecutar consultas, consulta Ejecutar una consulta interactiva.

bq

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

Si la vista está en un conjunto de datos de un proyecto que no es el predeterminado, añade el ID del proyecto al nombre del conjunto de datos con el siguiente formato: project_id:dataset.

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

Donde:

project_id es el ID del proyecto.
dataset es el nombre del conjunto de datos que contiene la tabla.
view es el nombre de la vista que vas a eliminar.

Ejemplos:

Puedes usar la herramienta de línea de comandos bq para ejecutar comandos bq.

En la Google Cloud consola, activa Cloud Shell.

Activar Cloud Shell

Introduce el siguiente comando para eliminar myview de mydataset. mydataset está en tu proyecto predeterminado.

bq rm -t mydataset.myview

Introduce el siguiente comando para eliminar myview de mydataset. mydataset está en myotherproject, no en tu proyecto predeterminado.

bq rm -t myotherproject:mydataset.myview

Introduce el siguiente comando para eliminar myview 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.myview

API

Llama al método de API tables.delete y especifica la vista que quieras eliminar con el parámetro tableId.

C#

Antes de probar este ejemplo, sigue las C#instrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API C# de BigQuery.


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

Go

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

TableId tableId = TableId.of(projectId, datasetName, tableName);
boolean deleted = bigquery.delete(tableId);
if (deleted) {
  // the table was deleted
} else {
  // the table was not found
}

Node.js

// 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 PHPinstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API PHP de BigQuery.

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


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 Rubyinstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Ruby de BigQuery.

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

Restaurar una vista

No puedes restaurar una vista eliminada directamente, pero hay soluciones alternativas para determinados casos:

Si se elimina una vista porque se ha eliminado el conjunto de datos principal, puede restaurar el conjunto de datos para recuperar la vista.
Si una vista se elimina explícitamente, puedes volver a crearla con la última consulta que se usó para crear o actualizar la vista. Puedes encontrar la definición de la consulta de la operación de creación o actualización de la vista en los registros.

Ver seguridad

Para controlar el acceso a las vistas en BigQuery, consulta Vistas autorizadas.

Siguientes pasos

Para obtener información sobre cómo crear vistas, consulta Crear vistas.
Para obtener información sobre cómo crear una vista autorizada, consulta el artículo Crear vistas autorizadas.
Para obtener información sobre cómo obtener metadatos de vistas, consulta Obtener información sobre las vistas.