JSON-Daten aus Cloud Storage laden

JSON-Dateien aus Cloud Storage laden

In Cloud Storage gespeicherte, durch Zeilenumbruch getrennte JSON-Daten können in eine neue Tabelle oder Partition geladen oder an eine vorhandene Tabelle oder Partition angefügt werden. Außerdem haben Sie die Möglichkeit, eine vorhandene Tabelle oder Partition damit zu überschreiben. Beim Laden der Daten in BigQuery werden diese in ein Spaltenformat für Capacitor (BigQuery-Speicherformat) konvertiert.

Wenn Sie Daten aus Cloud Storage in eine BigQuery-Tabelle laden, muss sich das Dataset, das die Tabelle enthält, am selben regionalen oder multiregionalen Standort wie der Cloud Storage-Bucket befinden.

Das JSON-Format mit Zeilenumbrüchen als Trennzeichen ist dasselbe wie das JSON Lines-Format.

Informationen zum Laden von JSON-Daten aus einer lokalen Datei finden Sie unter Daten aus einer lokalen Datenquelle in BigQuery laden.

Beschränkungen

Beachten Sie beim Laden von JSON-Daten aus Cloud Storage in BigQuery Folgendes:

  • JSON-Daten müssen durch Zeilenumbruch voneinander getrennt sein. Jedes JSON-Objekt muss sich in einer separaten Zeile in der Datei befinden.
  • Wenn Sie die gzip-Komprimierung verwenden, kann BigQuery die Daten nicht parallel lesen. Das Laden komprimierter JSON-Daten in BigQuery ist langsamer als das Laden nicht komprimierter Daten.
  • Es ist nicht möglich, sowohl komprimierte als auch nicht komprimierte Dateien in denselben Ladejob einzubeziehen.
  • BigQuery unterstützt keine Zuordnungen oder Wörterbücher in JSON, da in einem reinen JSON-Wörterbuch möglicherweise Schemainformationen fehlen. Wenn Sie beispielsweise eine Liste von Artikeln in einem Einkaufswagen darstellen möchten, ist "products": {"my_product": 40.0, "product2" : 16.5} nicht gültig, aber "products": [{"product_name": "my_product", "amount": 40.0}, {"product_name": "product2", "amount": 16.5}] ist gültig.

    Wenn Sie das gesamte JSON-Objekt beibehalten möchten, sollten Sie es in eine string-Spalte einfügen, die mit JSON-Funktionen abgefragt werden kann.

  • Wenn Sie CSV- oder JSON-Daten laden, muss für Werte in DATE-Spalten der Bindestrich (-) als Trennzeichen verwendet werden und das Datum muss das Format YYYY-MM-DD (Jahr-Monat-Tag) haben.
  • Wenn Sie JSON- oder CSV-Daten laden, muss für Werte in TIMESTAMP-Spalten der Bindestrich (-) als Trennzeichen verwendet werden und der Datumsabschnitt des Zeitstempels muss das Format YYYY-MM-DD (Jahr-Monat-Tag) haben. Im hh:mm:ss-Abschnitt (Stunde-Minute-Sekunde) des Zeitstempels muss als Trennzeichen ein Doppelpunkt (:) verwendet werden.

Erforderliche Berechtigungen

Wenn Sie Daten in BigQuery laden möchten, benötigen Sie Berechtigungen zum Ausführen eines Ladejobs und zum Laden von Daten in neue oder vorhandene BigQuery-Tabellen und -Partitionen. Zum Laden von Daten aus Cloud Storage benötigen Sie außerdem Berechtigungen für den Zugriff auf den Bucket, der Ihre Daten enthält.

BigQuery-Berechtigungen

Die folgenden Berechtigungen sind mindestens erforderlich, um Daten in BigQuery zu laden. Diese Berechtigungen werden benötigt, wenn Sie Daten in eine neue Tabelle oder Partition laden oder Daten in einer Tabelle oder Partition anfügen oder überschreiben möchten:

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

Diese vordefinierten Cloud IAM-Rollen enthalten die Berechtigungen bigquery.tables.create und bigquery.tables.updateData:

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

Die folgenden vordefinierten Cloud IAM-Rollen enthalten Berechtigungen des Typs bigquery.jobs.create:

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

Wenn ein Nutzer mit Berechtigungen vom Typ bigquery.datasets.create ein Dataset erstellt, hat er dafür außerdem bigquery.dataOwner-Zugriff. Mit bigquery.dataOwner-Zugriff hat der Nutzer die Möglichkeit, Tabellen im Dataset über einen Ladejob zu erstellen und zu aktualisieren.

Weitere Informationen zu Cloud IAM-Rollen und -Berechtigungen in BigQuery finden Sie unter Zugriffssteuerung.

Cloud Storage-Berechtigungen

Zum Laden von Daten aus einem Cloud Storage-Bucket benötigen Sie die Berechtigung storage.objects.get. Wenn Sie einen URI-Platzhalter verwenden, benötigen Sie außerdem die Berechtigung storage.objects.list.

Die vordefinierte Cloud IAM-Rolle storage.objectViewer kann erteilt werden, um Berechtigungen der Typen storage.objects.get und storage.objects.list zu gewähren.

JSON-Daten in neue Tabelle laden

Mit einer der folgenden Methoden können Sie durch Zeilenumbruch getrennte JSON-Daten aus Cloud Storage in eine neue BigQuery-Tabelle laden:

  • Mit der Cloud Console oder der klassischen Web-UI
  • Mit dem Befehl bq load des Befehlszeilentools bq
  • Durch Aufrufen der API-Methode jobs.insert und Konfigurieren eines load-Jobs
  • Mit den Clientbibliotheken

So laden Sie JSON-Daten aus Cloud Storage in eine neue BigQuery-Tabelle:

