Gérer des données de table

Ce document explique comment gérer les données de table dans BigQuery. Vous pouvez effectuer les opérations suivantes sur ces données :

  • Les charger dans une table
  • Les parcourir (ou les prévisualiser)
  • Les interroger
  • Les ajouter à une table ou les utiliser pour écraser une table
  • Les modifier à l'aide du langage de manipulation de données
  • Les copier
  • Les exporter

Pour en savoir plus sur la gestion des schémas de table, consultez la page Modifier des schémas de table.

Charger des données dans une table

Vous pouvez charger des données lors de la création d'une table, ou créer une table vide et charger les données ultérieurement. Lors du chargement des données, vous pouvez utiliser la fonctionnalité de détection automatique de schéma pour les formats de données acceptés, ou vous pouvez spécifier le schéma.

Pour plus d'informations sur le chargement des données, consultez la documentation correspondant au format et à l'emplacement de vos données source :

Parcourir les données d'une table

Vous pouvez parcourir les données d'une table des manières suivantes :

  • En utilisant la console GCP ou l'interface utilisateur Web classique de BigQuery
  • En utilisant la commande bq head de l'outil de ligne de commande
  • En appelant la méthode API tabledata.list

Autorisations requises

Au niveau des ensembles de données, la consultation des données d'une table requiert un accès READER à l'ensemble de données contenant la table concernée.

Au lieu des autorisations définies au niveau de l'ensemble de données, vous pouvez utiliser un rôle IAM au niveau du projet qui inclut les autorisations bigquery.tables.getData. Tous les rôles IAM prédéfinis au niveau du projet incluent les autorisations bigquery.tables.getData, à l'exception de bigquery.user, bigquery.jobUser et bigquery.metadataViewer.

En outre, étant donné que le rôle bigquery.user possède les autorisations bigquery.datasets.create, un utilisateur disposant du rôle bigquery.user peut lire les données de toute table dans tous les ensembles de données qu'il crée. Lorsqu'un utilisateur disposant du rôle bigquery.user crée un ensemble de données, il bénéficie d'un accès OWNER à cet ensemble de données. Un accès OWNER à un ensemble de données confère à l'utilisateur un contrôle total sur cet ensemble et sur toutes les tables qu'il contient.

Pour en savoir plus sur les rôles et les autorisations IAM dans BigQuery, consultez la page Contrôle des accès. Pour en savoir plus sur les rôles au niveau de l'ensemble de données, consultez la section Rôles primitifs pour les ensembles de données.

Parcourir les données d'une table

Pour parcourir les données d'une table, procédez comme indiqué ci-dessous.

Console

  1. Ouvrez l'interface utilisateur Web de BigQuery dans la console GCP.
    Accéder à l'UI Web de BigQuery

  2. Dans la section Ressources du panneau de navigation, développez votre projet et sélectionnez un ensemble de données. Les tables et vues de ce dernier s'affichent.

  3. Cliquez sur une table dans la liste.

  4. Cliquez sur Détails et notez la valeur indiquée pour le Nombre de lignes. Vous aurez peut-être besoin de cette valeur pour contrôler le point de départ de vos résultats à l'aide de l'interface de ligne de commande ou de l'API.

  5. Cliquez sur Preview (Aperçu). Un exemple d'ensemble de données s'affiche.

    Aperçu d'une table

UI classique

  1. Dans le volet de navigation de l'interface utilisateur Web classique de BigQuery, cliquez sur la flèche bleue située à gauche de l'ensemble de données pour le développer, ou double-cliquez sur le nom de l'ensemble de données. Les tables et vues de ce dernier s'affichent.

  2. Cliquez sur une table dans la liste.

  3. Cliquez sur Details (Détails) et notez la valeur indiquée pour le Nombre de lignes. Vous aurez peut-être besoin de cette valeur pour contrôler le point de départ de vos résultats à l'aide de l'interface de ligne de commande ou de l'API.

  4. Cliquez sur Preview (Aperçu). Un exemple d'ensemble de données s'affiche.

    Aperçu d'une table

Ligne de commande

Exécutez la commande bq head avec l'indicateur --max_rows pour répertorier tous les champs présents dans un certain nombre de lignes de la table. Si l'indicateur --max_rows n'est pas spécifié, la valeur par défaut est 100.

Pour parcourir un sous-ensemble de champs de la table (y compris les champs imbriqués et répétés), utilisez l'indicateur --selected_fields et spécifiez les champs sous forme de liste en les séparant par une virgule.

Pour spécifier le nombre de lignes à ignorer avant d'afficher les données de la table, utilisez l'indicateur --start_row=[INTEGER] (ou le raccourci -s). La valeur par défaut est 0. Vous pouvez récupérer le nombre de lignes d'une table en utilisant la commande bq show afin d'extraire les informations de la table.

Si la table que vous parcourez se trouve dans un projet autre que celui par défaut, ajoutez l'ID du projet à la commande en utilisant le format suivant : [PROJECT_ID]:[DATASET].[TABLE].

bq head --max_rows [INTEGER1] --start_row [INTEGER2] --selected_fields "[FIELDS]" [PROJECT_ID]:[DATASET].[TABLE]

