Charger des données par lot

Vous pouvez charger des données dans BigQuery à partir de Cloud Storage ou d'un fichier local en tant qu'opération par lot. Les données sources peuvent avoir l'un des formats suivants :

  • Avro
  • CSV (Comma-Separated Values)
  • JSON (délimité par un retour à la ligne)
  • ORC
  • Parquet
  • Exportations Firestore stockées dans Cloud Storage

Vous pouvez configurer des chargements récurrents de Cloud Storage vers BigQuery à l'aide du service de transfert de données BigQuery.

Faites l'essai

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

Profiter d'un essai gratuit de BigQuery

Autorisations requises

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

Autorisations BigQuery

Vous devez au moins disposer des autorisations suivantes pour charger des données dans BigQuery. Elles sont requises si vous chargez des données dans une nouvelle table ou partition, mais également si vous ajoutez ou écrasez une table ou une partition.

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

Les rôles IAM prédéfinis suivants incluent les autorisations bigquery.tables.create et bigquery.tables.updateData :

  • bigquery.dataEditor
  • bigquery.dataOwner
  • bigquery.admin

Les rôles IAM prédéfinis suivants incluent les autorisations bigquery.jobs.create :

  • bigquery.user
  • bigquery.jobUser
  • bigquery.admin

En outre, si un utilisateur possède les autorisations bigquery.datasets.create, il obtient également un accès bigquery.dataOwner à l'ensemble de données qu'il crée. L'accès correspondant au rôle bigquery.dataOwner permet à l'utilisateur de créer et de mettre à jour des tables dans l'ensemble de données à l'aide d'une tâche de chargement.

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

Autorisations Cloud Storage

Pour charger des données à partir d'un bucket Cloud Storage, vous devez disposer des autorisations storage.objects.get. Si vous utilisez un caractère générique dans l'URI, vous devez également disposer des autorisations storage.objects.list.

Le rôle IAM prédéfini storage.objectViewer peut être attribué afin d'octroyer les autorisations storage.objects.get et storage.objects.list.

Charger des données depuis Cloud Storage

BigQuery permet de charger des données à partir de l'une des classes de stockage Cloud Storage suivantes :

  • Standard
  • Nearline
  • Coldline
  • Archive

Pour savoir comment charger des données dans BigQuery, consultez la page correspondant à votre format de données :

Pour apprendre à configurer un chargement récurrent de Cloud Storage vers BigQuery, consultez la page Transferts Cloud Storage.

Considérations relatives aux zones

Lorsque vous choisissez une zone pour les données, envisagez d'entreprendre les actions suivantes :

  • Cohébergez vos buckets Cloud Storage pour charger des données.
    • Si votre ensemble de données BigQuery se trouve dans une zone multirégionale, le bucket Cloud Storage contenant les données que vous chargez doit se trouver dans un bucket régional ou multirégional du même emplacement. Par exemple, si votre ensemble de données BigQuery se trouve dans l'UE, le bucket Cloud Storage doit être situé dans un bucket régional ou multirégional de l'UE.
    • Si votre ensemble de données se trouve dans une zone régionale, le bucket Cloud Storage doit être un bucket régional du même emplacement. Par exemple, si votre ensemble de données se trouve dans la région Tokyo, le bucket Cloud Storage doit être un bucket régional situé à Tokyo.
    • Exception : Si votre ensemble de données se trouve dans la zone multirégionale États-Unis, vous pouvez charger des données à partir d'un bucket Cloud Storage situé dans n'importe quelle zone régionale ou multirégionale.
  • Élaborer un plan de gestion des données
    • Si vous choisissez une ressource de stockage régionale, telle qu'un ensemble de données BigQuery ou un bucket Cloud Storage, élaborez un plan de gestion géographique des données.

Pour en savoir plus sur les emplacements Cloud Storage, consultez la page Emplacements des buckets dans la documentation de Cloud Storage.

Vous ne pouvez pas modifier l'emplacement d'un ensemble de données après sa création. Toutefois, vous pouvez créer une copie de l'ensemble de données ou le déplacer manuellement. Pour en savoir plus, consultez les pages suivantes :

Récupérer l'URI Cloud Storage

Pour charger des données à partir d'une source de données Cloud Storage, vous devez fournir l'URI Cloud Storage.

