Importer des données dans BigQuery

Plutôt que de recourir à une tâche pour charger des données dans BigQuery, vous pouvez insérer celles-ci en flux continu (un enregistrement à la fois) à l'aide de la méthode tabledata.insertAll. Cette approche permet d'interroger les données sans attendre l'exécution d'une tâche de chargement.

Ce document présente les contraintes à prendre en considération avant de choisir une approche, y compris en ce qui concerne les quotas d'insertion en flux continu, la disponibilité des données et leur cohérence.

Avant de commencer

  1. Assurez-vous de disposer d'un accès en écriture à l'ensemble de données contenant votre table de destination. Pour écrire des données dans une table, vérifiez que celle-ci existe au préalable, sauf si vous utilisez des modèles de tables. Pour en savoir plus, consultez la section Créer des tables automatiquement à l'aide de modèles.

  2. Consultez les règles relatives aux quotas d'insertion en flux continu.

  3. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

L'insertion de données en flux continu n'est pas disponible avec la version gratuite. Le message d'erreur suivant s'affiche si vous essayez d'utiliser l'insertion en flux continu sans activer la facturation : BigQuery: Streaming insert is not allowed in the free tier..

Vérifier la disponibilité des données

Les données insérées en flux continu sont disponibles pour une analyse en temps réel quelques secondes après la première insertion dans une table. Dans de rares circonstances (telles qu'une panne), les données du tampon d'insertion en flux continu peuvent être temporairement indisponibles. Dans ce cas, les requêtes continuent de s'exécuter avec succès, mais ignorent certaines données qui se trouvent encore dans le tampon. Ces requêtes contiennent un avertissement visible dans le champ errors de bigquery.jobs.getQueryResults dans la réponse à bigquery.jobs.query, ou dans le champ status.errors de bigquery.jobs.get.

La disponibilité des données pour les opérations de copie peut prendre jusqu'à 90 minutes. En outre, lors de l'insertion en flux continu dans une table partitionnée, les données du tampon présentent une valeur NULL pour la pseudo-colonne _PARTITIONTIME. Pour savoir si les données peuvent être copiées, consultez la réponse tables.get pour une section nommée streamingBuffer. Si cette section est absente, les données doivent être disponibles pour la copie et présenter une valeur non nulle pour la pseudo-colonne _PARTITIONTIME. Le champ streamingBuffer.oldestEntryTime peut également être utilisé pour identifier l'âge des enregistrements dans le tampon d'insertion en flux continu.

Déduplication optimale

Lorsque vous fournissez insertId pour une ligne insérée, BigQuery utilise cet ID pour assurer la déduplication optimale pendant une durée maximale d'une minute. Par conséquent, si vous essayez d'insérer la même ligne en flux continu avec le même insertId plusieurs fois au cours de cette période dans la même table, BigQuery peut dédupliquer les multiples occurrences de cette ligne, en n'en conservant qu'une seule.

Cela est généralement destiné aux scénarios de nouvelle tentative dans un système distribué où il n'existe aucun moyen de déterminer l'état d'une insertion en flux continu en présence de certaines conditions d'erreur, telles que des erreurs réseau entre votre système et BigQuery, ou des erreurs internes à BigQuery. Dans ce cas, lors de la nouvelle tentative d'insertion, utilisez le même identifiant insertId pour le même ensemble de lignes afin que BigQuery puisse tenter de dédupliquer les données. Pour en savoir plus, consultez la section Dépannage pour les insertions en flux continu.

La déduplication optimale proposée par BigQuery ne doit pas être considérée comme un mécanisme permettant de garantir l'absence de doublons dans vos données. De plus, BigQuery peut à tout moment réduire la qualité de la déduplication optimale afin de garantir une plus grande fiabilité et une plus grande disponibilité des données.

Si vous avez des exigences strictes de déduplication pour vos données, sachez que le service Google Cloud Datastore autorise les transactions.

Désactiver la déduplication optimale

Vous pouvez désactiver la déduplication optimale en omettant le champ insertId pour chaque ligne insérée. Lorsque vous ne remplissez pas le champ insertId, vous obtenez des quotas d'ingestion en flux continu plus élevés dans certaines régions. Il s'agit de la méthode recommandée pour obtenir des limites de quotas d'ingestion en flux continu plus élevées. Pour en savoir plus, consultez la page Quotas et limites.

Apache Beam et Dataflow

Pour empêcher la déduplication optimale lorsque vous utilisez le connecteur d'E/S BigQuery d'Apache Beam pour Java, utilisez la méthode ignoreInsertIds().

Insérer des données en flux continu à plusieurs emplacements

Vous pouvez insérer des données en flux continu dans des ensembles de données situés aux États-Unis et en Europe. Lorsque BigQuery traite la requête insertAll, les données passent par des machines résidant en dehors de l'emplacement de l'ensemble de données. Si vous insérez des données en flux continu depuis un emplacement situé en dehors de celui de l'ensemble de données, vous risquez de rencontrer des taux de latence et d'erreur plus élevés.

Insérer des données en flux continu dans des tables partitionnées par date d'ingestion

Vous pouvez insérer des lignes individuelles en flux continu dans une table partitionnée à l'aide des requêtes insertAll. La partition de destination des données insérées est déduite par défaut de la date actuelle en fonction de l'heure UTC.

Si vous insérez des données en flux continu dans une table partitionnée par jour, vous pouvez remplacer la date déduite en fournissant un décorateur de partition dans la requête insertAll. Par exemple, vous avez la possibilité d'insérer des données en flux continu dans la partition correspondant à 2017-03-01 pour la table mydataset.table à l'aide du décorateur de partition suivant :

mydataset.table$20170301

Les données qui arrivent sont temporairement associées à la partition UNPARTITIONED dans le tampon d'insertion en flux continu. Par conséquent, les données du tampon peuvent être exclues d'une requête par le filtrage des valeurs NULL de la partition UNPARTITIONED à l'aide de l'une des pseudo-colonnes ([_PARTITIONTIME] ou [_PARTITIONDATE] selon le type de données préféré).

Lors de l'insertion en flux continu à l'aide d'un décorateur de partition, vous pouvez insérer des données dans des partitions pour la période comprise entre les 31 derniers jours et les 16 prochains jours par rapport à la date actuelle (heure UTC). Pour écrire sur des partitions pour des dates situées en dehors de ces limites autorisées, vous pouvez utiliser des tâches de chargement ou de requête, comme décrit dans la section Ajouter ou écraser des données dans une table partitionnée.

Insérer des données en flux continu dans des tables partitionnées

Vous pouvez insérer des données en flux continu dans une table partitionnée en fonction d'une colonne DATE ou TIMESTAMP située dans la période comprise entre les cinq années qui précèdent et l'année qui suit. Les données qui ne s'appliquent pas à cette période sont refusées.

Lorsque les données sont diffusées en continu, elles sont d'abord extraites dans la partition UNPARTITIONED. Lorsque les données non partitionnées sont suffisantes, elles sont partitionnées sur les partitions correspondantes.

Créer des tables automatiquement à l'aide de modèles

Les tables créées à partir de modèles fournissent un mécanisme permettant de diviser une table logique en tables plus petites pour créer des ensembles de données plus restreints (par exemple, par ID utilisateur). Les tables créées à partir de modèles présentent un certain nombre de limites, décrites ci-dessous. À la place, les tables partitionnées et les tables en cluster sont les méthodes recommandées pour obtenir ce comportement.

Pour utiliser un modèle de table avec l'API BigQuery, ajoutez un paramètre templateSuffix à la requête insertAll. Pour l'outil de ligne de commande bq, ajoutez l'option template_suffix à la commande insert. Si BigQuery détecte un paramètre templateSuffix ou l'option template_suffix, il traite la table ciblée en tant que modèle de base, et crée une table qui partage le même schéma que la table ciblée et dont le nom inclut le suffixe spécifié :

<targeted_table_name> + <templateSuffix>

Un modèle de table vous évite de devoir créer chaque table individuellement et de spécifier le schéma de chacune. Il vous suffit de créer un modèle unique et de fournir différents suffixes pour que BigQuery génère les nouvelles tables pour vous. BigQuery place les tables dans les mêmes projet et ensemble de données.

Les tables créées à partir de modèles sont généralement disponibles en quelques secondes. Il arrive en de rares occasions que le processus prenne plus de temps.

Modifier le schéma d'un modèle de table

Si vous modifiez le schéma d'un modèle de table, toutes les tables générées ultérieurement utilisent le schéma mis à jour. Les tables existantes ne sont pas concernées, sauf si elles contiennent toujours un tampon d'insertion en flux continu.

Si vous modifiez le schéma d'un modèle de table avec rétrocompatibilité, le schéma des tables existantes qui contiennent toujours un tampon d'insertion en flux continu est également mis à jour. Sans rétrocompatibilité par contre, toutes les données mises en mémoire tampon utilisant l'ancien schéma seront perdues. En outre, vous ne pourrez pas insérer de nouvelles données en flux continu dans des tables existantes qui utilisent l'ancien schéma, désormais incompatible.

Une fois que vous avez modifié le schéma d'un modèle de table, attendez la propagation des modifications avant d'essayer d'insérer de nouvelles données ou d'interroger des tables générées. Les requêtes d'insertion de nouveaux champs devraient aboutir en quelques minutes. Les tentatives d'interrogation des nouveaux champs peuvent prendre plus de temps, jusqu'à 90 minutes.

Pour modifier le schéma d'une table générée, attendez que l'insertion en flux continu à l'aide du modèle de table se termine et que la section des statistiques d'insertion disparaisse de la réponse tables.get() (ce qui indique qu'aucune donnée n'est mise en mémoire tampon dans la table).

Les tables partitionnées et les tables en cluster ne sont pas soumises aux limites mentionnées ci-dessus, et constituent le mécanisme recommandé.

Détails du modèle de table

Valeur du suffixe de modèle
La valeur templateSuffix (ou --template_suffix) ne doit contenir que des lettres (a-z, A-Z), des chiffres (0-9) ou des traits de soulignement (_). La longueur maximale combinée du nom de table et du suffixe de table est de 1 024 caractères.
Quota
Les tables créées à partir de modèles sont soumises aux mêmes limites de quotas d'insertions en flux continu que les autres tables. En outre, lorsque vous insérez du contenu en flux continu dans des tables créées à partir de modèles, la désactivation de la déduplication optimale n'entraîne pas des quotas plus élevés.
Durée de vie
La table générée hérite son délai d'expiration de l'ensemble de données. Comme les données insérées en flux continu, les tables générées ne peuvent pas être immédiatement copiées.
Déduplication
La déduplication ne se produit qu'entre des références uniformes à une table de destination. Par exemple, si vous insérez des données en flux continu dans une table générée à l'aide de modèles et d'une commande insertAll standard de façon simultanée, aucune déduplication ne se produit entre les lignes insérées par les modèles et par la commande insertAll standard.
Vues
Le modèle de table et les tables générées ne doivent pas être des vues.

Exemples de cas d'utilisation

Journalisation volumineuse d'événements

Si vous possédez une application qui collecte une grande quantité de données en temps réel, les insertions en flux continu peuvent être un choix judicieux. En général, ces types d'applications présentent les critères suivants :

  • Pas de mode transactionnel – Volume élevé de lignes ajoutées en permanence. L'application peut tolérer un cas de duplication ou d'indisponibilité temporaire des données de manière exceptionnelle.
  • Analyse globale – Les requêtes sont généralement effectuées en vue d'une analyse des tendances, par opposition à une sélection d'enregistrements restreinte ou unique.

Le suivi des événements est un exemple de journalisation volumineuse d'événements. Supposons que vous ayez une application mobile qui suit les événements. Cette application ou les serveurs mobiles peuvent enregistrer indépendamment les interactions des utilisateurs ou les erreurs système et les insérer en flux continu dans BigQuery. Vous pouvez analyser ces données pour déterminer des tendances générales (comme des zones générant un taux élevé d'interactions ou de problèmes) et surveiller les conditions d'erreur en temps réel.

