Parquet-Daten aus Cloud Storage laden

Diese Seite bietet einen Überblick über das Laden von Parquet-Daten aus Cloud Storage in BigQuery.

Parquet ist ein spaltenorientiertes Open-Source-Datenformat, das häufig in Verbindung mit Apache Hadoop genutzt wird.

Sie können aus Cloud Storage geladene Parquet-Daten in eine neue Tabelle oder Partition laden bzw. 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 diese in ein Spaltenformat für Capacitor (BigQuery-Speicherformat) umgewandelt.

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.

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

Parquet-Schemas

Wenn Sie Parquet-Dateien in BigQuery laden, wird das Tabellenschema automatisch aus den selbstbeschreibenden Quelldaten abgeleitet. Wenn BigQuery das Schema aus den Quelldaten ableitet, wird die alphabetisch letzte Datei verwendet.

In Cloud Storage gibt es z. B. die folgenden Parquet-Dateien:

gs://mybucket/00/
  a.parquet
  z.parquet
gs://mybucket/01/
  b.parquet

Mit dem folgenden Befehl werden alle diese Dateien geladen. Sie sind in der Befehlszeile als durch Kommas getrennte Liste angegeben und das Schema wird von mybucket/01/b.parquet abgeleitet:

bq load \
--source_format=PARQUET \
dataset.table \
"gs://mybucket/00/*.parquet","gs://mybucket/01/*.parquet"

Wenn Sie mehrere Parquet-Dateien mit unterschiedlichen Schemas laden, müssen identische Spalten, die in mehreren Schemas angegeben sind, in jeder Schemadefinition denselben Modus haben.

Wenn das Schema in BigQuery erkannt wird, werden bestimmte Parquet-Datentypen zu BigQuery-Datentypen konvertiert, damit sie mit der BigQuery-SQL-Syntax kompatibel sind. Weitere Informationen finden Sie unter Parquet-Konvertierungen.

Parquet-Komprimierung

BigQuery unterstützt die folgenden Komprimierungscodecs für Datenblöcke in Parquet-Dateien:

  • Snappy
  • GZip
  • LZO_1C and LZO_1X

Erforderliche Berechtigungen

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

BigQuery-Berechtigungen

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

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

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

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

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

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

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

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

Cloud Storage-Berechtigungen

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

Mit der vordefinierten Cloud IAM-Rolle storage.objectViewer können die Berechtigungen storage.objects.get und storage.objects.list gewährt werden.

Parquet-Daten in eine neue Tabelle laden

Es gibt verschiedene Methoden, mit denen Sie Parquet-Daten in eine neue Tabelle laden können:

  • Mit der Cloud Console oder der klassischen Web-UI
  • Über die Befehlszeile mit dem Befehl bq load
  • Durch Aufrufen der API-Methode jobs.insert und Konfigurieren eines load-Jobs
  • Mit den Clientbibliotheken

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

Console

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

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

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

    Tabelle erstellen

  4. Gehen Sie auf der Seite Tabelle erstellen im Bereich Quelle wie folgt vor:

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

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

      Datei auswählen

    • Wählen Sie als Dateiformat die Option Parquet aus.

  5. Gehen Sie auf der Seite Tabelle erstellen im Abschnitt Ziel so vor:

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

      Dataset aufrufen

    • Achten Sie darauf, dass Table Type (Tabellentyp) auf Native table (Native Tabelle) eingestellt ist.

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

  6. Im Abschnitt Schema muss nichts unternommen werden. Das Schema ist in Parquet-Dateien selbstbeschreibend.

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

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

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

  10. (Optional) Klicken Sie auf Erweiterte Optionen.

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

Klassische UI

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

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

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

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

    • Wählen Sie für Tabellenname das entsprechende Dataset aus und geben Sie im Namensfeld für die Tabelle den Namen der Tabelle ein, die Sie in BigQuery erstellen.
    • Achten Sie darauf, dass Table type (Tabellentyp) auf Native table (Native Tabelle) eingestellt ist.
  5. Im Abschnitt Schema muss nichts unternommen werden. Das Schema ist in Parquet-Dateien selbstbeschreibend.

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

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

Befehlszeile

