Charger des données CSV à partir de Cloud Storage

Charger des fichiers CSV à partir de Cloud Storage

Lorsque vous chargez des données CSV depuis Cloud Storage, vous pouvez les placer 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. Lorsque les données sont chargées dans BigQuery, elles sont converties au format en colonnes de Capacitor (format de stockage de BigQuery).

Lorsque vous chargez des données depuis Cloud Storage dans une table BigQuery, l'ensemble de données contenant la table doit se trouver dans le même emplacement régional ou multirégional que le bucket Cloud Storage.

Pour plus d'informations sur le chargement de données CSV à partir d'un fichier local, consultez la section Charger des données dans BigQuery à partir d'une source de données locale.

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 offerts pour exécuter, tester et déployer des charges de travail.

Profiter d'un essai gratuit de BigQuery

Limites

Lorsque vous chargez des fichiers CSV dans BigQuery, tenez compte des points suivants :

  • Les fichiers CSV ne prennent pas en charge les données imbriquées ou répétées.
  • Supprimez les caractères de l'indicateur d'ordre des octets (BOM). Ils peuvent entraîner des problèmes inattendus.
  • Si vous utilisez la compression gzip, BigQuery ne peut pas lire les données en parallèle. Le chargement de données CSV compressées dans BigQuery est plus lent que le chargement de données non compressées. Consultez la section Charger des données compressées et non compressées.
  • Vous ne pouvez pas inclure à la fois des fichiers compressés et non compressés dans la même tâche de chargement.
  • La taille maximale d'un fichier gzip est de 4 Go.
  • Lorsque vous chargez des données CSV ou JSON, les valeurs des colonnes DATE doivent utiliser le tiret (-) comme séparateur et la date doit avoir le format suivant : YYYY-MM-DD (année-mois-jour).
  • Lorsque vous chargez des données JSON ou CSV, les valeurs des colonnes TIMESTAMP doivent utiliser le tiret (-) comme séparateur pour la partie date de l'horodatage et la date doit être au format suivant : YYYY-MM-DD (année-mois-jour). La partie hh:mm:ss (heure-minute-seconde) de l'horodatage doit utiliser le signe deux-points (:) comme séparateur.

Avant de commencer

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

Autorisations requises

Pour charger des données dans BigQuery, vous devez disposer d'autorisations IAM pour exécuter une tâche de chargement et charger des données dans des tables et partitions BigQuery. Si vous chargez des données à partir de Cloud Storage, vous devez également disposer d'autorisations IAM pour accéder au bucket contenant vos données.

Autorisations pour charger des données dans BigQuery

Pour charger des données dans une nouvelle table ou partition BigQuery, ou pour ajouter ou écraser une table ou une partition existante, vous avez besoin des autorisations IAM suivantes :

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

