Créer et utiliser des tables

Ce document explique comment créer et utiliser des tables standards (intégrées) dans BigQuery. Pour en savoir plus sur la création d'autres types de tables, consultez les pages suivantes :

Après avoir créé une table, vous pouvez :

  • contrôler l'accès aux données de votre table ;
  • obtenir des informations sur vos tables ;
  • répertorier les tables dans un ensemble de données ;
  • obtenir les métadonnées d'une table.

Pour en savoir plus sur la gestion des tables, y compris la mise à jour des propriétés de tables, la copie et la suppression de tables, consultez la section Gérer des tables.

Avant de commencer

Avant de créer une table dans BigQuery, procédez comme suit :

Nommer les tables

Lorsque vous créez une table dans BigQuery, le nom de la table doit être unique pour chaque ensemble de données. Le nom de la table 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 table valides : table 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 tables et préfixes de noms de tables sont réservés. Si vous recevez une erreur indiquant que le nom ou le préfixe de votre table 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 des tables

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

  • Manuellement, dans la console Google Cloud ou en exécutant la commande bq mk de l'outil de ligne de commande bq
  • De manière automatisée, en appelant la méthode API tables.insert
  • En utilisant les bibliothèques clientes
  • À partir des résultats de requête
  • En définissant une table qui référence une source de données externe
  • Lorsque vous chargez des données
  • Via une instruction LDD (langage de définition de données) CREATE TABLE

Autorisations requises

Pour créer une table, vous devez disposer des autorisations IAM suivantes :

  • bigquery.tables.create
  • bigquery.tables.updateData
  • bigquery.jobs.create

En outre, vous pouvez avoir besoin de l'autorisation bigquery.tables.getData pour accéder aux données que vous écrivez dans la table.

Chacun des rôles IAM prédéfinis suivants inclut les autorisations dont vous avez besoin pour créer une table :

  • roles/bigquery.dataEditor
  • roles/bigquery.dataOwner
  • roles/bigquery.admin (inclut l'autorisation bigquery.jobs.create)
  • roles/bigquery.user (inclut l'autorisation bigquery.jobs.create)
  • roles/bigquery.jobUser (inclut l'autorisation bigquery.jobs.create)

En outre, si vous disposez de l'autorisation bigquery.datasets.create, vous pouvez créer et mettre à jour des tables dans les ensembles de données que vous créez.

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

Pour créer une table vide avec une définition de schéma :

Vous pouvez créer une table vide avec une définition de schéma de différentes manières :

  • En saisissant le schéma dans la console Google Cloud
  • En fournissant le schéma en ligne avec l'outil de ligne de commande bq.
  • En envoyant un fichier de schéma JSON avec l'outil de ligne de commande bq
  • En fournissant le schéma dans une ressource de table lorsque vous appelez la méthode API tables.insert.

Pour en savoir plus sur la spécification d'un schéma de table, consultez la page Spécifier un schéma.

Une fois la table créée, vous pouvez charger des données ou insérer des données dans celle-ci en y écrivant les résultats d'une requête.

Pour créer une table vide avec une définition de schéma :

Console

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

    Accéder à BigQuery

  2. Dans le volet Explorateur, développez votre projet, puis sélectionnez un ensemble de données.
  3. Dans la section Informations sur l'ensemble de données, cliquez sur Créer une table.
  4. Dans le panneau Créer une table, spécifiez les détails suivants :
    1. Dans la section Source, sélectionnez Table vide dans la liste Créer une table à partir de.
    2. Dans la section Destination, spécifiez les détails suivants :
      1. Pour Ensemble de données, sélectionnez l'ensemble de données dans lequel vous souhaitez créer la table.
      2. Dans le champ Table, saisissez le nom de la table que vous souhaitez créer.
      3. Vérifiez que le champ Type de table est défini sur Table native.
    3. Dans la section Schéma, saisissez la définition du schéma. Vous pouvez saisir les informations de schéma manuellement à l'aide de l'une des méthodes suivantes :
      • Option 1 : Cliquez sur Modifier sous forme de texte et collez le schéma sous la forme d'un tableau JSON. Lorsque vous utilisez un tableau JSON, vous générez le schéma en utilisant le même processus que pour la création d'un fichier de schéma JSON. Vous pouvez afficher le schéma d'une table existante au format JSON en saisissant la commande suivante :
            bq show --format=prettyjson dataset.table
            
      • Option 2 : Cliquez sur  Ajouter un champ et saisissez le schéma de la table. Spécifiez le nom, le type et le mode de chaque champ.
    4. Facultatif : spécifiez les paramètres de partitionnement et de clustering. Pour en savoir plus, consultez les pages Créer des tables partitionnées et Créer et utiliser des tables en cluster.
    5. Facultatif : dans la section Options avancées si vous souhaitez utiliser une clé de chiffrement gérée par le client, sélectionnezUtiliser une clé de chiffrement gérée par le client (CMEK). Par défaut, BigQuery chiffre le contenu client stocké au repos à l'aide d'une clé gérée par Google.
    6. Cliquez sur Créer une table.

SQL

L'exemple suivant crée une table nommée newtable qui expire le 1er janvier 2023 :

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

    Accéder à BigQuery

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

    CREATE TABLE mydataset.newtable (
      x INT64 OPTIONS (description = 'An optional INTEGER field'),
      y STRUCT <
        a ARRAY <STRING> OPTIONS (description = 'A repeated STRING field'),
        b BOOL
      >
    ) OPTIONS (
        expiration_timestamp = TIMESTAMP '2023-01-01 00:00:00 UTC',
        description = 'a table that expires in 2023',
        labels = [('org_unit', 'development')]);
    

  3. Cliquez sur Exécuter.

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

bq

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Exécutez la commande bq mk avec l'option --table ou -t. Vous pouvez fournir des informations de schéma de table en ligne ou via un fichier de schéma JSON. Les paramètres facultatifs incluent :

    • --expiration
    • --description
    • --time_partitioning_field
    • --time_partitioning_type
    • --range_partitioning
    • --clustering_fields
    • --destination_kms_key
    • --label

    --time_partitioning_field, --time_partitioning_type, --range_partitioning, --clustering_fields, et --destination_kms_key ne sont pas illustrés ici. Reportez-vous aux liens suivants pour plus d'informations sur ces paramètres facultatifs :

    Si vous créez une table dans un projet autre que votre projet par défaut, ajoutez l'ID du projet au nom de l'ensemble de données, en respectant le format suivant : project_id:dataset.

    Pour créer une table vide dans un ensemble de données existant avec une définition de schéma, saisissez le contenu suivant :

    bq mk \
    --table \
    --expiration integer \
    --description description \
    --label key_1:value_1 \
    --label key_2:value_2 \
    project_id:dataset.table \
    schema
    

    Remplacez les éléments suivants :

    • integer est la durée de vie par défaut (en secondes) de la table. La valeur minimale est de 3 600 secondes (une heure). L'heure d'expiration correspond à l'heure actuelle plus la valeur entière. Si vous définissez le délai d'expiration lorsque vous créez une table, le paramètre d'expiration de la table par défaut de l'ensemble de données est ignoré.
    • description est la description de la table entre guillemets.
    • key_1:value_1 et key_2:value_2 sont des paires clé/valeur qui spécifient des étiquettes.
    • project_id est l'ID de votre projet.
    • dataset est un ensemble de données dans votre projet.
    • table est le nom de la table que vous créez.
    • schema est une définition de schéma intégrée au format field:data_type,field:data_type ou le chemin d'accès au fichier de schéma JSON sur votre machine locale.

    Lorsque vous spécifiez le schéma sur la ligne de commande, vous ne pouvez pas inclure de type RECORD (STRUCT), ni de description de colonne. Vous ne pouvez pas non plus spécifier le mode de la colonne. Tous les modes prennent la valeur par défaut NULLABLE. Pour inclure des descriptions, des modes et des types RECORD, fournissez un fichier de schéma JSON à la place.

    Exemples :

    Saisissez la commande suivante pour créer une table à l'aide d'une définition de schéma intégrée. Cette commande crée une table nommée mytable dans l'ensemble de données mydataset au sein de votre projet par défaut. Le délai d'expiration de la table est défini sur 3 600 secondes (1 heure), la description est définie sur This is my table et le libellé est défini sur organization:development. La commande utilise le raccourci -t au lieu de --table. Le schéma est indiqué comme suit : qtr:STRING,sales:FLOAT,year:STRING.

    bq mk \
     -t \
     --expiration 3600 \
     --description "This is my table" \
     --label organization:development \
     mydataset.mytable \
     qtr:STRING,sales:FLOAT,year:STRING
    

    Saisissez la commande ci-dessous pour créer une table à l'aide d'un fichier de schéma JSON. Cette commande crée une table nommée mytable dans l'ensemble de données mydataset au sein de votre projet par défaut. Le délai d'expiration de la table est défini sur 3 600 secondes (1 heure), la description est définie sur This is my table et le libellé est défini sur organization:development. Le chemin d'accès au fichier de schéma est le suivant : /tmp/myschema.json.

    bq mk \
     --table \
     --expiration 3600 \
     --description "This is my table" \
     --label organization:development \
     mydataset.mytable \
     /tmp/myschema.json
    

    Saisissez la commande suivante pour créer une table à l'aide d'un fichier de schéma JSON. Cette commande crée une table nommée mytable dans l'ensemble de données mydataset au sein du projet myotherproject. Le délai d'expiration de la table est défini sur 3 600 secondes (1 heure), la description est définie sur This is my table et le libellé est défini sur organization:development. Le chemin d'accès au fichier de schéma est le suivant : /tmp/myschema.json.

    bq mk \
     --table \
     --expiration 3600 \
     --description "This is my table" \
     --label organization:development \
     myotherproject:mydataset.mytable \
     /tmp/myschema.json
    

    Une fois la table créée, vous pouvez mettre à jour son délai d'expiration, sa description et ses libellés. Vous pouvez également modifier la définition du schéma.

Terraform

Utilisez la ressource google_bigquery_table.

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.

Créer une table

L'exemple suivant crée une table nommée mytable :

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            = "mytable"
  deletion_protection = false # set to "true" in production

  schema = <<EOF
[
  {
    "name": "ID",
    "type": "INT64",
    "mode": "NULLABLE",
    "description": "Item ID"
  },
  {
    "name": "Item",
    "type": "STRING",
    "mode": "NULLABLE"
  }
]
EOF

}

Créer une table et accorder l'accès à cette table

L'exemple suivant crée une table nommée mytable et utilise ensuite la ressource google_bigquery_table_iam_policy pour accorder l'accès à cette table. N'effectuez cette étape que si vous souhaitez accorder l'accès à la table pour des comptes principaux qui n'ont pas accès à l'ensemble de données dans lequel se trouve la table.

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            = "mytable"
  deletion_protection = false # set to "true" in production

  schema = <<EOF
[
  {
    "name": "ID",
    "type": "INT64",
    "mode": "NULLABLE",
    "description": "Item ID"
  },
  {
    "name": "Item",
    "type": "STRING",
    "mode": "NULLABLE"
  }
]
EOF

}

data "google_iam_policy" "default" {
  binding {
    role = "roles/bigquery.dataOwner"
    members = [
      "user:raha@altostrat.com",
    ]
  }
}

resource "google_bigquery_table_iam_policy" "policy" {
  dataset_id  = google_bigquery_table.default.dataset_id
  table_id    = google_bigquery_table.default.table_id
  policy_data = data.google_iam_policy.default.policy_data
}

Créer une table avec une clé de chiffrement gérée par le client

L'exemple suivant crée un ensemble de données nommé mytable et utilise également les ressources google_kms_crypto_key et google_kms_key_ring pour spécifier une clé Cloud Key Management Service pour l'ensemble de données. Vous devez activer l'API Cloud Key Management Service avant d'exécuter cet exemple.

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            = "mytable"
  deletion_protection = false # set to "true" in production

  schema = <<EOF
[
  {
    "name": "ID",
    "type": "INT64",
    "mode": "NULLABLE",
    "description": "Item ID"
  },
  {
    "name": "Item",
    "type": "STRING",
    "mode": "NULLABLE"
  }
]
EOF

  encryption_configuration {
    kms_key_name = google_kms_crypto_key.crypto_key.id
  }

  depends_on = [google_project_iam_member.service_account_access]
}

