Diese Seite wurde von der Cloud Translation API übersetzt.

JSON-Daten aus Cloud Storage laden

Sie können durch Zeilenumbruch getrennte JSON-Daten (ndJSON) aus Cloud Storage in eine neue Tabelle oder Partition laden oder an eine vorhandene Tabelle oder Partition anfügen. Es ist außerdem möglich, eine Tabelle oder Partition zu überschreiben. Beim Laden von Daten in BigQuery werden die Daten in ein Spaltenformat für Capacitor (das 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 ndJSON-Format ist dasselbe wie das JSON Lines-Format.

Beschränkungen

Beim Laden von Daten aus einem Cloud Storage-Bucket in BigQuery gelten die folgenden Beschränkungen:

Wenn für den Speicherort Ihres Datasets ein anderer Wert als der multiregionale Wert US festgelegt ist, muss sich der Cloud Storage-Bucket in derselben Region befinden oder in derselben Multiregion enthalten sein wie das Dataset.
BigQuery übernimmt bei externen Datenquellen keine Garantie für die Datenkonsistenz. Werden die zugrunde liegenden Daten während der Ausführung der Abfrage geändert, kann dies zu einem unerwarteten Verhalten führen.
BigQuery unterstützt nicht die Cloud Storage-Objektversionierung. Wenn Sie dem Cloud Storage-URI eine Generierungsnummer hinzufügen, schlägt der Ladejob fehl.

Beachten Sie beim Laden von JSON-Dateien in BigQuery Folgendes:

JSON-Daten müssen durch Zeilenumbruch voneinander getrennt sein (ndJSON). 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.
Die maximale Größe für eine GZIP-Datei beträgt 4 GB.
BigQuery unterstützt den Typ JSON auch dann, wenn Schemainformationen zum Zeitpunkt der Aufnahme nicht bekannt sind. Ein Feld, das als JSON-Typ deklariert ist, wird mit den JSON-Rohwerten geladen.
Wenn Sie die BigQuery API verwenden, um eine Ganzzahl außerhalb des Bereichs von [-2⁵³+1, 2⁵³-1] (normalerweise bedeutet dies größer als 9.007.199.254.740.991) in eine Ganzzahlspalte (INT64) zu laden, übergeben Sie sie als String, damit keine Daten beschädigt werden. Dieses Problem wird durch eine Beschränkung der Ganzzahlgröße in JSON oder ECMAScript verursacht. Weitere Informationen finden Sie im Bereich "Numbers" von RFC 7159.
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 im Datumsabschnitt des Zeitstempels der Bindestrich (-) oder der Schrägstrich (/) als Trennzeichen verwendet werden und das Datum muss eines der folgenden Formate haben: YYYY-MM-DD (Jahr-Monat-Tag) oder YYYY/MM/DD (Jahr/Monat/Tag). Im hh:mm:ss-Abschnitt (Stunde-Minute-Sekunde) des Zeitstempels muss als Trennzeichen ein Doppelpunkt (:) verwendet werden.
Ihre Dateien müssen die in den Limits für Ladejobs beschriebenen Limits für die Größe von JSON-Dateien einhalten.

Hinweis

Erteilen Sie IAM-Rollen (Identity and Access Management), über die Nutzer die erforderlichen Berechtigungen zum Ausführen der einzelnen Aufgaben in diesem Dokument erhalten, und erstellen Sie ein Dataset zum Speichern Ihrer Daten.

Erforderliche Berechtigungen

Zum Laden von Daten in BigQuery benötigen Sie IAM-Berechtigungen, um einen Ladejob auszuführen und Daten in BigQuery-Tabellen und -Partitionen zu laden. Zum Laden von Daten aus Cloud Storage sind außerdem IAM-Berechtigungen für den Zugriff auf den Bucket erforderlich, der Ihre Daten enthält.

Berechtigungen zum Laden von Daten in BigQuery

Wenn Sie Daten in eine neue BigQuery-Tabelle oder -Partition laden oder eine vorhandene Tabelle oder Partition anfügen oder überschreiben möchten, benötigen Sie die folgenden IAM-Berechtigungen:

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

Die folgenden vordefinierten IAM-Rollen enthalten jeweils die Berechtigungen, die zum Laden von Daten in eine BigQuery-Tabelle oder -Partition erforderlich sind:

roles/bigquery.dataEditor
roles/bigquery.dataOwner
roles/bigquery.admin (einschließlich der Berechtigung bigquery.jobs.create)
bigquery.user (einschließlich der Berechtigung bigquery.jobs.create)
bigquery.jobUser (einschließlich der Berechtigung bigquery.jobs.create)

Wenn Sie die Berechtigung bigquery.datasets.create haben, können Sie außerdem mit einem Ladejob Tabellen in den von Ihnen erstellten Datasets anlegen und aktualisieren.

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

Berechtigungen zum Laden von Daten aus Cloud Storage

Um die Berechtigungen zu erhalten, die Sie zum Laden von Daten aus einem Cloud Storage-Bucket benötigen, bitten Sie Ihren Administrator, Ihnen die IAM-Rolle Storage Admin (roles/storage.admin) für den Bucket zu erteilen. Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Diese vordefinierte Rolle enthält die Berechtigungen, die zum Laden von Daten aus einem Cloud Storage-Bucket erforderlich sind. Erweitern Sie den Abschnitt Erforderliche Berechtigungen, um die erforderlichen Berechtigungen anzuzeigen:

Erforderliche Berechtigungen

Die folgenden Berechtigungen sind erforderlich, um Daten aus einem Cloud Storage-Bucket zu laden:

storage.buckets.get
storage.objects.get
storage.objects.list (required if you are using a URI wildcard)

Sie können diese Berechtigungen auch mit benutzerdefinierten Rollen oder anderen vordefinierten Rollen erhalten.

Dataset erstellen

Erstellen Sie ein BigQuery-Dataset zum Speichern Ihrer Daten.

JSON-Komprimierung

Mit dem Dienstprogramm gzip können Sie JSON-Dateien komprimieren. Beachten Sie, dass gzip eine vollständige Dateikomprimierung durchführt, im Gegensatz zur Komprimierung von Dateiinhalten, die von Komprimierungscodecs für andere Dateiformate wie Avro durchgeführt wird. Die Verwendung von gzip zur Komprimierung Ihrer JSON-Dateien kann sich auf die Leistung auswirken; Weitere Informationen zu den Vor- und Nachteilen finden Sie unter Komprimierte und unkomprimierte Daten laden.

JSON-Daten in neue Tabelle laden

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

Console

Öffnen Sie in der Google Cloud Console die Seite BigQuery.

BigQuery aufrufen
Maximieren Sie im Bereich Explorer Ihr Projekt und wählen Sie dann ein Dataset aus.
Klicken Sie im Abschnitt Dataset-Informationen auf Tabelle erstellen.
Geben Sie im Bereich Tabelle erstellen die folgenden Details an:

Wählen Sie im Abschnitt Quelle in der Liste Tabelle erstellen aus die Option Google Cloud Storage aus. Führen Sie anschließend folgende Schritte aus:
1. Wählen Sie eine Datei aus dem Cloud Storage-Bucket aus oder geben Sie den Cloud Storage-URI ein. In der Google 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 Tabelle enthält, die Sie erstellen, anhängen oder überschreiben möchten.
2. Wählen Sie für Dateiformat den Eintrag JSONL (durch Zeilenumbruch getrenntes JSON) aus.
Geben Sie im Bereich Ziel die folgenden Details an:
1. Wählen Sie bei Dataset das Dataset aus, in dem Sie die Tabelle erstellen möchten.
2. Geben Sie im Feld Tabelle den Namen der Tabelle ein, die Sie erstellen möchten.
3. Achten Sie darauf, dass das Feld Tabellentyp auf Native Tabelle eingestellt ist.
Geben Sie im Abschnitt Schema die Schemadefinition ein. Wählen Sie Automatisch erkennen aus, um die automatische Erkennung eines Schemas zu aktivieren. Sie können Schemainformationen manuell mit einer der folgenden Methoden eingeben:
- Option 1: Klicken Sie auf Als Text bearbeiten und fügen Sie das Schema in Form eines JSON-Arrays ein. Generieren Sie das Schema mit demselben Verfahren wie beim Erstellen einer JSON-Schemadatei, wenn Sie ein JSON-Array verwenden. Sie können das Schema einer vorhandenen Tabelle im JSON-Format ansehen. Geben Sie dafür folgenden Befehl ein:
```
    bq show --format=prettyjson dataset.table
    
```
- Option 2: Klicken Sie auf Feld hinzufügen und geben Sie das Tabellenschema ein. Geben Sie für jedes Feld Name, Typ und Modus an.
Optional: Geben Sie Partitions- und Clustereinstellungen an. Weitere Informationen finden Sie unter Partitionierte Tabellen erstellen und Geclusterte Tabellen erstellen und verwenden.
Klicken Sie auf Erweiterte Optionen und gehen Sie so vor:
- Lassen Sie unter Write preference (Schreibeinstellung) die Option Write if empty (Schreiben, wenn leer) ausgewählt. Mit dieser Option wird eine neue Tabelle erstellt und Ihre Daten werden in diese Tabelle geladen.
- Übernehmen Sie für Anzahl zulässiger Fehler den Standardwert 0 oder geben Sie die maximale Anzahl von Zeilen mit Fehlern an, die 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. Diese Option gilt nur für CSV- und JSON-Dateien.
- Wenn Sie Werte in einer Zeile ignorieren möchten, die im Schema der Tabelle nicht vorhanden sind, wählen Sie Unbekannte Werte aus.
- 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.
Klicken Sie auf Tabelle erstellen.

SQL

Verwenden Sie die DDL-Anweisung LOAD DATA. Im folgenden Beispiel wird eine JSON-Datei in die neue Tabelle mytable geladen:

Öffnen Sie in der Google Cloud Console die Seite BigQuery.

BigQuery aufrufen

Geben Sie im Abfrageeditor die folgende Anweisung ein:

LOAD DATA OVERWRITE mydataset.mytable
(x INT64,y STRING)
FROM FILES (
  format = 'JSON',
  uris = ['gs://bucket/path/file.json']);

Klicken Sie auf Ausführen.

Informationen zum Ausführen von Abfragen finden Sie unter Interaktive Abfrage ausführen.

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.
--time_partitioning_type: Aktiviert die zeitbasierte Partitionierung für eine Tabelle und legt den Partitionstyp fest. Mögliche Werte sind HOUR, DAY, MONTH und YEAR. Dieses Flag ist optional, wenn Sie eine Tabelle erstellen, die nach einer DATE-, DATETIME- oder TIMESTAMP-Spalte partitioniert wird. Der Standardpartitionstyp für die zeitbasierte Partitionierung ist DAY. Sie können die Partitionierungsspezifikation für eine vorhandene Tabelle nicht ändern.
--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 Partitionsfilter in Abfragen anfordern.
--clustering_fields: Eine durch Kommas getrennte Liste mit bis zu vier Spaltennamen zum Erstellen einer geclusterten Tabelle.
--destination_kms_key: Der Cloud KMS-Schlüssel für die Verschlüsselung der Tabellendaten.

Weitere Informationen zu partitionierten Tabellen finden Sie unter:
- Partitionierte Tabellen erstellen
Weitere Informationen zu geclusterten Tabellen finden Sie unter:
- Geclusterte Tabellen erstellen und verwenden
Weitere Informationen zur Tabellenverschlüsselung finden Sie unter:
- Daten mit Cloud KMS-Schlüsseln schützen

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. Wenn Sie eine Schemadatei verwenden, fügen Sie keine Erweiterung hinzu. 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 definiert:

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

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

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

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

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

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

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

API

Erstellen Sie einen load-Job, der auf die Quelldaten in Cloud Storage verweist.
Optional: Geben Sie Ihren Standort im Attribut location im Abschnitt jobReference der Jobressource an.
Das Attribut source URIs muss vollständig qualifiziert sein und das Format gs://BUCKET/OBJECT haben. Jeder URI kann ein Platzhalterzeichen (*) enthalten.
Geben Sie das JSON-Datenformat an. Legen Sie dazu das Attribut sourceFormat auf NEWLINE_DELIMITED_JSON fest.
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 für den zurückgegebenen Job 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. Sie können den Aufruf für eine bestimmte Job-ID beliebig oft wiederholen und höchstens einer dieser Vorgänge wird erfolgreich sein.

C#

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der C#-Einrichtungsanleitung in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery C# API.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

Verwenden Sie die Methode BigQueryClient.CreateLoadJob(), um einen Ladejob über Cloud Storage zu starten. Wenn Sie JSONL 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 = loadJob.PollUntilCompleted().ThrowOnAnyError();  // 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 anwenden, folgen Sie den Schritten zur Einrichtung von Go in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Go API.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

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 zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Java API.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

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.

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

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

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

  public static void loadJsonFromGCS(
      String datasetName, String tableName, String sourceUri, Schema schema) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

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

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

Node.js

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

// 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 zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery PHP API.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

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 zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Python API.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

Verwenden Sie die Methode Client.load_table_from_uri(), um einen Ladejob für Cloud Storage zu starten. Wenn Sie JSONL 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

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

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

job_config = bigquery.LoadJobConfig(
    schema=[
        bigquery.SchemaField("name", "STRING"),
        bigquery.SchemaField("post_abbr", "STRING"),
    ],
    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_id,
    location="US",  # Must match the destination dataset location.
    job_config=job_config,
)  # Make an API request.

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

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

Ruby

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

Verwenden Sie die Methode Dataset.load_job(), um einen Ladejob über Cloud Storage zu starten. Wenn Sie JSONL 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 einschließlich verschachtelter oder wiederholter Felder angezeigt werden.

Im folgenden Beispiel sind verschachtelte oder wiederkehrende Daten zu sehen. 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.

Halbstrukturierte JSON-Daten laden

BigQuery unterstützt das Laden semistrukturierter Daten, bei denen ein Feld Werte verschiedener Typen annehmen kann. Das folgende Beispiel zeigt Daten ähnlich wie das vorherige Beispiel für verschachtelte und wiederkehrende JSON-Daten, mit der Ausnahme, dass das Feld address ein STRING, ein STRUCT oder ARRAY sein kann:

{"id":"1","first_name":"John","last_name":"Doe","dob":"1968-01-22","address":"123 First Avenue, Seattle WA 11111"}

{"id":"2","first_name":"Jane","last_name":"Doe","dob":"1980-10-16","address":{"status":"current","address":"789 Any Avenue","city":"New York","state":"NY","zip":"33333","numberOfYears":"2"}}

{"id":"3","first_name":"Bob","last_name":"Doe","dob":"1982-01-10","address":[{"status":"current","address":"789 Any Avenue","city":"New York","state":"NY","zip":"33333","numberOfYears":"2"}, "321 Main Street Hoboken NJ 44444"]}

Sie können diese Daten mit dem folgenden Schema in BigQuery laden:

[
    {
        "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": "address",
        "type": "JSON",
        "mode": "NULLABLE"
    }
]

Das Feld address wird in eine Spalte mit dem Typ JSON geladen, sodass die gemischten Typen im Beispiel enthalten sein können. Sie können Daten als JSON aufnehmen, unabhängig davon, ob es gemischte Typen enthält oder nicht. Sie können beispielsweise JSON anstelle von STRING als Typ für das Feld first_name angeben. Weitere Informationen finden Sie unter Mit JSON-Daten in GoogleSQL arbeiten.

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 Google Cloud Console können Sie mit der Option 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	bq-Tool-Flag	BigQuery API-Attribut	Beschreibung
Schreiben, wenn leer	Nicht unterstützt	`WRITE_EMPTY`	Daten werden nur geschrieben, wenn die Tabelle leer ist.
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	`--replace` oder `--replace=true`	`WRITE_TRUNCATE`	Alle vorhandenen Daten in einer Tabelle werden gelöscht, bevor die neuen Daten geschrieben werden. Mit dieser Aktion werden auch das Tabellenschema und die Sicherheit auf Zeilenebene gelöscht und alle Cloud KMS-Schlüssel entfernt.

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:

Die Google Cloud Console
Der Befehl bq load des bq-Befehlszeilentools
Durch Aufrufen der API-Methode jobs.insert und Konfigurieren eines load-Jobs
Mit den Clientbibliotheken

Console

Öffnen Sie in der Google Cloud Console die Seite BigQuery.

BigQuery aufrufen
Maximieren Sie im Bereich Explorer Ihr Projekt und wählen Sie dann ein Dataset aus.
Klicken Sie im Abschnitt Dataset-Informationen auf Tabelle erstellen.
Geben Sie im Bereich Tabelle erstellen die folgenden Details an:

Wählen Sie im Abschnitt Quelle in der Liste Tabelle erstellen aus die Option Google Cloud Storage aus. Führen Sie anschließend folgende Schritte aus:
1. Wählen Sie eine Datei aus dem Cloud Storage-Bucket aus oder geben Sie den Cloud Storage-URI ein. In der Google 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 Tabelle enthält, die Sie erstellen, anhängen oder überschreiben möchten.
2. Wählen Sie für Dateiformat den Eintrag JSONL (durch Zeilenumbruch getrenntes JSON) aus.

Geben Sie im Bereich Ziel die folgenden Details an:
1. Wählen Sie bei Dataset das Dataset aus, in dem Sie die Tabelle erstellen möchten.
2. Geben Sie im Feld Tabelle den Namen der Tabelle ein, die Sie erstellen möchten.
3. Achten Sie darauf, dass das Feld Tabellentyp auf Native Tabelle eingestellt ist.
Geben Sie im Abschnitt Schema die Schemadefinition ein. Wählen Sie Automatisch erkennen aus, um die automatische Erkennung eines Schemas zu aktivieren. Sie können Schemainformationen manuell mit einer der folgenden Methoden eingeben:
- Option 1: Klicken Sie auf Als Text bearbeiten und fügen Sie das Schema in Form eines JSON-Arrays ein. Generieren Sie das Schema mit demselben Verfahren wie beim Erstellen einer JSON-Schemadatei, wenn Sie ein JSON-Array verwenden. Sie können das Schema einer vorhandenen Tabelle im JSON-Format ansehen. Geben Sie dafür folgenden Befehl ein:
```
    bq show --format=prettyjson dataset.table
    
```
- Option 2: Klicken Sie auf Feld hinzufügen und geben Sie das Tabellenschema ein. Geben Sie für jedes Feld Name, Typ und Modus an.
Optional: Geben Sie Partitions- und Clustereinstellungen an. Weitere Informationen finden Sie unter Partitionierte Tabellen erstellen und Geclusterte Tabellen erstellen und verwenden. Sie können eine Tabelle nicht durch Anfügen oder Überschreiben von Daten in eine partitionierte oder geclusterte Tabelle konvertieren. Die Google Cloud Console unterstützt nicht das Anfügen oder Überschreiben von Daten in partitionierten oder geclusterten Tabellen in einem Ladejob.
Klicken Sie auf Erweiterte Optionen und gehen Sie so vor:
- Wählen Sie unter Schreibeinstellung die Option An Tabelle anfügen oder Tabelle überschreiben aus.
- Übernehmen Sie für Anzahl zulässiger Fehler den Standardwert 0 oder geben Sie die maximale Anzahl von Zeilen mit Fehlern an, die 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. Diese Option gilt nur für CSV- und JSON-Dateien.
- Wenn Sie Werte in einer Zeile ignorieren möchten, die im Schema der Tabelle nicht vorhanden sind, wählen Sie Unbekannte Werte aus.
- 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.
Klicken Sie auf Tabelle erstellen.

SQL

Verwenden Sie die DDL-Anweisung LOAD DATA. Im folgenden Beispiel wird eine JSON-Datei an die Tabelle mytable angehängt:

Öffnen Sie in der Google Cloud Console die Seite BigQuery.

BigQuery aufrufen

Geben Sie im Abfrageeditor die folgende Anweisung ein:

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

Klicken Sie auf Ausführen.

Informationen zum Ausführen von Abfragen finden Sie unter Interaktive Abfrage ausführen.

bq

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:

Der folgende Befehl lädt Daten aus gs://mybucket/mydata.json und überschreibt eine Tabelle namens mytable in mydataset. 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 definiert.

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

API

Erstellen Sie einen load-Job, der auf die Quelldaten in Cloud Storage verweist.
Optional: Geben Sie Ihren Standort im Attribut location im Abschnitt jobReference der Jobressource an.
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. Die Platzhalter werden ebenfalls unterstützt.
Geben Sie das Datenformat an. Legen Sie dazu das Attribut configuration.load.sourceFormat auf NEWLINE_DELIMITED_JSON fest.
Geben Sie die Schreibeinstellung an. Legen Sie dazu das Attribut configuration.load.writeDisposition auf WRITE_TRUNCATE oder WRITE_APPEND fest.

Go

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

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
}

