Crear vistas lógicas

Consola

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

   Ir a BigQuery

2. Haz clic en add_box Consulta de SQL.

3. En el editor de consultas, introduce una consulta de SQL válida.

   También puedes abrir una consulta guardada.

4. Haz clic en Guardar > Guardar vista.

   

5. En el cuadro de diálogo Guardar vista, haz lo siguiente:

   • En el menú Proyecto, selecciona un proyecto en el que almacenar la vista.
   • En el menú Conjunto de datos, selecciona un conjunto de datos o crea uno para almacenar la vista. La vista se debe guardar en un conjunto de datos de la misma región que los datos de origen.
   • En el campo Tabla, introduce el nombre de la vista.
   • Haz clic en Guardar.

SQL

Usa la instrucción CREATE VIEW. En el siguiente ejemplo se crea una vista llamada usa_male_names a partir del conjunto de datos público USA names:

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

   Ir a BigQuery

2. En el editor de consultas, introduce la siguiente instrucción:

   CREATE VIEW mydataset.usa_male_names(name, number) AS (
     SELECT
       name,
       number
     FROM
       `bigquery-public-data.usa_names.usa_1910_current`
     WHERE
       gender = 'M'
     ORDER BY
       number DESC
   );

3. Haz clic en play_circle Ejecutar.

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

bq

Usa el comando bq mk con la marca --view. En las consultas de GoogleSQL, añade la marca --use_legacy_sql y asigna el valor false. Algunos parámetros opcionales son --add_tags, --expiration, --description y --label. Para ver la lista completa de parámetros, consulta la referencia del comando bq mk.

Si tu consulta hace referencia a recursos de funciones definidas por el usuario (UDF) externas almacenados 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 el uso de funciones definidas por el usuario, consulta Funciones definidas por el usuario.

Si va a crear una vista en un proyecto que no sea el predeterminado, especifique el ID del proyecto con la marca --project_id.

bq mk \
--use_legacy_sql=false \
--view_udf_resource=PATH_TO_FILE \
--expiration=INTEGER \
--description="DESCRIPTION" \
--label=KEY_1:VALUE_1 \
--add_tags=KEY_2:VALUE_2[,...] \
--view='QUERY9; \
--project_id=PROJECT_ID \
DATASET.VIEW

Haz los cambios siguientes:

• PATH_TO_FILE es el URI o la ruta del sistema de archivos local a un archivo de código que se cargará y evaluará inmediatamente como un recurso de función definida por el usuario que utiliza la vista. Repite la marca para especificar varios archivos.
• INTEGER define el tiempo de vida (en segundos) de la vista. Si INTEGER es 0, la vista no caduca. Si no incluyes la marca --expiration, BigQuery creará la vista con el tiempo de vida predeterminado de la tabla del conjunto de datos.
• DESCRIPTION es una descripción de la vista entre comillas.
• KEY_1:VALUE_1 es el par clave-valor que representa una etiqueta. Repite la marca --label para especificar varias etiquetas.
• KEY_2:VALUE_2 es el par clave-valor que representa una etiqueta. Añade varias etiquetas con la misma marca separando los pares clave:valor con comas.
• QUERY es una consulta válida.
• PROJECT_ID es el ID de tu proyecto (si no tienes ningún proyecto predeterminado configurado).
• DATASET es un conjunto de datos de tu proyecto.
• VIEW es el nombre de la vista que quieres crear.

Ejemplos:

Introduce el siguiente comando para crear una vista llamada myview en mydataset en tu proyecto predeterminado. El tiempo de vencimiento es de 3600 segundos (1 hora), la descripción es This is my view y la etiqueta es organization:development. La consulta usada para crear la vista consulta datos del conjunto de datos público "USA Name Data".

bq mk \
--use_legacy_sql=false \
--expiration 3600 \
--description "This is my view" \
--label organization:development \
--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 crear una vista llamada myview en mydataset en myotherproject. La descripción es This is my view, la etiqueta es organization:development y el vencimiento de la vista es el mismo que el de la tabla predeterminada del conjunto de datos. La consulta usada para crear la vista consulta datos del conjunto de datos público "USA Name Data".

bq mk \
--use_legacy_sql=false \
--description "This is my view" \
--label organization:development \
--project_id myotherproject \
--view \
'SELECT
  name,
  number
FROM
  `bigquery-public-data.usa_names.usa_1910_current`
WHERE
  gender = "M"
ORDER BY
  number DESC' \
mydataset.myview

Una vez creada la vista, puedes actualizar su fecha de vencimiento, su descripción y sus etiquetas. Para obtener más información, consulta Actualizar vistas.

Terraform

Usa el recurso google_bigquery_table.

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

En el siguiente ejemplo se crea una vista llamada myview:

resource "google_bigquery_dataset" "default" {
  dataset_id                      = "mydataset"
  default_partition_expiration_ms = 2592000000  # 30 days
  default_table_expiration_ms     = 31536000000 # 365 days
  description                     = "dataset description"
  location                        = "US"
  max_time_travel_hours           = 96 # 4 days

  labels = {
    billing_group = "accounting",
    pii           = "sensitive"
  }
}