resource "google_kms_crypto_key" "crypto_key" {
  name     = "example-key"
  key_ring = google_kms_key_ring.key_ring.id
}

resource "random_id" "default" {
  byte_length = 8
}

resource "google_kms_key_ring" "key_ring" {
  name     = "${random_id.default.hex}-example-keyring"
  location = "us"
}

# Enable the BigQuery service account to encrypt/decrypt Cloud KMS keys
data "google_project" "project" {
}

resource "google_project_iam_member" "service_account_access" {
  project = data.google_project.project.project_id
  role    = "roles/cloudkms.cryptoKeyEncrypterDecrypter"
  member  = "serviceAccount:bq-${data.google_project.project.number}@bigquery-encryption.iam.gserviceaccount.com"
}

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

Préparer Cloud Shell

  1. Lancez Cloud Shell.
  2. 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).

  1. 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
  2. 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.

  3. Examinez et modifiez les exemples de paramètres à appliquer à votre environnement.
  4. Enregistrez les modifications.
  5. 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

  1. 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.

  2. 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).

  3. 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 définie.

C#

Avant d'essayer cet exemple, suivez les instructions de configuration pour C# 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 C#.

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.


using Google.Cloud.BigQuery.V2;

public class BigQueryCreateTable
{
    public BigQueryTable CreateTable(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        var dataset = client.GetDataset(datasetId);
        // Create schema for new table.
        var schema = new TableSchemaBuilder
        {
            { "full_name", BigQueryDbType.String },
            { "age", BigQueryDbType.Int64 }
        }.Build();
        // Create the table
        return dataset.CreateTable(tableId: "your_table_id", schema: schema);
    }
}

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"
	"time"

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

// createTableExplicitSchema demonstrates creating a new BigQuery table and specifying a schema.
func createTableExplicitSchema(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()

	sampleSchema := bigquery.Schema{
		{Name: "full_name", Type: bigquery.StringFieldType},
		{Name: "age", Type: bigquery.IntegerFieldType},
	}

	metaData := &bigquery.TableMetadata{
		Schema:         sampleSchema,
		ExpirationTime: time.Now().AddDate(1, 0, 0), // Table will be automatically deleted in 1 year.
	}
	tableRef := client.Dataset(datasetID).Table(tableID)
	if err := tableRef.Create(ctx, metaData); 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.

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 com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Field;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.StandardSQLTypeName;
import com.google.cloud.bigquery.StandardTableDefinition;
import com.google.cloud.bigquery.TableDefinition;
import com.google.cloud.bigquery.TableId;
import com.google.cloud.bigquery.TableInfo;

public class CreateTable {

  public static void runCreateTable() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    Schema schema =
        Schema.of(
            Field.of("stringField", StandardSQLTypeName.STRING),
            Field.of("booleanField", StandardSQLTypeName.BOOL));
    createTable(datasetName, tableName, schema);
  }

  public static void createTable(String datasetName, String tableName, Schema schema) {
    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, tableName);
      TableDefinition tableDefinition = StandardTableDefinition.of(schema);
      TableInfo tableInfo = TableInfo.newBuilder(tableId, tableDefinition).build();

      bigquery.create(tableInfo);
      System.out.println("Table created successfully");
    } catch (BigQueryException e) {
      System.out.println("Table 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.

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 the Google Cloud client library and create a client
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function createTable() {
  // Creates a new table named "my_table" in "my_dataset".

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = "my_dataset";
  // const tableId = "my_table";
  // const schema = 'Name:string, Age:integer, Weight:float, IsMagic:boolean';

  // For all options, see https://cloud.google.com/bigquery/docs/reference/v2/tables#resource
  const options = {
    schema: schema,
    location: 'US',
  };

  // Create a new table in the dataset
  const [table] = await bigquery
    .dataset(datasetId)
    .createTable(tableId, options);

  console.log(`Table ${table.id} created.`);
}

PHP

Avant d'essayer cet exemple, suivez les instructions de configuration pour PHP 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 PHP.

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.

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';
// $fields = [
//    [
//        'name' => 'field1',
//        'type' => 'string',
//        'mode' => 'required'
//    ],
//    [
//        'name' => 'field2',
//        'type' => 'integer'
//    ],
//];

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$schema = ['fields' => $fields];
$table = $dataset->createTable($tableId, ['schema' => $schema]);
printf('Created table %s' . PHP_EOL, $tableId);

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.

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.

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 create.
# table_id = "your-project.your_dataset.your_table_name"

schema = [
    bigquery.SchemaField("full_name", "STRING", mode="REQUIRED"),
    bigquery.SchemaField("age", "INTEGER", mode="REQUIRED"),
]

table = bigquery.Table(table_id, schema=schema)
table = client.create_table(table)  # Make an API request.
print(
    "Created table {}.{}.{}".format(table.project, table.dataset_id, table.table_id)
)

Ruby

Avant d'essayer cet exemple, suivez les instructions de configuration pour Ruby 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 Ruby.

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.

require "google/cloud/bigquery"

def create_table dataset_id = "my_dataset"
  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id
  table_id = "my_table"

  table = dataset.create_table table_id do |updater|
    updater.string  "full_name", mode: :required
    updater.integer "age",       mode: :required
  end

  puts "Created table: #{table_id}"
end

Créer une table vide sans définition de schéma

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.

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

// Sample to create a table without schema
public class CreateTableWithoutSchema {

  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";
    createTableWithoutSchema(datasetName, tableName);
  }

  public static void createTableWithoutSchema(String datasetName, String tableName) {
    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, tableName);
      TableDefinition tableDefinition = StandardTableDefinition.of(Schema.of());
      TableInfo tableInfo = TableInfo.newBuilder(tableId, tableDefinition).build();

      bigquery.create(tableInfo);
      System.out.println("Table created successfully");
    } catch (BigQueryException e) {
      System.out.println("Table was not created. \n" + e.toString());
    }
  }
}

Créer une table à partir d'un résultat de requête

Pour créer une table à partir d'un résultat de requête, écrivez les résultats dans une table de destination.

Console

  1. Ouvrez la page BigQuery dans la console Google Cloud.

    Accéder à BigQuery

  2. Dans le panneau Explorateur, développez votre projet et sélectionnez un ensemble de données.

  3. Saisissez une requête SQL valide.

  4. Cliquez sur More (Plus), puis sélectionnez Query settings (Paramètres de requête).

    Paramètres de requête

  5. Sélectionnez l'option Définir une table de destination pour les résultats de la requête.

    Définir la destination

  6. Dans la section Destination, sélectionnez l'ensemble de données dans lequel vous souhaitez créer la table, puis choisissez un ID de table.

  7. Dans la section Préférence d'écriture pour la table de destination, choisissez l'une des options suivantes :

    • Écrire si la table est vide : n'écrit les résultats de requête dans la table que si celle-ci est vide.
    • Append to table (Ajouter à la table) : ajoute les résultats de requête à une table existante.
    • Écraser la table : écrase une table existante portant le même nom à l'aide des résultats de requête.
  8. Facultatif : Dans le champ Emplacement des données, sélectionnez votre emplacement.

  9. Pour mettre à jour les paramètres de la requête, cliquez sur Enregistrer.

  10. Cliquez sur Exécuter. Cette action crée une tâche de requête qui écrit les résultats dans la table spécifiée.

Si vous oubliez de spécifier une table de destination avant d'exécuter la requête, vous pouvez également copier la table de résultats mise en cache dans une table permanente en cliquant sur le bouton Enregistrer les résultats situé au-dessus de l'éditeur.

SQL

L'exemple suivant utilise l'instruction CREATE TABLE pour créer la table trips à partir de données figurant dans la table bikeshare_trips publique :

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

    Accéder à BigQuery

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

    CREATE TABLE mydataset.trips AS (
      SELECT
        bike_id,
        start_time,
        duration_minutes
      FROM
        bigquery-public-data.austin_bikeshare.bikeshare_trips
    );
    

  3. Cliquez sur Exécuter.

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

Pour en savoir plus, consultez la section Créer une table à partir d'une table existante.

