Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Creare viste logiche

Questo documento descrive come creare viste logiche in BigQuery.

Puoi creare una vista logica nei seguenti modi:

Utilizzando la Google Cloud console.
Utilizzando il comando bq mk dello strumento a riga di comando bq.
Chiamando il tables.insert metodo API.
Utilizzando le librerie client.
Inviando un'istruzione DDL (Data Definition Language) CREATE VIEW.

Limitazioni delle viste

Le viste BigQuery sono soggette alle seguenti limitazioni:

Le viste sono di sola lettura. Ad esempio, non puoi eseguire query che inseriscono, aggiornano o eliminano dati.
Se la vista fa riferimento a tabelle di località remote, devi abilitare le query globali prima di creare la vista.
Un riferimento all'interno di una vista deve essere qualificato con un set di dati. Il set di dati predefinito non influisce sul corpo di una vista.
Non puoi utilizzare il metodo API JSON TableDataList per recuperare i dati da una vista. Per saperne di più, consulta Tabledata: list.
Quando utilizzi le viste, non puoi combinare query GoogleSQL e SQL precedente. Una query GoogleSQL non può fare riferimento a una vista definita utilizzando la sintassi SQL precedente.
Non puoi fare riferimento ai parametri di query nelle viste.
Gli schemi delle tabelle sottostanti vengono archiviati con la vista quando viene creata. Se le colonne vengono aggiunte, eliminate o modificate dopo la creazione della vista, quest'ultima non viene aggiornata automaticamente e lo schema segnalato rimarrà impreciso finché la definizione SQL della vista non viene modificata o la vista non viene ricreata. Anche se lo schema segnalato potrebbe essere impreciso, tutte le query inviate producono risultati accurati.
Non puoi aggiornare automaticamente una vista SQL precedente alla sintassi GoogleSQL. Per modificare la query utilizzata per definire una vista, puoi utilizzare:
- L'op0}opzione Modifica query nella Google Cloud console
- Il comando bq update --view nello strumento a riga di comando bq
- Le librerie client di BigQuery
- I metodi API update o patch.
Non puoi includere una funzione definita dall'utente temporanea o una tabella temporanea nella query SQL che definisce una vista.
Non puoi fare riferimento a una vista in una query di tabella con caratteri jolly.
Le viste logiche non possono ereditare o definire esplicitamente tipi di dati con parametri, come STRING(n), poiché i tipi di dati con parametri sono supportati solo per le colonne della tabella di base e le variabili di script.

Per informazioni su quote e limiti applicabili alle viste, consulta Limiti delle viste.

Prima di iniziare

Concedi i ruoli IAM (Identity and Access Management) che forniscono agli utenti le autorizzazioni necessarie per eseguire ogni attività descritta in questo documento.

Autorizzazioni obbligatorie

Le viste vengono trattate come risorse tabella in BigQuery, pertanto la creazione di una vista richiede le stesse autorizzazioni della creazione di una tabella. Devi inoltre disporre delle autorizzazioni per eseguire query su tutte le tabelle a cui fa riferimento la query SQL della vista.

Per creare un set di dati, devi disporre dell'autorizzazione IAM bigquery.datasets.create sul progetto.
Per creare una vista, devi disporre dell'autorizzazione IAM bigquery.tables.create sul set di dati. Il ruolo IAM predefinito roles/bigquery.dataEditor include le autorizzazioni necessarie per creare una vista.
Per creare una vista che esegue query su una tabella a cui non hai accesso, devi disporre dell'autorizzazione bigquery.tables.getData sulla tabella su cui viene eseguita la query dalla vista.

Per saperne di più sui ruoli e sulle autorizzazioni IAM in BigQuery, consulta Ruoli e autorizzazioni predefiniti.

Denominazione delle viste

Quando crei una vista in BigQuery, il nome della vista deve essere univoco per ogni set di dati. Il nome della vista può:

Contenere caratteri con un totale massimo di 1024 byte UTF-8.
Contenere caratteri Unicode nelle categorie L (lettera), M (segno), N (numero), Pc (connettore, incluso il trattino basso), Pd (trattino), Zs (spazio). Per saperne di più, consulta Categoria generale.

Di seguito sono riportati alcuni esempi di nomi di viste validi: view 01, ग्राहक, 00_お客様, étudiant-01.

Precisazioni:

I nomi delle tabelle sono sensibili alle maiuscole per impostazione predefinita. mytable e MyTable possono coesistere nello stesso set di dati, a meno che non facciano parte di un set di dati con la distinzione tra maiuscole e minuscole disattivata.
Alcuni nomi di viste e prefissi di nomi di viste sono riservati. Se ricevi un messaggio di errore che indica che il nome o il prefisso della vista è riservato, seleziona un nome diverso e riprova.
Se includi più operatori punto (.) in una sequenza, gli operatori duplicati vengono rimossi implicitamente.

Ad esempio, project_name....dataset_name..table_name

Diventa project_name.dataset_name.table_name

Creare una vista

Puoi creare una vista componendo una query SQL utilizzata per definire i dati accessibili alla vista. La query SQL deve essere costituita da un'istruzione SELECT. Altri tipi di istruzioni (ad esempio le istruzioni DML) e query con più istruzioni non sono consentite nelle query delle viste, ad eccezione della @@session_id variabile di sistema.

Per creare una vista:

Console

Nella Google Cloud console, vai alla pagina BigQuery.

Vai a BigQuery
Fai clic su Query SQL.
Nell'editor di query, inserisci una query SQL valida.