Chacun des rôles IAM prédéfinis suivants inclut les autorisations dont vous avez besoin pour charger des données dans une table ou une partition BigQuery :

  • roles/bigquery.dataEditor
  • roles/bigquery.dataOwner
  • roles/bigquery.admin (inclut l'autorisation bigquery.jobs.create)
  • bigquery.user (inclut l'autorisation bigquery.jobs.create)
  • 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 à l'aide d'une tâche de chargement 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.

Autorisations pour charger des données à partir de Cloud Storage

Pour charger des données à partir d'un bucket Cloud Storage, vous devez disposer des autorisations IAM suivantes :

  • storage.objects.get
  • storage.objects.list (obligatoire si vous utilisez un caractère générique dans l'URI)

Le rôle IAM prédéfini roles/storage.objectViewer inclut toutes les autorisations dont vous avez besoin pour charger des données à partir d'un bucket Cloud Storage.

Charger des données CSV dans une table

Vous pouvez charger des données CSV depuis Cloud Storage dans une nouvelle table BigQuery de plusieurs façons :

  • À l'aide de Cloud Console
  • En exécutant la commande bq load de l'outil de ligne de commande bq
  • En appelant la méthode API jobs.insert et en configurant une tâche load
  • En utilisant les bibliothèques clientes

Pour charger des données CSV depuis Cloud Storage dans une nouvelle table BigQuery, procédez comme suit :

Console

Pour obtenir des conseils détaillés sur cette tâche directement dans l'éditeur Cloud Shell, cliquez sur Visite guidée :

VISITE GUIDÉE

La procédure décrite dans les sections suivantes, est la même que si vous cliquez sur Visite guidée.

  1. Dans Cloud Console, ouvrez la page "BigQuery".

    Accéder à BigQuery

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

  3. Développez l'option Actions puis cliquez sur Ouvrir.

  4. Dans le panneau de détails, cliquez sur Créer une table.

  5. Dans la section Source de la page Créer une table :

    • Pour le champ Créer une table à partir de, sélectionnez Cloud Storage.

    • Dans le champ de la source, recherchez ou saisissez l'URI Cloud Storage. Sachez que vous ne pouvez pas inclure plusieurs URI dans Cloud Console. En revanche, les caractères génériques sont acceptés. Le bucket Cloud Storage doit se trouver au même emplacement que l'ensemble de données contenant la table que vous créez.

      Sélectionner un fichier

    • Pour File format (Format de fichier), sélectionnez CSV.

  6. Dans la section Destination de la page Create Table (Créer une table) :

    • Sous Dataset name (Nom de l'ensemble de données), sélectionnez l'ensemble de données approprié.

      Afficher l'ensemble de données

    • Vérifiez que Type de table est défini sur Table native.

    • Dans le champ Nom de la table, saisissez le nom de la table que vous créez dans BigQuery.

  7. Dans la section Schéma, sous Détection automatique, cochez Schéma et paramètres d'entrée pour activer la détection automatique du schéma. Vous pouvez également saisir la définition du schéma manuellement de l'une des manières suivantes :

    • Activez l'option Modifier sous forme de texte et saisissez le schéma de la table sous forme de tableau JSON.

      Ajouter un schéma en tant que tableau JSON

    • Utilisez l'option Add field (Ajouter un champ) pour saisir manuellement le schéma.

      Ajouter une définition de schéma à l'aide du bouton "Ajouter un champ"

  8. (Facultatif) Pour partitionner la table, choisissez vos options dans Paramètres de partitionnement et de clustering : Pour en savoir plus, consultez la page Créer des tables partitionnées.

  9. (Facultatif) Pour le champ Filtre de partitionnement, cochez la case Demander un filtre de partitionnement pour obliger les utilisateurs à inclure une clause WHERE spécifiant les partitions à interroger. Ce type de filtre peut contribuer à réduire les coûts et à améliorer les performances. Pour en savoir plus, consultez la section Interroger des tables partitionnées. Cette option n'est pas disponible si Aucun partitionnement est sélectionné.

  10. (Facultatif) Pour mettre une table en cluster, saisissez entre un et quatre noms de champs dans la zone Ordre de clustering.

  11. (Facultatif) Cliquez sur Options avancées.

    • Pour le champ Préférence d'écriture, laissez l'option Écrire si la table est vide sélectionnée. Cette option crée une table et y charge vos données.
    • Pour le champ Nombre d'erreurs autorisées, acceptez la valeur par défaut 0 ou saisissez le nombre maximal de lignes contenant des erreurs qui peuvent être ignorées. Si le nombre de lignes contenant des erreurs dépasse cette valeur, la tâche renverra un message invalid et échouera.
    • Sous Valeurs inconnues, cochez la case Ignorer les valeurs inconnues pour ignorer les valeurs d'une ligne qui ne sont pas présentes dans le schéma de la table.
    • Sous Délimiteur de champ, sélectionnez le caractère qui sépare les cellules dans votre fichier CSV : Virgule, Tabulation, Barre verticale ou Personnalisé. Si vous sélectionnez Personnalisé, saisissez le délimiteur dans la zone Délimiteur de champ personnalisé. La valeur par défaut est Virgule.
    • Sous Lignes d'en-tête à ignorer, saisissez le nombre de lignes d'en-tête à ignorer en haut du fichier CSV. La valeur par défaut est 0.
    • Sous Nouvelles lignes entre guillemets, cochez Autoriser les nouvelles lignes entre guillemets pour autoriser les sections de données entre guillemets contenant des caractères de retour à la ligne dans un fichier CSV. La valeur par défaut est false.
    • Sous Lignes irrégulières, cochez Autoriser les lignes irrégulières pour accepter les lignes des fichiers CSV pour lesquelles il manque des colonnes facultatives finales. Les valeurs manquantes sont traitées comme des valeurs nulles. Si cette option n'est pas cochée, les enregistrements contenant des colonnes finales manquantes sont traités comme des enregistrements incorrects et, si le nombre d'enregistrements incorrects est trop élevé, une erreur "non valide" est renvoyée dans le résultat de la tâche. La valeur par défaut est false.
    • Pour le champ Chiffrement, cliquez sur Clé gérée par le client afin d'utiliser une clé Cloud Key Management Service. Si vous conservez le paramètre Clé gérée par Google, BigQuery chiffre les données au repos.

  12. Cliquez sur Créer une table.

bq

Exécutez la commande bq load, définissez CSV à l'aide de l'option --source_format et spécifiez un URI Cloud Storage. Vous pouvez inclure un seul URI, une liste d'URI séparés par des virgules ou un URI contenant un caractère générique. Fournissez le schéma de manière intégrée ou dans un fichier de définition de schéma, ou utilisez la détection automatique du schéma. Si vous ne spécifiez pas de schéma, que la valeur de --autodetect est false et que la table de destination existe, le schéma de la table de destination est utilisé.

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

Les autres options facultatives sont les suivantes :

  • --allow_jagged_rows : permet d'accepter les lignes dans les fichiers CSV pour lesquelles il manque des colonnes facultatives finales. Les valeurs manquantes sont traitées comme des valeurs nulles. Si cette option n'est pas cochée, les enregistrements contenant des colonnes finales manquantes sont traités comme des enregistrements incorrects et, si le nombre d'enregistrements incorrects est trop élevé, une erreur "non valide" est renvoyée dans le résultat de la tâche. La valeur par défaut est false.
  • --allow_quoted_newlines : permet d'autoriser les sections de données entre guillemets contenant des caractères de retour à la ligne dans un fichier CSV. La valeur par défaut est false.
  • --field_delimiter : caractère indiquant la délimitation entre les colonnes de données. Les options \t et tab sont autorisées pour les délimiteurs de tabulation. La valeur par défaut est ,.
  • --null_marker : chaîne personnalisée facultative qui représente une valeur NULL dans les données CSV.
  • --skip_leading_rows : spécifie le nombre de lignes d'en-tête à ignorer en haut du fichier CSV. La valeur par défaut est 0.
  • --quote : guillemet à utiliser pour délimiter les enregistrements. La valeur par défaut est ". Pour ne spécifier aucun caractère de guillemet, utilisez une chaîne vide.
  • --max_bad_records : entier spécifiant le nombre maximal d'enregistrements incorrects autorisés avant l'échec total de la tâche. La valeur par défaut est 0. Au plus, cinq erreurs de n'importe quel type sont renvoyées, quelle que soit la valeur --max_bad_records.
  • --ignore_unknown_values : si spécifié, permet d'autoriser et d'ignorer les valeurs supplémentaires non reconnues dans les données CSV ou JSON.
  • --autodetect : permet d'activer la détection automatique du schéma pour les données CSV et JSON.
  • --time_partitioning_type : active le partitionnement temporel sur une table et définit le type de partition. Les valeurs possibles sont HOUR, DAY, MONTH et YEAR. Cette option est facultative lorsque vous créez une table partitionnée sur une colonne DATE, DATETIME ou TIMESTAMP. Le type de partition par défaut pour le partitionnement temporel est DAY. Vous ne pouvez pas modifier la spécification de partitionnement sur une table existante.
  • --time_partitioning_expiration : entier qui spécifie (en secondes) le délai au terme duquel une partition temporelle doit être supprimée. Le délai d'expiration correspond à la date UTC de la partition plus la valeur entière.
  • --time_partitioning_field : colonne DATE ou TIMESTAMP utilisée pour créer une table partitionnée. Si le partitionnement par date est activé sans cette valeur, une table partitionnée par date d'ingestion est créée.
  • --require_partition_filter : si cette option est activée, elle oblige les utilisateurs à inclure une clause WHERE spécifiant les partitions à interroger. Ce type de filtre peut contribuer à réduire les coûts et à améliorer les performances. Pour en savoir plus, consultez la section Interroger des tables partitionnées.
  • --clustering_fields : liste pouvant contenir jusqu'à quatre noms de colonne séparés par une virgule, et utilisée pour créer une table en cluster.

  • --destination_kms_key : clé Cloud KMS pour le chiffrement des données de la table.

    Pour plus d'informations sur la commande bq load, consultez les pages suivantes :

    Pour en savoir plus sur les tables partitionnées, consultez :

    Pour en savoir plus sur les tables en cluster, consultez :

    Pour en savoir plus sur le chiffrement d'une table, consultez :

Pour charger des données CSV dans BigQuery, saisissez la commande suivante :

bq --location=location load \
--source_format=format \
dataset.table \
path_to_source \
schema

Où :

  • location correspond à votre emplacement. 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 définir une valeur par défaut correspondant à l'emplacement à l'aide du fichier bigqueryrc.
  • format est CSV.
  • dataset est un ensemble de données existant.
  • table est le nom de la table dans laquelle vous chargez des données.
  • path_to_source est un URI Cloud Storage complet ou une liste d'URI séparés par une virgule. Les caractères génériques sont également acceptés.
  • schema est un schéma valide. Ce schéma peut être un fichier JSON local ou il peut être intégré à la commande. Vous pouvez également utiliser l'option --autodetect au lieu de fournir une définition de schéma.

Exemples :

La commande suivante permet de charger les données de gs://mybucket/mydata.csv dans la table mytable de mydataset. Le schéma est défini dans un fichier de schéma local nommé myschema.json.

    bq load \
    --source_format=CSV \
    mydataset.mytable \
    gs://mybucket/mydata.csv \
    ./myschema.json

La commande suivante permet de charger les données de gs://mybucket/mydata.csv dans la table mytable de mydataset. Le schéma est défini dans un fichier de schéma local nommé myschema.json. Le fichier CSV comprend deux lignes d'en-tête. Si --skip_leading_rows n'est pas spécifié, le comportement par défaut consiste à supposer que le fichier ne contient pas d'en-têtes.

    bq load \
    --source_format=CSV \
    --skip_leading_rows=2
    mydataset.mytable \
    gs://mybucket/mydata.csv \
    ./myschema.json

La commande suivante permet de charger les données de gs://mybucket/mydata.csv dans la table partitionnée par date d'ingestion mytable de mydataset. Le schéma est défini dans un fichier de schéma local nommé myschema.json.

    bq load \
    --source_format=CSV \
    --time_partitioning_type=DAY \
    mydataset.mytable \
    gs://mybucket/mydata.csv \
    ./myschema.json

La commande suivante permet de charger les données de gs://mybucket/mydata.csv dans une nouvelle table partitionnée de mydataset nommée mytable. La table est partitionnée en fonction de la colonne mytimestamp. Le schéma est défini dans un fichier de schéma local nommé myschema.json.

    bq load \
    --source_format=CSV \
    --time_partitioning_field mytimestamp \
    mydataset.mytable \
    gs://mybucket/mydata.csv \
    ./myschema.json

La commande suivante permet de charger les données de gs://mybucket/mydata.csv dans la table mytable de mydataset. Le schéma est détecté automatiquement.

    bq load \
    --autodetect \
    --source_format=CSV \
    mydataset.mytable \
    gs://mybucket/mydata.csv

La commande suivante permet de charger les données de gs://mybucket/mydata.csv dans la table mytable de mydataset. Le schéma est défini de manière intégrée au format field:data_type,field:data_type.

    bq load \
    --source_format=CSV \
    mydataset.mytable \
    gs://mybucket/mydata.csv \
    qtr:STRING,sales:FLOAT,year:STRING

La commande ci-dessous permet de charger les données de plusieurs fichiers de gs://mybucket/ dans la table mytable de mydataset. L'URI Cloud Storage utilise un caractère générique. Le schéma est détecté automatiquement.

    bq load \
    --autodetect \
    --source_format=CSV \
    mydataset.mytable \
    gs://mybucket/mydata*.csv

La commande ci-dessous permet de charger les données de plusieurs fichiers de gs://mybucket/ dans la table mytable de mydataset. La commande inclut une liste d'URI Cloud Storage séparés par une virgule. Le schéma est défini dans un fichier de schéma local nommé myschema.json.

    bq load \
    --source_format=CSV \
    mydataset.mytable \
    "gs://mybucket/00/*.csv","gs://mybucket/01/*.csv" \
    ./myschema.json

API

  1. Créez une tâche de chargement (load) qui pointe vers les données sources dans Cloud Storage.

  2. (Facultatif) Spécifiez votre emplacement dans la propriété location de la section jobReference de la ressource de tâche.

  3. La propriété source URIs doit être complète et respecter le format gs://bucket/object. Chaque URI peut contenir un caractère générique (*).

  4. Spécifiez le format de données CSV en définissant la propriété sourceFormat sur CSV.

  5. Pour vérifier l'état de la tâche, appelez jobs.get(job_id*), où job_id correspond à l'ID de tâche renvoyé par la requête initiale.

    • Si la réponse est status.state = DONE, la tâche a bien été exécutée.
    • Si la propriété status.errorResult est présente, la requête a échoué. Cet objet inclura des informations décrivant le problème rencontré. Lorsqu'une requête échoue, aucune table n'est créée et aucune donnée n'est ajoutée.
    • Si la propriété status.errorResult est absente, la tâche a bien été exécutée. Toutefois, des erreurs non fatales, telles que des problèmes d'importation de lignes, ont pu se produire. Ces erreurs sont répertoriées dans la propriété status.errors de l'objet de tâche renvoyé.

Remarques relatives à l'API :

  • Les tâches de chargement sont atomiques et cohérentes. En cas d'échec d'une tâche de chargement, aucune donnée n'est disponible. Si une tâche aboutit, toutes les données sont disponibles.

  • Nous vous recommandons de générer un ID unique et de le transmettre en tant que jobReference.jobId lorsque vous appelez jobs.insert pour créer une tâche de chargement. Cette approche offre une protection plus robuste contre les pannes réseau, car le client peut lancer une requête ou effectuer de nouvelles tentatives en utilisant l'ID de tâche connu.

  • L'appel de jobs.insert sur un ID de tâche donné est idempotent. En d'autres termes, vous pouvez effectuer autant de tentatives que vous le souhaitez avec le même ID de tâche. L'une de ces opérations tout au plus aboutira.

C#

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


using Google.Cloud.BigQuery.V2;
using System;

public class BigQueryLoadTableGcsCsv
{
    public void LoadTableGcsCsv(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        var gcsURI = "gs://cloud-samples-data/bigquery/us-states/us-states.csv";
        var dataset = client.GetDataset(datasetId);
        var schema = new TableSchemaBuilder {
            { "name", BigQueryDbType.String },
            { "post_abbr", BigQueryDbType.String }
        }.Build();
        var destinationTableRef = dataset.GetTableReference(
            tableId: "us_states");
        // Create job configuration
        var jobOptions = new CreateLoadJobOptions()
        {
            // The source format defaults to CSV; line below is optional.
            SourceFormat = FileFormat.Csv,
            SkipLeadingRows = 1
        };
        // Create and run job
        var loadJob = client.CreateLoadJob(
            sourceUri: gcsURI, destination: destinationTableRef,
            schema: schema, options: jobOptions);
        loadJob.PollUntilCompleted();  // Waits for the job to complete.
        // Display the number of rows uploaded
        BigQueryTable table = client.GetTable(destinationTableRef);
        Console.WriteLine(
            $"Loaded {table.Resource.NumRows} rows to {table.FullyQualifiedId}");
    }
}

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 sur l'API BigQuery en langage Go. 

import (
	"context"
	"fmt"

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

// importCSVExplicitSchema demonstrates loading CSV data from Cloud Storage into a BigQuery
// table and providing an explicit schema for the data.
func importCSVExplicitSchema(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()

	gcsRef := bigquery.NewGCSReference("gs://cloud-samples-data/bigquery/us-states/us-states.csv")
	gcsRef.SkipLeadingRows = 1
	gcsRef.Schema = bigquery.Schema{
		{Name: "name", Type: bigquery.StringFieldType},
		{Name: "post_abbr", Type: bigquery.StringFieldType},
	}
	loader := client.Dataset(datasetID).Table(tableID).LoaderFrom(gcsRef)
	loader.WriteDisposition = bigquery.WriteEmpty

	job, err := loader.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}

	if status.Err() != nil {
		return fmt.Errorf("job completed with error: %v", status.Err())
	}
	return nil
}

Java

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

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.CsvOptions;
import com.google.cloud.bigquery.Field;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.LoadJobConfiguration;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.StandardSQLTypeName;
import com.google.cloud.bigquery.TableId;

// Sample to load CSV data from Cloud Storage into a new BigQuery table
public class LoadCsvFromGcs {

  public static void runLoadCsvFromGcs() throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String sourceUri = "gs://cloud-samples-data/bigquery/us-states/us-states.csv";
    Schema schema =
        Schema.of(
            Field.of("name", StandardSQLTypeName.STRING),
            Field.of("post_abbr", StandardSQLTypeName.STRING));
    loadCsvFromGcs(datasetName, tableName, sourceUri, schema);
  }

  public static void loadCsvFromGcs(
      String datasetName, String tableName, String sourceUri, 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();

      // Skip header row in the file.
      CsvOptions csvOptions = CsvOptions.newBuilder().setSkipLeadingRows(1).build();

      TableId tableId = TableId.of(datasetName, tableName);
      LoadJobConfiguration loadConfig =
          LoadJobConfiguration.newBuilder(tableId, sourceUri, csvOptions).setSchema(schema).build();

      // Load data from a GCS CSV file into the table
      Job job = bigquery.create(JobInfo.of(loadConfig));
      // Blocks until this load table job completes its execution, either failing or succeeding.
      job = job.waitFor();
      if (job.isDone()) {
        System.out.println("CSV from GCS successfully added during load append job");
      } else {
        System.out.println(
            "BigQuery was unable to load into the table due to an error:"
                + job.getStatus().getError());
      }
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Column not added during load append \n" + e.toString());
    }
  }
}

Node.js

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

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

// Instantiate clients
const bigquery = new BigQuery();
const storage = new Storage();

/**
 * This sample loads the CSV file at
 * https://storage.googleapis.com/cloud-samples-data/bigquery/us-states/us-states.csv
 *
 * TODO(developer): Replace the following lines with the path to your file.
 */
const bucketName = 'cloud-samples-data';
const filename = 'bigquery/us-states/us-states.csv';

async function loadCSVFromGCS() {
  // Imports a GCS file into a table with manually defined schema.

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

  // Configure the load job. For full list of options, see:
  // https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad
  const metadata = {
    sourceFormat: 'CSV',
    skipLeadingRows: 1,
    schema: {
      fields: [
        {name: 'name', type: 'STRING'},
        {name: 'post_abbr', type: 'STRING'},
      ],
    },
    location: 'US',
  };

  // Load data from a Google Cloud Storage file into the table
  const [job] = await bigquery
    .dataset(datasetId)
    .table(tableId)
    .load(storage.bucket(bucketName).file(filename), metadata);

  // load() waits for the job to finish
  console.log(`Job ${job.id} completed.`);

  // Check the job's status for errors
  const errors = job.status.errors;
  if (errors && errors.length > 0) {
    throw errors;
  }
}

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. 

use Google\Cloud\BigQuery\BigQueryClient;
use Google\Cloud\Core\ExponentialBackoff;

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

// instantiate the bigquery table service
$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$table = $dataset->table('us_states');

// create the import job
$gcsUri = 'gs://cloud-samples-data/bigquery/us-states/us-states.csv';
$schema = [
    'fields' => [
        ['name' => 'name', 'type' => 'string'],
        ['name' => 'post_abbr', 'type' => 'string']
    ]
];
$loadConfig = $table->loadFromStorage($gcsUri)->schema($schema)->skipLeadingRows(1);
$job = $table->runJob($loadConfig);
// poll the job until it is complete
$backoff = new ExponentialBackoff(10);
$backoff->execute(function () use ($job) {
    print('Waiting for job to complete' . PHP_EOL);
    $job->reload();
    if (!$job->isComplete()) {
        throw new Exception('Job has not yet completed', 500);
    }
});
// check if the job has errors
if (isset($job->info()['status']['errorResult'])) {
    $error = $job->info()['status']['errorResult']['message'];
    printf('Error running job: %s' . PHP_EOL, $error);
} else {
    print('Data imported successfully' . PHP_EOL);
}

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 de l'API BigQuery Python.

Utilisez la méthode Client.load_table_from_uri() pour charger des données à partir d'un fichier CSV dans Cloud Storage. Fournissez une définition de schéma explicite en définissant la propriété LoadJobConfig.schema sur une liste d'objets SchemaField.

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"

job_config = bigquery.LoadJobConfig(
    schema=[
        bigquery.SchemaField("name", "STRING"),
        bigquery.SchemaField("post_abbr", "STRING"),
    ],
    skip_leading_rows=1,
    # The source format defaults to CSV, so the line below is optional.
    source_format=bigquery.SourceFormat.CSV,
)
uri = "gs://cloud-samples-data/bigquery/us-states/us-states.csv"

load_job = client.load_table_from_uri(
    uri, table_id, job_config=job_config
)  # Make an API request.

load_job.result()  # Waits for the job to complete.

destination_table = client.get_table(table_id)  # Make an API request.
print("Loaded {} rows.".format(destination_table.num_rows))

Ruby

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

require "google/cloud/bigquery"

def load_table_gcs_csv dataset_id = "your_dataset_id"
  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id
  gcs_uri  = "gs://cloud-samples-data/bigquery/us-states/us-states.csv"
  table_id = "us_states"

  load_job = dataset.load_job table_id, gcs_uri, skip_leading: 1 do |schema|
    schema.string "name"
    schema.string "post_abbr"
  end
  puts "Starting job #{load_job.job_id}"

  load_job.wait_until_done! # Waits for table load to complete.
  puts "Job finished."

  table = dataset.table table_id
  puts "Loaded #{table.rows_count} rows to table #{table.id}"
end

Charger des données CSV dans une table utilisant un partitionnement temporel basé sur une colonne

Pour charger des données CSV à partir de Cloud Storage dans une table BigQuery qui utilise le partitionnement temporel basé sur une colonne :

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 sur l'API BigQuery en langage Go. 


import (
	"context"
	"fmt"
	"time"

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

// importPartitionedTable demonstrates specifing time partitioning for a BigQuery table when loading
// CSV data from Cloud Storage.
func importPartitionedTable(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()

	gcsRef := bigquery.NewGCSReference("gs://cloud-samples-data/bigquery/us-states/us-states-by-date.csv")
	gcsRef.SkipLeadingRows = 1
	gcsRef.Schema = bigquery.Schema{
		{Name: "name", Type: bigquery.StringFieldType},
		{Name: "post_abbr", Type: bigquery.StringFieldType},
		{Name: "date", Type: bigquery.DateFieldType},
	}
	loader := client.Dataset(destDatasetID).Table(destTableID).LoaderFrom(gcsRef)
	loader.TimePartitioning = &bigquery.TimePartitioning{
		Field:      "date",
		Expiration: 90 * 24 * time.Hour,
	}
	loader.WriteDisposition = bigquery.WriteEmpty

	job, err := loader.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}

	if status.Err() != nil {
		return fmt.Errorf("job completed with error: %v", status.Err())
	}
	return nil
}

Java

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

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.FormatOptions;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobId;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.LoadJobConfiguration;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.StandardSQLTypeName;
import com.google.cloud.bigquery.TableId;
import com.google.cloud.bigquery.TimePartitioning;
import java.time.Duration;
import java.time.temporal.ChronoUnit;
import java.util.UUID;

public class LoadPartitionedTable {

  public static void runLoadPartitionedTable() throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String sourceUri = "/path/to/file.csv";
    loadPartitionedTable(datasetName, tableName, sourceUri);
  }

  public static void loadPartitionedTable(String datasetName, String tableName, String sourceUri)
      throws Exception {
    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);

      Schema schema =
          Schema.of(
              Field.of("name", StandardSQLTypeName.STRING),
              Field.of("post_abbr", StandardSQLTypeName.STRING),
              Field.of("date", StandardSQLTypeName.DATE));

      // Configure time partitioning. For full list of options, see:
      // https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#TimePartitioning
      TimePartitioning partitioning =
          TimePartitioning.newBuilder(TimePartitioning.Type.DAY)
              .setField("date")
              .setExpirationMs(Duration.of(90, ChronoUnit.DAYS).toMillis())
              .build();

      LoadJobConfiguration loadJobConfig =
          LoadJobConfiguration.builder(tableId, sourceUri)
              .setFormatOptions(FormatOptions.csv())
              .setSchema(schema)
              .setTimePartitioning(partitioning)
              .build();

      // Create a job ID so that we can safely retry.
      JobId jobId = JobId.of(UUID.randomUUID().toString());
      Job loadJob = bigquery.create(JobInfo.newBuilder(loadJobConfig).setJobId(jobId).build());

      // Load data from a GCS parquet file into the table
      // Blocks until this load table job completes its execution, either failing or succeeding.
      Job completedJob = loadJob.waitFor();

      // Check for errors
      if (completedJob == null) {
        throw new Exception("Job not executed since it no longer exists.");
      } else if (completedJob.getStatus().getError() != null) {
        // You can also look at queryJob.getStatus().getExecutionErrors() for all
        // errors, not just the latest one.
        throw new Exception(
            "BigQuery was unable to load into the table due to an error: \n"
                + loadJob.getStatus().getError());
      }
      System.out.println("Data successfully loaded into time partitioned table during load job");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println(
          "Data not loaded into time partitioned table during load job \n" + e.toString());
    }
  }
}