L'URI Cloud Storage comprend le nom du bucket et l'objet (nom de fichier). Par exemple, si le bucket Cloud Storage est nommé mybucket et que le fichier de données s'appelle myfile.csv, l'URI du bucket sera gs://mybucket/myfile.csv. Si vos données sont séparées en plusieurs fichiers, vous pouvez utiliser un caractère générique dans l'URI. Pour en savoir plus, consultez les URI de requête Cloud Storage.

BigQuery ne prend pas en charge les URI sources qui comprennent plusieurs barres obliques consécutives après la double barre oblique initiale. Le nom des objets Cloud Storage peut contenir plusieurs barres obliques ("/") consécutives. Toutefois, BigQuery convertit les barres obliques consécutives en une seule. Par exemple, l'URI source suivant, bien qu'il soit valide dans Cloud Storage, ne fonctionne pas dans BigQuery : gs://bucket/my//object//name.

Pour récupérer l'URI Cloud Storage :

  1. Ouvrez la console Cloud Storage.

    Console Cloud Storage

  2. Accédez à l'emplacement de l'objet (fichier) contenant les données source.

  3. En haut de la console Cloud Storage, notez le chemin d'accès à l'objet. Pour composer l'URI, remplacez gs://bucket/file par le chemin d'accès approprié, par exemple, gs://mybucket/myfile.json. bucket correspond au nom du bucket Cloud Storage et file au nom de l'objet (fichier) contenant les données.

Gestion des caractères génériques dans les URI Cloud Storage

Si vos données Cloud Storage sont réparties dans plusieurs fichiers partageant un même nom de base, vous pouvez utiliser un caractère générique dans l'URI lors du chargement des données.

Pour insérer un caractère générique dans l'URI Cloud Storage, il vous suffit d'ajouter un astérisque (*) au nom de base. Par exemple, si vous avez deux fichiers nommés fed-sample000001.csv et fed-sample000002.csv dans un dossier nommé fed-samples, l'URI générique est gs://mybucket/fed-samples/fed-sample*. Vous pouvez ensuite utiliser cet URI générique dans Cloud Console, l'outil de ligne de commande bq, l'API ou les bibliothèques clientes.

Autre exemple, si vous ne souhaitez charger que les fichiers CSV, vous pouvez utiliser gs://mybucket/fed-samples/*.csv. Cet URI générique inclut également les fichiers de tous les sous-dossiers de ce chemin d'accès correspondant au format du nom de base. Par exemple, gs://mybucket/fed-samples/temp/temp-file.csv. Pour ne faire correspondre que les fichiers d'un dossier spécifique, utilisez un modèle de correspondance des fichiers au lieu d'un modèle correspondant à un dossier. Par exemple, gs://mybucket/fed-samples/fed-sample*.csv.

Vous ne pouvez utiliser qu'un seul caractère générique pour les objets (noms de fichiers) contenus dans votre bucket. Le caractère générique peut apparaître à l'intérieur ou à la fin du nom de l'objet. Vous ne pouvez pas ajouter un caractère générique au nom du bucket.

Pour les exportations Google Datastore, vous ne pouvez spécifier qu'un seul URI, qui doit se terminer par .backup_info ou .export_metadata.

Le caractère générique astérisque n'est pas autorisé lors des opérations suivantes :

  • Créer des tables externes associées à des exportations Datastore ou Firestore
  • Charger des données d'exportation Datastore ou Firestore à partir de Cloud Storage

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 US, le bucket Cloud Storage régional ou multirégional doit se trouver dans la même région que cet 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.

Selon le format de vos données sources Cloud Storage, des limitations supplémentaires peuvent s'appliquer. Pour en savoir plus, consultez les pages suivantes :

Charger des données à partir de fichiers locaux

Vous pouvez charger des données à partir d'une source de données lisible (telle que votre machine locale) en utilisant l'une des méthodes suivantes :

  • Google Cloud Console
  • Commande bq load de l'outil de ligne de commande bq
  • L'API
  • Les bibliothèques clientes

Lorsque vous chargez des données à l'aide de Cloud Console ou de l'outil de ligne de commande bq, une tâche de chargement est automatiquement créée.

Pour charger des données depuis une source de données locale, procédez comme suit :