In alternativa, puoi aprire una query salvata.
Fai clic su Salva > Salva vista.
Nella finestra di dialogo Salva vista:
- Nel menu Progetto, seleziona un progetto in cui archiviare la vista.
- Nel menu Set di dati, seleziona un set di dati o creane uno nuovo in cui archiviare la vista. Il set di dati di destinazione per una vista salvata deve trovarsi in nella stessa regione dell'origine.
- Nel campo Tabella, inserisci il nome della vista.
- Fai clic su Salva.

SQL

Utilizza l' CREATE VIEW statement. L'esempio seguente crea una vista denominata usa_male_names dal set di dati pubblico USA Names:

Nella Google Cloud console, vai alla pagina BigQuery.

Vai a BigQuery

Nell'editor di 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
);

Fai clic su Esegui.

Per saperne di più su come eseguire le query, consulta Eseguire una query interattiva.

bq

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

Se la query fa riferimento a risorse di funzione definita dall'utente (UDF) esterne archiviate in Cloud Storage o in file locali, utilizza il flag --view_udf_resource per specificare queste risorse. Il flag --view_udf_resource non è illustrato qui. Per saperne di più sull'utilizzo delle UDF, 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 è il percorso URI o del file system locale di un file di codice da caricare e valutare immediatamente come risorsa UDF utilizzata dalla vista. Ripeti il flag per specificare più file.
INTEGER imposta la durata (in secondi) della vista. Se INTEGER è 0, la vista non scade. Se non includi il flag --expiration, BigQuery crea la vista con la durata predefinita della tabella del set di dati.
DESCRIPTION è una descrizione della vista tra virgolette.
KEY_1:VALUE_1 è la coppia chiave-valore che rappresenta un' etichetta. Ripeti il flag --label per specificare più etichette.
KEY_2:VALUE_2 è la coppia chiave-valore che rappresenta un tag. Aggiungi più tag con lo stesso flag con le coppie chiave-valore separate da virgole.
QUERY è una query valida.
PROJECT_ID è l'ID progetto (se non hai configurato un progetto predefinito).
DATASET è un set di dati nel tuo progetto.
VIEW è il nome della vista che vuoi creare.

Esempi:

Inserisci il seguente comando per creare una vista denominata myview in mydataset nel tuo progetto predefinito. Il tempo di scadenza è impostato 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 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

Inserisci il seguente comando per creare una vista denominata myview in mydataset in myotherproject. La descrizione è impostata su This is my view, l'etichetta è impostata su organization:development e la scadenza della vista è impostata sulla scadenza predefinita della tabella del set di dati. La query utilizzata per creare la vista esegue query sui dati del set di dati pubblico 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

Dopo aver creato la vista, puoi aggiornarne la scadenza, la descrizione e le etichette. Per saperne di più, consulta Aggiornare le viste.

Terraform

Utilizza la google_bigquery_table risorsa.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, 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"

  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 in un Google Cloud progetto, completa i passaggi nelle sezioni seguenti.

Preparare Cloud Shell

Avvia Cloud Shell.
Imposta il Google Cloud progetto predefinito in cui 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 nel file di configurazione Terraform

Preparare la directory

Ogni file di configurazione Terraform deve avere una propria directory (chiamata anche modulo root).

In Cloud Shell, crea una directory e un nuovo file al suo interno. Il nome del file deve avere l' .tf estensione, ad esempio main.tf. In questo tutorial, il file viene chiamato main.tf.
```
mkdir DIRECTORY && cd DIRECTORY && touch main.tf
```
Se stai seguendo un tutorial, puoi copiare il codice campione in ogni sezione o passaggio.

Copia il codice campione nel file main.tf appena creato.

Facoltativamente, copia il codice da GitHub. Questa operazione è consigliata quando lo snippet Terraform fa parte di una soluzione end-to-end.
Esamina e modifica i parametri di esempio da applicare al tuo ambiente.
Salva le modifiche.
Inizializza Terraform. Devi eseguire questa operazione una sola volta per directory.
```
terraform init
```
Facoltativamente, per utilizzare la versione più recente del provider Google, includi l'opzione -upgrade:
```
terraform init -upgrade
```

Applicare le modifiche

Esamina la configurazione e verifica che le risorse che Terraform creerà o aggiornerà corrispondano alle tue aspettative:
```
terraform plan
```
Apporta le correzioni necessarie alla configurazione.
Applica la configurazione Terraform eseguendo il comando seguente e inserendo yes al prompt:
```
terraform apply
```
Attendi che Terraform visualizzi il messaggio "Apply complete!" (Applicazione completata).
Apri il tuo Google Cloud progetto per visualizzare i risultati. Nella Google Cloud console, vai alle risorse nell'interfaccia utente per assicurarti che Terraform le abbia create o aggiornate.

API

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

Vai

Prima di provare questo esempio, segui le istruzioni di configurazione di Go nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'Go API BigQuery.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

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

Prima di provare questo esempio, segui le istruzioni di configurazione Java nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Java BigQuery.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.TableId;
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

Prima di provare questo esempio, segui le istruzioni di configurazione Node.js nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'Node.js API BigQuery.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

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

async function 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

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API PythonBigQuery.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

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

Dopo aver creato la vista, puoi eseguirne una query come se fosse una tabella.

Sicurezza delle viste

Per controllare l'accesso alle viste in BigQuery, consulta Viste autorizzate.

Passaggi successivi

Per informazioni sulla creazione di una vista autorizzata, consulta Creare viste autorizzate.
Per informazioni su come ottenere i metadati delle viste, consulta Ottieni informazioni sulle viste.
Per saperne di più sulla gestione delle viste, consulta Gestire le viste.