Node.js

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

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

// Instantiate clients
const bigquery = new BigQuery();
const storage = new Storage();

/**
 * This sample loads the CSV file at
 * https://storage.googleapis.com/cloud-samples-data/bigquery/us-states/us-states.csv
 *
 * TODO(developer): Replace the following lines with the path to your file.
 */
const bucketName = 'cloud-samples-data';
const filename = 'bigquery/us-states/us-states-by-date.csv';

async function loadTablePartitioned() {
  // Load data into a table that uses column-based time partitioning.

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

  // Configure the load job. For full list of options, see:
  // https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad
  const partitionConfig = {
    type: 'DAY',
    expirationMs: '7776000000', // 90 days
    field: 'date',
  };

  const metadata = {
    sourceFormat: 'CSV',
    skipLeadingRows: 1,
    schema: {
      fields: [
        {name: 'name', type: 'STRING'},
        {name: 'post_abbr', type: 'STRING'},
        {name: 'date', type: 'DATE'},
      ],
    },
    location: 'US',
    timePartitioning: partitionConfig,
  };

  // Load data from a Google Cloud Storage file into the table
  const [job] = await bigquery
    .dataset(datasetId)
    .table(tableId)
    .load(storage.bucket(bucketName).file(filename), metadata);

  // load() waits for the job to finish
  console.log(`Job ${job.id} completed.`);
}

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 de l'API BigQuery Python. 

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"