Console

  1. Ouvrez la page "BigQuery" dans Cloud Console.

    Accéder à BigQuery

  2. Dans la section Ressources du panneau de navigation, développez votre projet Google Cloud et sélectionnez un ensemble de données.

  3. À droite de la fenêtre, dans le panneau de détails, cliquez sur Create table (Créer une table). Le processus de chargement des données est identique au processus de création d'une table vide.

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

    • Dans le champ Create table from (Créer une table à partir de), sélectionnez Upload (Importer).

      Importer une table

    • Sous Select file (Sélectionner un fichier), cliquez sur Browse (Parcourir).

      Parcourir les fichiers

    • Accédez au fichier et cliquez sur Ouvrir. Notez que les caractères génériques et les listes d'éléments séparés par une virgule ne sont pas acceptés pour les fichiers locaux.

    • Dans le champ File format (Format de fichier), sélectionnez CSV, JSON (délimité par un retour à la ligne), Avro, Parquet ou ORC.

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

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

      Afficher un ensemble de données

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

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

  6. Dans la section Schema (Schéma), saisissez la définition du schéma.

    • Pour les fichiers CSV et JSON, vous pouvez cocher l'option Auto-detect (Détection automatique) pour activer la détection automatique de schéma. Les informations de schéma sont auto-décrites dans les données sources pour d'autres types de fichiers compatibles.

    • Vous pouvez également saisir les informations du schéma manuellement en utilisant les méthodes suivantes :

      • En cliquant sur Modifier sous forme de texte, puis en saisissant le schéma de la table en tant que tableau JSON :

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

  7. Sélectionnez les éléments applicables dans la section Options avancées. Pour en savoir plus sur les options disponibles, consultez les options CSV et les options JSON.

  8. (Facultatif) Dans la section Options avancées, sélectionnez la disposition en écriture :

    • Écrire si la table est vide : n'écrit les données que si la table est vide.
    • Ajouter à la table : ajoute les données à la fin de la table. Il s'agit du paramètre par défaut.
    • Écraser la table : efface toutes les données existantes de la table avant d'écrire les nouvelles données.
  9. Cliquez sur Créer une table.

bq

Exécutez la commande bq load, spécifiez source_format et incluez le chemin d'accès au fichier local.

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

Si vous chargez des données dans un projet autre que votre projet par défaut, ajoutez l'ID du projet à l'ensemble de données, en respectant le format suivant : PROJECT_ID:DATASET.

bq --location=LOCATION load \
--source_format=FORMAT \
PROJECT_ID:DATASET.TABLE \
PATH_TO_SOURCE \
SCHEMA

Remplacez les éléments suivants :

  • LOCATION : votre position. L'option --location est facultative. Par exemple, si vous utilisez BigQuery dans la région de Tokyo, définissez la valeur de l'option sur asia-northeast1. Vous pouvez définir une valeur par défaut correspondant à l'emplacement en utilisant le fichier .bigqueryrc.
  • FORMAT : CSV, AVRO, PARQUET, ORC ou NEWLINE_DELIMITED_JSON.
  • project_id : ID de votre projet.
  • dataset : ensemble de données existant.
  • table : nom de la table dans laquelle vous chargez des données.
  • path_to_source : chemin d'accès au fichier local.
  • schema : 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.

En outre, vous pouvez ajouter des options pour les options qui vous permettent de contrôler la manière dont BigQuery analyse vos données. Par exemple, vous pouvez utiliser l'option --skip_leading_rows pour ignorer les lignes d'en-tête dans un fichier CSV. Pour en savoir plus, consultez les sections Options CSV et Options JSON.

Par exemple :

La commande suivante charge un fichier JSON local délimité par un retour à la ligne (mydata.json) dans une table nommée mytable de mydataset de votre projet par défaut. Le schéma est défini dans un fichier de schéma local nommé myschema.json.

    bq load \
    --source_format=NEWLINE_DELIMITED_JSON \
    mydataset.mytable \
    ./mydata.json \
    ./myschema.json

La commande suivante charge un fichier CSV local (mydata.csv) dans une table nommée mytable de mydataset du projet myotherproject. 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 \
    myotherproject:mydataset.mytable \
    ./mydata.csv \
    qtr:STRING,sales:FLOAT,year:STRING

La commande suivante charge un fichier CSV local (mydata.csv) dans une table nommée mytable de mydataset de votre projet par défaut. Le schéma est défini à l'aide de la fonctionnalité de détection automatique du schéma.

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

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

Le code suivant montre comment charger un fichier CSV local dans une nouvelle table BigQuery. Pour charger un fichier local d'un autre format, utilisez la classe d'options de mise à jour pour le format approprié à partir de la classe de base JobCreationOptions au lieu de UploadCsvOptions.


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