Java

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

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

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

  public static void loadJsonFromGCSTruncate(
      String datasetName, String tableName, String sourceUri, Schema schema) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      TableId tableId = TableId.of(datasetName, tableName);
      LoadJobConfiguration loadConfig =
          LoadJobConfiguration.newBuilder(tableId, sourceUri)
              .setFormatOptions(FormatOptions.json())
              // Set the write disposition to overwrite existing table data
              .setWriteDisposition(JobInfo.WriteDisposition.WRITE_TRUNCATE)
              .setSchema(schema)
              .build();

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

Node.js

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

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 ausprobieren, folgen Sie der Python-Einrichtungsanleitung in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Python API.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

import io

from google.cloud import bigquery

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

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

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

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

job_config = bigquery.LoadJobConfig(
    write_disposition=bigquery.WriteDisposition.WRITE_TRUNCATE,
    source_format=bigquery.SourceFormat.NEWLINE_DELIMITED_JSON,
)

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

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

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

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 ausprobieren, folgen Sie der Ruby-Einrichtungsanleitung in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Ruby API.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

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.

Details zum Laden von JSON-Daten

In diesem Abschnitt wird beschrieben, wie BigQuery verschiedene Datentypen beim Laden von JSON-Daten parst.

Datentypen

Boolean. BigQuery kann eines der folgenden Paare für boolesche Daten parsen: 1 oder 0, true oder false, t oder f, yes oder no oder y oder n (Groß-/Kleinschreibung wird nicht berücksichtigt). Die automatische Schemaerkennung erkennt alle Werte außer 0 und 1 automatisch.