job_config = bigquery.LoadJobConfig(
    schema=[
        bigquery.SchemaField("name", "STRING"),
        bigquery.SchemaField("post_abbr", "STRING"),
        bigquery.SchemaField("date", "DATE"),
    ],
    skip_leading_rows=1,
    time_partitioning=bigquery.TimePartitioning(
        type_=bigquery.TimePartitioningType.DAY,
        field="date",  # Name of the column to use for partitioning.
        expiration_ms=7776000000,  # 90 days.
    ),
)
uri = "gs://cloud-samples-data/bigquery/us-states/us-states-by-date.csv"

load_job = client.load_table_from_uri(
    uri, table_id, job_config=job_config
)  # Make an API request.

load_job.result()  # Wait for the job to complete.

table = client.get_table(table_id)
print("Loaded {} rows to table {}".format(table.num_rows, table_id))

Ajouter ou écraser des données dans une table avec des données CSV

Vous pouvez charger des données supplémentaires dans une table à partir de fichiers sources ou en ajoutant des résultats de requête.

Dans Cloud Console, utilisez l'option Préférence d'écriture pour spécifier l'action à entreprendre lorsque vous chargez des données à partir d'un fichier source ou d'un résultat de requête.

Vous disposez des options suivantes lorsque vous chargez des données supplémentaires dans une table :