Où :

  • [INTEGER1] correspond au nombre de lignes à afficher.
  • [INTEGER2] correspond au nombre de lignes à ignorer avant d'afficher les données.
  • [FIELDS] est une liste de champs séparés par une virgule.
  • [PROJECT_ID] est l'ID de votre projet.
  • [DATASET] est le nom de l'ensemble de données contenant la table.
  • [TABLE] est le nom de la table à parcourir.

Exemples :

Saisissez la commande ci-dessous pour répertorier tous les champs des 10 premières lignes de mydataset.mytable. mydataset se trouve dans le projet par défaut.

bq head --max_rows=10 mydataset.mytable

Saisissez la commande ci-dessous pour répertorier tous les champs des 100 premières lignes de mydataset.mytable. mydataset se trouve dans myotherproject, qui n'est pas le projet par défaut.

bq head myotherproject:mydataset.mytable

Saisissez la commande ci-dessous pour n'afficher que les champs field1 et field2 de mydataset.mytable. Elle utilise l'indicateur --start_row pour passer directement à la ligne 100. mydataset.mytable se trouve dans le projet par défaut.

bq head --start_row 100 --selected_fields "field1,field2" mydataset.mytable

Étant donné que la commande bq head ne crée pas de tâche de requête, elle n'apparaît pas dans l'historique des requêtes. Les commandes bq head ne vous sont donc pas facturées.

API

Parcourez les données d'une table en appelant tabledata.list. Indiquez le nom de la table dans le paramètre tableId.

Configurez les paramètres facultatifs ci-dessous pour contrôler la sortie.

  • maxResults : nombre maximal de résultats à renvoyer.
  • selectedFields : liste de champs à renvoyer, séparés par une virgule. Si ce paramètre n'est pas spécifié, tous les champs sont renvoyés.
  • startIndex : index basé sur zéro de la première ligne à lire.

Les valeurs renvoyées sont encapsulées dans un objet JSON que vous devez analyser, comme décrit dans la documentation de référence de tabledata.list.

C#

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour C# dans le 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 C#.

using Google.Api.Gax;
using Google.Apis.Bigquery.v2.Data;
using Google.Cloud.BigQuery.V2;
using System;
using System.Collections.Generic;
using System.Linq;

public class BigQueryBrowseTable
{
    public void BrowseTable(
        string projectId = "your-project-id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        TableReference tableReference = new TableReference()
        {
            TableId = "shakespeare",
            DatasetId = "samples",
            ProjectId = "bigquery-public-data"
        };
        // Load all rows from a table
        PagedEnumerable<TableDataList, BigQueryRow> result = client.ListRows(
            tableReference: tableReference,
            schema: null
        );
        // Print the first 10 rows
        foreach (BigQueryRow row in result.Take(10))
        {
            Console.WriteLine($"{row["corpus"]}: {row["word_count"]}");
        }
    }
}

Go

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Go décrite dans le 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 Go.

Par défaut, la bibliothèque cliente Google Cloud pour Go effectue automatiquement la pagination. Vous n'avez donc pas besoin d'effectuer cette tâche vous-même. Exemple :

table := client.Dataset(datasetID).Table(tableID)
it := table.Read(ctx)
for {
	var row []bigquery.Value
	err := it.Next(&row)
	if err == iterator.Done {
		break
	}
	if err != nil {
		return err
	}
	fmt.Println(row)
}

Java

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Java dans le 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 Java.

TableId tableIdObject = TableId.of(datasetName, tableName);
// This example reads the result 100 rows per RPC call. If there's no need to limit the number,
// simply omit the option.
TableResult tableData =
    bigquery.listTableData(tableIdObject, TableDataListOption.pageSize(100));
for (FieldValueList row : tableData.iterateAll()) {
  // do something with the row
}

Node.js

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Node.js dans le 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 Node.js.

Par défaut, la bibliothèque cliente Google Cloud pour Node.js effectue automatiquement la pagination. Vous n'avez donc pas besoin d'effectuer cette tâche vous-même. Exemple :

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

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

async function browseRows() {
  // Displays rows from "my_table" in "my_dataset".

  // Create a client
  const bigqueryClient = new BigQuery();

  // List rows in the table
  const [rows] = await bigqueryClient
    .dataset(datasetId)
    .table(tableId)
    .getRows();

  console.log('Rows:');
  rows.forEach(row => console.log(row));
}

browseRows();

PHP

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour PHP dans le 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 PHP.

La pagination s'effectue automatiquement dans la bibliothèque cliente Google Cloud pour PHP à l'aide de la fonction de générateur rows, qui récupère la page de résultats suivante lors de l'itération.

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';
// $maxResults = 10;

$maxResults = 10;
$startIndex = 0;

$options = [
    'maxResults' => $maxResults,
    'startIndex' => $startIndex
];
$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$table = $dataset->table($tableId);
$numRows = 0;
foreach ($table->rows($options) as $row) {
    print('---');
    foreach ($row as $column => $value) {
        printf('%s: %s' . PHP_EOL, $column, $value);
    }
    $numRows++;
}