Console

  1. Rufen Sie in der Cloud Console die BigQuery-Web-UI auf.
    Zur Cloud Console

  2. Maximieren Sie im Navigationsbereich im Abschnitt Ressourcen Ihr Google Cloud-Projekt und wählen Sie ein Dataset aus.

  3. Klicken Sie auf der rechten Seite des Fensters im Detailbereich auf Tabelle erstellen. Der Vorgang zum Laden von Daten entspricht dem Vorgang zum Erstellen einer leeren Tabelle.

    Tabelle erstellen.

  4. Gehen Sie auf der Seite Tabelle erstellen im Abschnitt Quelle so vor:

    • Wählen Sie unter Tabelle erstellen aus die Option "Google Cloud Storage" aus.

    • Suchen Sie im Feld für die Quelle nach dem Cloud Storage-URI oder geben Sie ihn ein. In der Cloud Console kann zwar nur ein URI eingefügt werden, aber Platzhalter werden unterstützt. Der Cloud Storage-Bucket muss sich am selben Standort wie das Dataset befinden, das die von Ihnen erstellte Tabelle enthält.

      Datei auswählen.

    • Wählen Sie für Dateiformat den Eintrag JSON (durch Zeilenumbruch getrennt) aus.

  5. Gehen Sie auf der Seite Tabelle erstellen im Abschnitt Ziel folgendermaßen vor:

    • Wählen Sie für Dataset-Name das entsprechende Dataset aus.

      Dataset aufrufen.

    • Achten Sie darauf, dass der Tabellentyp auf Native Tabelle eingestellt ist.

    • Geben Sie im Feld Tabellenname den Namen der Tabelle ein, die Sie in BigQuery erstellen.

  6. Klicken Sie im Abschnitt Schema bei Automatisch erkennen auf das Kästchen Schema und Eingabeparameter, um die automatische Schemaerkennung zu aktivieren. Alternativ können Sie die Schemadefinition auch manuell eingeben:

    • Klicken Sie auf Als Text bearbeiten und geben Sie das Tabellenschema als JSON-Array ein.

      Schema als JSON-Array hinzufügen.

    • Geben Sie das Schema mit Feld hinzufügen manuell ein.

      Schemadefinition über die Schaltfläche

  7. Optional: Wählen Sie zum Partitionieren der Tabelle die jeweiligen Optionen unter Partitions- und Clustereinstellungen aus:

    • Zum Erstellen einer partitionierten Tabelle klicken Sie auf Keine Partitionierung, wählen dann Nach Feld partitionieren und anschließend eine DATE- oder TIMESTAMP-Spalte aus. Diese Option ist nicht verfügbar, wenn Ihr Schema keine DATE- oder TIMESTAMP-Spalte enthält.
    • Zum Erstellen einer nach Aufnahmezeit partitionierten Tabelle klicken Sie auf Keine Partitionierung und wählen dann Nach Aufnahmezeit partitionieren aus.
  8. Optional: Klicken Sie unter Partitionierungsfilter auf das Kästchen Partitionsfilter anfordern, damit Nutzer eine WHERE-Klausel zum Angeben der abzufragenden Partitionen einfügen müssen. Das Anfordern eines Partitionsfilters kann die Kosten senken und die Leistung verbessern. Weitere Informationen finden Sie unter Partitionierte Tabellen abfragen. Diese Option ist nicht verfügbar, wenn Keine Partitionierung ausgewählt ist.

  9. Optional: Wenn Sie die Tabelle clustern möchten, geben Sie im Feld Clustering-Reihenfolge einen bis vier Feldnamen ein. Derzeit wird das Clustering nur für partitionierte Tabellen unterstützt.

  10. (Optional) Klicken Sie auf Erweiterte Optionen.

    • Lassen Sie unter Schreibeinstellung die Option Schreiben, wenn leer ausgewählt. Mit dieser Option werden eine neue Tabelle erstellt und Ihre Daten in diese Tabelle geladen.
    • Übernehmen Sie für Number of errors allowed (Anzahl zulässiger Fehler) den Standardwert 0 oder geben Sie an, wie viele Zeilen mit Fehlern maximal ignoriert werden können. Wenn die Anzahl der Zeilen mit Fehlern diesen Wert überschreitet, führt der Job zu einer invalid-Meldung und schlägt fehl.
    • Klicken Sie für Unbekannte Werte auf Unbekannte Werte ignorieren, um alle Werte in einer Zeile zu ignorieren, die im Schema der Tabelle nicht vorhanden sind.
    • Klicken Sie unter Verschlüsselung auf Vom Kunden verwalteter Schlüssel, um einen Cloud Key Management Service-Schlüssel zu verwenden. Wenn Sie die Einstellung Von Google verwalteter Schlüssel übernehmen, verschlüsselt BigQuery inaktive Daten.
  11. Klicken Sie auf Tabelle erstellen.

Klassische UI

  1. Rufen Sie die BigQuery-Web-UI auf.
    Zur BigQuery-Web-UI

  2. Bewegen Sie den Mauszeiger im Navigationsbereich auf ein Dataset. Klicken Sie auf den Abwärtspfeil Abwärtspfeilsymbol und dann auf Neue Tabelle erstellen. Der Vorgang zum Laden von Daten entspricht dem Vorgang zum Erstellen einer leeren Tabelle.

  3. Gehen Sie auf der Seite Tabelle erstellen im Abschnitt Quelldaten so vor:

    • Klicken Sie auf Aus Quelle erstellen.
    • Wählen Sie unter Speicherort die Option Cloud Storage aus und geben Sie im Quellfeld den Cloud Storage-URI ein. In der BigQuery-Web-UI kann zwar nur ein URI eingefügt werden, Platzhalter werden aber unterstützt. Der Cloud Storage-Bucket muss sich am selben Standort wie das Dataset befinden, das die von Ihnen erstellte Tabelle enthält.
    • Wählen Sie für Dateiformat den Eintrag JSON (durch Zeilenumbruch getrennt) aus.
  4. Gehen Sie im Abschnitt Zieltabelle folgendermaßen vor:

    • Wählen Sie für Tabellenname das entsprechende Dataset aus und geben Sie im Namensfeld für die Tabelle den Namen der Tabelle ein, die Sie in BigQuery erstellen.
    • Achten Sie darauf, dass der Tabellentyp auf Native Tabelle eingestellt ist.
  5. Klicken Sie im Abschnitt Schema bei Automatisch erkennen auf das Kästchen Schema und Eingabeparameter, um die automatische Schemaerkennung zu aktivieren. Alternativ können Sie die Schemadefinition auch manuell eingeben:

    • Klicken Sie auf Als Text bearbeiten und geben Sie das Tabellenschema als JSON-Array ein.

      Schema als JSON-Array hinzufügen.

    • Geben Sie das Schema mithilfe von Feld hinzufügen manuell ein:

      Schema durch Hinzufügen von Feldern einfügen.

  6. Optional: Gehen Sie im Bereich Optionen so vor:

    • Übernehmen Sie für Number of errors allowed (Anzahl zulässiger Fehler) den Standardwert 0 oder geben Sie an, wie viele Zeilen mit Fehlern maximal ignoriert werden können. Wenn die Anzahl der Zeilen mit Fehlern diesen Wert überschreitet, führt der Job zu einer invalid-Meldung und schlägt fehl.
    • Übernehmen Sie unter Schreibeinstellung die Option Schreiben, wenn leer. Mit dieser Option werden eine neue Tabelle erstellt und Ihre Daten in diese Tabelle geladen.
    • So partitionieren Sie die Tabelle:
      • Klicken Sie unter Partitionierungstyp auf Keiner und wählen Sie Tag aus.
      • Gehen Sie für Partitionierungsfeld so vor:
      • Wählen Sie zum Erstellen einer partitionierten Tabelle eine DATE- oder TIMESTAMP-Spalte aus. Diese Option ist nicht verfügbar, wenn Ihr Schema keine DATE- oder TIMESTAMP-Spalte enthält.
      • Übernehmen Sie zum Erstellen einer nach Aufnahmezeit partitionierten Tabelle den Standardwert _PARTITIONTIME.
      • Klicken Sie auf das Kästchen Partitionsfilter anfordern, wenn Nutzer beim Erstellen einer Tabelle mithilfe einer eingefügten WHERE-Klausel die Partitionen angeben sollen, die abgefragt werden sollen. Das Anfordern eines Partitionsfilters kann die Kosten senken und die Leistung verbessern. Weitere Informationen finden Sie unter Partitionierte Tabellen abfragen. Diese Option ist nicht verfügbar, wenn für Partitionierungstyp der Wert Keiner festgelegt ist.
    • Zum Clustern der Tabelle im Feld Clustering-Felder können Sie einen bis vier Feldnamen eingeben.
    • Wählen Sie unter Destination encryption die Option Customer-managed encryption aus, um einen Cloud Key Management Service-Schlüssel zum Verschlüsseln der Tabelle zu verwenden. Wenn Sie die Einstellung Default übernehmen, verschlüsselt BigQuery inaktive Daten mit einem von Google verwalteten Schlüssel.
  7. Klicken Sie auf Tabelle erstellen.