Verwenden Sie den Befehl bq load, geben Sie PARQUET 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.

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.
  • --time_partitioning_type: Aktiviert die zeitbasierte Partitionierung für eine Tabelle und legt den Partitionstyp fest. Der einzig mögliche Wert ist derzeit DAY. Er generiert eine Partition pro Tag. Dieses Flag ist optional, wenn Sie eine Tabelle erstellen, die nach einer DATE- oder TIMESTAMP-Spalte partitioniert wird.
  • --time_partitioning_expiration: Eine Ganzzahl, die (in Sekunden) angibt, wann eine zeitbasierte Partition gelöscht werden soll. Die Ablaufzeit entspricht dem UTC-Datum der Partition plus dem ganzzahligen Wert.
  • --time_partitioning_field: Die DATE- oder TIMESTAMP-Spalte zum Erstellen einer partitionierten Tabelle. Wenn die zeitbasierte Partitionierung ohne Angabe dieses Werts aktiviert wird, erstellt BigQuery eine nach Aufnahmezeit partitionierte Tabelle.
  • --require_partition_filter: Wenn diese Option aktiviert ist, müssen die Nutzer eine WHERE-Klausel zur Angabe der abzufragenden Partitionen einfügen. Das Anfordern eines Partitionsfilters kann die Kosten senken und die Leistung verbessern. Weitere Informationen finden Sie unter Partitionierte Tabellen abfragen.
  • --clustering_fields: Eine durch Kommas getrennte Liste mit bis zu vier Spaltennamen zum Erstellen einer geclusterten Tabelle. Dieses Flag kann nur für partitionierte Tabellen genutzt werden.
  • --destination_kms_key: Der Cloud KMS-Schlüssel für die Verschlüsselung der Tabellendaten.

    Weitere Informationen zu partitionierten Tabellen finden Sie unter:

    Weitere Informationen zu geclusterten Tabellen finden Sie unter:

    Weitere Informationen zur Tabellenverschlüsselung finden Sie unter:

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

bq --location=location load \
--source_format=format \
dataset.table \
path_to_source

Dabei gilt:

  • location ist Ihr Standort. Das Flag --location ist optional. Wenn Sie BigQuery beispielsweise 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 ist PARQUET.
  • dataset ist ein vorhandenes Dataset.
  • table ist der Name der Tabelle, in die Sie Daten laden.
  • path_to_source ist ein vollständig qualifizierter Cloud Storage-URI oder eine durch Kommas getrennte Liste von URIs. Platzhalter werden ebenfalls unterstützt.

Beispiele:

Mit dem folgenden Befehl werden Daten aus gs://mybucket/mydata.parquet in eine Tabelle mit dem Namen mytable in mydataset geladen.

    bq load \
    --source_format=PARQUET \
    mydataset.mytable \
    gs://mybucket/mydata.parquet

Mit dem folgenden Befehl werden Daten aus gs://mybucket/mydata.parquet in eine nach Aufnahmezeit partitionierte Tabelle mit dem Namen mytable in mydataset geladen:

    bq load \
    --source_format=PARQUET \
    --time_partitioning_type=DAY \
    mydataset.mytable \
    gs://mybucket/mydata.parquet

Mit dem folgenden Befehl werden Daten aus gs://mybucket/mydata.parquet in eine partitionierte Tabelle mit dem Namen mytable in mydataset geladen. Die Tabelle ist nach der Spalte mytimestamp partitioniert.

    bq load \
    --source_format=PARQUET \
    --time_partitioning_field mytimestamp \
    mydataset.mytable \
    gs://mybucket/mydata.parquet

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.

    bq load \
    --source_format=PARQUET \
    mydataset.mytable \
    gs://mybucket/mydata*.parquet

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.

    bq load \
    --source_format=PARQUET \
    mydataset.mytable \
    "gs://mybucket/00/*.parquet","gs://mybucket/01/*.parquet"

API

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

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

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

  4. Geben Sie das Parquet-Datenformat an. Legen Sie dazu das Attribut sourceFormat auf PARQUET fest.

  5. Rufen Sie zum Prüfen des Jobstatus jobs.get(job_id*) auf, wobei job_id die ID des Jobs ist, der von der ursprünglichen Anfrage zurückgegeben wurde.

    • Wenn status.state = DONE zurückgegeben wird, wurde der Job erfolgreich abgeschlossen.
    • Wenn das Attribut status.errorResult zurückgegeben wird, ist die Anfrage fehlgeschlagen. Das Objekt enthält in diesem Fall Angaben zur Fehlerursache. 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.