Byte Spalten mit BYTES-Typen müssen als Base64 codiert sein.

Date. Spalten mit DATE-Typen müssen das Format YYYY-MM-DD haben.

Datetime. Spalten mit DATETIME-Typen müssen das Format YYYY-MM-DD HH:MM:SS[.SSSSSS] haben.

Geografie: Spalten mit GEOGRAFIE-Typen müssen Strings in einem der folgenden Formate enthalten:

Well-known Text (WKT)
Well-known Binary (WKB)
GeoJSON

Wenn Sie WKB verwenden, sollte der Wert hex-codiert sein.

Die folgende Liste enthält Beispiele für gültige Daten:

WKT: POINT(1 2)
GeoJSON: { "type": "Point", "coordinates": [1, 2] }
Hex-codiertes WKB: 0101000000feffffffffffef3f0000000000000040

Lesen Sie vor dem Laden von Geografie-Daten auch den Abschnitt Raumbezogene Daten laden.

Intervall. Spalten mit INTERVALL-Typen müssen das ISO 8601-Format PYMDTHMS haben, wobei:

P = Bezeichner, der angibt, dass der Wert eine Dauer darstellt. Dieser muss immer angegeben werden.
Y = Jahr
M = Monat
D = Tag
T = Bezeichner, der den Zeitabschnitt der Dauer angibt. Dieser muss immer angegeben werden.
H = Stunde
M = Minute
S = Sekunde. Sekunden können als ganzer Wert oder als Bruchwert mit bis zu sechs Stellen mit Mikrosekundenpräzision angegeben werden.