bq

Verwenden Sie den Befehl bq load, geben Sie NEWLINE_DELIMITED_JSON mit dem Flag --source_format an und fügen Sie einen Cloud Storage-URI ein. Sie können einen einzelnen URI, eine durch Kommas getrennte Liste von URIs oder einen URI mit Platzhalter einfügen. Geben Sie das Schema inline bzw. in einer Schemadefinitionsdatei an oder verwenden Sie die automatische Schemaerkennung.

Optional: Geben Sie das Flag --location an und legen Sie als Wert Ihren Standort fest.

Andere optionale Flags sind:

  • --max_bad_records: Eine Ganzzahl, die die Höchstzahl ungültiger Datensätze angibt, bevor der gesamte Job fehlschlägt. Der Standardwert ist 0. Es werden höchstens fünf Fehler pro Typ zurückgegeben, unabhängig vom Wert --max_bad_records.
  • --ignore_unknown_values: Wenn dieses Flag angegeben ist, werden zusätzliche, nicht erkannte Werte in CSV- oder JSON-Daten zugelassen und ignoriert.
  • --autodetect: Wenn dieses Flag angegeben ist, wird die automatische Schemaerkennung für CSV- und JSON-Daten aktiviert.
  • --quote: Das Anführungszeichen zum Umschließen von Datensätzen. Der Standardwert ist ". Wenn Sie kein Anführungszeichen angeben möchten, verwenden Sie einen leeren String.
  • --time_partitioning_type: Aktiviert die zeitbasierte Partitionierung für eine Tabelle und legt den Partitionstyp fest. Der einzig mögliche Wert ist derzeit DAY. Er generiert eine Partition pro Tag. Dieses Flag ist optional, wenn Sie eine Tabelle erstellen, die nach einer DATE- oder TIMESTAMP-Spalte partitioniert wird.
  • --time_partitioning_expiration: Eine Ganzzahl, die (in Sekunden) angibt, wann eine zeitbasierte Partition gelöscht werden soll. Die Ablaufzeit entspricht dem UTC-Datum der Partition plus dem ganzzahligen Wert.
  • --time_partitioning_field: Die DATE- oder TIMESTAMP-Spalte zum Erstellen einer partitionierten Tabelle. Wenn die zeitbasierte Partitionierung ohne Angabe dieses Werts aktiviert wird, erstellt BigQuery eine nach Aufnahmezeit partitionierte Tabelle.
  • --require_partition_filter: Wenn diese Option aktiviert ist, müssen die Nutzer eine WHERE-Klausel zur Angabe der abzufragenden Partitionen einfügen. Das Anfordern eines Partitionsfilters kann die Kosten senken und die Leistung verbessern. Weitere Informationen finden Sie unter Partitionierte Tabellen abfragen.
  • --clustering_fields: Eine durch Kommas getrennte Liste mit bis zu vier Spaltennamen zum Erstellen einer geclusterten Tabelle. Dieses Flag kann nur für partitionierte Tabellen genutzt werden.
  • --destination_kms_key: Der Cloud KMS-Schlüssel für die Verschlüsselung der Tabellendaten.

    Weitere Informationen zu partitionierten Tabellen finden Sie unter:

    Weitere Informationen zu geclusterten Tabellen finden Sie unter:

    Weitere Informationen zur Tabellenverschlüsselung finden Sie unter:

Geben Sie den folgenden Befehl ein, um JSON-Daten in BigQuery zu laden:

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

Dabei gilt:

  • LOCATION: Ihr Standort. Das Flag --location ist optional. Wenn Sie BigQuery z. B. in der Region Tokio verwenden, können Sie für das Flag den Wert asia-northeast1 festlegen. Mit der Datei .bigqueryrc können Sie einen Standardwert für den Standort festlegen.
  • FORMAT: NEWLINE_DELIMITED_JSON.
  • DATASET: ein vorhandenes Dataset.
  • TABLE: der Name der Tabelle, in die Sie Daten laden.
  • PATH_TO_SOURCE: ein vollständig qualifizierter Cloud Storage-URI oder eine durch Kommas getrennte Liste von URIs. Platzhalter werden ebenfalls unterstützt.
  • SCHEMA: ein gültiges Schema. Das Schema kann als lokale JSON-Datei bereitgestellt oder als Bestandteil des Befehls inline eingegeben werden. Sie können statt der Schemadefinition auch das Flag --autodetect verwenden.