Option de la console Option de l'outil bq Propriété de l'API BigQuery Description
Écrire si la table est vide Incompatible WRITE_EMPTY N'écrit les données que si la table est vide.
Ajouter à la table --noreplace ou --replace=false. Si --[no]replace n'est pas spécifié, les données sont ajoutées par défaut. WRITE_APPEND (Par défaut) Ajoute les données à la fin de la table.
Écraser la table --replace ou --replace=true WRITE_TRUNCATE Efface toutes les données existantes d'une table avant d'écrire les nouvelles données. Cette action supprime également le schéma de la table et la clé Cloud KMS.

Si vous chargez des données dans une table existante, la tâche de chargement peut les ajouter ou écraser la table.

Vous pouvez ajouter des données ou écraser une table de plusieurs façons :

  • En utilisant Cloud Console
  • En exécutant la commande bq load de l'outil de ligne de commande bq
  • En appelant la méthode API jobs.insert et en configurant une tâche load
  • En utilisant les bibliothèques clientes

Console

  1. Dans Cloud Console, ouvrez la page "BigQuery".

    Accéder à BigQuery

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

  3. Développez l'option Actions puis cliquez sur Ouvrir.

  4. Dans le panneau de détails, cliquez sur Créer une table.

  5. Dans la section Source de la page Créer une table :

    • Pour le champ Create table from (Créer une table à partir de), sélectionnez Cloud Storage.

    • Dans le champ de la source, recherchez ou saisissez l'URI Cloud Storage. Sachez que vous ne pouvez pas inclure plusieurs URI dans Cloud Console. En revanche, les caractères génériques sont acceptés. Le bucket Cloud Storage doit se trouver au même emplacement que l'ensemble de données contenant la table à laquelle vous ajoutez des données ou que vous écrasez.

      Sélectionner un fichier

    • Pour File format (Format de fichier), sélectionnez CSV.

  6. Dans la section Destination de la page Create Table (Créer une table) :

    • Sous Dataset name (Nom de l'ensemble de données), sélectionnez l'ensemble de données approprié.

      Sélectionner un ensemble de données

    • Dans le champ Nom de la table, saisissez le nom de la table à laquelle vous ajoutez des données ou que vous écrasez dans BigQuery.

    • Vérifiez que Type de table est défini sur Table native.

  7. Dans la section Schéma, sous Détection automatique, cochez Schéma et paramètres d'entrée pour activer la détection automatique du schéma. Vous pouvez également saisir la définition du schéma manuellement de l'une des manières suivantes :

    • Activez l'option Modifier sous forme de texte et saisissez le schéma de la table sous forme de tableau JSON.

      Ajouter un schéma en tant que tableau JSON

    • Utilisez l'option Add field (Ajouter un champ) pour saisir manuellement le schéma.

      Ajouter une définition de schéma à l'aide du bouton "Add field" (Ajouter un champ)

  8. Sous Paramètres de partitionnement et de clustering, conservez les valeurs par défaut. Vous ne pouvez pas convertir une table en table partitionnée ou en cluster en y ajoutant ou en y écrasant des données. Par ailleurs, Cloud Console n'accepte ni l'ajout, ni l'écrasement de données dans une table partitionnée ou en cluster lors d'une tâche de chargement.

  9. Cliquez sur Advanced options (Options avancées).

    • Sous Write preference (Préférences d'écriture), choisissez Append to table (Ajouter à la table) ou Overwrite table (Écraser la table).
    • Pour le champ Nombre d'erreurs autorisées, acceptez la valeur par défaut 0 ou saisissez le nombre maximal de lignes contenant des erreurs qui peuvent être ignorées. Si le nombre de lignes contenant des erreurs dépasse cette valeur, la tâche renverra un message invalid et échouera.
    • Sous Valeurs inconnues, cochez la case Ignorer les valeurs inconnues pour ignorer les valeurs d'une ligne qui ne sont pas présentes dans le schéma de la table.
    • Sous Délimiteur de champ, sélectionnez le caractère qui sépare les cellules dans votre fichier CSV : Virgule, Tabulation, Barre verticale ou Personnalisé. Si vous sélectionnez Personnalisé, saisissez le délimiteur dans la zone Délimiteur de champ personnalisé. La valeur par défaut est Virgule.
    • Sous Lignes d'en-tête à ignorer, saisissez le nombre de lignes d'en-tête à ignorer en haut du fichier CSV. La valeur par défaut est 0.
    • Sous Nouvelles lignes entre guillemets, cochez Autoriser les nouvelles lignes entre guillemets pour autoriser les sections de données entre guillemets contenant des caractères de retour à la ligne dans un fichier CSV. La valeur par défaut est false.
    • Sous Lignes irrégulières, cochez Autoriser les lignes irrégulières pour accepter les lignes des fichiers CSV pour lesquelles il manque des colonnes facultatives finales. Les valeurs manquantes sont traitées comme des valeurs nulles. Si cette option n'est pas cochée, les enregistrements contenant des colonnes finales manquantes sont traités comme des enregistrements incorrects et, si le nombre d'enregistrements incorrects est trop élevé, une erreur "non valide" est renvoyée dans le résultat de la tâche. La valeur par défaut est false.

    • Pour le champ Chiffrement, cliquez sur Clé gérée par le client afin d'utiliser une clé Cloud Key Management Service. Si vous conservez le paramètre Clé gérée par Google, BigQuery chiffre les données au repos.

      Écraser la table

  10. Cliquez sur Créer une table.

bq

Exécutez la commande bq load, définissez CSV à l'aide de l'option --source_format et spécifiez un URI Cloud Storage. Vous pouvez inclure un seul URI, une liste d'URI séparés par des virgules ou un URI contenant un caractère générique.

Fournissez le schéma en l'intégrant à un fichier de définition de schéma ou utilisez la détection automatique de schéma. Si vous ne spécifiez pas de schéma, que la valeur de --autodetect est false et que la table de destination existe, le schéma de la table de destination est utilisé.

Spécifiez l'option --replace pour écraser la table. Utilisez l'option --noreplace pour ajouter des données à la table. Si aucune option n'est spécifiée, les données sont ajoutées par défaut.

Il est possible de modifier le schéma de la table lorsque vous y ajoutez ou écrasez des données. Pour en savoir plus sur les modifications de schéma acceptées lors d'un chargement, consultez la page Modifier des schémas de table.

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

Les autres options facultatives sont les suivantes :

  • --allow_jagged_rows : permet d'accepter les lignes dans les fichiers CSV pour lesquelles il manque des colonnes facultatives finales. Les valeurs manquantes sont traitées comme des valeurs nulles. Si cette option n'est pas cochée, les enregistrements contenant des colonnes finales manquantes sont traités comme des enregistrements incorrects et, si le nombre d'enregistrements incorrects est trop élevé, une erreur "non valide" est renvoyée dans le résultat de la tâche. La valeur par défaut est false.
  • --allow_quoted_newlines : permet d'autoriser les sections de données entre guillemets contenant des caractères de retour à la ligne dans un fichier CSV. La valeur par défaut est false.
  • --field_delimiter : caractère indiquant la délimitation entre les colonnes de données. Les options \t et tab sont autorisées pour les délimiteurs de tabulation. La valeur par défaut est ,.
  • --null_marker : chaîne personnalisée facultative qui représente une valeur NULL dans les données CSV.
  • --skip_leading_rows : spécifie le nombre de lignes d'en-tête à ignorer en haut du fichier CSV. La valeur par défaut est 0.
  • --quote : guillemet à utiliser pour délimiter les enregistrements. La valeur par défaut est ". Pour ne spécifier aucun caractère de guillemet, utilisez une chaîne vide.
  • --max_bad_records : entier spécifiant le nombre maximal d'enregistrements incorrects autorisés avant l'échec total de la tâche. La valeur par défaut est 0. Au plus, cinq erreurs de n'importe quel type sont renvoyées, quelle que soit la valeur --max_bad_records.
  • --ignore_unknown_values : si spécifié, permet d'autoriser et d'ignorer les valeurs supplémentaires non reconnues dans les données CSV ou JSON.
  • --autodetect : permet d'activer la détection automatique du schéma pour les données CSV et JSON.
  • --destination_kms_key : clé Cloud KMS pour le chiffrement des données de la table.
bq --location=location load \
--[no]replace \
--source_format=format \
dataset.table \
path_to_source \
schema

où :

  • location correspond à votre emplacement. L'option --location est facultative. Vous pouvez définir une valeur par défaut correspondant à l'emplacement en utilisant le fichier .bigqueryrc.
  • format est CSV.
  • dataset est un ensemble de données existant.
  • table est le nom de la table dans laquelle vous chargez des données.
  • path_to_source est un URI Cloud Storage complet ou une liste d'URI séparés par une virgule. Les caractères génériques sont également acceptés.
  • schema est un schéma valide. Ce schéma peut être un fichier JSON local ou il peut être intégré à la commande. Vous pouvez également utiliser l'option --autodetect au lieu de fournir une définition de schéma.

Exemples :

La commande suivante permet de charger les données de gs://mybucket/mydata.csv et d'écraser la table mytable de mydataset. Le schéma est défini à l'aide de la fonctionnalité de détection automatique du schéma.

    bq load \
    --autodetect \
    --replace \
    --source_format=CSV \
    mydataset.mytable \
    gs://mybucket/mydata.csv

La commande suivante permet de charger les données de gs://mybucket/mydata.csv et d'ajouter des données à la table mytable de mydataset. Le schéma est défini à l'aide d'un fichier de schéma JSON (myschema.json).

    bq load \
    --noreplace \
    --source_format=CSV \
    mydataset.mytable \
    gs://mybucket/mydata.csv \
    ./myschema.json

API

  1. Créez une tâche de chargement (load) qui pointe vers les données sources dans Cloud Storage.

  2. (Facultatif) Spécifiez votre emplacement dans la propriété location de la section jobReference de la ressource de tâche.

  3. La propriété source URIs doit être complète et respecter le format gs://bucket/object. Vous pouvez inclure plusieurs URI sous la forme d'une liste d'éléments séparés par une virgule. Sachez que les caractères génériques sont également acceptés.

  4. Spécifiez le format de données en définissant la propriété configuration.load.sourceFormat sur CSV.

  5. Spécifiez la préférence d'écriture en définissant la propriété configuration.load.writeDisposition sur WRITE_TRUNCATE ou WRITE_APPEND.

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 sur l'API BigQuery en langage Go. 

import (
	"context"
	"fmt"

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

// importCSVTruncate demonstrates loading data from CSV data in Cloud Storage and overwriting/truncating
// data in the existing table.
func importCSVTruncate(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()

	gcsRef := bigquery.NewGCSReference("gs://cloud-samples-data/bigquery/us-states/us-states.csv")
	gcsRef.SourceFormat = bigquery.CSV
	gcsRef.AutoDetect = true
	gcsRef.SkipLeadingRows = 1
	loader := client.Dataset(datasetID).Table(tableID).LoaderFrom(gcsRef)
	loader.WriteDisposition = bigquery.WriteTruncate

	job, err := loader.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}

	if status.Err() != nil {
		return fmt.Errorf("job completed with error: %v", status.Err())
	}
	return nil
}

Java

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

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.FormatOptions;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.JobInfo.WriteDisposition;
import com.google.cloud.bigquery.LoadJobConfiguration;
import com.google.cloud.bigquery.TableId;

// Sample to overwrite the BigQuery table data by loading a CSV file from GCS
public class LoadCsvFromGcsTruncate {

  public static void runLoadCsvFromGcsTruncate() throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String sourceUri = "gs://cloud-samples-data/bigquery/us-states/us-states.csv";
    loadCsvFromGcsTruncate(datasetName, tableName, sourceUri);
  }

  public static void loadCsvFromGcsTruncate(String datasetName, String tableName, String sourceUri)
      throws Exception {
    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);

      LoadJobConfiguration configuration =
          LoadJobConfiguration.builder(tableId, sourceUri)
              .setFormatOptions(FormatOptions.csv())
              // Set the write disposition to overwrite existing table data
              .setWriteDisposition(WriteDisposition.WRITE_TRUNCATE)
              .build();

      // For more information on Job see:
      // https://googleapis.dev/java/google-cloud-clients/latest/index.html?com/google/cloud/bigquery/package-summary.html
      // Load the table
      Job loadJob = bigquery.create(JobInfo.of(configuration));

      // Load data from a GCS parquet file into the table
      // Blocks until this load table job completes its execution, either failing or succeeding.
      Job completedJob = loadJob.waitFor();

      // Check for errors
      if (completedJob == null) {
        throw new Exception("Job not executed since it no longer exists.");
      } else if (completedJob.getStatus().getError() != null) {
        // You can also look at queryJob.getStatus().getExecutionErrors() for all
        // errors, not just the latest one.
        throw new Exception(
            "BigQuery was unable to load into the table due to an error: \n"
                + loadJob.getStatus().getError());
      }
      System.out.println("Table is successfully overwritten by CSV file loaded from GCS");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Column not added during load append \n" + e.toString());
    }
  }
}