bq

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Saisissez la commande bq query en spécifiant l'option --destination_table pour créer une table permanente basée sur les résultats de la requête. Spécifiez l'option use_legacy_sql=false pour utiliser la syntaxe GoogleSQL. Pour écrire les résultats des requêtes dans une table qui n'est pas dans votre projet par défaut, ajoutez l'ID du projet au nom de l'ensemble de données en respectant le format suivant : project_id:dataset.

    (Facultatif) Spécifiez l'option --location et définissez la valeur correspondant à votre localisation.

    Pour contrôler la disposition en écriture d'une table de destination existante, fournissez l'une des options facultatives suivantes :

    • --append_table : si la table de destination existe, les résultats de requête y sont ajoutés.
    • --replace : si la table de destination existe, elle est remplacée par les résultats de requête.

      bq --location=location query \
      --destination_table project_id:dataset.table \
      --use_legacy_sql=false 'query'
      

      Remplacez les éléments suivants :

    • location représente le nom de l'emplacement utilisé pour traiter la requête. L'option --location est facultative. Par exemple, si vous utilisez BigQuery dans la région de Tokyo, vous pouvez définir la valeur de l'option sur asia-northeast1. Vous pouvez spécifier une valeur par défaut pour l'emplacement à l'aide du fichier .bigqueryrc.

    • project_id est l'ID de votre projet.

    • dataset représente le nom de l'ensemble de données contenant la table dans laquelle vous écrivez les résultats de requête.

    • table représente le nom de la table dans laquelle vous écrivez les résultats de requête.

    • query est une requête dans la syntaxe GoogleSQL.

      Si aucune option de disposition en écriture n'est spécifiée, le comportement par défaut consiste à écrire les résultats dans la table uniquement si celle-ci est vide. Si la table existe et qu'elle n'est pas vide, l'erreur suivante est renvoyée : `BigQuery error in query operation: Error processing jobproject_id:bqjob_123abc456789_00000e1234f_1': Already Exists: Table project_id:dataset.table.

      Exemples :

      Saisissez la commande suivante pour écrire les résultats de la requête dans une table de destination nommée mytable au sein de l'ensemble de données mydataset. L'ensemble de données se trouve dans votre projet par défaut. Comme aucune option de disposition en écriture n'est spécifiée dans la commande, la table doit être nouvelle ou vide. Dans le cas contraire, une erreur Already exists est renvoyée. La requête récupère les données de l'ensemble de données public USA Name Data.

      bq query \
      --destination_table mydataset.mytable \
      --use_legacy_sql=false \
      'SELECT
      name,
      number
      FROM
      `bigquery-public-data`.usa_names.usa_1910_current
      WHERE
      gender = "M"
      ORDER BY
      number DESC'
      

      Saisissez la commande suivante pour que les résultats de requête écrasent une table de destination nommée mytable se trouvant dans l'ensemble de données mydataset. L'ensemble de données se trouve dans votre projet par défaut. La commande utilise l'option --replace pour écraser la table de destination.

      bq query \
      --destination_table mydataset.mytable \
      --replace \
      --use_legacy_sql=false \
      'SELECT
      name,
      number
      FROM
      `bigquery-public-data`.usa_names.usa_1910_current
      WHERE
      gender = "M"
      ORDER BY
      number DESC'
      

      Saisissez la commande suivante pour ajouter les résultats de requête à une table de destination nommée mytable au sein de l'ensemble de données mydataset. L'ensemble de données se trouve dans le projet my-other-project, et non dans votre projet par défaut. La commande utilise l'option --append_table pour ajouter les résultats de requête à la table de destination.

      bq query \
      --append_table \
      --use_legacy_sql=false \
      --destination_table my-other-project:mydataset.mytable \
      'SELECT
      name,
      number
      FROM
      `bigquery-public-data`.usa_names.usa_1910_current
      WHERE
      gender = "M"
      ORDER BY
      number DESC'
      

      Le résultat de chacun de ces exemples ressemble à ce qui suit. Pour des raisons de lisibilité, certains résultats sont tronqués.

      Waiting on bqjob_r123abc456_000001234567_1 ... (2s) Current status: DONE
      +---------+--------+
      |  name   | number |
      +---------+--------+
      | Robert  |  10021 |
      | John    |   9636 |
      | Robert  |   9297 |
      | ...              |
      +---------+--------+
      

API

Pour enregistrer les résultats de requête dans une table permanente, appelez la méthode jobs.insert, configurez une tâche query et ajoutez une valeur pour la propriété destinationTable. Pour contrôler la disposition en écriture d'une table de destination existante, configurez la propriété writeDisposition.

Pour contrôler la zone de traitement de la tâche de requête, spécifiez la propriété location dans la section jobReference de la ressource de tâche.

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"
	"io"

	"cloud.google.com/go/bigquery"
	"google.golang.org/api/iterator"
)

// queryWithDestination demonstrates saving the results of a query to a specific table by setting the destination
// via the API properties.
func queryWithDestination(w io.Writer, projectID, destDatasetID, destTableID 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()

	q := client.Query("SELECT 17 as my_col")
	q.Location = "US" // Location must match the dataset(s) referenced in query.
	q.QueryConfig.Dst = client.Dataset(destDatasetID).Table(destTableID)
	// Run the query and print results when the query job is completed.
	job, err := q.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}
	if err := status.Err(); err != nil {
		return err
	}
	it, err := job.Read(ctx)
	for {
		var row []bigquery.Value
		err := it.Next(&row)
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintln(w, row)
	}
	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.

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.

Pour enregistrer des résultats de requête dans une table permanente, définissez la table de destination sur l'identifiant TableId souhaité dans une configuration QueryJobConfiguration.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.QueryJobConfiguration;
import com.google.cloud.bigquery.TableId;

public class SaveQueryToTable {

  public static void runSaveQueryToTable() {
    // TODO(developer): Replace these variables before running the sample.
    String query = "SELECT corpus FROM `bigquery-public-data.samples.shakespeare` GROUP BY corpus;";
    String destinationTable = "MY_TABLE";
    String destinationDataset = "MY_DATASET";

    saveQueryToTable(destinationDataset, destinationTable, query);
  }

  public static void saveQueryToTable(
      String destinationDataset, String destinationTableId, 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();

      // Identify the destination table
      TableId destinationTable = TableId.of(destinationDataset, destinationTableId);

      // Build the query job
      QueryJobConfiguration queryConfig =
          QueryJobConfiguration.newBuilder(query).setDestinationTable(destinationTable).build();

      // Execute the query.
      bigquery.query(queryConfig);

      // The results are now saved in the destination table.

      System.out.println("Saved query ran successfully");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Saved query did not run \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.

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 the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function queryDestinationTable() {
  // Queries the U.S. given names dataset for the state of Texas
  // and saves results to permanent table.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = 'my_dataset';
  // const tableId = 'my_table';

  // Create destination table reference
  const dataset = bigquery.dataset(datasetId);
  const destinationTable = dataset.table(tableId);

  const query = `SELECT name
    FROM \`bigquery-public-data.usa_names.usa_1910_2013\`
    WHERE state = 'TX'
    LIMIT 100`;

  // For all options, see https://cloud.google.com/bigquery/docs/reference/v2/tables#resource
  const options = {
    query: query,
    // Location must match that of the dataset(s) referenced in the query.
    location: 'US',
    destination: destinationTable,
  };

  // Run the query as a job
  const [job] = await bigquery.createQueryJob(options);

  console.log(`Job ${job.id} started.`);
  console.log(`Query results loaded to table ${destinationTable.id}`);
}

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.

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.

Pour enregistrer des résultats de requête dans une table permanente, créez une configuration QueryJobConfig et définissez la destination sur la valeur TableReference souhaitée. Transmettez la configuration du job à la méthode de requête.
from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Set table_id to the ID of the destination table.
# table_id = "your-project.your_dataset.your_table_name"

job_config = bigquery.QueryJobConfig(destination=table_id)

sql = """
    SELECT corpus
    FROM `bigquery-public-data.samples.shakespeare`
    GROUP BY corpus;
"""

# Start the query, passing in the extra configuration.
query_job = client.query(sql, job_config=job_config)  # Make an API request.
query_job.result()  # Wait for the job to complete.

print("Query results loaded to the table {}".format(table_id))

Créer une table qui référence une source de données externe

Une source de données externe peut être interrogée directement depuis BigQuery, même si les données ne sont pas stockées dans un stockage BigQuery. Par exemple, vous pouvez stocker des données dans une autre base de données Google Cloud, dans des fichiers Cloud Storage ou dans un autre produit cloud que vous souhaitez analyser dans BigQuery mais que vous n'êtes pas prêt à migrer.

Pour en savoir plus, consultez la page Présentation des sources de données externes.

Créer une table lorsque vous chargez des données

Lorsque vous chargez des données dans BigQuery, vous pouvez charger des données dans une nouvelle table ou partition, les ajouter à une table ou une partition existante, ou bien les utiliser pour écraser une table ou une partition. Vous n'avez pas besoin de créer une table vide avant de charger des données. Vous pouvez créer la table et charger vos données en même temps.

Lorsque vous chargez des données dans BigQuery, vous pouvez fournir le schéma de table ou de partition. Pour les formats de données compatibles, vous pouvez également utiliser la détection automatique de schéma.

Pour en savoir plus sur le chargement des données, consultez la page Introduction au chargement de données dans BigQuery.

Contrôler l'accès aux tables

Pour configurer l'accès aux tables et aux vues, vous pouvez attribuer un rôle IAM à une entité située aux niveaux suivants, classés par ordre de ressources autorisées (de la plus grande à la plus petite) :

  • À un niveau élevé dans la hiérarchie des ressources Google Cloud, tel qu'au niveau du projet, du dossier ou de l'organisation
  • Au niveau de l'ensemble de données
  • Au niveau de la table ou de la vue

Vous pouvez également restreindre l'accès aux données dans les tables à l'aide des méthodes suivantes :

L'accès avec n'importe quelle ressource protégée par IAM est cumulatif. Par exemple, si une entité n'a pas accès au niveau supérieur (un projet, par exemple), vous pouvez lui accorder l'accès au niveau de l'ensemble de données afin qu'elle ait accès aux tables et aux vues de l'ensemble de données. De même, si l'entité n'a pas accès au niveau supérieur ou au niveau de l'ensemble de données, vous pouvez lui accorder l'accès au niveau de la table ou de la vue.

L'attribution de rôles IAM à un niveau supérieur dans la hiérarchie des ressources Google Cloud (au niveau du projet, du dossier ou de l'organisation) permet à l'entité d'accéder à un vaste ensemble de ressources. Par exemple, si vous attribuez un rôle à une entité au niveau du projet, elle obtient des autorisations qui s'appliquent à tous les ensembles de données du projet.

L'attribution d'un rôle au niveau de l'ensemble de données spécifie les opérations qu'une entité est autorisée à effectuer sur les tables et les vues de cet ensemble de données spécifique, même si cette entité n'a pas accès à un niveau supérieur. Pour en savoir plus sur la configuration des contrôles d'accès aux ensembles de données, consultez la page Contrôler l'accès aux ensembles de données.

L'attribution d'un rôle au niveau de la table ou de la vue spécifie les opérations qu'une entité est autorisée à effectuer sur des tables et des vues spécifiques, même si cette entité n'a pas accès à un niveau supérieur. Pour en savoir plus sur la configuration des contrôles d'accès au niveau des tables, consultez la page Contrôler l'accès aux tables et aux vues.

Vous pouvez également créer des rôles personnalisés IAM. Si vous créez un rôle personnalisé, les autorisations que vous accordez dépendent des opérations spécifiques que vous souhaitez autoriser l'entité à effectuer.

Vous ne pouvez pas définir une autorisation "deny" sur une ressource protégée par IAM.

Pour en savoir plus sur les rôles et les autorisations, consultez la page Comprendre les rôles dans la documentation IAM, ainsi que les rôles et autorisations IAM de BigQuery.

Obtenir des informations sur les tables