Python

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Python décrite dans le guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence sur l'API BigQuery Python.

# from google.cloud import bigquery
# client = bigquery.Client()

dataset_ref = client.dataset("samples", project="bigquery-public-data")
table_ref = dataset_ref.table("shakespeare")
table = client.get_table(table_ref)  # API call

# Load all rows from a table
rows = client.list_rows(table)
assert len(list(rows)) == table.num_rows

# Load the first 10 rows
rows = client.list_rows(table, max_results=10)
assert len(list(rows)) == 10

# Specify selected fields to limit the results to certain columns
fields = table.schema[:2]  # first two columns
rows = client.list_rows(table, selected_fields=fields, max_results=10)
assert len(rows.schema) == 2
assert len(list(rows)) == 10

# Use the start index to load an arbitrary portion of the table
rows = client.list_rows(table, start_index=10, max_results=10)

# Print row data in tabular format
format_string = "{!s:<16} " * len(rows.schema)
field_names = [field.name for field in rows.schema]
print(format_string.format(*field_names))  # prints column headers
for row in rows:
    print(format_string.format(*row))  # prints row data

Ruby

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Ruby dans le 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 Ruby.

La pagination s'effectue automatiquement dans la bibliothèque cliente Google Cloud pour Ruby à l'aide de Table#data et de Data#next.

require "google/cloud/bigquery"

def browse_table
  bigquery = Google::Cloud::Bigquery.new project_id: "bigquery-public-data"
  dataset  = bigquery.dataset "samples"
  table    = dataset.table "shakespeare"

  # Load all rows from a table
  rows = table.data

  # Load the first 10 rows
  rows = table.data max: 10

  # Print row data
  rows.each { |row| puts row }
end

Interroger les données d'une table

Après avoir chargé vos données dans BigQuery, vous pouvez interroger les données de vos tables. BigQuery accepte les deux types de requêtes suivants :

Par défaut, BigQuery exécute des requêtes interactives, ce qui signifie que ces dernières sont exécutées dès que possible.

Le service BigQuery permet également d'exécuter des requêtes par lot. Il met en file d'attente chaque requête par lot en votre nom et en lance une dès que des ressources inactives sont disponibles, généralement en quelques minutes.

Vous pouvez exécuter des requêtes interactives et par lot en utilisant les éléments suivants :

Pour en savoir plus sur l'interrogation des tables BigQuery, consultez la page Présentation du processus d'interrogation des données BigQuery.

Vous pouvez interroger non seulement les données présentes dans les tables BigQuery, mais également celles stockées hors de ces tables. Pour en savoir plus, consultez la page Présentation des sources de données externes.

Ajouter ou écraser des données dans une table

Vous pouvez écraser les données d'une table en effectuant une opération de chargement ou de requête. Vous avez la possibilité d'inclure des données dans une table existante en exécutant un chargement avec ajout ou en ajoutant des résultats de requête à la table.

Pour savoir comment ajouter ou écraser des données dans une table lors d'une opération de chargement, consultez la documentation correspondant au format de vos données sources :

Pour ajouter ou écraser des données dans une table à l'aide de résultats de requête, spécifiez une table de destination et définissez la disposition d'écriture sur l'un des paramètres suivants :

  • 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

Pour savoir comment utiliser des résultats de requête pour ajouter ou écraser des données, consultez la section Écrire des résultats de requête.

Modifier les données d'une table

En utilisant le dialecte SQL standard, vous pouvez modifier les données d'une table à l'aide d'instructions LMD. Ces instructions vous permettent d'effectuer de façon groupée des mises à jour, des insertions et des suppressions de lignes. Pour obtenir des exemples d'utilisation du langage LMD, consultez l'article Mettre à jour des données de table à l'aide du langage de manipulation de données.

L'ancien dialecte SQL n'accepte pas les instructions LMD. Pour mettre à jour ou supprimer des données à l'aide de l'ancien SQL, vous devez supprimer la table, puis la recréer avec de nouvelles données. Vous pouvez également créer une requête qui modifie les données et écrire les résultats de la requête dans une nouvelle table de destination.

Copier les données d'une table

Vous pouvez copier une table des manières suivantes :

  • Utilisation de la console GCP ou de l'interface utilisateur Web classique de BigQuery
  • Utilisation de la commande bq cp de l'outil de ligne de commande
  • Appel de la méthode API jobs.insert et configuration d'une tâche de copie

Pour en savoir plus sur la copie de tables, consultez la section Copier une table.

Exporter les données d'une table

Les données d'une table peuvent être exportées au format CSV, JSON ou Avro. Actuellement, vous devez exporter les données dans un bucket Cloud Storage. Il n'est pas possible de procéder à une exportation vers un ordinateur local. Toutefois, vous pouvez télécharger et enregistrer les résultats de requête à l'aide de la console GCP ou de l'interface utilisateur Web classique de BigQuery.

Pour en savoir plus, consultez la page Exporter des données de table.

Étapes suivantes

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

Besoin d'aide ? Consultez notre page d'assistance.