Créer des vues

Ce document explique comment créer des vues dans BigQuery.

Vous pouvez créer une vue dans BigQuery de différentes manières :

Utiliser la console Google Cloud
Utiliser la commande bq mk de l'outil de ligne de commande bq
Appeler la méthode API tables.insert
En utilisant les bibliothèques clientes
En soumettant une instruction LDD (langage de définition de données) CREATE VIEW

Limites associées aux vues

Les vues BigQuery font l'objet des limites suivantes :

Les vues sont en lecture seule. Par exemple, vous ne pouvez pas exécuter de requêtes qui insèrent, mettent à jour ou suppriment des données.
L'ensemble de données contenant la vue et celui contenant les tables référencées par celle-ci doivent se trouver dans le même emplacement.
Une référence à l'intérieur d'une vue doit être qualifiée avec un ensemble de données. L'ensemble de données par défaut n'affecte pas le corps d'une vue.
Vous ne pouvez pas utiliser la méthode d'API JSON TableDataList pour extraire des données d'une vue. Pour en savoir plus, consultez la page sur la méthode Tabledata.list.
Lorsque vous utilisez des vues, vous ne pouvez pas combiner des requêtes en GoogleSQL et en ancien SQL. Une requête en GoogleSQL ne peut pas référencer une vue définie à l'aide d'une syntaxe en ancien SQL.
Vous ne pouvez pas référencer les paramètres de requête dans les vues.
Les schémas des tables sous-jacentes sont stockés avec la vue lors de la création de celle-ci. Si des colonnes sont ajoutées, supprimées ou modifiées après la création de la vue, le schéma indiqué sera inexact jusqu'à ce que la vue soit mise à jour. Même avec un schéma inexact, toutes les requêtes soumises produisent des résultats corrects.
Vous ne pouvez pas mettre à jour automatiquement une vue en ancien SQL vers la syntaxe GoogleSQL. Pour modifier la requête utilisée pour définir une vue, vous pouvez utiliser les éléments suivants :
- L'option Modifier la requête dans la console Google Cloud
- La commande bq update --view de l'outil de ligne de commande bq
- Les bibliothèques clientes BigQuery
- Les méthodes API update ou patch
Vous ne pouvez pas inclure une fonction temporaire définie par l'utilisateur ou une table temporaire dans la requête SQL qui définit une vue.
Vous ne pouvez pas référencer de vue dans une requête de table générique.

Pour plus d'informations sur les quotas et les limites applicables aux vues, consultez la section Limites associées aux vues.

Avant de commencer

Attribuez aux utilisateurs des rôles IAM (Identity and Access Management) incluant les autorisations nécessaires pour effectuer l'ensemble des tâches du présent document.

Autorisations requises

Les vues sont traitées comme des ressources de table dans BigQuery. Par conséquent, la création d'une vue nécessite les mêmes autorisations que la création d'une table. Vous devez également être autorisé à interroger les tables référencées par la requête SQL de la vue.

Pour créer une vue, vous avez besoin de l'autorisation IAM bigquery.tables.create. Le rôle IAM prédéfini roles/bigquery.dataEditor inclut les autorisations dont vous avez besoin pour créer une vue.

En outre, si vous disposez de l'autorisation bigquery.datasets.create, vous pouvez créer des vues dans les ensembles de données que vous créez. Pour créer une vue pour des données qui ne vous appartiennent pas, vous devez disposer de l'autorisation bigquery.tables.getData pour cette table.

Pour en savoir plus sur les rôles et les autorisations IAM dans BigQuery, consultez la page Rôles prédéfinis et autorisations.

Dénomination des vues

Lorsque vous créez une vue dans BigQuery, son nom doit être unique pour chaque ensemble de données. Le nom de la vue peut :

contenir des caractères comportant jusqu'à 1 024 octets UTF-8 ;
contenir des caractères Unicode des catégories L (lettre), M (marque), N (nombre), Pc (ponctuation de type connecteur, y compris trait de soulignement), Pd (ponctuation de type tiret), Zs (espace). Pour en savoir plus, consultez la section décrivant les catégories générales.

Voici des exemples de noms de vues valides : view 01, ग्राहक, 00_お客様, étudiant-01.

Mises en garde :