Supprimer manuellement les doublons

Vous pouvez suivre le processus manuel ci-dessous pour vérifier l'absence de ligne en double après l'insertion en flux continu.

  1. Ajoutez la valeur insertId en tant que colonne du schéma de table et incluez insertId dans les données de chaque ligne.
  2. Lorsque l'insertion en flux continu est terminée, exécutez la requête suivante pour rechercher les doublons :

    #standardSQL
    SELECT
      MAX(count) FROM(
      SELECT
        ID_COLUMN,
        count(*) as count
      FROM
        `TABLE_NAME`
      GROUP BY
        ID_COLUMN)

    Si le résultat est supérieur à 1, il existe des doublons.
  3. Pour supprimer les lignes en double, exécutez la requête suivante. Vous devez spécifier une table de destination, autoriser les résultats volumineux et désactiver leur regroupement.

    #standardSQL
    SELECT
      * EXCEPT(row_number)
    FROM (
      SELECT
        *,
        ROW_NUMBER()
              OVER (PARTITION BY ID_COLUMN) row_number
      FROM
        `TABLE_NAME`)
    WHERE
      row_number = 1

Remarques sur la requête de suppression des doublons :

  • La stratégie la plus sûre consiste à cibler une nouvelle table. Vous pouvez également cibler la table source avec la préférence d'écriture WRITE_TRUNCATE.
  • La requête de suppression des doublons ajoute une colonne row_number avec la valeur 1 à la fin du schéma de table. Elle utilise une instruction SELECT * EXCEPT du langage SQL standard pour exclure la colonne row_number de la table de destination. Le préfixe #standardSQL active le langage SQL standard pour cette requête. Vous pouvez également sélectionner des noms de colonne spécifiques pour omettre cette colonne.
  • Pour interroger des données actives avec doublons supprimés, vous pouvez également créer une vue sur votre table à l'aide de la requête de suppression des doublons. Sachez que le coût de la requête par rapport à la vue est calculé en fonction des colonnes sélectionnées dans votre vue, ce qui peut entraîner de grandes tailles d'octets analysés.