Node.js

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

Pour remplacer les lignes d'une table existante, définissez la valeur writeDisposition du paramètre metadata sur 'WRITE_TRUNCATE'.

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

// Instantiate clients
const bigquery = new BigQuery();
const storage = new Storage();

/**
 * This sample loads the CSV file at
 * https://storage.googleapis.com/cloud-samples-data/bigquery/us-states/us-states.csv
 *
 * TODO(developer): Replace the following lines with the path to your file.
 */
const bucketName = 'cloud-samples-data';
const filename = 'bigquery/us-states/us-states.csv';

async function loadCSVFromGCSTruncate() {
  /**
   * Imports a GCS file into a table and overwrites
   * table data if table already exists.
   */

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

  // Configure the load job. For full list of options, see:
  // https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad
  const metadata = {
    sourceFormat: 'CSV',
    skipLeadingRows: 1,
    schema: {
      fields: [
        {name: 'name', type: 'STRING'},
        {name: 'post_abbr', type: 'STRING'},
      ],
    },
    // Set the write disposition to overwrite existing table data.
    writeDisposition: 'WRITE_TRUNCATE',
    location: 'US',
  };

  // Load data from a Google Cloud Storage file into the table
  const [job] = await bigquery
    .dataset(datasetId)
    .table(tableId)
    .load(storage.bucket(bucketName).file(filename), metadata);
  // load() waits for the job to finish
  console.log(`Job ${job.id} completed.`);

  // Check the job's status for errors
  const errors = job.status.errors;
  if (errors && errors.length > 0) {
    throw errors;
  }
}

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. 