Um einen negativen Wert anzugeben, stellen Sie dem Wert einen Bindestrich (-) voran.

Die folgende Liste enthält Beispiele für gültige Daten:

P-10000Y0M-3660000DT-87840000H0M0S
P0Y0M0DT0H0M0.000001S
P10000Y0M3660000DT87840000H0M0S

Zum Laden von INTERVALL-Daten müssen Sie den Befehl bq load verwenden und das Flag --schema verwenden, um ein Schema anzugeben. Sie können INTERVALL-Daten nicht über die Console hochladen.

Zeit: Spalten mit TIME-Typen müssen das Format HH:MM:SS[.SSSSSS] haben.

Timestamp. BigQuery akzeptiert verschiedene Zeitstempelformate. Der Zeitstempel muss einen Datumsteil und einen Zeitteil enthalten.

Der Datumsteil kann das Format YYYY-MM-DD oder YYYY/MM/DD haben.
Der Zeitstempelteil muss als HH:MM[:SS[.SSSSSS]] formatiert sein. Sekunden und Sekundenbruchteile sind dabei optional.
Datum und Uhrzeit müssen durch ein Leerzeichen oder ein "T" getrennt sein.
Optional kann dem Datum und der Uhrzeit ein UTC-Versatz oder der UTC-Zonenbezeichner (Z) folgen. Weitere Informationen finden Sie unter Zeitzonen.