Les noms de table sont sensibles à la casse par défaut. mytable et MyTable peuvent coexister dans le même ensemble de données, sauf si elles font partie d'un ensemble de données avec la sensibilité à la casse désactivée.
Certains noms de vues et préfixes de noms de vues sont réservés. Si vous recevez une erreur indiquant que le nom ou le préfixe de votre vue est réservé, sélectionnez-en un autre et réessayez.
Si vous incluez plusieurs opérateurs point (.) dans une séquence, les opérateurs en double sont implicitement supprimés.

Par exemple, ceci :project_name....dataset_name..table_name

Devient : project_name.dataset_name.table_name

Créer une vue

Vous pouvez créer une vue en saisissant une requête SQL utilisée pour définir les données accessibles à la vue. La requête SQL doit contenir une instruction SELECT. Les autres types d'instructions (par exemple, les instructions LMD) et les requêtes multi-instructions ne sont pas autorisés dans les requêtes d'affichage.

Pour créer une vue :

Console

Après avoir exécuté une requête, pour enregistrer celle-ci en tant que vue, cliquez sur le bouton Enregistrer l'affichage qui figure au-dessus de la fenêtre des résultats de la requête.
Dans la boîte de dialogue Enregistrer la vue :
- Dans le champ Nom du projet, sélectionnez un projet où stocker la vue.
- Dans le champ Nom de l'ensemble de données, choisissez un ensemble de données où stocker la vue. L'ensemble de données contenant la vue et celui contenant les tables référencées par celle-ci doivent se trouver dans le même emplacement.
- Dans Nom de la table, saisissez le nom de la vue.
- Cliquez sur Enregistrer.

SQL

Utilisez l'instruction CREATE VIEW. L'exemple suivant crée une vue nommée usa_male_names à partir de l'ensemble de données public "USA Names" :

Dans Google Cloud Console, accédez à la page BigQuery.

Accéder à BigQuery

Dans l'éditeur de requête, saisissez l'instruction suivante :

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

Cliquez sur Exécuter.

Pour en savoir plus sur l'exécution des requêtes, consultez Exécuter une requête interactive.

bq

Exécutez la commande bq mk avec l'option --view. Pour les requêtes GoogleSQL, ajoutez l'option --use_legacy_sql et définissez-la sur false. Les paramètres facultatifs incluent --expiration, --description et --label.

Si votre requête fait référence à des ressources externes de fonction définie par l'utilisateur (UDF), stockées dans Cloud Storage ou dans des fichiers locaux, spécifiez ces ressources à l'aide de l'option --view_udf_resource. L'option --view_udf_resource n'est pas présentée ici. Pour en savoir plus sur l'utilisation des fonctions définies par l'utilisateur, consultez la section Fonctions définies par l'utilisateur.

Si vous créez une vue dans un projet autre que votre projet par défaut, ajoutez l'ID du projet à la commande en utilisant l'option --project_id.

bq mk \
--use_legacy_sql=false \
--view_udf_resource=PATH_TO_FILE \
--expiration INTEGER \
--description "DESCRIPTION" \
--label KEY:VALUE \
--view 'QUERY' \
--project_id PROJECT_ID \
DATASET.VIEW

Remplacez les éléments suivants :

PATH_TO_FILE est le chemin de l'URI ou du système de fichiers local permettant d'accéder à un fichier de code, qui doit être chargé et évalué immédiatement en tant que ressource de fonction définie par l'utilisateur utilisée par la vue. Répétez l'option pour spécifier plusieurs fichiers.
INTEGER définit la durée de vie (en secondes) de la vue. Si INTEGER est défini sur 0, la vue n'expire pas. Si vous n'incluez pas l'option --expiration, BigQuery crée la vue avec la durée de vie par défaut de la table de l'ensemble de données.
DESCRIPTION est la description du libellé.
KEY:VALUE est la paire clé-valeur qui représente un libellé. Répétez l'option --label pour spécifier plusieurs libellés.
QUERY est une requête valide.
PROJECT_ID est l'ID de votre projet (si vous n'avez pas configuré de projet par défaut).
DATASET est un ensemble de données dans votre projet.
VIEW est le nom de la vue que vous souhaitez créer.