Vous pouvez obtenir des informations ou des métadonnées sur les tables de différentes manières :

  • Utiliser la console Google Cloud
  • À l'aide de la commande bq show de l'outil de ligne de commande bq
  • Appeler la méthode API tables.get
  • En utilisant les bibliothèques clientes
  • En interrogeant les vues INFORMATION_SCHEMA (version bêta)

Autorisations requises

Pour obtenir des informations sur les tables, vous devez au minimum disposer des autorisations bigquery.tables.get. Les rôles IAM prédéfinis suivants incluent les autorisations bigquery.tables.get :

  • bigquery.metadataViewer
  • bigquery.dataViewer
  • bigquery.dataOwner
  • bigquery.dataEditor
  • bigquery.admin

En outre, si un utilisateur possède les autorisations bigquery.datasets.create, il obtient également un accès bigquery.dataOwner à l'ensemble de données qu'il crée. L'accès bigquery.dataOwner permet à l'utilisateur de récupérer les métadonnées d'une table.

Pour en savoir plus sur les rôles et les autorisations IAM dans BigQuery, consultez la page Contrôle des accès.

Obtenir des informations sur la table

Pour obtenir des informations sur les tables :

Console

  1. Dans la section Ressources du panneau de navigation, développez votre projet, puis sélectionnez un ensemble de données.

  2. Cliquez sur le nom de l'ensemble de données pour le développer. Les tables et les vues de l'ensemble de données s'affichent.

  3. Cliquez sur le nom de la table.

  4. Dans le panneau Details (Détails), cliquez sur Details (Détails) pour afficher la description et les informations de la table.

  5. Si vous le souhaitez, accédez à l'onglet Schema (Schéma) pour afficher la définition du schéma de la table.

bq

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Exécutez la commande bq show pour afficher toutes les informations sur la table. L'option --schema permet de n'afficher que les informations de schéma de table. Vous pouvez contrôler le résultat à l'aide de l'option --format.

    Si vous souhaitez obtenir des informations sur une table se trouvant dans un projet autre que celui par défaut, ajoutez l'ID du projet au nom de l'ensemble de données, en respectant le format suivant : project_id:dataset.

    bq show \
    --schema \
    --format=prettyjson \
    project_id:dataset.table
    

    Où :

    • project_id est l'ID de votre projet.
    • dataset est le nom de l'ensemble de données.
    • table est le nom de la table.

    Exemples :

    Saisissez la commande suivante pour afficher toutes les informations sur la table mytable dans mydataset. mydataset se trouve dans votre projet par défaut.

    bq show --format=prettyjson mydataset.mytable
    

    Saisissez la commande suivante pour afficher toutes les informations sur la table mytable dans mydataset. mydataset se trouve dans le projet myotherproject, et non dans votre projet par défaut.

    bq show --format=prettyjson myotherproject:mydataset.mytable
    

    Saisissez la commande suivante pour n'afficher que les informations de schéma sur mytable dans mydataset. mydataset se trouve dans myotherproject, et non dans votre projet par défaut.

    bq show --schema --format=prettyjson myotherproject:mydataset.mytable
    

API

Appelez la méthode tables.get et définissez tous les paramètres pertinents.

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"
	"io"

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