public class BigQueryLoadFromFile
{
    public void LoadFromFile(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id",
        string tableId = "your_table_id",
        string filePath = "path/to/file.csv"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        // Create job configuration
        var uploadCsvOptions = new UploadCsvOptions()
        {
            SkipLeadingRows = 1,  // Skips the file headers
            Autodetect = true
        };
        using (FileStream stream = File.Open(filePath, FileMode.Open))
        {
            // Create and run job
            // Note that there are methods available for formats other than CSV
            BigQueryJob job = client.UploadCsv(
                datasetId, tableId, null, stream, uploadCsvOptions);
            job.PollUntilCompleted();  // Waits for the job to complete.
            // Display the number of rows uploaded
            BigQueryTable table = client.GetTable(datasetId, tableId);
            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.

Le code suivant montre comment charger un fichier CSV local dans une nouvelle table BigQuery. Pour charger un fichier local d'un autre format, définissez la propriété DataFormat de NewReaderSource sur le format approprié.

import (
	"context"
	"fmt"
	"os"

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

// importCSVFromFile demonstrates loading data into a BigQuery table using a file on the local filesystem.
func importCSVFromFile(projectID, datasetID, tableID, filename 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()

	f, err := os.Open(filename)
	if err != nil {
		return err
	}
	source := bigquery.NewReaderSource(f)
	source.AutoDetect = true   // Allow BigQuery to determine schema.
	source.SkipLeadingRows = 1 // CSV has a single header line.

	loader := client.Dataset(datasetID).Table(tableID).LoaderFrom(source)

	job, err := loader.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}
	if err := status.Err(); err != nil {
		return err
	}
	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.

Le code suivant montre comment charger un fichier CSV local dans une nouvelle table BigQuery. Pour charger un fichier local d'un autre format, définissez FormatOptions sur le format approprié.

TableId tableId = TableId.of(datasetName, tableName);
WriteChannelConfiguration writeChannelConfiguration =
    WriteChannelConfiguration.newBuilder(tableId).setFormatOptions(FormatOptions.csv()).build();
// The location must be specified; other fields can be auto-detected.
JobId jobId = JobId.newBuilder().setLocation(location).build();
TableDataWriteChannel writer = bigquery.writer(jobId, writeChannelConfiguration);
// Write data to writer
try (OutputStream stream = Channels.newOutputStream(writer)) {
  Files.copy(csvPath, stream);
}
// Get load job
Job job = writer.getJob();
job = job.waitFor();
LoadStatistics stats = job.getStatistics();
return stats.getOutputRows();

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.

Le code suivant montre comment charger un fichier CSV local dans une nouvelle table BigQuery. Pour charger un fichier local d'un autre format, définissez le paramètre metadata de la fonction load sur le format approprié.

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

async function loadLocalFile() {
  // Imports a local file into a table.

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

  // Load data from a local file into the table
  const [job] = await bigquery
    .dataset(datasetId)
    .table(tableId)
    .load(filename);

  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.

Le code suivant montre comment charger un fichier CSV local dans une nouvelle table BigQuery. Pour charger un fichier local d'un autre format, définissez sourceFormat sur le format approprié.

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';
// $source     = 'The path to the CSV source file to import';

// instantiate the bigquery table service
$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$table = $dataset->table($tableId);
// create the import job
$loadConfig = $table->load(fopen($source, 'r'))->sourceFormat('CSV');

$job = $table->runJob($loadConfig);
// poll the job until it is complete
$backoff = new ExponentialBackoff(10);
$backoff->execute(function () use ($job) {
    printf('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.

Le code suivant montre comment charger un fichier CSV local dans une nouvelle table BigQuery. Pour charger un fichier local d'un autre format, définissez la propriété LoadJobConfig.source_format sur le format approprié.

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(
    source_format=bigquery.SourceFormat.CSV, skip_leading_rows=1, autodetect=True,
)

with open(file_path, "rb") as source_file:
    job = client.load_table_from_file(source_file, table_id, job_config=job_config)

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

table = client.get_table(table_id)  # Make an API request.
print(
    "Loaded {} rows and {} columns to {}".format(
        table.num_rows, len(table.schema), table_id
    )
)

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.

Le code suivant montre comment charger un fichier CSV local dans une nouvelle table BigQuery. Pour charger un fichier local d'un autre format, définissez le paramètre format de la méthode Table#load_job sur le format approprié.

require "google/cloud/bigquery"

def load_from_file dataset_id = "your_dataset_id",
                   file_path  = "path/to/file.csv"

  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id
  table_id = "new_table_id"

  # Infer the config.location based on the location of the referenced dataset.
  load_job = dataset.load_job table_id, file_path do |config|
    config.skip_leading = 1
    config.autodetect   = true
  end
  load_job.wait_until_done! # Waits for table load to complete.

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

Limites

Le chargement de données à partir d'une source de données locale est soumis aux limites suivantes :

  • Les caractères génériques et les listes d'éléments séparés par une virgule ne sont pas compatibles avec le chargement de fichiers depuis une source de données locale. Les fichiers doivent être chargés individuellement.
  • Lorsque vous utilisez Cloud Console, les fichiers chargés à partir d'une source de données locale ne peuvent pas dépasser 10 Mo. Dans le cas de fichiers plus volumineux, chargez-les à partir de Cloud Storage.

Charger des données compressées et non compressées

Le format binaire Avro est le format préconisé pour le chargement des données compressées. Les données Avro sont plus rapides à charger, car elles peuvent être lues en parallèle, même lorsque les blocs de données sont compressés. Les fichiers Avro compressés ne sont pas acceptés, à la différence des blocs de données compressés. Consultez la section Compression de fichies Avro.

Le format binaire Parquet est également un choix judicieux, car l'encodage par colonne de Parquet se traduit généralement par un meilleur taux de compression et des fichiers moins volumineux. Les fichiers Parquet exploitent également les techniques de compression qui permettent de charger les fichiers en parallèle. Les fichiers Parquet compressés ne sont pas acceptés, à la différence des blocs de données compressés. Consultez la section Compression de fichiers Parquet.

Le format binaire ORC offre des avantages semblables à ceux du format Parquet. Les données dans les fichiers ORC sont rapides à charger, car les bandes de données peuvent être lues en parallèle. Les lignes de chaque bande de données sont chargées de manière séquentielle. Pour optimiser le temps de chargement, utilisez une taille de bande de données d'environ 256 Mo au maximum. Les fichiers ORC compressés ne sont pas acceptés, à la différence des pieds de page et des bandes de fichiers compressés. Consultez la section Compression ORC.

Pour les autres formats de données tels que CSV et JSON, BigQuery peut charger les fichiers non compressés beaucoup plus rapidement que les fichiers compressés, car les fichiers non compressés peuvent être lus en parallèle. Les fichiers non compressés étant plus volumineux, leur utilisation peut entraîner des restrictions de bande passante et une augmentation des coûts de stockage pour les données stockées dans Cloud Storage avant leur chargement dans BigQuery. Gardez à l'esprit que l'ordre des lignes n'est pas garanti pour les fichiers compressés ou non compressés. Il est important de prendre en compte ces compromis en fonction de votre cas d'utilisation.

En général, si la bande passante est limitée, compressez vos fichiers CSV et JSON à l'aide de gzip avant de les télécharger sur Cloud Storage. Actuellement, gzip est le seul type de compression de fichier compatible pour les fichiers CSV et JSON lors du chargement de données dans BigQuery. Si la vitesse de chargement est importante pour votre application et que vous avez beaucoup de bande passante pour charger vos données, conservez vos fichiers non compressés.

Ajouter des données à une table ou écraser une table

Vous pouvez charger des données supplémentaires dans une table à partir de fichiers sources ou en ajoutant des résultats de requête. Si le schéma des données ne correspond pas au schéma de la table ou de la partition de destination, vous pouvez mettre à jour le schéma lorsque vous y ajoutez des données ou lorsque vous le remplacez.

Si vous mettez à jour le schéma lors de l'ajout de données, BigQuery vous permet d'effectuer les opérations suivantes :

  • Ajouter des champs
  • Changer des champs REQUIRED en NULLABLE

Si vous écrasez une table, le schéma est toujours remplacé. Les mises à jour de schéma ne sont pas limitées lorsque vous écrasez une table.

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. L'outil de ligne de commande bq et l'API incluent les options suivantes :

Option de la console Option de l'outil bq Propriété de l'API BigQuery Description
Écrire si la table est vide Aucun WRITE_EMPTY N'écrit les données que si la table est vide.
Ajouter à la table --noreplace ou --replace=false. Si --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.

Règle de quota

Pour en savoir plus sur les règles de quota pour le chargement des données par lot, consultez la section Tâches de chargement de la page "Quotas et limites".

Tarifs

Le chargement des données par lot dans BigQuery est gratuit. Pour en savoir plus, consultez les tarifs d'ingestion de données BigQuery.