Exemples :

Saisissez la commande suivante pour créer une vue nommée myview dans l'ensemble de données mydataset au sein de votre projet par défaut. Le délai d'expiration est défini sur 3 600 secondes (une heure), la description est définie sur This is my view et le libellé est défini sur organization:development. La requête utilisée pour créer la vue interroge les données de l'ensemble de données public 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

Saisissez la commande suivante pour créer une vue nommée myview dans l'ensemble de données mydataset au sein du projet myotherproject. La description est définie sur This is my view, le libellé est défini sur organization:development et le délai d'expiration de la vue est défini sur le délai d'expiration par défaut pour les tables de l'ensemble de données. La requête utilisée pour créer la vue interroge les données de l'ensemble de données public 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

Une fois la vue créée, vous pouvez mettre à jour son délai d'expiration, sa description et ses libellés. Pour en savoir plus, consultez la page Mettre à jour les propriétés d'une vue.

Terraform

Utilisez la ressource google_bigquery_table.

L'exemple suivant crée une vue nommée 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
  }

}

Pour appliquer votre configuration Terraform dans un projet Google Cloud, suivez les procédures des sections suivantes.

Préparer Cloud Shell

Lancez Cloud Shell.
Définissez le projet Google Cloud par défaut dans lequel vous souhaitez appliquer vos configurations Terraform.

Vous n'avez besoin d'exécuter cette commande qu'une seule fois par projet et vous pouvez l'exécuter dans n'importe quel répertoire.
```
export GOOGLE_CLOUD_PROJECT=PROJECT_ID
```
Les variables d'environnement sont remplacées si vous définissez des valeurs explicites dans le fichier de configuration Terraform.

Préparer le répertoire

Chaque fichier de configuration Terraform doit avoir son propre répertoire (également appelé module racine).

Dans Cloud Shell, créez un répertoire et un nouveau fichier dans ce répertoire. Le nom du fichier doit comporter l'extension .tf, par exemple main.tf. Dans ce tutoriel, le fichier est appelé main.tf.
```
mkdir DIRECTORY && cd DIRECTORY && touch main.tf
```
Si vous suivez un tutoriel, vous pouvez copier l'exemple de code dans chaque section ou étape.

Copiez l'exemple de code dans le fichier main.tf que vous venez de créer.

Vous pouvez également copier le code depuis GitHub. Cela est recommandé lorsque l'extrait Terraform fait partie d'une solution de bout en bout.
Examinez et modifiez les exemples de paramètres à appliquer à votre environnement.
Enregistrez les modifications.
Initialisez Terraform. Cette opération n'est à effectuer qu'une seule fois par répertoire.
```
terraform init
```
Vous pouvez également utiliser la dernière version du fournisseur Google en incluant l'option -upgrade :
```
terraform init -upgrade
```

Appliquer les modifications

Examinez la configuration et vérifiez que les ressources que Terraform va créer ou mettre à jour correspondent à vos attentes :
```
terraform plan
```
Corrigez les modifications de la configuration si nécessaire.
Appliquez la configuration Terraform en exécutant la commande suivante et en saisissant yes lorsque vous y êtes invité :
```
terraform apply
```
Attendez que Terraform affiche le message "Apply completed!" (Application terminée).
Ouvrez votre projet Google Cloud pour afficher les résultats. Dans la console Google Cloud, accédez à vos ressources dans l'interface utilisateur pour vous assurer que Terraform les a créées ou mises à jour.

API

Appelez la méthode tables.insert avec une ressource de table contenant une propriété view.

Go

Avant d'essayer cet exemple, suivez les instructions de configuration pour Go du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour Go.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes.

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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Java du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour 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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Node.js du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour 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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Python du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour 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)}")

Une fois la vue créée, vous l'interrogez de la même manière qu'une table.

Afficher la sécurité

Pour contrôler l'accès aux vues dans BigQuery, consultez la page Vues autorisées.

Étapes suivantes

Pour en savoir plus sur la création de vues autorisées, consultez la page Créer des vues autorisées.
Pour en savoir plus sur l'obtention de métadonnées de vue, consultez la page Obtenir des informations sur les vues.
Pour en savoir plus sur la gestion des vues, consultez la page Gérer les vues.