Daten aus einer lokalen Datenquelle laden

Auf dieser Seite wird erläutert, wie Sie Daten aus einer lokalen Datenquelle laden.

Anleitungen zum Laden von Daten aus einer lokalen Datenquelle finden Sie unter:

Übersicht

Sie können mit einer der folgenden Methoden Daten aus einer lesbaren Datenquelle (z. B. von Ihrem lokalen Rechner) laden:

  • Cloud Console
  • Mit dem Befehl bq des bq load-Befehlszeilentools
  • Mit der API
  • Mit den Clientbibliotheken

Beim Laden von Daten über die Cloud Console oder das bq-Befehlszeilentool wird automatisch ein Ladejob erstellt.

Beschränkungen

Platzhalter und durch Kommas getrennte Listen werden nicht unterstützt. Dateien müssen einzeln geladen werden.

Erforderliche Berechtigungen

Zum Laden von Daten in BigQuery benötigen Sie mindestens die folgenden Berechtigungen:

  • bigquery.tables.create, um eine neue Tabelle zu erstellen
  • bigquery.tables.updateData, wenn Sie Daten in einer Tabelle überschreiben oder anfügen
  • bigquery.jobs.create, um den Ladejob auszuführen

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 Zugriff als bigquery.dataOwner. Mit bigquery.dataOwner-Zugriff haben Nutzer die Möglichkeit, Daten in Tabellen innerhalb eines Datasets zu laden.

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

Daten aus einer lokalen Datenquelle laden

Wenn Sie Daten aus einer lokalen Datenquelle in BigQuery laden möchten, benötigen Sie dafür zuerst ein Dataset, in dem sie enthalten sein sollen. Weitere Informationen zum Erstellen eines Datasets finden Sie auf der Seite Datasets erstellen.

So laden Sie Daten aus einer lokalen Datenquelle:

Console

  1. Öffnen Sie in der Cloud Console die Seite "BigQuery".

    Zur Seite "BigQuery"

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

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

    Tabelle erstellen.

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

    • Wählen Sie unter Tabelle erstellen aus die Option Hochladen aus.

      Screenshot: Hochladen einer Tabelle

    • Klicken Sie unter Datei auswählen auf Durchsuchen.

      Screenshot: In Dateien suchen

    • Gehen Sie dann zur gewünschten Datei und klicken Sie auf Öffnen. Beachten Sie, dass Platzhalter und durch Kommas getrennte Listen in lokalen Dateien nicht unterstützt werden.

    • Wählen Sie für File format (Dateiformat) die Option CSV, JSON (newline delimited) (JSON (durch Zeilenumbruch getrennt)), Avro, Parquet oder ORC aus.

  5. Gehen Sie auf der Seite Create table (Tabelle erstellen) im Abschnitt Destination (Ziel) so vor:

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

      Screenshot: Dataset aufrufen

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

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

  6. Geben Sie im Abschnitt Schema die Schemadefinition ein.

    • Für CSV- und JSON-Dateien können Sie die Option Auto-detect (Automatisch erkennen) anklicken, um die automatische Schemaerkennung zu aktivieren. Die Schemainformationen sind in den Quelldaten für andere unterstützte Dateitypen selbstbeschreibend.

    • Sie können Schemainformationen auch manuell eingeben:

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

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

  7. Wählen Sie die entsprechenden Elemente im Abschnitt Advanced options (Erweiterte Optionen) aus und klicken Sie dann auf Create Table (Tabelle erstellen). Informationen zu den verfügbaren Optionen finden Sie unter CSV-Optionen und JSON-Optionen.

bq

Verwenden Sie den Befehl bq load und geben Sie das source_format sowie den Pfad zur lokalen Datei an.

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

Wenn Sie Daten in ein anderes Projekt als Ihr Standardprojekt laden, fügen Sie die Projekt-ID im folgenden Format dem Dataset hinzu: PROJECT_ID:DATASET.

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

Dabei gilt:

  • LOCATION: Ihr Standort. Das Flag --location ist optional. Wenn Sie beispielsweise BigQuery in der Region Tokio verwenden, legen Sie den Wert des Flags auf asia-northeast1 fest. Mit der Datei ".bigqueryrc" können Sie für den Standort einen Standardwert festlegen.
  • FORMAT: CSV, AVRO, PARQUET, ORC oder NEWLINE_DELIMITED_JSON.
  • project_id: Ihre Projekt-ID.
  • dataset: ein vorhandenes Dataset.
  • table: der Name der Tabelle, in die Sie Daten laden.
  • path_to_source: der Pfad zur lokalen Datei.
  • 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 Bereitstellung einer Schemadefinition auch das Flag --autodetect verwenden.

Darüber hinaus haben Sie die Möglichkeit, Flags für Optionen einzufügen, mit denen sich steuern lässt, wie BigQuery Ihre Daten parst. Sie können beispielsweise mit dem Flag --skip_leading_rows festlegen, dass Header-Zeilen in einer CSV-Datei ignoriert werden. Weitere Informationen finden Sie unter CSV-Optionen und JSON-Optionen.

Beispiele:

Mit dem folgenden Befehl wird eine durch Zeilenumbruch getrennte JSON-Datei (mydata.json) von Ihrem lokalen Computer in eine Tabelle namens mytable in mydataset in Ihrem Standardprojekt geladen. Das Schema ist in einer lokalen Schemadatei namens myschema.json definiert:

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