// printTableInfo demonstrates fetching metadata from a table and printing some basic information
// to an io.Writer.
func printTableInfo(w io.Writer, 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()

	meta, err := client.Dataset(datasetID).Table(tableID).Metadata(ctx)
	if err != nil {
		return err
	}
	// Print basic information about the table.
	fmt.Fprintf(w, "Schema has %d top-level fields\n", len(meta.Schema))
	fmt.Fprintf(w, "Description: %s\n", meta.Description)
	fmt.Fprintf(w, "Rows in managed storage: %d\n", meta.NumRows)
	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.

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

public class GetTable {

  public static void runGetTable() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "bigquery_public_data";
    String datasetName = "samples";
    String tableName = "shakespeare";
    getTable(projectId, datasetName, tableName);
  }

  public static void getTable(String projectId, String datasetName, String tableName) {
    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(projectId, datasetName, tableName);
      Table table = bigquery.getTable(tableId);
      System.out.println("Table info: " + table.getDescription());
    } catch (BigQueryException e) {
      System.out.println("Table not retrieved. \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.

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 the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function getTable() {
  // Retrieves table named "my_table" in "my_dataset".

  /**
   * TODO(developer): Uncomment the following lines before running the sample
   */
  // const datasetId = "my_dataset";
  // const tableId = "my_table";

  // Retrieve table reference
  const dataset = bigquery.dataset(datasetId);
  const [table] = await dataset.table(tableId).get();

  console.log('Table:');
  console.log(table.metadata.tableReference);
}
getTable();

PHP

Avant d'essayer cet exemple, suivez les instructions de configuration pour PHP 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 PHP.

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.

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

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.

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.


from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Set table_id to the ID of the model to fetch.
# table_id = 'your-project.your_dataset.your_table'

table = client.get_table(table_id)  # Make an API request.

# View table properties
print(
    "Got table '{}.{}.{}'.".format(table.project, table.dataset_id, table.table_id)
)
print("Table schema: {}".format(table.schema))
print("Table description: {}".format(table.description))
print("Table has {} rows".format(table.num_rows))

Obtenir des informations sur la table à l'aide de INFORMATION_SCHEMA

INFORMATION_SCHEMA est une série de vues donnant accès aux métadonnées sur des ensembles de données, des routines, des tables, des vues, des tâches, des réservations et des données de streaming.

Vous pouvez interroger les vues suivantes pour obtenir des informations sur la table :

  • Utilisez les vues INFORMATION_SCHEMA.TABLES et INFORMATION_SCHEMA.TABLE_OPTIONS pour extraire les métadonnées des tables et vues d'un projet.
  • Utilisez les vues INFORMATION_SCHEMA.COLUMNS et INFORMATION_SCHEMA.COLUMN_FIELD_PATHS pour extraire les métadonnées des colonnes (champs) d'une table.
  • Utilisez les vues INFORMATION_SCHEMA.TABLE_STORAGE pour extraire les métadonnées concernant l'utilisation actuelle et historique de l'espace de stockage par une table.

Les vues TABLES et TABLE_OPTIONS contiennent également des informations générales sur les vues. Pour obtenir des informations détaillées, interrogez plutôt la vue INFORMATION_SCHEMA.VIEWS.

Vue TABLES

Lorsque vous interrogez la vue INFORMATION_SCHEMA.TABLES, les résultats de la requête contiennent une ligne pour chaque table ou vue d'un ensemble de données. Pour obtenir des informations détaillées sur les vues, interrogez plutôt la vue INFORMATION_SCHEMA.VIEWS.

La vue INFORMATION_SCHEMA.TABLES présente le schéma suivant :

Nom de la colonne Type de données Value
table_catalog STRING ID du projet qui contient l'ensemble de données.
table_schema STRING Nom de l'ensemble de données contenant la table ou la vue, également appelé datasetId.
table_name STRING Nom de la table ou de la vue, également appelé tableId.
table_type STRING Type de table (l'un des éléments suivants) :
is_insertable_into STRING YES ou NO, suivant que la table accepte ou non les instructions LMD INSERT
is_typed STRING La valeur est toujours NO
creation_time TIMESTAMP Date/Heure de création de la table
base_table_catalog STRING Pour les clones de table et les instantanés de table, le projet de la table de base. Applicable uniquement aux tables dont la valeur table_type est définie sur CLONE ou SNAPSHOT.
base_table_schema STRING Pour les clones de table et les instantanés de table, l'ensemble de données de la table de base. Applicable uniquement aux tables dont la valeur table_type est définie sur CLONE ou SNAPSHOT.
base_table_name STRING Pour les clones de table et les instantanés de table, le nom de la table de base. Applicable uniquement aux tables dont la valeur table_type est définie sur CLONE ou SNAPSHOT.
snapshot_time_ms TIMESTAMP Pour les clones de tables et les instantanés de table, le moment où l'opération de clonage ou de génération d'instantané a été exécutée sur la table de base pour créer cette table. Si la fonctionnalité temporelle a été utilisée, ce champ contient l'horodatage de la fonctionnalité temporelle. Sinon, le champ snapshot_time_ms est identique au champ creation_time. Applicable uniquement aux tables dont la valeur table_type est définie sur CLONE ou SNAPSHOT.
replica_source_catalog STRING Pour les instances répliquées de vues matérialisées, le projet de la vue matérialisée de base.
replica_source_schema STRING Pour les instances répliquées de vues matérialisées, l'ensemble de données de la vue matérialisée de base.
replica_source_name STRING Pour les instances répliquées de vues matérialisées, le nom de la vue matérialisée de base.
replication_status STRING Pour les instances répliquées de vues matérialisées, l'état de la réplication de la vue matérialisée de base vers l'instance répliquée de la vue matérialisée ; l'une des options suivantes :
  • REPLICATION_STATUS_UNSPECIFIED
  • ACTIVE : la réplication est active sans erreur.
  • SOURCE_DELETED : la vue matérialisée source a été supprimée.
  • PERMISSION_DENIEDLa vue matérialisée source n'a pas été autorisée sur l'ensemble de données contenant les tables sources BigLake Amazon S3 utilisées dans la requête qui a créé la vue matérialisée.
  • UNSUPPORTED_CONFIGURATION : il existe un problème avec les conditions préalables de l'instance répliquée autres que l'autorisation de la vue matérialisée source.
replication_error STRING Si replication_status indique un problème de réplication pour une instance répliquée de vue matérialisée, replication_error fournit des informations supplémentaires.
ddl STRING L'Instruction LDD peut être utilisée pour recréer la table, par exemple CREATE TABLE ou CREATE VIEW
default_collation_name STRING Nom de la spécification de classement par défaut, le cas échéant. Dans le cas contraire, cette valeur est définie sur NULL.
upsert_stream_apply_watermark TIMESTAMP Heure de la dernière application des modifications de ligne pour les tables qui utilisent la capture des données modifiées (CDC). Pour en savoir plus, consultez la page Surveiller la progression des opérations upsert de la table.

Examples

Exemple 1 :

L'exemple suivant récupère les métadonnées de toutes les tables de l'ensemble de données nommé mydataset. Les métadonnées renvoyées concernent tous les types de tables de mydataset dans votre projet par défaut.

mydataset contient les tables suivantes :

  • mytable1 : une table BigQuery standard
  • myview1 : une vue BigQuery

Pour exécuter la requête sur un projet autre que celui par défaut, ajoutez l'ID du projet à l'ensemble de données, en respectant le format suivant : `project_id`.dataset.INFORMATION_SCHEMA.view. Par exemple : `myproject`.mydataset.INFORMATION_SCHEMA.TABLES.

SELECT
  table_catalog, table_schema, table_name, table_type,
  is_insertable_into, creation_time, ddl
FROM
  mydataset.INFORMATION_SCHEMA.TABLES;

Le résultat ressemble à ce qui suit. Pour des raisons de lisibilité, certaines colonnes sont exclues des résultats.

+----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+
| table_catalog  | table_schema  |   table_name   | table_type | is_insertable_into |    creation_time    |                     ddl                     |
+----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+
| myproject      | mydataset     | mytable1       | BASE TABLE | YES                | 2018-10-29 20:34:44 | CREATE TABLE `myproject.mydataset.mytable1` |
|                |               |                |            |                    |                     | (                                           |
|                |               |                |            |                    |                     |   id INT64                                  |
|                |               |                |            |                    |                     | );                                          |
| myproject      | mydataset     | myview1        | VIEW       | NO                 | 2018-12-29 00:19:20 | CREATE VIEW `myproject.mydataset.myview1`   |
|                |               |                |            |                    |                     | AS SELECT 100 as id;                        |
+----------------+---------------+----------------+------------+--------------------+---------------------+---------------------------------------------+
Exemple 2 :

L'exemple suivant récupère les métadonnées de toutes les tables de type CLONE ou SNAPSHOT à partir de la vue INFORMATION_SCHEMA.TABLES. Les métadonnées renvoyées concernent les tables dans mydataset, dans votre projet par défaut.

Pour exécuter la requête sur un projet autre que celui par défaut, ajoutez l'ID du projet à l'ensemble de données, en respectant le format suivant : `project_id`.dataset.INFORMATION_SCHEMA.view. Par exemple : `myproject`.mydataset.INFORMATION_SCHEMA.TABLES.

  SELECT
    table_name, table_type, base_table_catalog,
    base_table_schema, base_table_name, snapshot_time_ms
  FROM
    mydataset.INFORMATION_SCHEMA.TABLES
  WHERE
    table_type = 'CLONE'
  OR
    table_type = 'SNAPSHOT';

Le résultat ressemble à ce qui suit. Pour des raisons de lisibilité, certaines colonnes sont exclues des résultats.

  +--------------+------------+--------------------+-------------------+-----------------+---------------------+
  | table_name   | table_type | base_table_catalog | base_table_schema | base_table_name | snapshot_time_ms    |
  +--------------+------------+--------------------+-------------------+-----------------+---------------------+
  | items_clone  | CLONE      | myproject          | mydataset         | items           | 2018-10-31 22:40:05 |
  | orders_bk    | SNAPSHOT   | myproject          | mydataset         | orders          | 2018-11-01 08:22:39 |
  +--------------+------------+--------------------+-------------------+-----------------+---------------------+

Exemple 3 :

L'exemple suivant récupère les colonnes table_name et ddl de la vue INFORMATION_SCHEMA.TABLES pour la table population_by_zip_2010 de l'ensemble de données census_bureau_usa. Celui-ci fait partie du programme d'ensembles de données publics de BigQuery.

Comme la table que vous interrogez se trouve dans un autre projet, ajoutez l'ID du projet à l'ensemble de données en utilisant le format suivant : `project_id`.dataset.INFORMATION_SCHEMA.view. Dans cet exemple, la valeur est `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES.

SELECT
  table_name, ddl
FROM
  `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES
WHERE
  table_name = 'population_by_zip_2010';

Le résultat ressemble à ce qui suit :

+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|       table_name       |                                                                                                            ddl                                                                                                             |
+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| population_by_zip_2010 | CREATE TABLE `bigquery-public-data.census_bureau_usa.population_by_zip_2010`                                                                                                                                               |
|                        | (                                                                                                                                                                                                                          |
|                        |   geo_id STRING OPTIONS(description="Geo code"),                                                                                                                                                                           |
|                        |   zipcode STRING NOT NULL OPTIONS(description="Five digit ZIP Code Tabulation Area Census Code"),                                                                                                                          |
|                        |   population INT64 OPTIONS(description="The total count of the population for this segment."),                                                                                                                             |
|                        |   minimum_age INT64 OPTIONS(description="The minimum age in the age range. If null, this indicates the row as a total for male, female, or overall population."),                                                          |
|                        |   maximum_age INT64 OPTIONS(description="The maximum age in the age range. If null, this indicates the row as having no maximum (such as 85 and over) or the row is a total of the male, female, or overall population."), |
|                        |   gender STRING OPTIONS(description="male or female. If empty, the row is a total population summary.")                                                                                                                    |
|                        | )                                                                                                                                                                                                                          |
|                        | OPTIONS(                                                                                                                                                                                                                   |
|                        |   labels=[("freebqcovid", "")]                                                                                                                                                                                             |
|                        | );                                                                                                                                                                                                                         |
+------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
  

Vue TABLE_OPTIONS

Lorsque vous interrogez la vue INFORMATION_SCHEMA.TABLE_OPTIONS, les résultats de la requête contiennent une ligne pour chaque option, pour chaque table ou vue d'un ensemble de données. Pour obtenir des informations détaillées sur les vues, interrogez plutôt la vue INFORMATION_SCHEMA.VIEWS.

La vue INFORMATION_SCHEMA.TABLE_OPTIONS présente le schéma suivant :

Nom de la colonne Type de données Valeur
TABLE_CATALOG STRING ID du projet qui contient l'ensemble de données
TABLE_SCHEMA STRING Nom de l'ensemble de données contenant la table ou la vue, également appelé datasetId
TABLE_NAME STRING Nom de la table ou de la vue, également appelé tableId
OPTION_NAME STRING Une des valeurs de nom figurant dans la table d'options
OPTION_TYPE STRING Une des valeurs de type de données figurant dans la table d'options
OPTION_VALUE STRING Une des options de valeur figurant dans la table d'options
Table d'options
OPTION_NAME OPTION_TYPE OPTION_VALUE
partition_expiration_days FLOAT64 Durée de vie par défaut, en jours, de toutes les partitions d'une table partitionnée
expiration_timestamp TIMESTAMP Heure d'expiration de cette table
kms_key_name STRING Nom de la clé Cloud KMS employée pour chiffrer la table
friendly_name STRING Nom descriptif de la table
description STRING Description de la table
labels ARRAY<STRUCT<STRING, STRING>> Tableau de valeurs STRUCT représentant les étiquettes de la table
require_partition_filter BOOL Filtre de partition nécessaire ou non pour les requêtes sur la table
enable_refresh BOOL Indique si l'actualisation automatique est activée pour une vue matérialisée.
refresh_interval_minutes FLOAT64 Fréquence d'actualisation d'une vue matérialisée

Pour les tables externes, les options suivantes sont également possibles :

Options
allow_jagged_rows

BOOL

Si la valeur est true, autorise les lignes auxquelles il manque des colonnes finales facultatives.

S'applique aux données CSV.

allow_quoted_newlines

BOOL

Si la valeur est true, autorise les sections de données entre guillemets contenant des caractères de retour à la ligne dans le fichier.

S'applique aux données CSV.

bigtable_options

STRING

Obligatoire uniquement lors de la création d'une table externe Bigtable.

Spécifie le schéma de la table externe Bigtable au format JSON.

Pour obtenir la liste des options de définition de table Bigtable, reportez-vous à la section BigtableOptions dans la documentation de référence de l'API REST.

column_name_character_map

STRING

Définit l'étendue des caractères de nom de colonne acceptés et le comportement de traitement des caractères non acceptés.

Les valeurs autorisées incluent les suivantes :

  • STRICT. Active les noms de colonnes flexibles. Les jobs de chargement contenant des caractères non compatibles dans les noms de colonnes échouent avec un message d'erreur. Il s'agit de la valeur par défaut.
  • V1. Les noms de colonnes ne peuvent contenir que des caractères standards. Les caractères non autorisés sont remplacés par des traits de soulignement.
  • V2. Active les noms de colonnes flexibles. Les caractères non compatibles sont remplacés par des traits de soulignement. Il s'agit du paramètre recommandé, sauf dans les cas d'utilisation avec des tables externes.
compression

STRING

Type de compression de la source de données. Valeur autorisée : GZIP. Si cette option n'est pas spécifiée, la source de données n'est pas compressée.

S'applique aux données CSV et JSON.

decimal_target_types

ARRAY<STRING>

Détermine comment convertir un type Decimal. Équivaut à ExternalDataConfiguration.decimal_target_types.

Exemple : ["NUMERIC", "BIGNUMERIC"]

description

STRING

Description de cette table.

enable_list_inference

BOOL

Si la valeur est définie sur true, utilise l'inférence de schéma spécifiquement pour le type logique LIST Parquet.

S'applique aux données Parquet.

enable_logical_types

BOOL

Si la valeur est true, convertit les types logiques Avro en types SQL correspondants. Pour en savoir plus, consultez la section Types logiques.

S'applique aux données Avro.

encoding

STRING

Encodage des caractères des données. Valeurs autorisées : UTF8 (ou UTF-8), ISO_8859_1 (ou ISO-8859-1).

S'applique aux données CSV.

enum_as_string

BOOL

Si la valeur est définie sur true, déduit le type logique ENUM Parquet en tant que STRING au lieu de BYTES par défaut.

S'applique aux données Parquet.

expiration_timestamp

TIMESTAMP

Date et heure d'expiration de cette table. Si cette option n'est pas spécifiée, la table n'expire pas.

Exemple : "2025-01-01 00:00:00 UTC".

field_delimiter

STRING

Séparateur des champs dans un fichier CSV.

S'applique aux données CSV.

format

STRING

Format des données externes. Les valeurs acceptées pour CREATE EXTERNAL TABLE incluent les valeurs suivantes : AVRO, CLOUD_BIGTABLE, CSV, DATASTORE_BACKUP, DELTA_LAKE (bêta), GOOGLE_SHEETS, NEWLINE_DELIMITED_JSON (ou JSON), ORC, PARQUET.

Les valeurs acceptées pour LOAD DATA incluent les valeurs suivantes : AVRO, CSV, DELTA_LAKE (bêta), NEWLINE_DELIMITED_JSON (ou JSON), ORC, PARQUET.

La valeur JSON est équivalente à NEWLINE_DELIMITED_JSON.

hive_partition_uri_prefix

STRING

Préfixe commun à tous les URI sources avant le début de l'encodage de la clé de partition. Ne s'applique qu'aux tables externes partitionnées avec Hive.

S'applique aux données Avro, CSV, JSON, Parquet et ORC.

Exemple : "gs://bucket/path"

file_set_spec_type

STRING

Spécifie comment interpréter les URI sources des tâches de chargement et des tables externes. Dans l'aperçu.

Les valeurs autorisées incluent les suivantes :

  • FILE_SYSTEM_MATCH. Étend les URI sources en répertoriant les fichiers à partir du magasin d'objets. Il s'agit du comportement par défaut si FileSetSpecType n'est pas défini.
  • NEW_LINE_DELIMITED_MANIFEST. Indique que les URI fournis sont des fichiers manifestes délimités par un retour à la ligne, avec un URI par ligne. Les URI génériques ne sont pas compatibles avec les fichiers manifestes.

Par exemple, si vous disposez de l'URI source "gs://bucket/path/file" et que file_set_spec_type est FILE_SYSTEM_MATCH, le fichier est utilisé directement en tant que fichier de données. Si file_set_spec_type est défini sur NEW_LINE_DELIMITED_MANIFEST, chaque ligne du fichier est interprétée comme un URI qui pointe vers un fichier de données.

ignore_unknown_values

BOOL

Si la valeur est true, ignore les valeurs supplémentaires qui ne sont pas représentées dans le schéma de la table, sans renvoyer d'erreur.

S'applique aux données CSV et JSON.

json_extension

STRING

Pour les données JSON, indique un format d'échange JSON particulier. Si ce n'est pas le cas, BigQuery lit les données sous forme d'enregistrements JSON génériques.

Les valeurs acceptées sont les suivantes :
GEOJSON. Données GeoJSON délimitées par des retours à la ligne. Pour en savoir plus, consultez la section Créer une table externe à partir d'un fichier GeoJSON délimité par un retour à la ligne.

max_bad_records

INT64

Nombre maximal d'enregistrements incorrects à ignorer lors de la lecture des données.

S'applique aux données CSV, JSON et Sheets.

max_staleness

INTERVAL

Applicable aux tables BigLake et aux tables d'objets.

Indique si les métadonnées mises en cache sont utilisées par les opérations sur la table et indique le niveau nécessaire de fraîcheur des métadonnées mises en cache pour que l'opération puisse les utiliser.

Pour désactiver la mise en cache des métadonnées, spécifiez 0. Il s'agit de la valeur par défaut.

Pour activer la mise en cache des métadonnées, spécifiez une valeur de littéral d'intervalle comprise entre 30 minutes et 7 jours. Par exemple, spécifiez INTERVAL 4 HOUR pour un intervalle d'obsolescence de quatre heures. Avec cette valeur, les opérations sur la table utilisent les métadonnées mises en cache si elles ont été actualisées au cours des quatre dernières heures. Si les métadonnées mises en cache sont plus anciennes, l'opération extrait les métadonnées de Cloud Storage.

metadata_cache_mode

STRING

Applicable aux tables BigLake et aux tables d'objets.

Indique si le cache de métadonnées de la table est actualisé automatiquement ou manuellement.

Définissez cet élément sur AUTOMATIC pour que le cache de métadonnées soit actualisé à un intervalle défini par le système, généralement entre 30 et 60 minutes.

Définissez la valeur sur MANUAL si vous souhaitez actualiser le cache de métadonnées selon une programmation que vous déterminez. Dans ce cas, vous pouvez appeler la procédure système BQ.REFRESH_EXTERNAL_METADATA_CACHE pour actualiser le cache.

Vous devez définir metadata_cache_mode si max_staleness est défini sur une valeur supérieure à 0.

null_marker

STRING

Chaîne représentant les valeurs NULL dans un fichier CSV.

S'applique aux données CSV.

object_metadata

STRING

Obligatoire seulement lors de la création d'une table d'objets.

Définissez la valeur de cette option sur SIMPLE lors de la création d'une table d'objets.

preserve_ascii_control_characters

BOOL

Si la valeur est true, les caractères de contrôle ASCII intégrés qui sont les 32 premiers caractères de la table ASCII, allant de "\x00" à "\x1F", sont conservés.

S'applique aux données CSV.

projection_fields

STRING

Liste des propriétés d'entité à charger.

S'applique aux données Datastore.

quote

STRING

Chaîne utilisée pour citer des sections de données dans un fichier CSV. Si vos données contiennent des caractères de retour à la ligne entre guillemets, définit également la propriété allow_quoted_newlines sur true.

S'applique aux données CSV.

reference_file_schema_uri

STRING

Fichier de référence fourni par l'utilisateur avec le schéma de la table.

S'applique aux données Parquet/ORC/AVRO.

Exemple : "gs://bucket/path/reference_schema_file.parquet"

require_hive_partition_filter

BOOL

Si la valeur est true, toutes les requêtes sur cette table nécessitent un filtre de partition pouvant être utilisé pour éliminer les partitions lors de la lecture des données. Ne s'applique qu'aux tables externes partitionnées avec Hive.

S'applique aux données Avro, CSV, JSON, Parquet et ORC.

sheet_range

STRING

Plage d'une feuille de calcul Sheets à interroger.

S'applique aux données Google Sheets.

Exemple : "sheet1!A1:B20".

skip_leading_rows

INT64

Nombre de lignes en haut d'un fichier à ignorer lors de la lecture des données.

S'applique aux données CSV et Sheets.

uris

Pour les tables externes, y compris les tables d'objets, qui ne sont pas des tables Bigtable :

ARRAY<STRING>

Tableau d'URI complets pour les emplacements de données externes. Chaque URI peut contenir un caractère générique de type astérisque (*), qui doit être placé après le nom du bucket. Lorsque vous spécifiez des valeurs uris qui ciblent plusieurs fichiers, tous ces fichiers doivent partager un schéma compatible.

Les exemples suivants montrent des valeurs uris valides :

  • ['gs://bucket/path1/myfile.csv']
  • ['gs://bucket/path1/*.csv']
  • ['gs://bucket/path1/*', 'gs://bucket/path2/file00*']

Pour les tables Bigtable :

STRING

URI identifiant la table Bigtable à utiliser comme source de données. Vous ne pouvez spécifier qu'un seul URI Bigtable.

Exemple : https://googleapis.com/bigtable/projects/project_id/instances/instance_id[/appProfiles/app_profile]/tables/table_name

Pour en savoir plus sur la construction d'un URI Bigtable, consultez la section Récupérer l'URI Bigtable.

Examples

Exemple 1 :

L'exemple suivant récupère les délais d'expiration par défaut de toutes les tables de l'ensemble de données mydataset de votre projet par défaut (myproject) en interrogeant la vue INFORMATION_SCHEMA.TABLE_OPTIONS.

Pour exécuter la requête sur un projet autre que celui par défaut, ajoutez l'ID du projet à l'ensemble de données, en respectant le format suivant : `project_id`.dataset.INFORMATION_SCHEMA.view. Par exemple : `myproject`.mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS.

  SELECT
    *
  FROM
    mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
  WHERE
    option_name = 'expiration_timestamp';

Le résultat ressemble à ce qui suit :

  +----------------+---------------+------------+----------------------+-------------+--------------------------------------+
  | table_catalog  | table_schema  | table_name |     option_name      | option_type |             option_value             |
  +----------------+---------------+------------+----------------------+-------------+--------------------------------------+
  | myproject      | mydataset     | mytable1   | expiration_timestamp | TIMESTAMP   | TIMESTAMP "2020-01-16T21:12:28.000Z" |
  | myproject      | mydataset     | mytable2   | expiration_timestamp | TIMESTAMP   | TIMESTAMP "2021-01-01T21:12:28.000Z" |
  +----------------+---------------+------------+----------------------+-------------+--------------------------------------+
  

Exemple 2 :

L'exemple suivant récupère les métadonnées de toutes les tables de mydataset contenant des données de test. La requête utilise les valeurs de l'option description pour rechercher les tables dont la description contient "test". mydataset se trouve dans votre projet par défaut : myproject.

Pour exécuter la requête sur un projet autre que votre projet par défaut, ajoutez l'ID du projet à l'ensemble de données au format suivant : `project_id`.dataset.INFORMATION_SCHEMA.view. Par exemple, `myproject`.mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS.

  SELECT
    *
  FROM
    mydataset.INFORMATION_SCHEMA.TABLE_OPTIONS
  WHERE
    option_name = 'description'
    AND option_value LIKE '%test%';

Le résultat ressemble à ce qui suit :

  +----------------+---------------+------------+-------------+-------------+--------------+
  | table_catalog  | table_schema  | table_name | option_name | option_type | option_value |
  +----------------+---------------+------------+-------------+-------------+--------------+
  | myproject      | mydataset     | mytable1   | description | STRING      | "test data"  |
  | myproject      | mydataset     | mytable2   | description | STRING      | "test data"  |
  +----------------+---------------+------------+-------------+-------------+--------------+
  

Vue COLUMNS

Lorsque vous lancez une requête sur la vue INFORMATION_SCHEMA.COLUMNS, les résultats de la requête contiennent une ligne pour chaque colonne (champ) d'une table.

La vue INFORMATION_SCHEMA.COLUMNS présente le schéma suivant :

Nom de la colonne Type de données Valeur
TABLE_CATALOG STRING ID du projet qui contient l'ensemble de données
TABLE_SCHEMA STRING Nom de l'ensemble de données contenant la table, également appelé datasetId
TABLE_NAME STRING Nom de la table ou de la vue, également appelé tableId
COLUMN_NAME STRING Nom de la colonne
ORDINAL_POSITION INT64 Décalage avec un indice de 1 de la colonne dans la table. S'il s'agit d'une pseudo-colonne telle que _PARTITIONTIME ou _PARTITIONDATE, la valeur est NULL.
IS_NULLABLE STRING YES ou NO selon que le mode de la colonne autorise ou non les valeurs NULL
DATA_TYPE STRING Type de données GoogleSQL de la colonne
IS_GENERATED STRING La valeur est toujours NEVER
GENERATION_EXPRESSION STRING La valeur est toujours NULL
IS_STORED STRING La valeur est toujours NULL
IS_HIDDEN STRING YES ou NO selon que la colonne est une pseudo-colonne telle que _PARTITIONTIME ou _PARTITIONDATE
IS_UPDATABLE STRING La valeur est toujours NULL
IS_SYSTEM_DEFINED STRING YES ou NO selon que la colonne est une pseudo-colonne telle que _PARTITIONTIME ou _PARTITIONDATE
IS_PARTITIONING_COLUMN STRING YES ou NO selon qu'il s'agit ou non d'une colonne de partitionnement
CLUSTERING_ORDINAL_POSITION INT64 Décalage avec un indice de 1 de la colonne dans les colonnes de clustering de la table. La valeur est NULL si la table n'est pas une table en cluster.
COLLATION_NAME STRING Nom de la spécification de classement si elle existe. Dans le cas contraire, NULL

Si une valeur STRING ou ARRAY<STRING> est transmise, la spécification de classement est renvoyée si elle existe. Sinon, NULL est renvoyé.
COLUMN_DEFAULT STRING Valeur par défaut de la colonne, si elle existe ; sinon, la valeur est NULL.
ROUNDING_MODE STRING Mode d'arrondi utilisé pour les valeurs écrites dans le champ si son type est de type NUMERIC ou BIGNUMERIC paramétré. Sinon, la valeur est NULL.

Examples

L'exemple suivant récupère les métadonnées de la vue INFORMATION_SCHEMA.COLUMNS pour la table population_by_zip_2010 de l'ensemble de données census_bureau_usa. Celui-ci fait partie du programme d'ensembles de données publics de BigQuery.

Comme la table que vous interrogez se trouve dans un autre projet (bigquery-public-data), vous ajoutez l'ID de projet à l'ensemble de données, en respectant le format `project_id`.dataset.INFORMATION_SCHEMA.view. Par exemple : `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.TABLES.

Les colonnes suivantes sont exclues des résultats de la requête, car elles sont actuellement réservées en vue d'une utilisation ultérieure :

  • IS_GENERATED
  • GENERATION_EXPRESSION
  • IS_STORED
  • IS_UPDATABLE
  SELECT
    * EXCEPT(is_generated, generation_expression, is_stored, is_updatable)
  FROM
    `bigquery-public-data`.census_bureau_usa.INFORMATION_SCHEMA.COLUMNS
  WHERE
    table_name = 'population_by_zip_2010';

Le résultat ressemble à ce qui suit. Pour des raisons de lisibilité, certaines colonnes sont exclues des résultats.

+------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+
|       table_name       | column_name | ordinal_position | is_nullable | data_type | is_hidden | is_system_defined | is_partitioning_column | clustering_ordinal_position |
+------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+
| population_by_zip_2010 | zipcode     |                1 | NO          | STRING    | NO        | NO                | NO                     |                        NULL |
| population_by_zip_2010 | geo_id      |                2 | YES         | STRING    | NO        | NO                | NO                     |                        NULL |
| population_by_zip_2010 | minimum_age |                3 | YES         | INT64     | NO        | NO                | NO                     |                        NULL |
| population_by_zip_2010 | maximum_age |                4 | YES         | INT64     | NO        | NO                | NO                     |                        NULL |
| population_by_zip_2010 | gender      |                5 | YES         | STRING    | NO        | NO                | NO                     |                        NULL |
| population_by_zip_2010 | population  |                6 | YES         | INT64     | NO        | NO                | NO                     |                        NULL |
+------------------------+-------------+------------------+-------------+-----------+-----------+-------------------+------------------------+-----------------------------+
  

Vue COLUMN_FIELD_PATHS

Lorsque vous interrogez la vue INFORMATION_SCHEMA.COLUMN_FIELD_PATHS, les résultats de la requête contiennent une ligne pour chaque colonne imbriquée dans une colonne RECORD (ou STRUCT).

La vue INFORMATION_SCHEMA.COLUMN_FIELD_PATHS présente le schéma suivant :

Nom de la colonne Type de données Valeur
TABLE_CATALOG STRING ID du projet qui contient l'ensemble de données
TABLE_SCHEMA STRING Nom de l'ensemble de données contenant la table, également appelé datasetId
TABLE_NAME STRING Nom de la table ou de la vue, également appelé tableId
COLUMN_NAME STRING Nom de la colonne
FIELD_PATH STRING Chemin d'accès à une colonne imbriquée dans une colonne RECORD (ou STRUCT)
DATA_TYPE STRING Type de données GoogleSQL de la colonne
DESCRIPTION STRING Description de la colonne
COLLATION_NAME STRING Nom de la spécification de classement si elle existe. Dans le cas contraire, NULL

Si un champ STRING, ARRAY<STRING> ou STRING d'un élément STRUCT est transmis, la spécification de classement est renvoyée si elle existe. Sinon, NULL est renvoyé.
ROUNDING_MODE STRING Mode d'arrondi utilisé lors de l'application de la précision et de l'échelle à des valeurs NUMERIC ou BIGNUMERIC paramétrées. Sinon, la valeur est NULL.

Examples

L'exemple suivant récupère les métadonnées de la vue INFORMATION_SCHEMA.COLUMN_FIELD_PATHS pour la table commits de l'ensemble de données github_repos. Celui-ci fait partie du programme d'ensembles de données publics de BigQuery.

Comme la table que vous interrogez se trouve dans un autre projet (bigquery-public-data), vous ajoutez l'ID de projet à l'ensemble de données, en respectant le format `project_id`.dataset.INFORMATION_SCHEMA.view. Par exemple : `bigquery-public-data`.github_repos.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS.

La table commits contient les colonnes imbriquées ainsi que les colonnes imbriquées et répétées suivantes :

  • author : colonne imbriquée RECORD
  • committer : colonne imbriquée RECORD
  • trailer : colonne imbriquée et répétée RECORD
  • difference : colonne imbriquée et répétée RECORD

Pour afficher les métadonnées des colonnes author et difference, exécutez la requête suivante.

SELECT
  *
FROM
  `bigquery-public-data`.github_repos.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS
WHERE
  table_name = 'commits'
  AND (column_name = 'author' OR column_name = 'difference');

Le résultat ressemble à ce qui suit. Pour des raisons de lisibilité, certaines colonnes sont exclues des résultats.

  +------------+-------------+---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+-------------+
  | table_name | column_name |     field_path      |                                                                      data_type                                                                      | description |
  +------------+-------------+---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+-------------+
  | commits    | author      | author              | STRUCT<name STRING, email STRING, time_sec INT64, tz_offset INT64, date TIMESTAMP>                                                                  | NULL        |
  | commits    | author      | author.name         | STRING                                                                                                                                              | NULL        |
  | commits    | author      | author.email        | STRING                                                                                                                                              | NULL        |
  | commits    | author      | author.time_sec     | INT64                                                                                                                                               | NULL        |
  | commits    | author      | author.tz_offset    | INT64                                                                                                                                               | NULL        |
  | commits    | author      | author.date         | TIMESTAMP                                                                                                                                           | NULL        |
  | commits    | difference  | difference          | ARRAY<STRUCT<old_mode INT64, new_mode INT64, old_path STRING, new_path STRING, old_sha1 STRING, new_sha1 STRING, old_repo STRING, new_repo STRING>> | NULL        |
  | commits    | difference  | difference.old_mode | INT64                                                                                                                                               | NULL        |
  | commits    | difference  | difference.new_mode | INT64                                                                                                                                               | NULL        |
  | commits    | difference  | difference.old_path | STRING                                                                                                                                              | NULL        |
  | commits    | difference  | difference.new_path | STRING                                                                                                                                              | NULL        |
  | commits    | difference  | difference.old_sha1 | STRING                                                                                                                                              | NULL        |
  | commits    | difference  | difference.new_sha1 | STRING                                                                                                                                              | NULL        |
  | commits    | difference  | difference.old_repo | STRING                                                                                                                                              | NULL        |
  | commits    | difference  | difference.new_repo | STRING                                                                                                                                              | NULL        |
  +------------+-------------+---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+-------------+
  

Vue TABLE_STORAGE

Les vues TABLE_STORAGE et TABLE_STORAGE_BY_ORGANIZATION présentent le schéma suivant :

Nom de colonne Type de données Value
PROJECT_ID STRING ID du projet qui contient l'ensemble de données.
PROJECT_NUMBER INT64 Numéro du projet qui contient l'ensemble de données.
TABLE_CATALOG STRING ID du projet qui contient l'ensemble de données.
TABLE_SCHEMA STRING Nom de l'ensemble de données qui contient la table ou la vue matérialisée, également appelé datasetId.
TABLE_NAME STRING Nom de la table ou de la vue matérialisée, également appelé tableId.
CREATION_TIME TIMESTAMP Horodatage de création de la table.
TOTAL_ROWS INT64 Nombre total de lignes dans la table ou la vue matérialisée.
TOTAL_PARTITIONS INT64 Nombre de partitions présentes dans la table ou la vue matérialisée. Les tables non partitionnées renvoient la valeur 0.
TOTAL_LOGICAL_BYTES INT64 Nombre total d'octets logiques (non compressés) dans la table ou la vue matérialisée.
ACTIVE_LOGICAL_BYTES INT64 Nombre d'octets logiques (non compressés) datant de moins de 90 jours.
LONG_TERM_LOGICAL_BYTES INT64 Nombre d'octets logiques (non compressés) datant de plus de 90 jours.
CURRENT_PHYSICAL_BYTES INT64 Nombre total d'octets physiques pour le stockage actuel de la table sur l'ensemble des partitions.
TOTAL_PHYSICAL_BYTES INT64 Nombre total d'octets physiques (compressés) utilisés pour le stockage, y compris les octets actifs, à long terme, de fonctionnalité temporelle (données supprimées ou modifiées) et de sécurité intégrée (données supprimées ou modifiées conservées après une fenêtre de fonctionnalité temporelle).
ACTIVE_PHYSICAL_BYTES INT64 Nombre d'octets physiques (compressés) datant de moins de 90 jours, y compris les octets de fonctionnalité temporelle (données supprimées ou modifiées).
LONG_TERM_PHYSICAL_BYTES INT64 Nombre d'octets physiques (compressés) datant de plus de 90 jours.
TIME_TRAVEL_PHYSICAL_BYTES INT64 Nombre d'octets physiques (compressés) utilisés par le stockage temporel (données supprimées ou modifiées).
STORAGE_LAST_MODIFIED_TIME TIMESTAMP Date et heure de la dernière écriture des données dans la table.
DELETED BOOLEAN Indique si la table est supprimée ou non.
TABLE_TYPE STRING Type de table. Par exemple, EXTERNAL ou BASE TABLE.
FAIL_SAFE_PHYSICAL_BYTES INT64 Nombre d'octets (compressés) physiques utilisés par le stockage protégé des défaillance (données supprimées ou modifiées).

Examples

Exemple 1 :

L'exemple suivant montre le nombre total d'octets logiques facturés pour le projet en cours.

SELECT
  SUM(total_logical_bytes) AS total_logical_bytes
FROM
  `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE;

Le résultat ressemble à ce qui suit :

+---------------------+
| total_logical_bytes |
+---------------------+
| 971329178274633     |
+---------------------+
Exemple 2 :

L'exemple suivant montre comment prévoir la différence de prix par ensemble de données entre les modèles de facturation logiques et physiques pour les 30 prochains jours. Dans cet exemple, nous partons du principe que l'utilisation future de l'espace de stockage est constante au cours des 30 prochains jours à compter de l'exécution de la requête. Notez que les prévisions sont limitées aux tables de base. Elles excluent tous les autres types de tables au sein d'un ensemble de données.

Les tarifs utilisés dans les variables de tarification de cette requête concernent la région us-central1. Si vous souhaitez exécuter cette requête pour une autre région, mettez à jour les variables de tarification de manière appropriée. Pour en savoir plus, consultez les Tarifs de stockage.

  1. Ouvrez la page BigQuery dans la console Google Cloud.

    Accéder à la page "BigQuery"

  2. Saisissez la requête GoogleSQL suivante dans la zone Éditeur de requête. INFORMATION_SCHEMA requiert la syntaxe GoogleSQL. GoogleSQL est la syntaxe par défaut dans la console Google Cloud.

    DECLARE active_logical_gib_price FLOAT64 DEFAULT 0.02;
    DECLARE long_term_logical_gib_price FLOAT64 DEFAULT 0.01;
    DECLARE active_physical_gib_price FLOAT64 DEFAULT 0.04;
    DECLARE long_term_physical_gib_price FLOAT64 DEFAULT 0.02;
    
    WITH
     storage_sizes AS (
       SELECT
         table_schema AS dataset_name,
         -- Logical
         SUM(IF(deleted=false, active_logical_bytes, 0)) / power(1024, 3) AS active_logical_gib,
         SUM(IF(deleted=false, long_term_logical_bytes, 0)) / power(1024, 3) AS long_term_logical_gib,
         -- Physical
         SUM(active_physical_bytes) / power(1024, 3) AS active_physical_gib,
         SUM(active_physical_bytes - time_travel_physical_bytes) / power(1024, 3) AS active_no_tt_physical_gib,
         SUM(long_term_physical_bytes) / power(1024, 3) AS long_term_physical_gib,
         -- Restorable previously deleted physical
         SUM(time_travel_physical_bytes) / power(1024, 3) AS time_travel_physical_gib,
         SUM(fail_safe_physical_bytes) / power(1024, 3) AS fail_safe_physical_gib,
       FROM
         `region-REGION`.INFORMATION_SCHEMA.TABLE_STORAGE_BY_PROJECT
       WHERE total_physical_bytes > 0
         -- Base the forecast on base tables only for highest precision results
         AND table_type  = 'BASE TABLE'
         GROUP BY 1
     )
    SELECT
      dataset_name,
      -- Logical
      ROUND(active_logical_gib, 2) AS active_logical_gib,
      ROUND(long_term_logical_gib, 2) AS long_term_logical_gib,
      -- Physical
      ROUND(active_physical_gib, 2) AS active_physical_gib,
      ROUND(long_term_physical_gib, 2) AS long_term_physical_gib,
      ROUND(time_travel_physical_gib, 2) AS time_travel_physical_gib,
      ROUND(fail_safe_physical_gib, 2) AS fail_safe_physical_gib,
      -- Compression ratio
      ROUND(SAFE_DIVIDE(active_logical_gib, active_no_tt_physical_gib), 2) AS active_compression_ratio,
      ROUND(SAFE_DIVIDE(long_term_logical_gib, long_term_physical_gib), 2) AS long_term_compression_ratio,
      -- Forecast costs logical
      ROUND(active_logical_gib * active_logical_gib_price, 2) AS forecast_active_logical_cost,
      ROUND(long_term_logical_gib * long_term_logical_gib_price, 2) AS forecast_long_term_logical_cost,
      -- Forecast costs physical
      ROUND((active_no_tt_physical_gib + time_travel_physical_gib + fail_safe_physical_gib) * active_physical_gib_price, 2) AS forecast_active_physical_cost,
      ROUND(long_term_physical_gib * long_term_physical_gib_price, 2) AS forecast_long_term_physical_cost,
      -- Forecast costs total
      ROUND(((active_logical_gib * active_logical_gib_price) + (long_term_logical_gib * long_term_logical_gib_price)) -
         (((active_no_tt_physical_gib + time_travel_physical_gib + fail_safe_physical_gib) * active_physical_gib_price) + (long_term_physical_gib * long_term_physical_gib_price)), 2) AS forecast_total_cost_difference
    FROM
      storage_sizes
    ORDER BY
      (forecast_active_logical_cost + forecast_active_physical_cost) DESC;
    
  3. Cliquez sur Exécuter.

Le résultat se présente comme suit :

+--------------+--------------------+-----------------------+---------------------+------------------------+--------------------------+-----------------------------+------------------------------+----------------------------------+-------------------------------+----------------------------------+--------------------------------+
| dataset_name | active_logical_gib | long_term_logical_gib | active_physical_gib | long_term_physical_gib | active_compression_ratio | long_term_compression_ratio | forecast_active_logical_cost | forecaset_long_term_logical_cost | forecast_active_physical_cost | forecast_long_term_physical_cost | forecast_total_cost_difference |
+--------------+--------------------+-----------------------+---------------------+------------------------+--------------------------+-----------------------------+------------------------------+----------------------------------+-------------------------------+----------------------------------+--------------------------------+
| dataset1     |               10.0 |                  10.0 |                 1.0 |                    1.0 |                     10.0 |                        10.0 |                          0.2 |                              0.1 |                          0.04 |                             0.02 |                           0.24 |

Répertorier les tables dans un ensemble de données

Vous pouvez répertorier des tables dans des ensembles de données de plusieurs manières :

  • Utiliser la console Google Cloud
  • À l'aide de la commande bq ls de l'outil de ligne de commande bq
  • Appeler la méthode API tables.list
  • En utilisant les bibliothèques clientes

Autorisations requises

Pour répertorier les tables d'un ensemble de données, vous devez au minimum disposer des autorisations bigquery.tables.list. Les rôles IAM prédéfinis suivants incluent les autorisations bigquery.tables.list :

  • bigquery.user
  • bigquery.metadataViewer
  • bigquery.dataViewer
  • bigquery.dataEditor
  • bigquery.dataOwner
  • bigquery.admin

Pour en savoir plus sur les rôles et les autorisations IAM dans BigQuery, consultez la page Contrôle des accès.

Répertorier des tables

Pour répertorier les tables dans un ensemble de données :

Console

  1. Dans le volet de navigation de la console Google Cloud, cliquez sur l'ensemble de données pour le développer. Les tables et vues de ce dernier s'affichent.

  2. Faites défiler la liste pour voir les tables de l'ensemble de données. Les tables et les vues sont identifiées par des icônes différentes.

bq

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Exécutez la commande bq ls. Vous pouvez contrôler le résultat à l'aide de l'option --format. Si vous répertoriez des tables dans un projet autre que votre projet par défaut, ajoutez l'ID du projet à l'ensemble de données, en respectant le format suivant : project_id:dataset.

    Les options supplémentaires comprennent les éléments suivants :

    • --max_results ou -n : entier indiquant le nombre maximal de résultats. La valeur par défaut est 50.
    bq ls \
    --format=pretty \
    --max_results integer \
    project_id:dataset
    

    Où :

    • integer est un entier représentant le nombre de tables à répertorier.
    • project_id est l'ID de votre projet.
    • dataset est le nom de l'ensemble de données.

    Lorsque vous exécutez la commande, le champ Type affiche TABLE ou VIEW. Par exemple :

    +-------------------------+-------+----------------------+-------------------+
    |         tableId         | Type  |        Labels        | Time Partitioning |
    +-------------------------+-------+----------------------+-------------------+
    | mytable                 | TABLE | department:shipping  |                   |
    | myview                  | VIEW  |                      |                   |
    +-------------------------+-------+----------------------+-------------------+
    

    Exemples :

    Saisissez la commande suivante pour répertorier les tables de l'ensemble de données mydataset dans votre projet par défaut.

       bq ls --format=pretty mydataset
    

    Saisissez la commande suivante pour renvoyer plus de 50 tables (sortie par défaut) de l'ensemble de données mydataset. mydataset se trouve dans votre projet par défaut.

       bq ls --format=pretty --max_results 60 mydataset
    

    Saisissez la commande suivante pour répertorier les tables de l'ensemble de données mydataset dans myotherproject.

       bq ls --format=pretty myotherproject:mydataset
    

API

Pour répertorier les tables à l'aide de l'API, appelez la méthode tables.list.

C#

Avant d'essayer cet exemple, suivez les instructions de configuration pour C# 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 C#.

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.


using Google.Cloud.BigQuery.V2;
using System;
using System.Collections.Generic;
using System.Linq;

public class BigQueryListTables
{
    public void ListTables(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        // Retrieve list of tables in the dataset
        List<BigQueryTable> tables = client.ListTables(datasetId).ToList();
        // Display the results
        if (tables.Count > 0)
        {
            Console.WriteLine($"Tables in dataset {datasetId}:");
            foreach (var table in tables)
            {
                Console.WriteLine($"\t{table.Reference.TableId}");
            }
        }
        else
        {
            Console.WriteLine($"{datasetId} does not contain any tables.");
        }
    }
}

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"
	"io"

	"cloud.google.com/go/bigquery"
	"google.golang.org/api/iterator"
)

// listTables demonstrates iterating through the collection of tables in a given dataset.
func listTables(w io.Writer, projectID, datasetID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	ts := client.Dataset(datasetID).Tables(ctx)
	for {
		t, err := ts.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintf(w, "Table: %q\n", t.TableID)
	}
	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.

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 com.google.api.gax.paging.Page;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQuery.TableListOption;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.DatasetId;
import com.google.cloud.bigquery.Table;

public class ListTables {

  public static void runListTables() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "bigquery-public-data";
    String datasetName = "samples";
    listTables(projectId, datasetName);
  }

  public static void listTables(String projectId, String datasetName) {
    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();

      DatasetId datasetId = DatasetId.of(projectId, datasetName);
      Page<Table> tables = bigquery.listTables(datasetId, TableListOption.pageSize(100));
      tables.iterateAll().forEach(table -> System.out.print(table.getTableId().getTable() + "\n"));

      System.out.println("Tables listed successfully.");
    } catch (BigQueryException e) {
      System.out.println("Tables were not listed. Error occurred: " + 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.

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 the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function listTables() {
  // Lists tables in 'my_dataset'.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = 'my_dataset';

  // List all tables in the dataset
  const [tables] = await bigquery.dataset(datasetId).getTables();

  console.log('Tables:');
  tables.forEach(table => console.log(table.id));
}

PHP

Avant d'essayer cet exemple, suivez les instructions de configuration pour PHP 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 PHP.

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.

use Google\Cloud\BigQuery\BigQueryClient;

/** Uncomment and populate these variables in your code */
// $projectId  = 'The Google project ID';
// $datasetId  = 'The BigQuery dataset ID';

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$tables = $dataset->tables();
foreach ($tables as $table) {
    print($table->id() . PHP_EOL);
}

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.

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.


from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Set dataset_id to the ID of the dataset that contains
#                  the tables you are listing.
# dataset_id = 'your-project.your_dataset'

tables = client.list_tables(dataset_id)  # Make an API request.

print("Tables contained in '{}':".format(dataset_id))
for table in tables:
    print("{}.{}.{}".format(table.project, table.dataset_id, table.table_id))

Ruby

Avant d'essayer cet exemple, suivez les instructions de configuration pour Ruby 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 Ruby.

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.

require "google/cloud/bigquery"

def list_tables dataset_id = "your_dataset_id"
  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id

  puts "Tables in dataset #{dataset_id}:"
  dataset.tables.each do |table|
    puts "\t#{table.table_id}"
  end
end

Sécurité des tables

Pour savoir comment contrôler l'accès aux tables dans BigQuery, consultez la page Présentation des contrôles d'accès aux tables.

Étapes suivantes

Faites l'essai

Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de BigQuery en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.

Profiter d'un essai gratuit de BigQuery