resource "google_bigquery_table" "default" {
  dataset_id          = google_bigquery_dataset.default.dataset_id
  table_id            = "myview"
  deletion_protection = false # set to "true" in production

  view {
    query          = "SELECT global_id, faa_identifier, name, latitude, longitude FROM `bigquery-public-data.faa.us_airports`"
    use_legacy_sql = false
  }

}

Para aplicar la configuración de Terraform en un proyecto, sigue los pasos que se indican en las siguientes secciones. Google Cloud

Preparar Cloud Shell

1. Abre Cloud Shell.

2. Define el Google Cloud proyecto Google Cloud predeterminado en el que quieras aplicar tus configuraciones de Terraform.

   Solo tiene que ejecutar este comando una vez por proyecto y puede hacerlo en cualquier directorio.

   export GOOGLE_CLOUD_PROJECT=PROJECT_ID

   Las variables de entorno se anulan si defines valores explícitos en el archivo de configuración de Terraform.

Preparar el directorio

Cada archivo de configuración de Terraform debe tener su propio directorio (también llamado módulo raíz).

1. En Cloud Shell, crea un directorio y un archivo nuevo en ese directorio. El nombre del archivo debe tener la extensión .tf. Por ejemplo, main.tf. En este tutorial, nos referiremos al archivo como main.tf.

   mkdir DIRECTORY && cd DIRECTORY && touch main.tf

2. Si estás siguiendo un tutorial, puedes copiar el código de ejemplo de cada sección o paso.

   Copia el código de ejemplo en el archivo main.tf que acabas de crear.

   También puedes copiar el código de GitHub. Se recomienda cuando el fragmento de Terraform forma parte de una solución integral.

3. Revisa y modifica los parámetros de ejemplo para aplicarlos a tu entorno.
4. Guarda los cambios.
5. Inicializa Terraform. Solo tienes que hacerlo una vez por directorio.

   terraform init

   Si quieres usar la versión más reciente del proveedor de Google, incluye la opción -upgrade:

   terraform init -upgrade

Aplica los cambios

1. Revisa la configuración y comprueba que los recursos que va a crear o actualizar Terraform se ajustan a tus expectativas:

   terraform plan

   Haga las correcciones necesarias en la configuración.

2. Aplica la configuración de Terraform ejecutando el siguiente comando e introduciendo yes en la petición:

   terraform apply

   Espera hasta que Terraform muestre el mensaje "Apply complete!".

3. Abre tu Google Cloud proyecto para ver los resultados. En la Google Cloud consola, ve a tus recursos en la interfaz de usuario para asegurarte de que Terraform los ha creado o actualizado.

API

Llama al método tables.insert con un recurso de tabla que contenga una propiedad view.

Go

import (
	"context"
	"fmt"

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

// createView demonstrates creation of a BigQuery logical view.
func createView(projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydatasetid"
	// tableID := "mytableid"
	ctx := context.Background()

	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("&bigquery.NewClient: %v", err)
	}
	defer client.Close()

	meta := bigquery.TableMetadata{
		// This example shows how to create a view of the shakespeare sample dataset, which
		// provides word frequency information.  This view restricts the results to only contain
		// results for works that contain the "king" in the title, e.g. King Lear, King Henry V, etc.
		ViewQuery: "SELECT word, word_count, corpus, corpus_date FROM `bigquery-public-data.samples.shakespeare` WHERE corpus LIKE '%king%'",
	}
	if err := client.Dataset(datasetID).Table(tableID).Create(ctx, meta); err != nil {
		return err
	}
	return nil
}

Java

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 create a view
public class CreateView {

  public static void main(String[] args) {
    // 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 query =
        String.format(
            "SELECT TimestampField, StringField, BooleanField FROM %s.%s", datasetName, tableName);
    createView(datasetName, viewName, query);
  }

  public static void createView(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();

      TableId tableId = TableId.of(datasetName, viewName);

      ViewDefinition viewDefinition =
          ViewDefinition.newBuilder(query).setUseLegacySql(false).build();

      bigquery.create(TableInfo.of(tableId, viewDefinition));
      System.out.println("View created successfully");
    } catch (BigQueryException e) {
      System.out.println(";View was not created. \n" + e.toString());
    }
  }
}

Node.js

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

async function createView() {
  // Creates a new view named "my_shared_view" in "my_dataset".

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const myDatasetId = "my_table"
  // const myTableId = "my_table"
  // const projectId = "bigquery-public-data";
  // const sourceDatasetId = "usa_names"
  // const sourceTableId = "usa_1910_current";
  const myDataset = await bigquery.dataset(myDatasetId);

  // For all options, see https://cloud.google.com/bigquery/docs/reference/v2/tables#resource
  const options = {
    view: `SELECT name 
    FROM \`${projectId}.${sourceDatasetId}.${sourceTableId}\`
    LIMIT 10`,
  };

  // Create a new view in the dataset
  const [view] = await myDataset.createTable(myTableId, options);

  console.log(`View ${view.id} created.`);
}

Python

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 'W'.
view.view_query = f"SELECT name, post_abbr FROM `{source_id}` WHERE name LIKE 'W%'"

# Make an API request to create the view.
view = client.create_table(view)
print(f";Created {view.table_type}: {str(view.reference)}")