use Google\Cloud\BigQuery\BigQueryClient;
use Google\Cloud\Core\ExponentialBackoff;

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

// instantiate the bigquery table service
$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$table = $bigQuery->dataset($datasetId)->table($tableId);

// create the import job
$gcsUri = 'gs://cloud-samples-data/bigquery/us-states/us-states.csv';
$loadConfig = $table->loadFromStorage($gcsUri)->skipLeadingRows(1)->writeDisposition('WRITE_TRUNCATE');
$job = $table->runJob($loadConfig);

// poll the job until it is complete
$backoff = new ExponentialBackoff(10);
$backoff->execute(function () use ($job) {
    print('Waiting for job to complete' . PHP_EOL);
    $job->reload();
    if (!$job->isComplete()) {
        throw new Exception('Job has not yet completed', 500);
    }
});

// check if the job has errors
if (isset($job->info()['status']['errorResult'])) {
    $error = $job->info()['status']['errorResult']['message'];
    printf('Error running job: %s' . PHP_EOL, $error);
} else {
    print('Data imported successfully' . PHP_EOL);
}

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 de l'API BigQuery Python.

Pour remplacer les lignes d'une table existante, définissez la propriété LoadJobConfig.write_disposition sur la constante SourceFormat WRITE_TRUNCATE.

import six

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

job_config = bigquery.LoadJobConfig(
    schema=[
        bigquery.SchemaField("name", "STRING"),
        bigquery.SchemaField("post_abbr", "STRING"),
    ],
)

body = six.BytesIO(b"Washington,WA")
client.load_table_from_file(body, table_id, job_config=job_config).result()
previous_rows = client.get_table(table_id).num_rows
assert previous_rows > 0

job_config = bigquery.LoadJobConfig(
    write_disposition=bigquery.WriteDisposition.WRITE_TRUNCATE,
    source_format=bigquery.SourceFormat.CSV,
    skip_leading_rows=1,
)

uri = "gs://cloud-samples-data/bigquery/us-states/us-states.csv"
load_job = client.load_table_from_uri(
    uri, table_id, job_config=job_config
)  # Make an API request.

load_job.result()  # Waits for the job to complete.

destination_table = client.get_table(table_id)
print("Loaded {} rows.".format(destination_table.num_rows))

Charger des données CSV partitionnées avec Hive

BigQuery accepte le chargement de données CSV partitionnées avec Hive et stockées dans Cloud Storage. Il insère alors les colonnes de partitionnement Hive en tant que colonnes dans la table de destination gérée par BigQuery. Pour en savoir plus, consultez la page Charger des données partitionnées externes.

Informations sur le chargement des données CSV

Cette section décrit comment BigQuery gère les différentes options de mise en forme des fichiers CSV.

Encodage

BigQuery s'attend à ce que les données CSV soient encodées au format UTF-8. Si vous avez des fichiers CSV avec des données encodées au format ISO-8859-1 (également connu sous le nom de Latin-1), vous devez spécifier explicitement l'encodage afin que BigQuery puisse convertir correctement les données au format UTF-8.

Si vous ne spécifiez pas d'encodage, ou si vous spécifiez l'encodage UTF-8 alors que le fichier CSV n'est pas encodé dans ce format, BigQuery tente de convertir les données au format UTF-8. En règle générale, vos données sont chargées avec succès, mais ne correspondent peut-être pas à vos attentes octet par octet. Pour éviter cela, spécifiez l'encodage approprié à l'aide de l'option --encoding.

Si BigQuery ne peut pas convertir un caractère autre que le caractère ASCII 0, il le convertit en caractère de remplacement Unicode standard : �.

Délimiteurs de champs

Dans les fichiers CSV, les délimiteurs peuvent être n'importe quel caractère à un octet. Si le fichier source utilise l'encodage ISO-8859-1, tous les caractères peuvent être des délimiteurs. Si le fichier source utilise l'encodage UTF-8, n'importe quel caractère de la plage décimale 1-127 (U+0001-U+007F) peut être utilisé sans modification. Vous pouvez insérer un caractère ISO-8859-1 en dehors de cette plage en tant que délimiteur. BigQuery l'interprétera correctement. Toutefois, si vous utilisez un caractère à plusieurs octets comme délimiteur, certains octets seront interprétés de manière incorrecte comme faisant partie de la valeur du champ.