Go

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

import (
	"context"
	"fmt"

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

// importParquet demonstrates loading Apache Parquet data from Cloud Storage into a table.
func importParquet(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.parquet")
	gcsRef.SourceFormat = bigquery.Parquet
	gcsRef.AutoDetect = true
	loader := client.Dataset(datasetID).Table(tableID).LoaderFrom(gcsRef)

	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.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
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.TableId;
import java.math.BigInteger;

public class LoadParquet {

  public static void runLoadParquet() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    loadParquet(datasetName);
  }

  public static void loadParquet(String datasetName) {
    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();

      String sourceUri = "gs://cloud-samples-data/bigquery/us-states/us-states.parquet";
      TableId tableId = TableId.of(datasetName, "us_states");

      LoadJobConfiguration configuration =
          LoadJobConfiguration.builder(tableId, sourceUri)
              .setFormatOptions(FormatOptions.parquet())
              .build();

      // For more information on Job see:
      // https://googleapis.dev/java/google-cloud-clients/latest/index.html?com/google/cloud/bigquery/package-summary.html
      // Load the table
      Job job = bigquery.create(JobInfo.of(configuration));

      // Blocks until this load table job completes its execution, either failing or succeeding.
      Job completedJob = job.waitFor();
      if (completedJob == null) {
        System.out.println("Job not executed since it no longer exists.");
        return;
      } else if (completedJob.getStatus().getError() != null) {
        System.out.println(
            "BigQuery was unable to load the table due to an error: \n"
                + job.getStatus().getError());
        return;
      }

      // Check number of rows loaded into the table
      BigInteger numRows = bigquery.getTable(tableId).getNumRows();
      System.out.printf("Loaded %d rows. \n", numRows);

      System.out.println("GCS parquet loaded successfully.");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("GCS Parquet was not loaded. \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 Informationen finden Sie in der Referenzdokumentation zur BigQuery Node.js API.

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

// Instantiate clients
const bigquery = new BigQuery();
const storage = new Storage();

/**
 * This sample loads the Parquet file at
 * https://storage.googleapis.com/cloud-samples-data/bigquery/us-states/us-states.parquet
 *
 * TODO(developer): Replace the following lines with the path to your file.
 */
const bucketName = 'cloud-samples-data';
const filename = 'bigquery/us-states/us-states.parquet';

async function loadTableGCSParquet() {
  // Imports a GCS file into a table with Parquet source format.

  /**
   * 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: 'PARQUET',
    location: 'US',
  };

  // Load data from a Google Cloud Storage file into the table
  const [job] = await bigquery
    .dataset(datasetId)
    .table(tableId)
    .load(storage.bucket(bucketName).file(filename), metadata);

  // load() waits for the job to finish
  console.log(`Job ${job.id} completed.`);

  // Check the job's status for errors
  const errors = job.status.errors;
  if (errors && errors.length > 0) {
    throw errors;
  }
}

PHP

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

use Google\Cloud\BigQuery\BigQueryClient;
use Google\Cloud\Core\ExponentialBackoff;

/** Uncomment and populate these variables in your code */
// $projectId  = 'The Google project ID';
// $datasetId  = 'The BigQuery dataset ID';

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

// create the import job
$gcsUri = 'gs://cloud-samples-data/bigquery/us-states/us-states.parquet';
$loadConfig = $table->loadFromStorage($gcsUri)->sourceFormat('PARQUET');
$job = $table->runJob($loadConfig);
// poll the job until it is complete
$backoff = new ExponentialBackoff(10);
$backoff->execute(function () use ($job) {
    print('Waiting for job to complete' . PHP_EOL);
    $job->reload();
    if (!$job->isComplete()) {
        throw new Exception('Job has not yet completed', 500);
    }
});
// check if the job has errors
if (isset($job->info()['status']['errorResult'])) {
    $error = $job->info()['status']['errorResult']['message'];
    printf('Error running job: %s' . PHP_EOL, $error);
} else {
    print('Data imported successfully' . PHP_EOL);
}

Python

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

Verwenden Sie die Methode Client.load_table_from_uri(), um einen Ladejob für Cloud Storage zu starten. Wenn Sie Parquet verwenden möchten, legen Sie für das Attribut LoadJobConfig.source_format die SourceFormat-Konstante PARQUET fest und übergeben die Jobkonfiguration als job_config-Argument an die Methode load_table_from_uri().

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

dataset_ref = client.dataset(dataset_id)
job_config = bigquery.LoadJobConfig()
job_config.source_format = bigquery.SourceFormat.PARQUET
uri = "gs://cloud-samples-data/bigquery/us-states/us-states.parquet"

load_job = client.load_table_from_uri(
    uri, dataset_ref.table("us_states"), job_config=job_config
)  # API request
print("Starting job {}".format(load_job.job_id))

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

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

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

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

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

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

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

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

Mit den folgenden Methoden können Sie Daten an Tabellen anfügen oder in diesen überschreiben:

  • Mit der Cloud Console oder der klassischen Web-UI
  • Über die Befehlszeile mit dem Befehl bq load
  • Durch Aufrufen der API-Methode jobs.insert und Konfigurieren eines load-Jobs
  • Mit den Clientbibliotheken

So fügen Sie Parquet-Daten an eine Tabelle an oder überschreiben die Tabelle damit:

Console

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

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

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

    Tabelle erstellen

  4. Gehen Sie auf der Seite Tabelle erstellen im Bereich Quelle wie folgt vor:

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

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

      Datei auswählen

    • Wählen Sie als Dateiformat die Option Parquet aus.

  5. Gehen Sie auf der Seite Tabelle erstellen im Abschnitt Ziel so vor:

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

      Dataset auswählen

    • Geben Sie im Feld für den Tabellennamen 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.

  6. Im Abschnitt Schema muss nichts unternommen werden. Das Schema ist in Parquet-Dateien selbstbeschreibend.

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

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

    • Wählen Sie für Write preference (Schreibeinstellung) die Option Append to table (An Tabelle anfügen) oder Overwrite table (Tabelle überschreiben) aus.
    • Übernehmen Sie für Number of errors allowed (Anzahl zulässiger Fehler) den Standardwert 0 oder geben Sie an, wie viele Zeilen mit Fehlern maximal ignoriert werden können. Wenn die Anzahl der Zeilen mit Fehlern diesen Wert überschreitet, führt der Job zu einer invalid-Meldung und schlägt fehl.
    • Übernehmen Sie unter Unbekannte Werte das Kästchen Unbekannte Werte ignorieren ohne Häkchen. Diese Option gilt nur für CSV- und JSON-Dateien.
    • 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.

      Overwrite table (Tabelle überschreiben)

  9. Klicken Sie auf Create table (Tabelle erstellen).

Klassische UI

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

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

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

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

    • Wählen Sie als Table name (Tabellenname) das entsprechende Dataset aus und geben Sie im Namensfeld für die Tabelle den Namen der Tabelle ein, in der Daten angefügt oder überschrieben werden sollen.
    • Achten Sie darauf, dass Table type (Tabellentyp) auf Native table (Native Tabelle) eingestellt ist.
  5. Im Abschnitt Schema muss nichts unternommen werden. Schemainformationen sind in den Parquet-Dateien selbstbeschreibend.

  6. Im Bereich Optionen gehen Sie so vor:

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

Befehlszeile

Geben Sie den Befehl bq load mit dem Flag --replace ein, 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. Geben Sie das Flag --source_format an und setzen Sie es auf PARQUET. Da Parquet-Schemas automatisch aus den selbstbeschreibenden Quelldaten abgerufen werden, müssen Sie keine Schemadefinition angeben.

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

Dabei gilt:

  • location ist Ihr Standort. Das Flag --location ist optional. Mit der Datei .bigqueryrc können Sie für den Standort einen Standardwert festlegen.
  • format ist PARQUET.
  • dataset ist ein vorhandenes Dataset.
  • table ist der Name der Tabelle, in die Sie Daten laden.
  • path_to_source ist ein vollständig qualifizierter Cloud Storage-URI oder eine durch Kommas getrennte Liste von URIs. Platzhalter werden ebenfalls unterstützt.

Beispiele:

Der folgende Befehl lädt Daten aus gs://mybucket/mydata.parquet und überschreibt eine Tabelle namens mytable in mydataset.

    bq load \
    --replace \
    --source_format=PARQUET \
    mydataset.mytable \
    gs://mybucket/mydata.parquet

Mit dem folgenden Befehl werden Daten aus gs://mybucket/mydata.parquet geladen und an eine Tabelle namens mytable in mydataset angefügt.

    bq load \
    --noreplace \
    --source_format=PARQUET \
    mydataset.mytable \
    gs://mybucket/mydata.parquet

Weitere Informationen zum Anfügen und Überschreiben von Daten in partitionierten Tabellen mithilfe der Befehlszeile finden Sie unter Daten in partitionierten Tabellen anfügen oder überschreiben.

API

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

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

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

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

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

Go

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

import (
	"context"
	"fmt"

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

// importParquetTruncate demonstrates loading Apache Parquet data from Cloud Storage into a table
// and overwriting/truncating existing data in the table.
func importParquetTruncate(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.parquet")
	gcsRef.SourceFormat = bigquery.Parquet
	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

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.


import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.FormatOptions;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.JobInfo.WriteDisposition;
import com.google.cloud.bigquery.LoadJobConfiguration;
import com.google.cloud.bigquery.TableId;
import java.math.BigInteger;

public class LoadParquetReplaceTable {

  public static void runLoadParquetReplaceTable() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    loadParquetReplaceTable(datasetName);
  }

  public static void loadParquetReplaceTable(String datasetName) {
    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();

      // Imports a GCS file into a table and overwrites table data if table already exists.
      // This sample loads CSV file at:
      // https://storage.googleapis.com/cloud-samples-data/bigquery/us-states/us-states.csv
      String sourceUri = "gs://cloud-samples-data/bigquery/us-states/us-states.parquet";
      TableId tableId = TableId.of(datasetName, "us_states");

      // For more information on LoadJobConfiguration see:
      // https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/bigquery/LoadJobConfiguration.Builder.html
      LoadJobConfiguration configuration =
          LoadJobConfiguration.builder(tableId, sourceUri)
              .setFormatOptions(FormatOptions.parquet())
              // Set the write disposition to overwrite existing table data.
              .setWriteDisposition(WriteDisposition.WRITE_TRUNCATE)
              .build();

      // For more information on Job see:
      // https://googleapis.dev/java/google-cloud-clients/latest/index.html?com/google/cloud/bigquery/package-summary.html
      // Load the table
      Job job = bigquery.create(JobInfo.of(configuration));

      // Load data from a GCS parquet file into the table
      // Blocks until this load table job completes its execution, either failing or succeeding.
      Job completedJob = job.waitFor();
      if (completedJob == null) {
        System.out.println("Job not executed since it no longer exists.");
        return;
      } else if (completedJob.getStatus().getError() != null) {
        System.out.println(
            "BigQuery was unable to load into the table due to an error: \n"
                + job.getStatus().getError());
        return;
      }

      // Check number of rows loaded into the table
      BigInteger numRows = bigquery.getTable(tableId).getNumRows();
      System.out.printf("Loaded %d rows. \n", numRows);

      System.out.println("GCS parquet overwrote existing table successfully.");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Table extraction job was interrupted. \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 Informationen finden Sie in der Referenzdokumentation zur BigQuery Node.js API.

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

// Instantiate clients
const bigquery = new BigQuery();
const storage = new Storage();

/**
 * This sample loads the CSV file at
 * https://storage.googleapis.com/cloud-samples-data/bigquery/us-states/us-states.csv
 *
 * TODO(developer): Replace the following lines with the path to your file.
 */
const bucketName = 'cloud-samples-data';
const filename = 'bigquery/us-states/us-states.parquet';

async function loadParquetFromGCSTruncate() {
  /**
   * 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: 'PARQUET',
    // Set the write disposition to overwrite existing table data.
    writeDisposition: 'WRITE_TRUNCATE',
    location: 'US',
  };

  // Load data from a Google Cloud Storage file into the table
  const [job] = await bigquery
    .dataset(datasetId)
    .table(tableId)
    .load(storage.bucket(bucketName).file(filename), metadata);
  // load() waits for the job to finish
  console.log(`Job ${job.id} completed.`);

  // Check the job's status for errors
  const errors = job.status.errors;
  if (errors && errors.length > 0) {
    throw errors;
  }
}

PHP

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

use Google\Cloud\BigQuery\BigQueryClient;
use Google\Cloud\Core\ExponentialBackoff;

/** Uncomment and populate these variables in your code */
// $projectId = 'The Google project ID';
// $datasetId = 'The BigQuery dataset ID';
// $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.parquet';
$loadConfig = $table->loadFromStorage($gcsUri)->sourceFormat('PARQUET')->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

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

Wenn Sie die Zeilen in einer vorhandenen Tabelle ersetzen möchten, legen Sie für das Attribut LoadJobConfig.write_disposition die WriteDisposition-Konstante WRITE_TRUNCATE fest.

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

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

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

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

Mit Hive partitionierte Parquet-Daten laden

BigQuery unterstützt das Laden von mit Hive partitionierten Parquet-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 aus Cloud Storage laden.

Parquet-Konvertierungen

BigQuery konvertiert Parquet-Datentypen in folgende BigQuery-Datentypen:

Typkonvertierungen

Parquet-Typ Konvertierte Parquet-Typen BigQuery-Datentyp
BOOLEAN NONE Boolesch
INT32 NONE, UINT_8, UINT_16, UINT_32, INT_8, INT_16, INT_32 Ganzzahl
INT32 DECIMAL (siehe Annotation "DECIMAL") Numerisch
INT32 DATE Datum
INT64 NONE, UINT_64, INT_64 Ganzzahl
INT64 DECIMAL (siehe Annotation "DECIMAL") Numerisch
INT64 TIMESTAMP_MILLIS Zeitstempel
INT64 TIMESTAMP_MICROS Zeitstempel
INT96 NONE Zeitstempel
FLOAT NONE Gleitkomma
DOUBLE NONE Gleitkomma
BYTE_ARRAY NONE Byte
BYTE_ARRAY UTF8 String
FIXED_LEN_BYTE_ARRAY DECIMAL (siehe Annotation "DECIMAL") Numerisch
FIXED_LEN_BYTE_ARRAY NONE Byte

Andere Kombinationen von Parquet-Typen und konvertierten Typen werden nicht unterstützt.

Annotation "Decimal"

Parquet-Typen mit der Annotation DECIMAL dürfen höchstens eine Genauigkeit von 38 (Gesamtzahl der Ziffern) und höchstens eine Skalierung von 9 (Ziffern rechts von der Dezimalstelle) haben. Die Anzahl der Ziffern des ganzzahligen Teils, die der Differenz aus Genauigkeit und Skalierung entspricht, darf höchstens 29 betragen. Beispielsweise wird DECIMAL(38, 9) unterstützt, da die Genauigkeit 38 und die Skalierung 9 beträgt. In diesem Beispiel beträgt die Anzahl der Ziffern des ganzzahligen Teils 29. DECIMAL(38, 5) wird nicht unterstützt, da die Genauigkeit 38 und die Skalierung 5 beträgt. In diesem Beispiel beträgt die Anzahl der Ziffern des ganzzahligen Teils 33.

Konvertierungen von Spaltennamen

Ein Spaltenname darf nur Buchstaben (a–z, A–Z), Ziffern (0–9) oder Unterstriche (_) enthalten und muss mit einem Buchstaben oder einem Unterstrich beginnen. Die maximale Länge des Spaltennamens beträgt 128 Zeichen. In Spaltennamen darf keines der folgenden Präfixe verwendet werden:

  • _TABLE_
  • _FILE_
  • _PARTITION

Mehrere identische Spaltennamen sind auch bei unterschiedlicher Groß-/Kleinschreibung nicht zulässig. So wird beispielsweise der Spaltenname Column1 als identisch mit dem Spaltennamen column1 angesehen.

Derzeit können keine Parquet-Dateien mit Spalten, in deren Namen ein Punkt (.) enthalten ist, geladen werden.

Wenn ein Parquet-Spaltenname (neben einem Punkt) andere Zeichen enthält, werden diese Zeichen durch Unterstriche ersetzt. Hinter Spaltennamen können Unterstriche angefügt werden, um Kollisionen zu vermeiden. Wenn eine Parquet-Datei beispielsweise die beiden Spalten Column1 und column1 enthält, können die Spalten als Column1 und column1_ geladen werden.