Mit dem folgenden Befehl wird eine CSV-Datei (mydata.csv) von Ihrem lokalen Computer in eine Tabelle namens mytablein mydataset in myotherproject geladen. Das Schema ist inline im Format FIELD:DATA_TYPE, FIELD:DATA_TYPE definiert.

    bq load \
    --source_format=CSV \
    myotherproject:mydataset.mytable \
    ./mydata.csv \
    qtr:STRING,sales:FLOAT,year:STRING

Mit dem folgenden Befehl wird eine CSV-Datei (mydata.csv) von Ihrem lokalen Computer in eine Tabelle namens mytable in mydataset in Ihrem Standardprojekt geladen. Das Schema wird mithilfe der automatischen Schemaerkennung definiert.

    bq load \
    --autodetect \
    --source_format=CSV \
    mydataset.mytable \
    ./mydata.csv

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.

Im folgenden Codebeispiel wird gezeigt, wie Sie eine lokale CSV-Datei in eine neue BigQuery-Tabelle laden. Für lokale Dateien anderer Formate verwenden Sie anstelle von UploadCsvOptions die Klasse "UploadOptions" für das entsprechende Format aus der Basisklasse JobCreationOptions.


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

public class BigQueryLoadFromFile
{
    public void LoadFromFile(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id",
        string tableId = "your_table_id",
        string filePath = "path/to/file.csv"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        // Create job configuration
        var uploadCsvOptions = new UploadCsvOptions()
        {
            SkipLeadingRows = 1,  // Skips the file headers
            Autodetect = true
        };
        using (FileStream stream = File.Open(filePath, FileMode.Open))
        {
            // Create and run job
            // Note that there are methods available for formats other than CSV
            BigQueryJob job = client.UploadCsv(
                datasetId, tableId, null, stream, uploadCsvOptions);
            job.PollUntilCompleted();  // Waits for the job to complete.
            // Display the number of rows uploaded
            BigQueryTable table = client.GetTable(datasetId, tableId);
            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.

Im folgenden Codebeispiel wird gezeigt, wie Sie eine lokale CSV-Datei in eine neue BigQuery-Tabelle laden. Zum Laden lokaler Dateien anderer Formate legen Sie das entsprechende Format mit dem Attribut DateFormat von NewReaderSource fest.

import (
	"context"
	"fmt"
	"os"

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

// importCSVFromFile demonstrates loading data into a BigQuery table using a file on the local filesystem.
func importCSVFromFile(projectID, datasetID, tableID, filename 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()

	f, err := os.Open(filename)
	if err != nil {
		return err
	}
	source := bigquery.NewReaderSource(f)
	source.AutoDetect = true   // Allow BigQuery to determine schema.
	source.SkipLeadingRows = 1 // CSV has a single header line.

	loader := client.Dataset(datasetID).Table(tableID).LoaderFrom(source)

	job, err := loader.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}
	if err := status.Err(); err != nil {
		return 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.

Im folgenden Codebeispiel wird gezeigt, wie Sie eine lokale CSV-Datei in eine neue BigQuery-Tabelle laden. Zum Laden lokaler Dateien anderer Formate legen Sie für FormatOptions das entsprechende Format fest.

TableId tableId = TableId.of(datasetName, tableName);
WriteChannelConfiguration writeChannelConfiguration =
    WriteChannelConfiguration.newBuilder(tableId).setFormatOptions(FormatOptions.csv()).build();
// The location must be specified; other fields can be auto-detected.
JobId jobId = JobId.newBuilder().setLocation(location).build();
TableDataWriteChannel writer = bigquery.writer(jobId, writeChannelConfiguration);
// Write data to writer
try (OutputStream stream = Channels.newOutputStream(writer)) {
  Files.copy(csvPath, stream);
}
// Get load job
Job job = writer.getJob();
job = job.waitFor();
LoadStatistics stats = job.getStatistics();
return stats.getOutputRows();

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.

Im folgenden Codebeispiel wird gezeigt, wie Sie eine lokale CSV-Datei in eine neue BigQuery-Tabelle laden. Zum Laden lokaler Dateien anderer Formate legen Sie für den Parameter metadata der load-Funktion das entsprechende Format fest.

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

async function loadLocalFile() {
  // Imports a local file into a table.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const filename = '/path/to/file.csv';
  // const datasetId = 'my_dataset';
  // const tableId = 'my_table';

  // Load data from a local file into the table
  const [job] = await bigquery
    .dataset(datasetId)
    .table(tableId)
    .load(filename);

  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.

Im folgenden Codebeispiel wird gezeigt, wie Sie eine lokale CSV-Datei in eine neue BigQuery-Tabelle laden. Für lokale Dateien anderer Formate geben Sie für sourceFormat das entsprechende Format an.

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';
// $source     = 'The path to the CSV source file to import';

// instantiate the bigquery table service
$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$table = $dataset->table($tableId);
// create the import job
$loadConfig = $table->load(fopen($source, 'r'))->sourceFormat('CSV');

$job = $table->runJob($loadConfig);
// poll the job until it is complete
$backoff = new ExponentialBackoff(10);
$backoff->execute(function () use ($job) {
    printf('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.

Im folgenden Codebeispiel wird gezeigt, wie Sie eine lokale CSV-Datei in eine neue BigQuery-Tabelle laden. Zum Laden lokaler Dateien anderer Formate geben Sie für das Attribut LoadJobConfig.source_format das entsprechende Format an.

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(
    source_format=bigquery.SourceFormat.CSV, skip_leading_rows=1, autodetect=True,
)

with open(file_path, "rb") as source_file:
    job = client.load_table_from_file(source_file, table_id, job_config=job_config)

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

table = client.get_table(table_id)  # Make an API request.
print(
    "Loaded {} rows and {} columns to {}".format(
        table.num_rows, len(table.schema), table_id
    )
)

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.

Im folgenden Codebeispiel wird gezeigt, wie Sie eine lokale CSV-Datei in eine neue BigQuery-Tabelle laden. Zum Laden lokaler Dateien anderer Formate legen Sie für den Parameter format der Methode Table#load_job das entsprechende Format fest.

require "google/cloud/bigquery"

def load_from_file dataset_id = "your_dataset_id",
                   file_path  = "path/to/file.csv"

  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id
  table_id = "new_table_id"

  # Infer the config.location based on the location of the referenced dataset.
  load_job = dataset.load_job table_id, file_path do |config|
    config.skip_leading = 1
    config.autodetect   = true
  end
  load_job.wait_until_done! # Waits for table load to complete.

  table = dataset.table table_id
  puts "Loaded #{table.rows_count} rows into #{table.id}"
end

Daten mithilfe einer lokalen Datei an eine Tabelle anfügen oder Tabelle mithilfe einer lokalen Datei überschreiben

Zusätzliche Daten können entweder aus Quelldateien oder durch das Anfügen von Abfrageergebnissen in eine Tabelle geladen werden. Sollte das Schema der Daten nicht mit dem Schema der Zieltabelle oder -partition übereinstimmen, können Sie das Schema aktualisieren, wenn Sie Daten an das Ziel anfügen oder das Ziel überschreiben.

Wenn Sie das Schema beim Anfügen von Daten aktualisieren, können Sie in BigQuery folgende Vorgänge ausführen:

  • Neue Felder hinzufügen
  • Felder vom Typ REQUIRED in den Typ NULLABLE ändern (herunterstufen)

Beim Überschreiben einer Tabelle wird immer auch das Schema überschrieben. Schemaaktualisierungen sind beim Überschreiben einer Tabelle nicht eingeschränkt.

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. Das bq-Befehlszeilentool und die API umfassen die folgenden Optionen:

Console-Option bq-Tool-Flag BigQuery API-Attribut Beschreibung
Schreiben, wenn leer Keine WRITE_EMPTY Daten werden nur geschrieben, wenn die Tabelle leer ist.
An Tabelle anfügen --noreplace oder --replace=false. Wenn --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.

So laden Sie CSV-, JSON-, Avro-, Parquet- oder ORC-Daten aus einer lokalen Datei und fügen sie an eine BigQuery-Tabelle an oder überschreiben die Tabelle:

Console

  1. Öffnen Sie in der Cloud Console die Seite "BigQuery".

    Zur Seite "BigQuery"

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

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

    Tabelle erstellen.

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

    • Wählen Sie unter Tabelle erstellen aus die Option Hochladen aus.

      Screenshot: Hochladen einer Tabelle

    • Klicken Sie unter Datei auswählen auf Durchsuchen.

      Screenshot: In Dateien suchen

    • Gehen Sie dann zur gewünschten Datei und klicken Sie auf Öffnen. Beachten Sie, dass Platzhalter und durch Kommas getrennte Listen in lokalen Dateien nicht unterstützt werden.

    • Wählen Sie für File format (Dateiformat) die Option CSV, JSON (newline delimited) (JSON (durch Zeilenumbruch getrennt)), Avro, Parquet oder ORC aus.

  5. Gehen Sie auf der Seite Create table (Tabelle erstellen) im Abschnitt Destination (Ziel) so vor:

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

      Grafik: Dataset auswählen

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

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

  6. Geben Sie im Abschnitt Schema die Schemadefinition ein.

    • Für CSV- und JSON-Dateien können Sie die Option Auto-detect (Automatisch erkennen) anklicken, um die automatische Schemaerkennung zu aktivieren. Die Schemainformationen sind in den Quelldaten für andere unterstützte Dateitypen selbstbeschreibend.

    • Sie können Schemainformationen auch manuell eingeben:

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

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

  7. Wählen Sie im Abschnitt Advanced options (Erweiterte Optionen) für Write preference (Schreibeinstellung) die Option Write if empty (Schreiben, wenn leer), Append to table (An Tabelle anfügen) oder Overwrite table (Tabelle überschreiben) aus.

  8. Klicken Sie auf Tabelle erstellen.

bq

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.

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

Wenn Sie Daten in einer Tabelle anfügen oder überschreiben, können Sie das Flag --schema_update_option verwenden, um das Schema der Zieltabelle mit dem Schema der neuen Daten zu aktualisieren. Mit dem Flag --schema_update_option können die folgenden Optionen verwendet werden:

  • ALLOW_FIELD_ADDITION: fügt dem Schema neue Felder hinzu. Neue Felder können nicht vom Typ REQUIRED sein.
  • ALLOW_FIELD_RELAXATION: stuft Pflichtfelder zu Nicht-Pflichtfeldern herunter. Verwenden Sie diese Option wiederholt, um eine Werteliste anzugeben.
bq --location=LOCATION load \
--[no]replace \
DATASET.TABLE \
PATH_TO_SOURCE \
SCHEMA

Dabei gilt:

  • LOCATION: Ihr Standort. Das Flag --location ist optional. Wenn Sie beispielsweise BigQuery in der Region Tokio verwenden, legen Sie den Wert des Flags auf asia-northeast1 fest. Mit der Datei ".bigqueryrc" können Sie einen Standardwert für den Standort festlegen.
  • DATASET: ein vorhandenes Dataset.
  • TABLE: der Name der Tabelle, in die Sie Daten laden.
  • PATH_TO_SOURCE: der Pfad zur lokalen Datei. Beachten Sie, dass Platzhalter und durch Kommas getrennte Listen in lokalen Dateien nicht unterstützt werden.
  • 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 Bereitstellung einer Schemadefinition auch das Flag --autodetect verwenden.

Außerdem können Sie Flags für JSON-Optionen und CSV-Optionen einfügen, mit denen sich steuern lässt, wie BigQuery Ihre Daten parst.

Beispiele:

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

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

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

    bq load \
    --autodetect \
    --noreplace \
    --source_format=NEWLINE_DELIMITED_JSON \
    mydataset.mytable \
    ./mydata.json \
    ./myschema.json

Mit dem folgenden Befehl werden Daten aus mydata.json geladen und an eine Tabelle namens mytable in mydataset angefügt. Es wird eine lokale JSON-Schemadatei namens myschema.json verwendet. Die Schemadefinition enthält neue Felder, die in der Zieltabelle nicht vorhanden sind:

    bq load \
    --noreplace \
    --schema_update_option=ALLOW_FIELD_ADDITION \
    --source_format=NEWLINE_DELIMITED_JSON \
    mydataset.mytable \
    ./mydata.json \
    ./myschema.json

Mit dem folgenden Befehl werden Daten aus mydata.csv geladen und an eine Tabelle namens mytable in mydataset angefügt. Es wird eine lokale JSON-Schemadatei namens myschema.json verwendet. Durch die Schemadefinition werden zwei Felder vom Typ REQUIRED in NULLABLE geändert (heruntergestuft):

    bq load \
    --noreplace \
    --schema_update_option=ALLOW_FIELD_RELAXATION \
    --source_format=NEWLINE_DELIMITED_JSON \
    mydataset.mytable \
    ./mydata.csv \
    ./myschema.json

API-Uploads

Mit der Funktion zum Hochladen von Medien können Sie Daten über die BigQuery API in der Cloud speichern und für den Server bereitstellen. Sie können Fotos, Videos, PDF-Dateien, ZIP-Dateien und beliebige andere Arten von Daten hochladen.

Uploadoptionen

Über die BigQuery API können Sie bestimmte Typen von Binärdaten oder Medien hochladen. Die besonderen Merkmale der Daten, die hochgeladen werden können, finden Sie auf den Referenzseiten der Methoden, die Medienuploads unterstützen:

  • Maximale Upload-Dateigröße: Die maximale Datenmenge, die mit dieser Methode gespeichert werden kann.
  • Zulässige Medien-MIME-Typen: Die Typen von Binärdaten, die mit dieser Methode gespeichert werden können.

Uploadanfragen können folgendermaßen gestellt werden. Geben Sie die Methode an, die Sie für den uploadType-Anfrageparameter verwenden.

  • Mehrteiliger Upload: uploadType=multipart. Übertragen Sie für eine schnelle Übermittlung kleinerer Dateien und Metadaten die Datei in einer einzelnen Anfrage zusammen mit beschreibenden Metadaten.
  • Fortsetzbarer Upload: uploadType=resumable. Für zuverlässige Übertragungen. Dies ist insbesondere bei größeren Dateien wichtig. Bei dieser Methode wird eine sitzungsinitiierende Anfrage verwendet, die optional Metadaten umfassen kann. Es ist eine gute Strategie für die meisten Anwendungen, da sie zum Preis von nur einer zusätzlichen HTTP-Anfrage auch für kleinere Dateien verwendet werden kann.

Für den Upload von Medien wird ein besonderer URI verwendet. Tatsächlich gibt es in Methoden, die Medienuploads unterstützen, zwei URI-Endpunkte:

  • Der /upload-URI (für die Medien). Das Format des Upload-Endpunkts ist der Standardressourcen-URI mit dem Präfix "/upload". Verwenden Sie diesen URI beim Übertragen der eigentlichen Mediendaten. Beispiel: POST /upload/bigquery/v2/projects/projectId/jobs.
  • Der Standardressourcen-URI (für die Metadaten). Wenn die Ressource Datenfelder enthält, werden diese zum Speichern von Metadaten verwendet, die die hochgeladene Datei beschreiben. Sie können diesen URI zum Erstellen oder Aktualisieren von Metadatenwerten verwenden. Beispiel: POST /bigquery/v2/projects/projectId/jobs.

Mehrteiliger Upload

Wenn Metadaten zusammen mit den hochzuladenden Daten gesendet werden sollen, können Sie eine einzelne Anfrage (multipart/related) stellen. Das ist eine gute Wahl, wenn die gesendeten Daten klein genug sind, um sie noch einmal komplett hochzuladen, wenn die Verbindung fehlschlägt.

Wenn Sie den mehrteiligen Upload verwenden möchten, stellen Sie eine POST-Anfrage an den /upload-URI der Methode und fügen dabei den Abfrageparameter uploadType=multipart hinzu. Beispiel:

POST https://www.googleapis.com/upload/bigquery/v2/projects/projectId/jobs?uploadType=multipart

Zu den Top-Level-HTTP-Headern beim Stellen einer mehrteiligen Uploadanfrage gehören:

  • Content-Type. Setzen Sie den Wert auf "multipart/related" und fügen Sie den Grenzstring ein, den Sie zum Identifizieren der Teile der Anfrage verwenden.
  • Content-Length. Setzen Sie den Wert auf die Gesamtanzahl von Byte im Anfragetext. Der Medienteil der Anfrage muss kleiner als die maximale Dateigröße sein, die für diese Methode angegeben ist.

Der Text der Anfrage ist als Inhaltstyp multipart/related [RFC 2387] formatiert und enthält genau zwei Teile. Die Teile werden durch einen Grenzstring identifiziert und auf den finalen Grenzstring folgen zwei Bindestriche.

Für jeden Teil der mehrteiligen Anfrage ist als zusätzlicher Header Content-Type erforderlich:

  1. Metadatenteil: muss als Erstes angegeben werden und Content-Type muss einem der zulässigen Metadatenformate entsprechen.
  2. Medienteil: muss als Zweites angegeben werden und Content-Type muss einem der zulässigen Medien-MIME-Typen der Methode entsprechen.

Eine Liste der zulässigen Medien-MIME-Typen und der Größenbeschränkungen für hochgeladene Dateien finden Sie in der API-Referenz für die jeweilige Methode.

Hinweis: Wenn Sie nur den Metadatenteil erstellen oder aktualisieren möchten, ohne die zugehörigen Daten hochzuladen, senden Sie einfach eine Anfrage vom Typ POST oder PUT an den Standardressourcenendpunkt https://www.googleapis.com/bigquery/v2/projects/projectId/jobs.

Beispiel: Mehrteiliger Upload

Das Beispiel unten zeigt eine mehrteilige Uploadanfrage an die BigQuery API.

POST /upload/bigquery/v2/projects/projectId/jobs?uploadType=multipart HTTP/1.1
Host: www.googleapis.com
Authorization: Bearer your_auth_token
Content-Type: multipart/related; boundary=foo_bar_baz
Content-Length: number_of_bytes_in_entire_request_body

--foo_bar_baz
Content-Type: application/json; charset=UTF-8

{
  "configuration": {
    "load": {
      "sourceFormat": "NEWLINE_DELIMITED_JSON",
      "schema": {
        "fields": [
          {"name": "f1", "type": "STRING"},
          {"name": "f2", "type": "INTEGER"}
        ]
      },
      "destinationTable": {
        "projectId": "projectId",
        "datasetId": "datasetId",
        "tableId": "tableId"
      }
    }
  }
}

--foo_bar_baz
Content-Type: */*

CSV, JSON, AVRO, PARQUET, or ORC data
--foo_bar_baz--

Ist die Anfrage erfolgreich, gibt der Server den Statuscode "HTTP 200 OK" zusammen mit vorhandenen Metadaten zurück:

HTTP/1.1 200
Content-Type: application/json

{
  "configuration": {
    "load": {
      "sourceFormat": "NEWLINE_DELIMITED_JSON",
      "schema": {
        "fields": [
          {"name": "f1", "type": "STRING"},
          {"name": "f2", "type": "INTEGER"}
        ]
      },
      "destinationTable": {
        "projectId": "projectId",
        "datasetId": "datasetId",
        "tableId": "tableId"
      }
    }
  }
}

Fortsetzbarer Upload

Für einen zuverlässigeren Upload von Datendateien können Sie das Protokoll für fortsetzbare Uploads verwenden. Mit diesem Protokoll können Sie einen Uploadvorgang fortsetzen, nachdem ein Kommunikationsfehler den Datenfluss unterbrochen hat. Das ist besonders nützlich, wenn große Dateien übertragen werden und die Wahrscheinlichkeit einer Netzwerkunterbrechung oder eines anderen Übertragungsfehlers hoch ist (z. B. beim Hochladen von einer mobilen Client-App). Es kann auch die Auslastung Ihrer Bandbreite bei einem Netzwerkausfall reduzieren, da Sie Uploads großer Dateien nicht von Beginn an neu starten müssen.

Die Verwendung eines fortsetzbaren Uploads umfasst die folgenden Schritte:

  1. Starten Sie eine fortsetzbare Sitzung. Führen Sie eine erste Anfrage an den Upload-URI durch, in dem die Metadaten enthalten sind (sofern vorhanden).
  2. Speichern Sie den URI der fortsetzbaren Sitzung. Speichern Sie den Sitzungs-URI, der als Antwort auf die erste Anfrage zurückgegeben wurde. Er wird für die weiteren Anfragen in dieser Sitzung benötigt.
  3. Laden Sie die Datei hoch. Senden Sie die Mediendatei an den URI der fortsetzbaren Sitzung.

Außerdem müssen Anwendungen, die den fortsetzbaren Upload verwenden, Code zum Fortsetzen eines unterbrochenen Uploads enthalten. Wird ein Upload unterbrochen, prüfen Sie, wie viele Daten erfolgreich empfangen wurden, und setzen Sie dann den Upload ab diesem Punkt fort.

Hinweis: Ein Upload-URI läuft nach einer Woche ab.

Schritt 1: Fortsetzbare Sitzung starten

Zum Starten eines fortsetzbaren Uploads stellen Sie eine POST-Anfrage an den /upload-URI der Methode und fügen dabei den Abfrageparameter uploadType=resumable hinzu. Beispiel:

POST https://www.googleapis.com/upload/bigquery/v2/projects/projectId/jobs?uploadType=resumable

Für diese erste Anfrage ist der Text entweder leer oder enthält ausschließlich die Metadaten. Es werden die tatsächlichen Inhalte der Datei übertragen, die in den nachfolgenden Anfragen hochgeladen werden sollen.

Verwenden Sie in der ersten Anfrage die folgenden HTTP-Header:

  • X-Upload-Content-Type. Legen Sie als Wert den Medien-MIME-Typ der Uploaddaten fest, die in den folgenden Anfragen übertragen werden sollen.
  • X-Upload-Content-Length. Legen Sie als Wert die Anzahl von Byte für die Uploaddaten fest, die in den folgenden Anfragen übertragen werden sollen.  Ist die Länge zu Beginn der Anfrage unbekannt, können Sie diesen Header weglassen.
  • Bei Bereitstellung von Metadaten: Content-Type. Legen Sie als Wert den entsprechenden Datentyp der Metadaten fest.
  • Content-Length. Legen Sie als Wert die Anzahl von Byte fest, die im Text dieser ersten Anfrage bereitgestellt werden. Nicht erforderlich bei Verwendung der aufgeteilten Transferverschlüsselung.

Eine Liste der zulässigen Medien-MIME-Typen und der Größenbeschränkungen für hochgeladene Dateien finden Sie in der API-Referenz für die jeweilige Methode.

Beispiel: Anfrage zum Start einer fortsetzbaren Sitzung

Das folgende Beispiel zeigt, wie Sie über die BigQuery API eine fortsetzbare Sitzung starten.

POST /upload/bigquery/v2/projects/projectId/jobs?uploadType=resumable HTTP/1.1
Host: www.googleapis.com
Authorization: Bearer your_auth_token
Content-Length: 38
Content-Type: application/json; charset=UTF-8
X-Upload-Content-Type: */*
X-Upload-Content-Length: 2000000

{
  "configuration": {
    "load": {
      "sourceFormat": "NEWLINE_DELIMITED_JSON",
      "schema": {
        "fields": [
          {"name": "f1", "type": "STRING"},
          {"name": "f2", "type": "INTEGER"}
        ]
      },
      "destinationTable": {
        "projectId": "projectId",
        "datasetId": "datasetId",
        "tableId": "tableId"
      }
    }
  }
}

Hinweis: Wenn es sich um eine erstmalige Anfrage für einen fortsetzbaren Upload ohne Metadaten handelt, lassen Sie den Textbereich der Anfrage leer und legen für den Content-Length-Header den Wert 0 fest.

Im nächsten Abschnitt wird der Umgang mit der Antwort beschrieben.

Schritt 2: URI der fortsetzbaren Sitzung speichern

Wenn die Anfrage zum Starten der Sitzung erfolgreich war, gibt der API-Server den HTTP-Statuscode 200 OK zurück. Außerdem stellt er einen Header vom Typ Location bereit, der den URI der fortsetzbaren Sitzung angibt. Der im Beispiel unten gezeigte Header Location umfasst einen Abschnitt mit dem Abfrageparameter upload_id, der die eindeutige Upload-ID für diese Sitzung liefert.

Beispiel: Antwort auf Anfrage zum Start einer fortsetzbaren Sitzung

Dies ist die Antwort auf die Anfrage in Schritt 1:

HTTP/1.1 200 OK
Location: https://www.googleapis.com/upload/bigquery/v2/projects/projectId/jobs?uploadType=resumable&upload_id=xa298sd_sdlkj2
Content-Length: 0

Der Wert des Location-Headers, wie in der Beispielantwort oben gezeigt, ist der Sitzungs-URI, der als HTTP-Endpunkt für den tatsächlichen Dateiupload oder die Abfrage des Uploadstatus dient.

Kopieren und speichern Sie den Sitzungs-URI, damit Sie ihn für nachfolgende Anfragen verwenden können.

Schritt 3: Datei hochladen

Senden Sie zum Hochladen einer Datei eine PUT-Anfrage an den Upload-URI, den Sie im vorherigen Schritt erhalten haben. Das Format der Uploadanfrage lautet:

PUT session_uri

Einer der HTTP-Header, der bei Anfragen für fortsetzbare Dateiuploads verwendet werden muss, ist Content-Length. Legen Sie als Wert die Anzahl von Byte fest, die Sie in dieser Anfrage hochladen möchten. Dies entspricht normalerweise der Upload-Dateigröße.

Beispiel: Anfrage für fortsetzbaren Datei-Upload

Hierbei handelt es sich um eine fortsetzbare Anfrage zum Hochladen der insgesamt 2.000.000 Byte großen CSV-, JSON-, AVRO-, PARQUET- bzw. ORC-Datei im aktuellen Beispiel.

PUT https://www.googleapis.com/upload/bigquery/v2/projects/projectId/jobs?uploadType=resumable&upload_id=xa298sd_sdlkj2 HTTP/1.1
Content-Length: 2000000
Content-Type: */*

bytes 0-1999999

Ist die Anfrage erfolgreich, gibt der Server den Statuscode HTTP 201 Created zusammen mit allen Metadaten, die dieser Ressource zugeordnet sind, zurück. Wäre die erste Anfrage der fortsetzbaren Sitzung eine Anfrage vom Typ PUT zum Aktualisieren einer vorhandenen Ressource gewesen, hätte die Erfolgsmeldung 200 OK gelautet, zusammen mit allen Metadaten, die dieser Ressource möglicherweise zugeordnet sind.

Wenn die Uploadanfrage unterbrochen wird oder der Server eine Antwort vom Typ HTTP 503 Service Unavailable oder 5xx zurückgibt, gehen Sie wie im Abschnitt Unterbrochenen Upload fortsetzen beschrieben vor.


Datei in Teilen hochladen

Bei fortsetzbaren Uploads können Sie eine Datei aufteilen und eine Reihe von Anfragen senden, um jeden Teil der Reihe nach hochzuladen. Dies ist nicht der bevorzugte Ansatz, da die zusätzlichen Anfragen Leistungskosten verursachen und in der Regel nicht erforderlich sind. Unter bestimmten Umständen ist die Aufteilung jedoch erforderlich, um die Menge von Daten zu reduzieren, die bei einer einzelnen Anfrage übertragen werden. Dies ist hilfreich, wenn für einzelne Anfragen eine feste Zeitbegrenzung vorliegt (z. B. für bestimmte Arten von Google App Engine-Anfragen). Der Prozess ermöglicht außerdem, Aufgaben wie das Bereitstellen von Upload-Fortschrittsanzeigen für alte Browser durchzuführen, die dies standardmäßig nicht unterstützen.


Unterbrochenen Upload fortsetzen

Wird die Uploadanfrage vor dem Erhalten einer Antwort beendet oder erhalten Sie vom Server eine Antwort vom Typ 503 Service Unavailable, müssen Sie den unterbrochenen Upload fortsetzen. So gehen Sie dazu vor:

  1. Status abfragen. Fragen Sie den derzeitigen Status des Uploads ab, indem Sie eine leere PUT-Anfrage an den Upload-URI senden. Bei dieser Anfrage sollten die HTTP-Header einen Content-Range-Header enthalten, der anzeigt, dass die derzeitige Position in der Datei unbekannt ist.  Setzen Sie beispielsweise Content-Range auf */2000000, wenn die Dateigröße insgesamt 2.000.000 ist. Sollte die Gesamtgröße der Datei nicht bekannt sein, legen Sie für Content-Range den Wert */* fest.

    Hinweis :Es ist auch möglich, den Status zwischen Teilen anzufragen, und zwar nicht nur bei einer Unterbrechung des Uploads. Dies ist beispielsweise dann nützlich, wenn die Upload-Fortschrittsanzeigen von alten Browsern dargestellt werden sollen.

  2. Anzahl der hochgeladenen Byte abrufen. Verarbeiten Sie die Antwort der Statusabfrage. Der Server verwendet den Header Range in der Antwort, um anzugeben, welche Byte bisher empfangen wurden.  Der Header Range mit einem Wert von 0-299999 gibt beispielsweise an, dass die ersten 300.000 Byte der Datei empfangen wurden.
  3. Verbleibende Daten hochladen. Senden Sie nun, da Sie wissen, wo Sie die Anfrage fortsetzen müssen, die verbleibenden Daten bzw. den aktuellen Teil. Beachten Sie, dass Sie die verbleibenden Daten in jedem Fall als separaten Teil behandeln müssen. Es muss also der Header Content-Range gesendet werden, um den Upload fortzusetzen.
Beispiel: Unterbrochenen Upload fortsetzen

1) Fordern Sie den Uploadstatus an.

In der folgenden Anfrage wird der Header Content-Range verwendet, um anzugeben, dass die aktuelle Position in der 2.000.000 Byte großen Datei unbekannt ist.

PUT {session_uri} HTTP/1.1
Content-Length: 0
Content-Range: bytes */2000000

2) Extrahieren Sie die Anzahl von Byte, die bisher hochgeladen wurden, aus der Antwort.

Die Antwort des Servers enthält den Header Range, um anzugeben, dass er bisher die ersten 43 Byte der Datei erhalten hat. Sie können anhand des oberen Werts des Range-Headers ermitteln, von wo aus der fortgesetzte Upload gestartet werden soll.

HTTP/1.1 308 Resume Incomplete
Content-Length: 0
Range: 0-42

Hinweis: Nach Abschluss des Uploads wird eventuell die Statusantwort 201 Created oder 200 OK ausgegeben. Dies kann passieren, wenn die Verbindung unterbrochen wird, nachdem alle Byte hochgeladen worden sind, aber bevor der Client eine Antwort vom Server erhalten hat.

3) Setzen Sie den Upload von dem Punkt aus fort, an dem er unterbrochen wurde.

Die folgende Anfrage setzt den Upload fort, indem die verbleibenden Byte der Datei ab Byte 43 gesendet werden.

PUT {session_uri} HTTP/1.1
Content-Length: 1999957
Content-Range: bytes 43-1999999/2000000

bytes 43-1999999

Best Practices

Beim Hochladen von Medien ist es hilfreich, einige Best Practices zur Fehlerbehandlung zu kennen.

  • Fortsetzen oder Wiederholen von Uploads, die aufgrund von Verbindungsunterbrechungen oder 5xx-Fehlern fehlgeschlagen sind, darunter:
    • 500 Internal Server Error
    • 502 Bad Gateway
    • 503 Service Unavailable
    • 504 Gateway Timeout
  • Verwenden Sie einen exponentiellen Backoff, wenn beim Fortsetzen oder Wiederholen von Uploadanfragen ein Serverfehler des Typs 5xx zurückgegeben wird. Diese Fehler können auftreten, wenn ein Server überlastet ist. Mit exponentiellen Backoffs können solche Probleme in Zeiten mit sehr vielen Anfragen oder bei hohem Netzwerktraffic reduziert werden.
  • Andere Arten von Anfragen sollten nicht mit exponentiellen Backoffs ausgeführt werden. Sie können aber eine bestimmte Anzahl dieser Anfragen wiederholen. Beschränken Sie dabei die Anzahl der Wiederholungen. Beispielsweise kann durch den Code die Anzahl der Wiederholungen vor der Ausgabe eines Fehlers auf zehn oder weniger beschränkt werden.
  • Wenn bei fortsetzbaren Uploads Fehler des Typs 404 Not Found und 410 Gone auftreten, starten Sie den gesamten Upload von Beginn an neu.

Exponentielle Backoffs

Exponentielle Backoffs bilden eine Standard-Fehlerbehandlungsstrategie für Netzwerkanwendungen, bei denen der Client eine fehlgeschlagene Anfrage über einen immer länger werdenden Zeitraum periodisch wiederholt. Wenn bei sehr vielen Anfragen oder bei hohem Netzwerktraffic der Server Fehler ausgibt, kann ein exponentieller Backoff eine hilfreiche Strategie zur Fehlerbehandlung sein. Dagegen ist ein exponentieller Backoff keine gute Strategie für die Handhabung von Fehlern, die nicht aufgrund des Netzwerkvolumens oder von Antwortzeiten auftreten, z. B. Fehler wegen ungültiger Autorisierungsdaten oder nicht gefundener Dateien.

Bei richtigem Einsatz erhöht der exponentielle Backoff die Effizienz der Bandbreitennutzung, verringert die Anzahl der Anfragen, die für den Erhalt einer erfolgreichen Antwort erforderlich sind, und maximiert den Durchsatz von Anfragen in Umgebungen mit Gleichzeitigkeit.

Der Ablauf für das Implementieren eines einfachen exponentiellen Backoffs sieht so aus:

  1. Stellen Sie eine Anfrage an die API.
  2. Sie erhalten eine HTTP 503-Antwort, die angibt, dass Sie die Anfrage wiederholen müssen.
  3. Warten Sie 1 Sekunde + random_number_milliseconds und wiederholen Sie die Anfrage.
  4. Sie erhalten eine HTTP 503-Antwort, die angibt, dass Sie die Anfrage wiederholen müssen.
  5. Warten Sie 2 Sekunden + random_number_milliseconds und wiederholen Sie die Anfrage.
  6. Sie erhalten eine HTTP 503-Antwort, die angibt, dass Sie die Anfrage wiederholen müssen.
  7. Warten Sie 4 Sekunden + random_number_milliseconds und wiederholen Sie die Anfrage.
  8. Sie erhalten eine HTTP 503-Antwort, die angibt, dass Sie die Anfrage wiederholen müssen.
  9. Warten Sie 8 Sekunden + random_number_milliseconds und wiederholen Sie die Anfrage.
  10. Sie erhalten eine HTTP 503-Antwort, die angibt, dass Sie die Anfrage wiederholen müssen.
  11. Warten Sie 16 Sekunden + random_number_milliseconds Millisekunden und wiederholen Sie die Anfrage.
  12. Beenden Sie den Vorgang. Melden oder protokollieren Sie einen Fehler.

Im oben beschriebenen Ablauf steht random_number_milliseconds für eine zufällige Anzahl von Millisekunden, deren Wert größer oder gleich 1.000 ist. Dies ist erforderlich, da eine kurze zufällige Verzögerung die Last gleichmäßiger verteilt und verhindert, dass der Server blockiert wird. Der Wert von random_number_milliseconds muss nach jeder Wartezeit neu definiert werden.

Hinweis: Die Wartezeit beträgt immer (2 ^ n) + random_number_milliseconds Millisekunden, wobei n eine gleichförmig ansteigende Ganzzahl ist, die anfänglich auf 0 gesetzt ist. Die Ganzzahl n wird bei jeder Iteration bzw. Anfrage um 1 erhöht.

Der Algorithmus ist so eingerichtet, dass er endet, wenn n = 5. Diese Obergrenze verhindert, dass die Clients unendlich fortfahren, und führt zu einer Verzögerung von insgesamt 32 Sekunden, bevor eine Anfrage als "nicht zu behebender Fehler" gilt. Sie können eine größere maximale Anzahl an Wiederholungen angeben, insbesondere wenn es sich um einen langen Upload handelt. Wichtig ist nur, dass die Wiederholungsverzögerung bei einem akzeptablen Wert liegt, zum Beispiel bei unter einer Minute.