Charger des données 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

Vous êtes soumis aux limitations suivantes lorsque vous chargez des données dans BigQuery à partir d'un bucket Cloud Storage :

Si l'emplacement de votre ensemble de données est défini sur une valeur autre que la zone multirégionale US, le bucket Cloud Storage doit se trouver dans le même emplacement que l'ensemble de données.
BigQuery ne garantit pas la cohérence des données pour les sources de données externes. Les modifications apportées aux données sous-jacentes lors de l'exécution d'une requête peuvent entraîner un comportement inattendu.
BigQuery n'est pas compatible avec la gestion des versions d'objets Cloud Storage. Si vous incluez un numéro de génération dans l'URI Cloud Storage, la tâche de chargement échoue.

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 de ce document et créer un ensemble de données pour stocker les données.

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.buckets.get
storage.objects.get
storage.objects.list (obligatoire si vous utilisez un caractère générique dans l'URI)

Créer un ensemble de données

Créez un ensemble de données BigQuery pour stocker vos données.

Charger des données CSV dans une table

Pour charger des données CSV à partir de Cloud Storage dans une nouvelle table BigQuery, sélectionnez l'une des options suivantes :

Console

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

Visite guidée

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

Accéder à BigQuery
Dans le volet Explorateur, développez votre projet, puis sélectionnez un ensemble de données.
Dans la section Informations sur l'ensemble de données, cliquez sur Créer une table.
Dans le panneau Créer une table, spécifiez les détails suivants :

Dans la section Source, sélectionnez Google Cloud Storage dans la liste Créer une table à partir de. Ensuite, procédez comme suit :
1. Sélectionnez un fichier dans le bucket Cloud Storage ou saisissez l'URI Cloud Storage. Vous ne pouvez pas inclure plusieurs URI dans la console Google Cloud. 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 souhaitez créer, ajouter ou écraser.
2. Pour Format de fichier, sélectionnez CSV.
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.
Dans la section Schéma, saisissez la définition du schéma. Pour activer la détection automatique du schéma, sélectionnez Détection automatique. Vous pouvez saisir les informations de schéma manuellement à l'aide de l'une des méthodes suivantes :
- Option 2 : 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.
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.
Cliquez sur Options avancées et procédez comme suit :
- Sous 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 pouvant être ignorées. Si le nombre de lignes contenant des erreurs dépasse cette valeur, la tâche renverra un message invalid et échouera. Cette option ne s'applique qu'aux fichiers CSV et JSON.
- Si vous souhaitez ignorer les valeurs d'une ligne qui ne sont pas présentes dans le schéma de la table, sélectionnez Valeurs inconnues.
- 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.
Cliquez sur Créer une table.

SQL

Utilisez l'instruction LDD LOAD DATA : L'exemple suivant charge un fichier CSV dans la nouvelle table mytable :

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

Accéder à BigQuery

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

LOAD DATA OVERWRITE mydataset.mytable
FROM FILES (
  format = 'CSV',
  uris = ['gs://bucket/path/file.csv']);

Cliquez sur Exécuter.

Pour en savoir plus sur l'exécution des requêtes, consultez la page Exécuter des requêtes interactives.

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 :
- Documentation de référence sur la ligne de commande
Pour en savoir plus sur les tables partitionnées, consultez :
- Créer des tables partitionnées
Pour en savoir plus sur les tables en cluster, consultez :
- Créer et utiliser des tables en cluster
Pour en savoir plus sur le chiffrement d'une table, consultez :
- Protéger les données avec des clés Cloud KMS

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 :

    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

Créez une tâche de chargement (load) qui pointe vers les données sources dans Cloud Storage.
(Facultatif) Spécifiez votre emplacement dans la propriété location de la section jobReference de la ressource de tâche.
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 (*).
Spécifiez le format de données CSV en définissant la propriété sourceFormat sur CSV.
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 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#.

Afficher sur GitHub Commentaires


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

Afficher sur GitHub Commentaires

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

Afficher sur GitHub Commentaires

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

Afficher sur GitHub Commentaires

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

Afficher sur GitHub Commentaires

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

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.

Afficher sur GitHub Commentaires

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

Afficher sur GitHub Commentaires

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

Afficher sur GitHub Commentaires


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

Afficher sur GitHub Commentaires

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

Afficher sur GitHub Commentaires

// 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

Afficher sur GitHub Commentaires

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 la console Google Cloud, 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.

Console

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

Accéder à BigQuery
Dans le volet Explorateur, développez votre projet, puis sélectionnez un ensemble de données.
Dans la section Informations sur l'ensemble de données, cliquez sur Créer une table.
Dans le panneau Créer une table, spécifiez les détails suivants :

Dans la section Source, sélectionnez Google Cloud Storage dans la liste Créer une table à partir de. Ensuite, procédez comme suit :
1. Sélectionnez un fichier dans le bucket Cloud Storage ou saisissez l'URI Cloud Storage. Vous ne pouvez pas inclure plusieurs URI dans la console Google Cloud. 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 souhaitez créer, ajouter ou écraser.
2. Pour Format de fichier, sélectionnez CSV.

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.
Dans la section Schéma, saisissez la définition du schéma. Pour activer la détection automatique du schéma, sélectionnez Détection automatique. Vous pouvez saisir les informations de schéma manuellement à l'aide de l'une des méthodes suivantes :
- Option 2 : 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.
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. Vous ne pouvez pas convertir une table en table partitionnée ou en cluster en y ajoutant des données ou les écrasant. La console Google Cloud ne permet pas d'ajouter ni d'écraser des données dans des tables partitionnées ou en cluster lors d'une tâche de chargement.
Cliquez sur Options avancées et procédez comme suit :
- Sous Préférences d'écriture, choisissez Ajouter à la table ou É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 pouvant être ignorées. Si le nombre de lignes contenant des erreurs dépasse cette valeur, la tâche renverra un message invalid et échouera. Cette option ne s'applique qu'aux fichiers CSV et JSON.
- Si vous souhaitez ignorer les valeurs d'une ligne qui ne sont pas présentes dans le schéma de la table, sélectionnez Valeurs inconnues.
- 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.
Cliquez sur Créer une table.

SQL

Utilisez l'instruction LDD LOAD DATA : L'exemple suivant ajoute un fichier CSV à la table mytable :

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

Accéder à BigQuery

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

LOAD DATA INTO mydataset.mytable
FROM FILES (
  format = 'CSV',
  uris = ['gs://bucket/path/file.csv']);

Cliquez sur Exécuter.

Pour en savoir plus sur l'exécution des requêtes, consultez la page Exécuter des requêtes interactives.

bq

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

Créez une tâche de chargement (load) qui pointe vers les données sources dans Cloud Storage.
(Facultatif) Spécifiez votre emplacement dans la propriété location de la section jobReference de la ressource de tâche.
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.
Spécifiez le format de données en définissant la propriété configuration.load.sourceFormat sur CSV.
Spécifiez la préférence d'écriture en définissant la propriété configuration.load.writeDisposition sur WRITE_TRUNCATE ou WRITE_APPEND.

Go

Afficher sur GitHub Commentaires

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

Afficher sur GitHub Commentaires

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

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

Afficher sur GitHub Commentaires

// 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;
  }
}