En règle générale, il est recommandé d'utiliser un délimiteur standard, tel qu'une tabulation, une barre verticale ou une virgule. La valeur par défaut est la virgule.

Types de données

Boolean. BigQuery peut analyser n'importe laquelle des paires suivantes pour les données booléennes : 1 ou 0, true ou false, t ou f, yes ou no, ou y ou n (tous non sensibles à la casse). La détection automatique de schéma détecte automatiquement ces paires, à l'exception de 0 et 1.

Octets. Les colonnes de type OCTETS doivent être encodées en Base64.

Date. les colonnes de type DATE doivent être au format YYYY-MM-DD.

Datetime. les colonnes de type DATETIME doivent être au format YYYY-MM-DD HH:MM:SS[.SSSSSS].

Time : les colonnes de type TIME doivent être au format HH:MM:SS[.SSSSSS].

Timestamp. BigQuery accepte différents formats d'horodatage. L'horodatage doit inclure une partie date et une partie heure.

  • La partie date peut être au format YYYY-MM-DD ou YYYY/MM/DD.

  • La partie horodatage doit être au format HH:MM[:SS[.SSSSSS]] (les secondes et les fractions de secondes sont facultatives).

  • La date et l'heure doivent être séparées par un espace ou le caractère "T".

  • La date et l'heure peuvent également être suivies d'un décalage UTC ou de l'indicateur de zone UTC (Z). Pour en savoir plus, consultez la section Fuseaux horaires.

Par exemple, les valeurs d'horodatage suivantes sont valides :

  • 2018-08-19 12:11
  • 2018-08-19 12:11:35
  • 2018-08-19 12:11:35.22
  • 2018/08/19 12:11
  • 2018-07-05 12:54:00 UTC
  • 2018-08-19 07:11:35.220 -05:00
  • 2018-08-19T12:11:35.220Z

Si vous fournissez un schéma, BigQuery accepte également l'epoch Unix comme valeur d'horodatage. Toutefois, la détection automatique de schéma ne détecte pas ce cas et traite la valeur comme un type numérique ou une chaîne.

Exemples de valeurs d'horodatage avec l'epoch Unix :

  • 1534680695
  • 1.534680695e11

Options CSV

Pour modifier la façon dont BigQuery analyse les données CSV, spécifiez des options supplémentaires dans Cloud Console, l'outil de ligne de commande bq ou l'API.

Pour plus d'informations sur le format CSV, consultez la RFC 4180.

Option CSV Option de la console Option de l'outil bq Propriété de l'API BigQuery Description
Délimiteur de champ Délimiteur de champ : virgule, tabulation, barre verticale, personnalisé -F ou --field_delimiter fieldDelimiter (Java, Python) (Facultatif) Le séparateur des champs dans un fichier CSV. Le séparateur peut être n'importe quel caractère ISO-8859-1 à un octet. BigQuery convertit la chaîne selon l'encodage ISO-8859-1 et utilise le premier octet de la chaîne codée pour fractionner les données dans leur état binaire brut. BigQuery est également compatible avec la séquence d'échappement "\t" pour spécifier la tabulation comme séparateur. La valeur par défaut est une virgule (,).
Lignes d'en-tête Lignes d'en-tête à ignorer --skip_leading_rows skipLeadingRows (Java, Python) (Facultatif) Un entier indiquant le nombre de lignes d'en-tête dans les données sources.
Nombre d'enregistrements incorrects autorisés Nombre d'erreurs autorisées --max_bad_records maxBadRecords (Java, Python) (Facultatif) Nombre maximal d'enregistrements incorrects pouvant être ignorés par BigQuery lors de l'exécution de la tâche. Si le nombre d'enregistrements incorrects dépasse cette valeur, une erreur "non valide" est renvoyée dans le résultat de la tâche. La valeur par défaut est 0, ce qui nécessite que tous les enregistrements soient valides.
Caractères de retour à la ligne Autoriser les nouvelles lignes entre guillemets --allow_quoted_newlines allowQuotedNewlines (Java, Python) (Facultatif) Indique s'il faut autoriser les sections de données entre guillemets contenant des caractères de retour à la ligne dans un fichier CSV. La valeur par défaut est false.
Valeurs NULL personnalisées Aucun --null_marker nullMarker (Java, Python) (Facultatif) Spécifie une chaîne représentant une valeur nulle dans un fichier CSV. Par exemple, si vous spécifiez "\N", BigQuery interprète "\N" comme une valeur nulle lors du chargement d'un fichier CSV. La valeur par défaut est une chaîne vide. Si vous définissez cette propriété sur une valeur personnalisée, BigQuery génère une erreur si une chaîne vide est présente pour tous les types de données, à l'exception de STRING et BYTE. Pour les colonnes STRING et BYTE, BigQuery interprète la chaîne vide comme une valeur vide.
Colonnes facultatives finales Autoriser les lignes irrégulières --allow_jagged_rows allowJaggedRows (Java, Python) (Facultatif) Accepte les lignes pour lesquelles il manque des colonnes facultatives finales. Les valeurs manquantes sont traitées comme des valeurs nulles. Si la valeur est "false", les enregistrements contenant des colonnes finales manquantes sont traités comme des enregistrements incorrects et, s'il y a trop d'enregistrements incorrects, une erreur "non valide" est renvoyée dans le résultat de la tâche. La valeur par défaut est "false". Applicable uniquement au format CSV, ignoré pour les autres formats.
Valeurs inconnues Ignorer les valeurs inconnues --ignore_unknown_values ignoreUnknownValues (Java, Python) (Facultatif) Indique si BigQuery doit autoriser des valeurs supplémentaires qui ne sont pas représentées dans le schéma de la table. Si le champ est défini sur "true", les valeurs supplémentaires sont ignorées. Si la valeur est "false", les enregistrements comportant des colonnes supplémentaires sont traités comme des enregistrements incorrects et, si le nombre d'enregistrements incorrects est trop élevé, une erreur "non valide" est renvoyée dans le résultat de la tâche. La valeur par défaut est false. La propriété sourceFormat détermine ce que BigQuery considère comme une valeur supplémentaire :
  • CSV : colonnes finales
  • JSON : valeurs nommées ne correspondant à aucun nom de colonne
Guillemets Aucun --quote quote (Java, Python) (Facultatif) Valeur utilisée pour citer des sections de données dans un fichier CSV. BigQuery convertit la chaîne selon l'encodage ISO-8859-1, puis utilise le premier octet de la chaîne encodée pour fractionner les données dans leur état binaire brut. La valeur par défaut est un guillemet double ('"'). Si vos données ne contiennent pas de sections entre guillemets, définissez la valeur de la propriété sur une chaîne vide. Si vos données contiennent des caractères de retour à la ligne entre guillemets, vous devez également définir la propriété allowQuotedNewlines sur true. Pour inclure le caractère spécifique de guillemet dans une valeur entre guillemets, faites précéder la valeur d'un guillemet supplémentaire. Par exemple, pour échapper le caractère par défaut ' " ', utilisez ' "" '.
Encodage Aucun -E ou --encoding encoding (Java, Python) (Facultatif) Codage des caractères des données. Les valeurs acceptées sont UTF-8 ou ISO-8859-1. La valeur par défaut est UTF-8. BigQuery décode les données une fois que les données binaires brutes ont été fractionnées à l'aide des valeurs des propriétés quote et fieldDelimiter.