Résolution des erreurs d'insertion en flux continu

Pour en savoir plus, consultez la section Résolution des erreurs d'insertion en flux continu de la page relative au dépannage.

Haut de page

Exemples d'insertions en flux continu

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 en langage C#.


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

public class BigQueryTableInsertRows
{
    public void TableInsertRows(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id",
        string tableId = "your_table_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        BigQueryInsertRow[] rows = new BigQueryInsertRow[]
        {
            // The insert ID is optional, but can avoid duplicate data
            // when retrying inserts.
            new BigQueryInsertRow(insertId: "row1") {
                { "name", "Washington" },
                { "post_abbr", "WA" }
            },
            new BigQueryInsertRow(insertId: "row2") {
                { "name", "Colorado" },
                { "post_abbr", "CO" }
            }
        };
        client.InsertRows(datasetId, tableId, rows);
    }
}

Go

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

import (
	"context"
	"fmt"

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

// Item represents a row item.
type Item struct {
	Name string
	Age  int
}

// Save implements the ValueSaver interface.
// This example disables best-effort de-duplication, which allows for higher throughput.
func (i *Item) Save() (map[string]bigquery.Value, string, error) {
	return map[string]bigquery.Value{
		"full_name": i.Name,
		"age":       i.Age,
	}, bigquery.NoDedupeID, nil
}

// insertRows demonstrates inserting data into a table using the streaming insert mechanism.
func insertRows(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()

	inserter := client.Dataset(datasetID).Table(tableID).Inserter()
	items := []*Item{
		// Item implements the ValueSaver interface.
		{Name: "Phred Phlyntstone", Age: 32},
		{Name: "Wylma Phlyntstone", Age: 29},
	}
	if err := inserter.Put(ctx, items); 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 en langage Java.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryError;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.InsertAllRequest;
import com.google.cloud.bigquery.InsertAllResponse;
import com.google.cloud.bigquery.TableId;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

// Sample to inserting rows into a table without running a load job.
public class TableInsertRows {

  public static void runTableInsertRows() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    // Create a row to insert
    Map<String, Object> rowContent = new HashMap<>();
    rowContent.put("booleanField", true);
    rowContent.put("numericField", "3.14");

    tableInsertRows(datasetName, tableName, rowContent);
  }

  public static void tableInsertRows(
      String datasetName, String tableName, Map<String, Object> rowContent) {
    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();

      // Get table
      TableId tableId = TableId.of(datasetName, tableName);

      // Inserts rowContent into datasetName:tableId.
      InsertAllResponse response =
          bigquery.insertAll(
              InsertAllRequest.newBuilder(tableId)
                  // More rows can be added in the same RPC by invoking .addRow() on the builder.
                  // You can also supply optional unique row keys to support de-duplication
                  // scenarios.
                  .addRow(rowContent)
                  .build());

      if (response.hasErrors()) {
        // If any of the insertions failed, this lets you inspect the errors
        for (Map.Entry<Long, List<BigQueryError>> entry : response.getInsertErrors().entrySet()) {
          System.out.println("Response error: \n" + entry.getValue());
        }
      }
      System.out.println("Rows successfully inserted into table");
    } catch (BigQueryException e) {
      System.out.println("Insert operation not performed \n" + e.toString());
    }
  }
}

