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 lokalen Dateien 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 die BigQuery API verwenden, um eine Ganzzahl außerhalb des Bereichs von [-2⁵³+1, 2⁵³-1] (in den meisten Fällen bedeutet dies größer als 9.007.199.254.740.991), in eine Ganzzahlspalte (INT64) zu laden, müssen Sie diese als String übergeben, damit keine Daten beschädigt werden. Dieses Problem wird durch eine Beschränkung der Ganzzahlgröße im JSON/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 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 sind außerdem Berechtigungen für den Zugriff auf den Bucket erforderlich, der Ihre Daten enthält.

BigQuery-Berechtigungen

Die folgenden Berechtigungen sind mindestens erforderlich, um Daten in BigQuery zu laden. Sie 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

Die folgenden vordefinierten IAM-Rollen enthalten die Berechtigungen bigquery.tables.create und bigquery.tables.updateData:

bigquery.dataEditor
bigquery.dataOwner
bigquery.admin

Die folgenden vordefinierten IAM-Rollen enthalten Berechtigungen vom Typ 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 kann der Nutzer Tabellen im Dataset über einen Ladejob erstellen und aktualisieren.

Weitere Informationen zu 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 IAM-Rolle storage.objectViewer kann erteilt werden, um die Berechtigungen 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:

Cloud Console
Mit dem Befehl bq des bq load-Befehlszeilentools
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

Öffnen Sie in der Cloud Console die Seite „BigQuery“.

Zur Seite "BigQuery"
Maximieren Sie im Navigationsbereich im Abschnitt Ressourcen Ihr Google Cloud-Projekt und wählen Sie ein Dataset aus.
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.
Gehen Sie auf der Seite Tabelle erstellen im Abschnitt Quelle so vor:
- Wählen Sie unter Create table from (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 direkt 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.
- Wählen Sie für Dateiformat den Eintrag JSON (durch Zeilenumbruch getrennt) aus.
Gehen Sie auf der Seite Tabelle erstellen im Abschnitt Ziel folgendermaßen vor:
- Wählen Sie für Dataset-Name das entsprechende Dataset aus.
- Achten Sie darauf, dass der Tabellentyp auf Native Tabelle eingestellt ist.
- Geben Sie im Feld Table name (Tabellenname) den Namen der Tabelle ein, die Sie in BigQuery erstellen.
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.
  
  Hinweis: Sie können das Schema einer vorhandenen Tabelle im JSON-Format ansehen. Geben Sie dafür folgenden Befehl im bq-Befehlszeilentool ein: bq show --format=prettyjson dataset.table.
- Geben Sie das Schema mit Feld hinzufügen manuell ein.
(Optional) Wählen Sie zum Partitionieren der Tabelle die jeweiligen Optionen unter Partition and cluster settings (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.
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.
Optional: Wenn Sie die Tabelle clustern möchten, geben Sie im Feld Clustering-Reihenfolge einen bis vier Feldnamen ein.
(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.
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.
--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 und verwenden
- Nach Aufnahmezeit partitionierte Tabellen erstellen und verwenden
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. 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

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 für das Attribut sourceFormat den Wert 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 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.

Auf GitHub ansehen Feedback


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.

Auf GitHub ansehen Feedback

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.

Auf GitHub ansehen

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: Clientbibliotheken verwenden. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Node.js API.

Auf GitHub ansehen Feedback

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

Auf GitHub ansehen Feedback

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

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

Auf GitHub ansehen Feedback

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

Auf GitHub ansehen Feedback

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 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	–	`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 wird auch das Tabellenschema gelöscht und alle Cloud KMS-Schlüssel werden 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:

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

Console

Öffnen Sie in der Cloud Console die Seite „BigQuery“.

Zur Seite "BigQuery"
Maximieren Sie im Navigationsbereich im Abschnitt Ressourcen Ihr Cloud-Projekt und wählen Sie ein Dataset aus.
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.
Gehen Sie auf der Seite Tabelle erstellen im Abschnitt Quelle so vor:
- Wählen Sie unter Create table from (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 befinden wie das Dataset, das die Tabelle enthält, in der Sie Daten anfügen oder überschreiben.
- Wählen Sie für Dateiformat den Eintrag JSON (durch Zeilenumbruch getrennt) aus.
Gehen Sie auf der Seite Tabelle erstellen im Abschnitt Ziel folgendermaßen vor:
- Wählen Sie für Dataset-Name das entsprechende Dataset aus.
- Geben Sie im Feld Tabellenname den Namen der Tabelle ein, in der Daten in BigQuery angefügt oder überschrieben werden.
- Achten Sie darauf, dass Table type (Tabellentyp) auf Native table (Native Tabelle) eingestellt ist.
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.
  
  Hinweis: 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.
- Geben Sie das Schema mit Feld hinzufügen manuell ein.
Hinweis: Das Schema der Tabelle kann beim Anfügen oder Überschreiben geändert werden. Weitere Informationen zu unterstützten Schemaänderungen während eines Ladevorgangs finden Sie unter Tabellenschemas ändern.
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.
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.
Klicken Sie auf Tabelle erstellen.

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

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

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

Auf GitHub ansehen Feedback

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

Auf GitHub ansehen

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

Auf GitHub ansehen Feedback

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

Auf GitHub ansehen Feedback

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.

Auf GitHub ansehen Feedback

import six

from google.cloud import bigquery

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

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

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

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

job_config = bigquery.LoadJobConfig(
    write_disposition=bigquery.WriteDisposition.WRITE_TRUNCATE,
    source_format=bigquery.SourceFormat.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".

Auf GitHub ansehen Feedback

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.

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.

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.

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

Timestamp. BigQuery akzeptiert eine Vielzahl von Zeitstempelformaten. 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 Stringtyp.

Beispiele für Zeitstempelwerte der Unix-Epoche:

1534680695
1.534680695e11

JSON-Optionen

Wenn Sie ändern möchten, wie BigQuery JSON-Daten parst, geben Sie in der 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`	(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`	(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.