Alle folgenden Zeitstempelwerte sind zulässig:

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

Wenn Sie ein Schema angeben, akzeptiert BigQuery als Zeitstempelwerte auch die Zeit der Unix-Epoche. Die automatische Schemaerkennung erkennt diesen Fall jedoch nicht und behandelt den Wert stattdessen als numerischen Typ oder als Stringtyp.

Beispiele für Zeitstempelwerte der Unix-Epoche:

1534680695
1.534680695e11

Array (wiederholtes Feld). Der Wert muss ein JSON-Array oder null sein. JSON null wird in SQL NULL konvertiert. Das Array selbst darf keine null-Werte enthalten.

Automatische Schemaerkennung

In diesem Abschnitt wird das Verhalten der automatischen Schemaerkennung beim Laden von JSON-Dateien beschrieben.

Verschachtelte und wiederkehrende Felder in JSON

BigQuery leitet verschachtelte und wiederkehrende Felder in JSON-Dateien ab. Wenn ein Feldwert ein JSON-Objekt ist, lädt BigQuery die Spalte als RECORD-Typ. Wenn ein Feldwert ein Array ist, lädt BigQuery die Spalte als wiederkehrende Spalte. Ein Beispiel für JSON-Daten mit verschachtelten und wiederkehrenden Daten finden Sie unter Verschachtelte und wiederkehrende JSON-Daten laden.