Node.js

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

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

async function insertRowsAsStream() {
  // Inserts the JSON objects into my_dataset:my_table.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = 'my_dataset';
  // const tableId = 'my_table';
  // const rows = [{name: 'Tom', age: 30}, {name: 'Jane', age: 32}];

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

  // Insert data into a table
  await bigqueryClient
    .dataset(datasetId)
    .table(tableId)
    .insert(rows);
  console.log(`Inserted ${rows.length} rows`);
}
insertRowsAsStream();

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 en langage PHP.

use Google\Cloud\BigQuery\BigQueryClient;

/** Uncomment and populate these variables in your code */
// $projectId = 'The Google project ID';
// $datasetId = 'The BigQuery dataset ID';
// $tableId   = 'The BigQuery table ID';
// $data = [
//     "field1" => "value1",
//     "field2" => "value2",
// ];

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

$insertResponse = $table->insertRows([
    ['data' => $data],
    // additional rows can go here
]);
if ($insertResponse->isSuccessful()) {
    print('Data streamed into BigQuery successfully' . PHP_EOL);
} else {
    foreach ($insertResponse->failedRows() as $row) {
        foreach ($row['errors'] as $error) {
            printf('%s: %s' . PHP_EOL, $error['reason'], $error['message']);
        }
    }
}