Beispiele:

Mit dem folgenden Befehl werden Daten aus gs://mybucket/mydata.json in eine Tabelle mit dem Namen mytable in mydataset geladen. Das Schema ist in einer lokalen Schemadatei namens myschema.json definiert:

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

Mit dem folgenden Befehl werden Daten aus gs://mybucket/mydata.json in eine nach Aufnahmezeit partitionierte Tabelle mit dem Namen mytable in mydataset geladen. Das Schema ist in einer lokalen Schemadatei namens myschema.json definiert:

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

Mit dem folgenden Befehl werden Daten aus gs://mybucket/mydata.json in eine partitionierte Tabelle mit dem Namen mytable in mydataset geladen. Die Tabelle ist nach der Spalte mytimestamp partitioniert. Das Schema ist in einer lokalen Schemadatei namens myschema.json definiert.

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

Mit dem folgenden Befehl werden Daten aus gs://mybucket/mydata.json in eine Tabelle mit dem Namen mytable in mydataset geladen. Das Schema wird automatisch erkannt.

    bq load \
    --autodetect \
    --source_format=NEWLINE_DELIMITED_JSON \
    mydataset.mytable \
    gs://mybucket/mydata.json

Mit dem folgenden Befehl werden Daten aus gs://mybucket/mydata.json in eine Tabelle mit dem Namen mytable in mydataset geladen. Das Schema ist inline im Format FIELD:DATA_TYPE, FIELD:DATA_TYPE definiert.

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

Mit dem folgenden Befehl werden Daten aus mehreren Dateien in gs://mybucket/ in eine Tabelle namens mytable in mydataset geladen. Für den Cloud Storage-URI wird ein Platzhalter verwendet. Das Schema wird automatisch erkannt.

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

Mit dem folgenden Befehl werden Daten aus mehreren Dateien in gs://mybucket/ in eine Tabelle namens mytable in mydataset geladen. Der Befehl enthält eine durch Kommas getrennte Liste von Cloud Storage-URIs mit Platzhaltern. Das Schema ist in einer lokalen Schemadatei namens myschema.json definiert.

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

API

  1. Erstellen Sie einen load-Job, der auf die Quelldaten in Cloud Storage verweist.

  2. Optional: Geben Sie Ihren Standort im Attribut location im Abschnitt jobReference der Jobressource an.

  3. Das Attribut source URIs muss vollständig qualifiziert sein und das Format gs://BUCKET/OBJECT haben. Jeder URI kann ein Platzhalterzeichen (*) enthalten.

  4. Geben Sie das JSON-Datenformat an. Legen Sie dazu für das Attribut sourceFormat den Wert NEWLINE_DELIMITED_JSON fest.

  5. Rufen Sie zum Prüfen des Jobstatus jobs.get(JOB_ID*) auf. Ersetzen Sie dabei JOB_ID durch die ID des Jobs, der von der ersten Anfrage zurückgegeben wurde.

    • Wenn status.state = DONE zurückgegeben wird, wurde der Job erfolgreich abgeschlossen.
    • Wenn das Attribut status.errorResult vorhanden ist, schlug die Anfrage fehl und dieses Objekt enthält eine Fehlerbeschreibung. Wenn eine Anfrage fehlschlägt, wird keine Tabelle erstellt und es werden keine Daten geladen.
    • Wenn das Attribut status.errorResult nicht vorhanden ist, wurde der Job erfolgreich abgeschlossen. Es können aber einige nicht schwerwiegende Fehler aufgetreten sein, z. B. Probleme beim Importieren einiger Zeilen. Nicht schwerwiegende Fehler werden im Attribut status.errors des Objekts des zurückgegebenen Jobs aufgeführt.

API-Hinweise:

  • Ladejobs sind atomar und konsistent. Wenn ein Ladejob fehlschlägt, sind keine der zu ladenden Daten verfügbar. Wenn ein Ladejob erfolgreich ist, sind alle Daten verfügbar.

  • Erstellen Sie als Best Practice eine nur einmal vorkommende ID und übergeben Sie diese als jobReference.jobId, wenn jobs.insert zum Erstellen eines Ladejobs aufgerufen wird. Diese Vorgehensweise ist weniger anfällig für Netzwerkfehler, da der Client anhand der bekannten Job-ID einen Abruf oder einen neuen Versuch ausführen kann.

  • Das Aufrufen von jobs.insert für eine bestimmte Job-ID ist idempotent. Das bedeutet, dass Sie den Aufruf für dieselbe Job-ID beliebig oft wiederholen können. Höchstens einer dieser Vorgänge ist dann erfolgreich.

C#

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von C# in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery C# API.

Verwenden Sie die Methode BigQueryClient.CreateLoadJob(), um einen Ladejob über Cloud Storage zu starten. Wenn Sie durch Zeilenumbruch getrennte JSON-Daten verwenden möchten, erstellen Sie das Objekt CreateLoadJobOptions und setzen dessen Attribut SourceFormat auf FileFormat.NewlineDelimitedJson.


using Google.Apis.Bigquery.v2.Data;
using Google.Cloud.BigQuery.V2;
using System;