Afficher sur GitHub Commentaires

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

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

Afficher sur GitHub Commentaires

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

Géographie. Les colonnes de type GEOGRAPHY doivent contenir des chaînes à l'un des formats suivants :

Texte connu (WKT)
Binaire connu (WKB)
GeoJSON

Si vous utilisez le langage WKB, la valeur doit être encodée en hexadécimal.

La liste suivante présente des exemples de données valides :

WKT : POINT(1 2)
GeoJSON : { "type": "Point", "coordinates": [1, 2] }
WKB encodé en hexadécimal : 0101000000feffffffffffef3f0000000000000040

Avant de charger des données de type GEOGRAPHY, consultez également la section Charger des données géospatiales.

Interval. Les colonnes de type INTERVAL doivent être au format Y-M D H:M:S[.F], où :

Y = année. La plage acceptée est comprise entre 0 et 10 000.
M = mois. Plage comprise entre 1 et 12.
D = jour. La plage acceptée est comprise entre 1 et [dernier jour du mois indiqué].
H = heure.
M = minute.
S = seconde.
[.F] = fractions d'une seconde jusqu'à six chiffres, avec une précision de l'ordre de la microseconde.

Vous pouvez indiquer une valeur négative en ajoutant un tiret (-).

La liste suivante présente des exemples de données valides :

10-6 0 0:0:0
0-0 -5 0:0:0
0-0 0 0:0:1.25

Pour charger des données de type INTERVAL, vous devez utiliser la commande bq load et utiliser l'option --schema pour spécifier un schéma. Vous ne pouvez pas importer de données de type INTERVAL à l'aide de la console.

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

Détection automatique de schéma

Cette section décrit le comportement de la détection automatique de schéma lors du chargement de fichiers CSV.

Délimiteur de fichier CSV

BigQuery détecte les délimiteurs suivants :

Virgule ( , )
Barre verticale ( | )
Tabulation ( \t )

En-tête CSV

BigQuery déduit les en-têtes en comparant la première ligne du fichier avec ses autres lignes. Si la première ligne ne contient que des chaînes et que les autres lignes contiennent d'autres types de données, BigQuery suppose que la première ligne est une ligne d'en-tête. Dans ce cas, BigQuery attribue des noms de colonnes en fonction des noms de champs dans la ligne d'en-tête. Les noms peuvent être modifiés pour répondre aux règles de dénomination des colonnes de BigQuery. Par exemple, les espaces seront remplacés par des traits de soulignement.

Sinon, BigQuery considère que la première ligne est une ligne de données et attribue des noms de colonnes génériques tels que string_field_1. Notez qu'une fois la table créée, les noms de colonne ne peuvent pas être mis à jour dans le schéma, mais vous pouvez les modifier manuellement après la création de la table. Une autre option consiste à fournir un schéma explicite au lieu d'utiliser la détection automatique.

Vous pouvez avoir un fichier CSV avec une ligne d'en-tête, où tous les champs de données sont des chaînes. Dans ce cas, BigQuery ne détecte pas automatiquement que la première ligne est un en-tête. Utilisez l'option --skip_leading_rows pour ignorer la ligne d'en-tête. Sinon, l'en-tête sera importé en tant que ligne de données. Pensez également à fournir un schéma explicite dans ce cas, afin de pouvoir attribuer des noms de colonne.

Lignes entre guillemets de fichier CSV

BigQuery détecte les nouvelles lignes entre guillemets dans un champ CSV et ne les interprète pas comme une limite de ligne.

Options CSV

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

Pour plus d'informations sur le format CSV, consultez 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`.
Caractère de contrôle ASCII	Aucune	`--preserve_ascii_control_characters`	Aucune	(Facultatif) Si vous souhaitez autoriser le caractère de contrôle ASCII 0 et d'autres caractères ASCII, définissez `--preserve_ascii_control_characters` sur `true` pour vos jobs de chargement.