Python

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

from google.cloud import bigquery

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

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

rows_to_insert = [
    {u"full_name": u"Phred Phlyntstone", u"age": 32},
    {u"full_name": u"Wylma Phlyntstone", u"age": 29},
]

errors = client.insert_rows_json(table_id, rows_to_insert)  # Make an API request.
if errors == []:
    print("New rows have been added.")
else:
    print("Encountered errors while inserting rows: {}".format(errors))

Ruby

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

require "google/cloud/bigquery"

def table_insert_rows dataset_id = "your_dataset_id", table_id = "your_table_id"
  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id
  table    = dataset.table table_id

  row_data = [
    { name: "Alice", value: 5  },
    { name: "Bob",   value: 10 }
  ]
  response = table.insert row_data

  if response.success?
    puts "Inserted rows successfully"
  else
    puts "Failed to insert #{response.error_rows.count} rows"
  end
end

Vous n'avez pas besoin de renseigner le champ insertId lorsque vous insérez des lignes. Les exemples suivants montrent comment éviter l'envoi de insertId pour chaque ligne lors de l'insertion en flux continu.

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 en langage Java.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryError;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.InsertAllRequest;
import com.google.cloud.bigquery.InsertAllResponse;
import com.google.cloud.bigquery.TableId;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

// Sample to insert rows without row ids in a table
public class TableInsertRowsWithoutRowIds {

  public static void runTableInsertRowsWithoutRowIds() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    // Create rows to insert
    Map<String, Object> rowContent1 = new HashMap<>();
    rowContent1.put("stringField", "Phred Phlyntstone");
    rowContent1.put("numericField", 32);
    Map<String, Object> rowContent2 = new HashMap<>();
    rowContent2.put("stringField", "Wylma Phlyntstone");
    rowContent2.put("numericField", 29);
    List<InsertAllRequest.RowToInsert> rowContent = new ArrayList<>();
    // insertId is null if not specified
    rowContent.add(InsertAllRequest.RowToInsert.of(rowContent1));
    rowContent.add(InsertAllRequest.RowToInsert.of(rowContent2));
    tableInsertRowsWithoutRowIds(datasetName, tableName, rowContent);
  }

  public static void tableInsertRowsWithoutRowIds(
      String datasetName, String tableName, Iterable<InsertAllRequest.RowToInsert> rows) {
    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();

      // Get table
      TableId tableId = TableId.of(datasetName, tableName);

      // Inserts rowContent into datasetName:tableId.
      InsertAllResponse response =
          bigquery.insertAll(InsertAllRequest.newBuilder(tableId).setRows(rows).build());

      if (response.hasErrors()) {
        // If any of the insertions failed, this lets you inspect the errors
        for (Map.Entry<Long, List<BigQueryError>> entry : response.getInsertErrors().entrySet()) {
          System.out.println("Response error: \n" + entry.getValue());
        }
      }
      System.out.println("Rows successfully inserted into table without row ids");
    } catch (BigQueryException e) {
      System.out.println("Insert operation not performed \n" + e.toString());
    }
  }
}

Python

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

from google.cloud import bigquery

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

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

rows_to_insert = [
    {u"full_name": u"Phred Phlyntstone", u"age": 32},
    {u"full_name": u"Wylma Phlyntstone", u"age": 29},
]

errors = client.insert_rows_json(
    table_id, rows_to_insert, row_ids=[None] * len(rows_to_insert)
)  # Make an API request.
if errors == []:
    print("New rows have been added.")
else:
    print("Encountered errors while inserting rows: {}".format(errors))

Haut de page