Crea visualizzazioni

Console

1. Dopo aver eseguito una query, fai clic sul pulsante Salva visualizzazione sopra la query finestra dei risultati per salvare la query come visualizzazione.

   

2. Nella finestra di dialogo Salva visualizzazione:

   • In Nome progetto, seleziona un progetto in cui archiviare la vista.
   • In Nome set di dati, scegli un set di dati in cui archiviare la vista. Il set di dati che contiene la tua vista e quello che contiene le tabelle a cui fa riferimento la vista devono trovarsi nella stessa località.
   • In Nome tabella, inserisci il nome della vista.
   • Fai clic su Salva.

SQL

Utilizza la CREATE VIEW. Le seguenti esempio crea una vista denominata usa_male_names dai nomi USA set di dati pubblico:

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

   Vai a BigQuery

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

   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. Fai clic su play_circle Esegui.

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

bq

Usa il comando bq mk con il flag --view. Per le query GoogleSQL, aggiungi il flag --use_legacy_sql e impostalo su false. Alcuni facoltativi i parametri includono --add_tags, --expiration, --description e --label. Per un elenco completo dei parametri, vedi Comando bq mk riferimento.

Se la query fa riferimento a risorse di funzione definita dall'utente esterne archiviati in Cloud Storage o in file locali, utilizza --view_udf_resource per specificare queste risorse. La La segnalazione di --view_udf_resource non è mostrata qui. Per ulteriori informazioni delle funzioni definite dall'utente, consulta UDF.

Se stai creando una vista in un progetto diverso da quello predefinito, specifica l'ID progetto utilizzando il flag --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='QUERY' \
--project_id=PROJECT_ID \
DATASET.VIEW

Sostituisci quanto segue:

• PATH_TO_FILE è l'URI o il percorso del file system locale a un file di codice da caricare e valutare immediatamente come risorsa UDF usata dalla vista. Ripeti il flag per specificare più file.
• INTEGER imposta la durata (in secondi) di la vista. Se INTEGER è 0, la visualizzazione non scadono. Se non includi il flag --expiration, BigQuery crea la vista con la durata predefinita della tabella del set di dati.
• DESCRIPTION è una descrizione della visualizzazione tra virgolette.
• KEY_1:VALUE_1 è la coppia chiave-valore che rappresenta un label. Ripeti il flag --label per specificare più etichette.
• KEY_2:VALUE_2 è la coppia chiave-valore che rappresenta un tag. Aggiungi più tag sotto lo stesso flag con virgole tra le coppie chiave:valore.
• QUERY è una query valida.
• PROJECT_ID è il tuo ID progetto (se non disponi di è configurato un progetto predefinito).
• DATASET è un set di dati nel tuo progetto.
• VIEW è il nome della vista che vuoi creare.

Esempi:

Inserisci questo comando per creare una vista denominata myview in mydataset nel progetto predefinito. La scadenza è impostata su 3600 secondi (1 ora), la descrizione è impostata su This is my view e l'etichetta è impostata su organization:development. La query utilizzata per creare la vista esegue query sui dati del set di dati pubblico Name Data USA.

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

Inserisci questo comando per creare una vista denominata myview in mydataset a myotherproject. La descrizione è impostata su This is my view, l'etichetta è impostata su organization:development, e la scadenza della vista è impostata sulla tabella predefinita del set di dati la scadenza del periodo di conservazione. La query utilizzata per creare la vista esegue query sui dati del set di dati pubblico Name Data USA.

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

Dopo aver creato una vista, puoi aggiornarne scadenza, descrizione ed etichette. Per ulteriori informazioni, vedi Aggiornamento delle visualizzazioni.

Terraform

Utilizza la google_bigquery_table risorsa.

Per eseguire l'autenticazione in BigQuery, configura il valore predefinito dell'applicazione Credenziali. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

L'esempio seguente crea una vista denominata 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
  }

}

Per applicare la configurazione Terraform a un progetto Google Cloud, completa i passaggi nella le sezioni seguenti.

Prepara Cloud Shell

1. Avvia Cloud Shell.

2. Imposta il progetto Google Cloud predefinito dove vuoi applicare le configurazioni Terraform.

   Devi eseguire questo comando una sola volta per progetto e puoi eseguirlo in qualsiasi directory.

   export GOOGLE_CLOUD_PROJECT=PROJECT_ID

   Le variabili di ambiente vengono sostituite se imposti valori espliciti in Terraform di configurazione del deployment.

Prepara la directory

Ogni file di configurazione Terraform deve avere una directory (inoltre chiamato modulo principale).

1. In Cloud Shell, crea una directory e un nuovo all'interno di quella directory. Il nome del file deve contenere .tf, ad esempio main.tf. In questo tutorial, il file è denominato main.tf.

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

2. Se stai seguendo un tutorial, puoi copiare il codice campione in ogni sezione o passaggio.

   Copia il codice campione nel nuovo oggetto main.tf.

   Facoltativamente, copia il codice da GitHub. Opzione consigliata quando lo snippet Terraform fa parte di una soluzione end-to-end.

3. Esamina e modifica i parametri di esempio da applicare al tuo ambiente.
4. Salva le modifiche.
5. Inizializza Terraform. Devi eseguire questa operazione una sola volta per directory.

   terraform init

   Facoltativamente, per utilizzare la versione più recente del provider Google, includi -upgrade :

   terraform init -upgrade

Applica le modifiche

1. Rivedi la configurazione e verifica che le risorse che Terraform creerà o che l'aggiornamento soddisfi le tue aspettative:

   terraform plan

   Apporta le correzioni necessarie alla configurazione.

2. Applica la configurazione Terraform eseguendo questo comando e inserendo yes alla richiesta:

   terraform apply

   Attendi finché Terraform non visualizzi il messaggio "Applicazione completata!". .

3. Apri il progetto Google Cloud per visualizzare i risultati. Nella console Google Cloud, vai alle risorse nella UI per assicurarti create o aggiornate da Terraform.

API

Chiama il metodo tables.insert con una risorsa di tabella contiene una proprietà view.

Vai

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