public class BigQueryLoadTableGcsJson
{
    public void LoadTableGcsJson(
        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.json";
        var dataset = client.GetDataset(datasetId);
        var schema = new TableSchemaBuilder {
            { "name", BigQueryDbType.String },
            { "post_abbr", BigQueryDbType.String }
        }.Build();
        TableReference destinationTableRef = dataset.GetTableReference(
            tableId: "us_states");
        // Create job configuration
        var jobOptions = new CreateLoadJobOptions()
        {
            SourceFormat = FileFormat.NewlineDelimitedJson
        };
        // Create and run job
        BigQueryJob 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

Bevor Sie dieses Beispiel ausprobieren, folgen Sie den Schritten zur Einrichtung von Go in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Go API.

import (
	"context"
	"fmt"

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

// importJSONExplicitSchema demonstrates loading newline-delimited JSON data from Cloud Storage
// into a BigQuery table and providing an explicit schema for the data.
func importJSONExplicitSchema(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.json")
	gcsRef.SourceFormat = bigquery.JSON
	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

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Java in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery Java API.

Verwenden Sie die Methode LoadJobConfiguration.builder(tableId, sourceUri), um einen Ladejob über Cloud Storage zu starten. Wenn Sie eine durch Zeilenumbruch getrennte JSON-Datei verwenden möchten, legen Sie den Parameter LoadJobConfiguration.setFormatOptions(FormatOptions.json()) fest.

String sourceUri = "gs://cloud-samples-data/bigquery/us-states/us-states.json";
TableId tableId = TableId.of(datasetName, tableName);
// Table field definition
Field[] fields =
    new Field[] {
      Field.of("name", LegacySQLTypeName.STRING),
      Field.of("post_abbr", LegacySQLTypeName.STRING)
    };
// Table schema definition
Schema schema = Schema.of(fields);
LoadJobConfiguration configuration =
    LoadJobConfiguration.builder(tableId, sourceUri)
        .setFormatOptions(FormatOptions.json())
        .setCreateDisposition(CreateDisposition.CREATE_IF_NEEDED)
        .setSchema(schema)
        .build();
// Load the table
Job loadJob = bigquery.create(JobInfo.of(configuration));
loadJob = loadJob.waitFor();
// Check the table
System.out.println("State: " + loadJob.getStatus().getState());
return ((StandardTableDefinition) bigquery.getTable(tableId).getDefinition()).getNumRows();

Node.js

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Node.js in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Node.js API.

// 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 json file at
 * https://storage.googleapis.com/cloud-samples-data/bigquery/us-states/us-states.json
 *
 * TODO(developer): Replace the following lines with the path to your file.
 */
const bucketName = 'cloud-samples-data';
const filename = 'bigquery/us-states/us-states.json';

async function loadJSONFromGCS() {
  // 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: 'NEWLINE_DELIMITED_JSON',
    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

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von PHP in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery PHP API.

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.json';
$schema = [
    'fields' => [
        ['name' => 'name', 'type' => 'string'],
        ['name' => 'post_abbr', 'type' => 'string']
    ]
];
$loadConfig = $table->loadFromStorage($gcsUri)->schema($schema)->sourceFormat('NEWLINE_DELIMITED_JSON');
$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

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Python in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery Python API.

Verwenden Sie die Methode Client.load_table_from_uri(), um einen Ladejob über Cloud Storage zu starten. Wenn Sie durch Zeilenumbruch getrennte JSON-Daten verwenden möchten, legen Sie das Attribut LoadJobConfig.source_format auf den String NEWLINE_DELIMITED_JSON fest und übergeben die Jobkonfiguration als job_config-Argument an die Methode load_table_from_uri().

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

dataset_ref = client.dataset(dataset_id)
job_config = bigquery.LoadJobConfig()
job_config.schema = [
    bigquery.SchemaField("name", "STRING"),
    bigquery.SchemaField("post_abbr", "STRING"),
]
job_config.source_format = bigquery.SourceFormat.NEWLINE_DELIMITED_JSON
uri = "gs://cloud-samples-data/bigquery/us-states/us-states.json"

load_job = client.load_table_from_uri(
    uri,
    dataset_ref.table("us_states"),
    location="US",  # Location must match that of the destination dataset.
    job_config=job_config,
)  # API request
print("Starting job {}".format(load_job.job_id))

load_job.result()  # Waits for table load to complete.
print("Job finished.")

destination_table = client.get_table(dataset_ref.table("us_states"))
print("Loaded {} rows.".format(destination_table.num_rows))

Ruby

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Ruby in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery Ruby API.

Verwenden Sie die Methode Dataset.load_job(), um einen Ladejob über Cloud Storage zu starten. Wenn Sie durch Zeilenumbruch voneinander getrennte JSON-Daten verwenden möchten, setzen Sie den Parameter format auf "json".

require "google/cloud/bigquery"

def load_table_gcs_json 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.json"
  table_id = "us_states"

  load_job = dataset.load_job table_id, gcs_uri, format: "json" 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

Verschachtelte und wiederkehrende JSON-Daten laden

BigQuery unterstützt das Laden verschachtelter und wiederkehrender Daten aus Quellformaten, die objektbasierte Schemas unterstützen. Das sind z. B. JSON, Avro, ORC, Parquet, Firestore und Datastore.

In jeder Zeile muss ein JSON-Objekt einschließlich verschachtelter/wiederkehrende Felder angezeigt werden.

Nachfolgend sehen Sie ein Beispiel für verschachtelte/wiederkehrende Daten. Diese Tabelle enthält Informationen zu Personen. Sie umfasst die folgenden Felder:

  • id
  • first_name
  • last_name
  • dob (Geburtsdatum)
  • addresses (verschachteltes und wiederkehrendes Feld)
    • addresses.status (aktueller oder vorheriger Status)
    • addresses.address
    • addresses.city
    • addresses.state
    • addresses.zip
    • addresses.numberOfYears (Jahre an der Adresse)

Die JSON-Datendatei würde so aussehen. Beachten Sie, dass das Adressfeld ein Array von Werten enthält (angezeigt durch [ ]).

{"id":"1","first_name":"John","last_name":"Doe","dob":"1968-01-22","addresses":[{"status":"current","address":"123 First Avenue","city":"Seattle","state":"WA","zip":"11111","numberOfYears":"1"},{"status":"previous","address":"456 Main Street","city":"Portland","state":"OR","zip":"22222","numberOfYears":"5"}]}
{"id":"2","first_name":"Jane","last_name":"Doe","dob":"1980-10-16","addresses":[{"status":"current","address":"789 Any Avenue","city":"New York","state":"NY","zip":"33333","numberOfYears":"2"},{"status":"previous","address":"321 Main Street","city":"Hoboken","state":"NJ","zip":"44444","numberOfYears":"3"}]}

Das Schema für diese Tabelle würde so aussehen:

[
    {
        "name": "id",
        "type": "STRING",
        "mode": "NULLABLE"
    },
    {
        "name": "first_name",
        "type": "STRING",
        "mode": "NULLABLE"
    },
    {
        "name": "last_name",
        "type": "STRING",
        "mode": "NULLABLE"
    },
    {
        "name": "dob",
        "type": "DATE",
        "mode": "NULLABLE"
    },
    {
        "name": "addresses",
        "type": "RECORD",
        "mode": "REPEATED",
        "fields": [
            {
                "name": "status",
                "type": "STRING",
                "mode": "NULLABLE"
            },
            {
                "name": "address",
                "type": "STRING",
                "mode": "NULLABLE"
            },
            {
                "name": "city",
                "type": "STRING",
                "mode": "NULLABLE"
            },
            {
                "name": "state",
                "type": "STRING",
                "mode": "NULLABLE"
            },
            {
                "name": "zip",
                "type": "STRING",
                "mode": "NULLABLE"
            },
            {
                "name": "numberOfYears",
                "type": "STRING",
                "mode": "NULLABLE"
            }
        ]
    }
]

Informationen zum Angeben verschachtelter und wiederkehrender Schemas finden Sie unter Verschachtelte und wiederkehrende Felder angeben.

JSON-Daten an eine Tabelle anfügen oder Tabelle mit JSON-Daten überschreiben

Zusätzliche Daten können entweder aus Quelldateien oder durch das Anfügen von Abfrageergebnissen in eine Tabelle geladen werden.

In der Console oder der klassischen Web-UI von BigQuery können Sie mit der Option Write preference (Schreibeinstellung) festlegen, welche Aktion beim Laden von Daten aus einer Quelldatei oder aus einem Abfrageergebnis ausgeführt werden soll.

Sie haben folgende Möglichkeiten, wenn Sie zusätzliche Daten in eine Tabelle laden:

Console-Option Option der klassischen Web-UI Befehlszeilen-Flag BigQuery API-Attribut Beschreibung
Schreiben, wenn leer Schreiben, wenn leer WRITE_EMPTY Daten werden nur geschrieben, wenn die Tabelle leer ist.
An Tabelle anfügen Append to table (An Tabelle anfügen) --noreplace oder --replace=false. Wenn --[no]replace nicht angegeben ist, werden Daten standardmäßig angefügt. WRITE_APPEND (Standard) Daten werden an das Ende der Tabelle angefügt.
Tabelle überschreiben Tabelle überschreiben --replace oder --replace=true WRITE_TRUNCATE Alle vorhandenen Daten in einer Tabelle werden gelöscht, bevor die neuen Daten geschrieben werden.

Wenn Sie Daten in eine vorhandene Tabelle laden, kann der Ladejob die Daten anfügen oder die Tabelle damit überschreiben.

Sie können eine Tabelle mit einer der folgenden Methoden anfügen oder überschreiben:

  • Mit der Cloud Console oder der klassischen Web-UI
  • Mit dem Befehl bq load des Befehlszeilentools bq
  • Durch Aufrufen der API-Methode jobs.insert und Konfigurieren eines load-Jobs
  • Mit den Clientbibliotheken

Console

  1. Rufen Sie in der Cloud Console die BigQuery-Web-UI auf.
    Zur Cloud Console

  2. Maximieren Sie im Navigationsbereich im Abschnitt Ressourcen Ihr Cloud-Projekt und wählen Sie ein Dataset aus.

  3. Klicken Sie im Detailfeld auf Tabelle erstellen. Der Vorgang zum Anfügen und Überschreiben von Daten in einem Ladejob ist mit dem Vorgang zum Erstellen einer Tabelle in einem Ladejob identisch.

    Tabelle erstellen.

  4. Gehen Sie auf der Seite Tabelle erstellen im Abschnitt Quelle so vor:

    • Wählen Sie unter Tabelle erstellen aus die Option "Google Cloud Storage" aus.

    • Suchen Sie im Feld für die Quelle nach dem Cloud Storage-URI oder geben Sie ihn ein. In der BigQuery-Web-UI kann zwar nur ein URI eingefügt werden, Platzhalter werden aber unterstützt. Der Cloud Storage-Bucket muss sich am selben Standort befinden wie das Dataset, das die Tabelle enthält, in der Sie Daten anfügen oder überschreiben.

      Datei auswählen.

    • Wählen Sie für Dateiformat den Eintrag JSON (durch Zeilenumbruch getrennt) aus.

  5. Gehen Sie auf der Seite Tabelle erstellen im Abschnitt Ziel folgendermaßen vor:

    • Wählen Sie für Dataset-Name das entsprechende Dataset aus.

      Dataset auswählen.

    • Geben Sie im Feld Tabellenname den Namen der Tabelle ein, in der Daten in BigQuery angefügt oder überschrieben werden.

    • Achten Sie darauf, dass der Tabellentyp auf Native Tabelle eingestellt ist.

  6. Klicken Sie im Abschnitt Schema bei Automatisch erkennen auf das Kästchen Schema und Eingabeparameter, um die automatische Schemaerkennung zu aktivieren. Alternativ können Sie die Schemadefinition auch manuell eingeben:

    • Klicken Sie auf Als Text bearbeiten und geben Sie das Tabellenschema als JSON-Array ein.

      Schema als JSON-Array hinzufügen.

    • Geben Sie das Schema mit Feld hinzufügen manuell ein.

      Schemadefinition über die Schaltfläche

  7. Behalten Sie für Partitions- und Clustereinstellungen die Standardwerte bei. Sie können eine Tabelle nicht durch Anfügen oder Überschreiben von Daten in eine partitionierte oder geclusterte Tabelle umwandeln. Außerdem unterstützt die Cloud Console das Anfügen bzw. Überschreiben von Daten in partitionierten oder geclusterten Tabellen in einem Ladejob nicht.

  8. Klicken Sie auf Advanced options (Erweiterte Optionen).

    • Wählen Sie für Write preference (Schreibeinstellung) die Option Append to table (An Tabelle anfügen) oder Overwrite table (Tabelle überschreiben) aus.
    • Übernehmen Sie für Number of errors allowed (Anzahl zulässiger Fehler) den Standardwert 0 oder geben Sie an, wie viele Zeilen mit Fehlern maximal ignoriert werden können. Wenn die Anzahl der Zeilen mit Fehlern diesen Wert überschreitet, führt der Job zu einer invalid-Meldung und schlägt fehl.
    • Klicken Sie für Unbekannte Werte auf Unbekannte Werte ignorieren, um alle Werte in einer Zeile zu ignorieren, die im Schema der Tabelle nicht vorhanden sind.
    • Klicken Sie unter Verschlüsselung auf Vom Kunden verwalteter Schlüssel, um einen Cloud Key Management Service-Schlüssel zu verwenden. Wenn Sie die Einstellung Von Google verwalteter Schlüssel übernehmen, verschlüsselt BigQuery inaktive Daten.

      Tabelle überschreiben.

  9. Klicken Sie auf Tabelle erstellen.

Klassische UI

  1. Rufen Sie die BigQuery-Web-UI auf.
    Zur BigQuery-Web-UI

  2. Bewegen Sie den Mauszeiger im Navigationsbereich auf ein Dataset. Klicken Sie auf den Abwärtspfeil Abwärtspfeilsymbol und dann auf Neue Tabelle erstellen. Der Vorgang zum Anfügen und Überschreiben von Daten in einem Ladejob entspricht dem Vorgang zum Erstellen einer Tabelle in einem Ladejob.

  3. Gehen Sie auf der Seite Tabelle erstellen im Abschnitt Quelldaten so vor:

    • Wählen Sie unter Speicherort die Option Cloud Storage aus und geben Sie im Quellfeld den Cloud Storage-URI ein. In der UI kann zwar nur ein URI eingefügt werden, aber Platzhalter werden unterstützt. Der Cloud Storage-Bucket muss sich am selben Standort befinden wie das Dataset, das die Tabelle enthält, in der Sie Daten anfügen bzw. überschreiben.
    • Wählen Sie für Dateiformat den Eintrag JSON (durch Zeilenumbruch getrennt) aus.
  4. Gehen Sie auf der Seite Create Table (Tabelle erstellen) im Abschnitt Destination Table (Zieltabelle) so vor:

    • Wählen Sie als Table name (Tabellenname) das entsprechende Dataset aus und geben Sie im Namensfeld für die Tabelle den Namen der Tabelle ein, in der Daten angefügt oder überschrieben werden sollen.
    • Achten Sie darauf, dass der Tabellentyp auf Native Tabelle eingestellt ist.
  5. Geben Sie im Abschnitt Schema die Schemadefinition ein.

    • Für JSON-Dateien können Sie durch Klicken auf das Kästchen Automatically detect (Automatisch erkennen) die automatische Schemaerkennung aktivieren.

      Link für automatische Schemaerkennung.

    • Sie können Schemainformationen auch manuell eingeben:

      • Klicken Sie dazu auf Als Text bearbeiten und geben Sie das Tabellenschema als JSON-Array ein:

        Schema als JSON-Array hinzufügen.

      • Geben Sie das Schema mithilfe von Feld hinzufügen manuell ein:

        Schema durch Hinzufügen von Feldern einfügen.

  6. Im Bereich Optionen gehen Sie so vor:

    • Übernehmen Sie für Number of errors allowed (Anzahl zulässiger Fehler) den Standardwert 0 oder geben Sie an, wie viele Zeilen mit Fehlern maximal ignoriert werden können. Wenn die Anzahl der Zeilen mit Fehlern diesen Wert überschreitet, führt der Job zu einer invalid-Meldung und schlägt fehl.
    • Wählen Sie unter Schreibeinstellung die Option An Tabelle anfügen oder Tabelle überschreiben aus.
    • Behalten Sie die Standardwerte für Partitionierungstyp, Partitionierungsfeld, Partitionsfilter anfordern und Clustering-Felder bei. Sie können eine Tabelle nicht durch Anfügen oder Überschreiben von Daten in eine partitionierte oder geclusterte Tabelle konvertieren. Außerdem unterstützt die Web-UI das Anfügen bzw. Überschreiben von Daten in partitionierten oder geclusterten Tabellen in einem Ladejob nicht.
    • Wählen Sie unter Destination encryption die Option Customer-managed encryption aus, um einen Cloud Key Management Service-Schlüssel zum Verschlüsseln der Tabelle zu verwenden. Wenn Sie die Einstellung Default übernehmen, verschlüsselt BigQuery inaktive Daten mit einem von Google verwalteten Schlüssel.
  7. Klicken Sie auf Tabelle erstellen.

bq

Verwenden Sie den Befehl bq load, geben Sie NEWLINE_DELIMITED_JSON mit dem Flag --source_format an und fügen Sie einen Cloud Storage-URI ein. Sie können einen einzelnen URI, eine durch Kommas getrennte Liste von URIs oder einen URI mit Platzhalter einfügen.

Geben Sie das Schema inline bzw. in einer Schemadefinitionsdatei an oder verwenden Sie die automatische Schemaerkennung.

Geben Sie das Flag --replace an, um die Tabelle zu überschreiben. Verwenden Sie das Flag --noreplace, um Daten an die Tabelle anzufügen. Wenn kein Flag angegeben ist, werden Daten standardmäßig angefügt.

Das Schema der Tabelle kann beim Anfügen oder Überschreiben von Daten geändert werden. Weitere Informationen zu unterstützten Schemaänderungen während eines Ladevorgangs finden Sie unter Tabellenschemas ändern.

Optional: Geben Sie das Flag --location an und legen Sie als Wert Ihren Standort fest.

Andere optionale Flags sind:

  • --max_bad_records: Eine Ganzzahl, die die Höchstzahl ungültiger Datensätze angibt, bevor der gesamte Job fehlschlägt. Der Standardwert ist 0. Es werden höchstens fünf Fehler pro Typ zurückgegeben, unabhängig vom Wert --max_bad_records.
  • --ignore_unknown_values: Wenn dieses Flag angegeben ist, werden zusätzliche, nicht erkannte Werte in CSV- oder JSON-Daten zugelassen und ignoriert.
  • --autodetect: Wenn dieses Flag angegeben ist, wird die automatische Schemaerkennung für CSV- und JSON-Daten aktiviert.
  • --destination_kms_key: Der Cloud KMS-Schlüssel für die Verschlüsselung der Tabellendaten.
bq --location=LOCATION load \
--[no]replace \
--source_format=FORMAT \
DATASET.TABLE \
PATH_TO_SOURCE \
SCHEMA

Dabei gilt:

  • LOCATION: Ihr Standort. Das Flag --location ist optional. Mit der Datei ".bigqueryrc" können Sie einen Standardwert für den Standort festlegen.
  • FORMAT: NEWLINE_DELIMITED_JSON.
  • DATASET: ein vorhandenes Dataset.
  • TABLE: der Name der Tabelle, in die Sie Daten laden.
  • PATH_TO_SOURCE: ein vollständig qualifizierter Cloud Storage-URI oder eine durch Kommas getrennte Liste von URIs. Platzhalter werden ebenfalls unterstützt.
  • SCHEMA: ein gültiges Schema. Das Schema kann als lokale JSON-Datei bereitgestellt oder als Bestandteil des Befehls inline eingegeben werden. Sie können statt der Schemadefinition auch das Flag --autodetect verwenden.

Beispiele:

Mit dem folgenden Befehl werden Daten aus gs://mybucket/mydata.json geladen und eine Tabelle namens mytable in mydataset wird überschrieben. Das Schema wird mithilfe der automatischen Schemaerkennung definiert.

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

Mit dem folgenden Befehl werden Daten aus gs://mybucket/mydata.json geladen und an eine Tabelle namens mytable in mydataset angefügt. Das Schema wird mithilfe der JSON-Schemadatei myschema.json definiert.

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

API

  1. Erstellen Sie einen load-Job, der auf die Quelldaten in Cloud Storage verweist.

  2. Optional: Geben Sie Ihren Standort im Attribut location im Abschnitt jobReference der Jobressource an.

  3. Das Attribut source URIs muss vollständig qualifiziert sein und das Format gs://BUCKET/OBJECT haben. Sie können mehrere URIs als durch Kommas getrennte Liste einfügen. Platzhalter werden ebenfalls unterstützt.

  4. Geben Sie das Datenformat an. Legen Sie dazu das Attribut configuration.load.sourceFormat auf NEWLINE_DELIMITED_JSON fest.

  5. Geben Sie die Schreibeinstellung an. Legen Sie dazu das Attribut configuration.load.writeDisposition auf WRITE_TRUNCATE oder WRITE_APPEND fest.

Go

Bevor Sie dieses Beispiel ausprobieren, folgen Sie den Schritten zur Einrichtung von Go in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Go API.

import (
	"context"
	"fmt"

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

// importJSONTruncate demonstrates loading data from newline-delimeted JSON data in Cloud Storage
// and overwriting/truncating data in the existing table.
func importJSONTruncate(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.json")
	gcsRef.SourceFormat = bigquery.JSON
	gcsRef.AutoDetect = true
	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
}

Node.js

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Node.js in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Node.js API.

// 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 JSON file at
 * https://storage.googleapis.com/cloud-samples-data/bigquery/us-states/us-states.json
 *
 * TODO(developer): Replace the following lines with the path to your file.
 */
const bucketName = 'cloud-samples-data';
const filename = 'bigquery/us-states/us-states.json';

async function loadJSONFromGCSTruncate() {
  /**
   * 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: 'NEWLINE_DELIMITED_JSON',
    schema: {
      fields: [
        {name: 'name', type: 'STRING'},
        {name: 'post_abbr', type: 'STRING'},
      ],
    },
    // Set the write disposition to overwrite existing table data.
    writeDisposition: 'WRITE_TRUNCATE',
  };

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

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von PHP in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery PHP API.

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.json';
$loadConfig = $table->loadFromStorage($gcsUri)->sourceFormat('NEWLINE_DELIMITED_JSON')->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

Wenn Sie Zeilen in einer vorhandenen Tabelle ersetzen möchten, legen Sie das Attribut LoadJobConfig.write_disposition auf den String WRITE_TRUNCATE fest.

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Python in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery Python API.

# from google.cloud import bigquery
# client = bigquery.Client()
# table_ref = client.dataset('my_dataset').table('existing_table')

job_config = bigquery.LoadJobConfig()
job_config.write_disposition = bigquery.WriteDisposition.WRITE_TRUNCATE
job_config.source_format = bigquery.SourceFormat.NEWLINE_DELIMITED_JSON
uri = "gs://cloud-samples-data/bigquery/us-states/us-states.json"
load_job = client.load_table_from_uri(
    uri, table_ref, job_config=job_config
)  # API request
print("Starting job {}".format(load_job.job_id))

load_job.result()  # Waits for table load to complete.
print("Job finished.")

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

Ruby

Wenn Sie Zeilen in einer vorhandenen Tabelle ersetzen möchten, setzen Sie den Parameter write von Table.load_job() auf "WRITE_TRUNCATE".

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Ruby in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery Ruby API.

require "google/cloud/bigquery"

def load_table_gcs_json_truncate(
    dataset_id = "your_dataset_id",
    table_id   = "your_table_id"
  )
  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id
  gcs_uri  = "gs://cloud-samples-data/bigquery/us-states/us-states.json"

  load_job = dataset.load_job table_id,
                              gcs_uri,
                              format: "json",
                              write:  "truncate"
  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

Mit Hive partitionierte JSON-Daten laden

BigQuery unterstützt das Laden von mit Hive partitionierten JSON-Daten, die in Cloud Storage gespeichert sind, und füllt die Hive-Partitionierungsspalten so aus, als wären Sie Spalten in der verwalteten BigQuery-Zieltabelle. Weitere Informationen finden Sie unter Extern partitionierte Daten laden.

JSON-Optionen

Wenn Sie ändern möchten, wie BigQuery JSON-Daten parst, geben Sie in der Konsole, der klassischen Benutzeroberfläche, der Befehlszeile, der API oder den Clientbibliotheken zusätzliche Optionen an.

JSON-Option Console-Option Option der klassischen UI Befehlszeilen-Flag BigQuery API-Attribut Beschreibung
Anzahl der zulässigen fehlerhaften Datensätze Anzahl zulässiger Fehler Anzahl der zulässigen Fehler --max_bad_records maxBadRecords (Optional) Die maximale Anzahl von fehlerhaften Datensätzen, die BigQuery beim Ausführen des Jobs ignorieren darf. Wenn die Anzahl fehlerhafter Datensätze diesen Wert überschreitet, wird im Jobergebnis ein Fehler wegen ungültiger Werte zurückgegeben. Der Standardwert ist 0. In diesem Fall müssen alle Datensätze gültig sein.
Unbekannte Werte Unbekannte Werte ignorieren Unbekannte Werte ignorieren --ignore_unknown_values ignoreUnknownValues (Optional) Gibt an, ob BigQuery zusätzliche Werte zulassen soll, die nicht im Tabellenschema enthalten sind. Wird diese Option auf "true" gesetzt, werden die zusätzlichen Werte ignoriert. Bei "false" werden Datensätze mit zusätzlichen Spalten wie fehlerhafte Datensätze behandelt. Wenn zu viele fehlerhafte Datensätze vorliegen, wird im Jobergebnis ein Fehler wegen ungültiger Werte zurückgegeben. Der Standardwert ist "false". Das Attribut "sourceFormat" legt fest, was BigQuery als zusätzlichen Wert behandelt: CSV: nachgestellte Spalten, JSON: benannte Werte, die keinem Spaltennamen entsprechen.