Stringkonvertierung

Wenn Sie die automatische Schemaerkennung aktivieren, wandelt BigQuery Strings nach Möglichkeit in boolesche, numerische oder Datums-/Uhrzeittypen um. Bei der Verwendung der folgenden JSON-Daten wandelt die automatische Schemaerkennung das Feld id beispielsweise in eine Spalte vom Typ INTEGER um:

{ "name":"Alice","id":"12"}
{ "name":"Bob","id":"34"}
{ "name":"Charles","id":"45"}

Codierungstypen

BigQuery geht davon aus, dass JSON-Daten UTF-8-codiert sind. Wenn Sie JSON-Dateien mit anderen unterstützten Codierungstypen haben, sollten Sie die Codierung explizit über das --encoding-Flag angeben, damit BigQuery die Daten in UTF-8 konvertiert.

BigQuery unterstützt folgende Codierungstypen für JSON-Dateien:

UTF-8
ISO-8859-1
UTF-16BE (UTF-16 Big Endian)
UTF-16LE (UTF-16 Little Endian)
UTF-32BE (UTF-32 Big Endian)
UTF-32LE (UTF-32 Little Endian)

JSON-Optionen

Wenn Sie ändern möchten, wie BigQuery JSON-Daten parst, geben Sie in der Google Cloud Console, dem bq-Befehlszeilentool, der API oder den Clientbibliotheken zusätzliche Optionen an.

JSON-Option	Console-Option	bq-Tool-Flag	BigQuery API-Attribut	Beschreibung
Anzahl der zulässigen fehlerhaften Datensätze	Anzahl zulässiger Fehler	`--max_bad_records`	`maxBadRecords` (Java, Python)	(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	`--ignore_unknown_values`	`ignoreUnknownValues` (Java, Python)	(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.
Codierung	Keine	`-E` oder `--encoding`	`encoding` (Python)	(Optional) Die Zeichencodierung der Daten. Die unterstützten Werte sind UTF-8, ISO-8859-1, UTF-16BE, UTF-16LE, UTF-32BE oder UTF-32LE. Der Standardwert ist UTF-8.

Nächste Schritte

Informationen zum Laden von JSON-Daten aus einer lokalen Datei finden Sie unter Daten aus lokalen Dateien laden.
Weitere Informationen zum Erstellen, Aufnehmen und Abfragen von JSON-Daten finden Sie unter Mit JSON-Daten in GoogleSQL arbeiten.