Tabellenschemas ändern

Console

1. Rufen Sie in der Google Cloud Console die Seite "BigQuery" auf.

   BigQuery aufrufen

2. Klicken Sie im linken Bereich auf explore Explorer:

   

   Wenn Sie den linken Bereich nicht sehen, klicken Sie auf last_page Linken Bereich maximieren, um ihn zu öffnen.

3. Maximieren Sie im Bereich Explorer Ihr Projekt, klicken Sie auf Datasets und wählen Sie dann ein Dataset aus.

4. Klicken Sie auf Übersicht > Tabellen und wählen Sie dann die Tabelle aus.

5. Klicken Sie im Detailbereich auf den Tab Schema.

6. Klicken Sie auf Schema bearbeiten. Eventuell müssen Sie scrollen, um diese Schaltfläche zu sehen.

7. Klicken Sie auf der Seite Aktuelles Schema unter Neue Felder auf Feld hinzufügen.

   • Geben Sie unter Name den Spaltennamen ein.
   • Wählen Sie unter Type (Typ) den Datentyp aus.
   • Wählen Sie unter Mode (Modus) NULLABLE oder REPEATED aus.

8. Wenn Sie die gewünschten Spalten hinzugefügt haben, klicken Sie auf Save (Speichern).

SQL

Verwenden Sie die DDL-Anweisung ALTER TABLE ADD COLUMN:

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

   BigQuery aufrufen

2. Geben Sie im Abfrageeditor die folgende Anweisung ein:

   ALTER TABLE mydataset.mytable
   ADD COLUMN new_column STRING;

3. Klicken Sie auf play_circle Ausführen.

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

bq

Führen Sie den Befehl bq update aus und geben Sie dabei eine JSON-Schemadatei an. Wenn sich die zu aktualisierende Tabelle in einem anderen Projekt als Ihrem Standardprojekt befindet, fügen Sie dem Dataset-Namen die Projekt-ID im folgenden Format hinzu: PROJECT_ID:DATASET.

bq update PROJECT_ID:DATASET.TABLE SCHEMA

Dabei gilt:

• PROJECT_ID ist Ihre Projekt-ID.
• DATASET: der Name des Datasets, das die zu aktualisierende Tabelle enthält.
• TABLE: der Name der zu aktualisierenden Tabelle.
• SCHEMA: der Pfad zur JSON-Schemadatei auf Ihrem lokalen Rechner.

Wenn Sie ein Inline-Schema angeben, können Sie nicht die Spaltenbeschreibung, den Modus und den Typ RECORD (STRUCT) angeben. Alle Spaltenmodi sind standardmäßig auf NULLABLE gesetzt. Wenn Sie also einem RECORD eine neue verschachtelte Spalte hinzufügen, müssen Sie eine JSON-Schemadatei bereitstellen.

Wenn Sie versuchen, Spalten mithilfe einer Inline-Schemadefinition hinzuzufügen, müssen Sie die gesamte Schemadefinition einschließlich der neuen Spalten angeben. Da Sie keine Spaltenmodi mithilfe einer Inline-Schemadefinition angeben können, ändert jede Aktualisierung alle vorhandenen REPEATED-Spalten in NULLABLE, was folgenden Fehler erzeugt: BigQuery error in update operation: Provided Schema does not match Table PROJECT_ID:dataset.table. Field field has changed mode from REPEATED to NULLABLE.

Die bevorzugte Methode zum Hinzufügen von Spalten zu einer vorhandenen Tabelle mit dem -Befehlszeilentool ist das Bereitstellen einer JSON-Schemadatei.

So fügen Sie dem Schema einer Tabelle mithilfe einer JSON-Schemadatei leere Spalten hinzu:

1. Führen Sie zuerst den Befehl bq show mit dem Flag --schema aus und schreiben Sie das vorhandene Tabellenschema in eine Datei. Wenn sich die zu aktualisierende Tabelle in einem anderen Projekt als Ihrem Standardprojekt befindet, fügen Sie dem Dataset-Namen die Projekt-ID im folgenden Format hinzu: PROJECT_ID:DATASET.

   bq show \
   --schema \
   --format=prettyjson \
   PROJECT_ID:DATASET.TABLE > SCHEMA

   Dabei gilt:

   • PROJECT_ID ist Ihre Projekt-ID.
   • DATASET: der Name des Datasets, das die zu aktualisierende Tabelle enthält.
   • TABLE: der Name der zu aktualisierenden Tabelle.
   • SCHEMA: die Schemadefinitionsdatei, die auf Ihren lokalen Rechner geschrieben wird.

   Wenn Sie beispielsweise die Schemadefinition von mydataset.mytable in eine Datei schreiben möchten, geben Sie den unten aufgeführten Befehl ein. mydataset.mytable befindet sich in Ihrem Standardprojekt.

      bq show \
      --schema \
      --format=prettyjson \
      mydataset.mytable > /tmp/myschema.json
   

2. Öffnen Sie die Schemadatei in einem Texteditor. Das Schema sollte so aussehen:

   [
     {
       "mode": "REQUIRED",
       "name": "column1",
       "type": "STRING"
     },
     {
       "mode": "REQUIRED",
       "name": "column2",
       "type": "FLOAT"
     },
     {
       "mode": "REPEATED",
       "name": "column3",
       "type": "STRING"
     }
   ]
   

3. Fügen Sie die neuen Spalten am Ende der Schemadefinition hinzu. Wenn Sie versuchen, neue Spalten an anderer Stelle im Array hinzuzufügen, wird der folgende Fehler zurückgegeben: BigQuery error in update operation: Precondition Failed.

   Mit einer JSON-Datei können Sie für neue Spalten Beschreibungen, die Modi NULLABLE oder REPEATED und RECORD-Typen angeben. Wenn Sie beispielsweise die Schemadefinition aus dem vorherigen Schritt verwenden, sieht Ihr neues JSON-Array so aus. In diesem Beispiel wird die neue column4-Spalte mit dem Namen NULLABLE hinzugefügt. column4 enthält eine Beschreibung.

     [
       {
         "mode": "REQUIRED",
         "name": "column1",
         "type": "STRING"
       },
       {
         "mode": "REQUIRED",
         "name": "column2",
         "type": "FLOAT"
       },
       {
         "mode": "REPEATED",
         "name": "column3",
         "type": "STRING"
       },
       {
         "description": "my new column",
         "mode": "NULLABLE",
         "name": "column4",
         "type": "STRING"
       }
     ]
     

   Weitere Informationen zum Arbeiten mit JSON-Schemadateien finden Sie unter JSON-Schemadatei festlegen.

4. Nachdem Sie die Schemadatei aktualisiert haben, führen Sie den folgenden Befehl aus, um die Schemadefinition der Tabelle zu aktualisieren. Wenn sich die zu aktualisierende Tabelle in einem anderen Projekt als Ihrem Standardprojekt befindet, fügen Sie dem Dataset-Namen die Projekt-ID im folgenden Format hinzu: PROJECT_ID:DATASET.

   bq update PROJECT_ID:DATASET.TABLE SCHEMA

   Dabei gilt:

   • PROJECT_ID ist Ihre Projekt-ID.
   • DATASET: der Name des Datasets, das die zu aktualisierende Tabelle enthält.
   • TABLE: der Name der zu aktualisierenden Tabelle.
   • SCHEMA: die Schemadefinitionsdatei, die auf Ihren lokalen Rechner geschrieben wird.

   Geben Sie beispielsweise den unten aufgeführten Befehl ein, um die Schemadefinition von mydataset.mytable in Ihrem Standardprojekt zu aktualisieren. Der Pfad zur Schemadatei auf Ihrem lokalen Rechner lautet /tmp/myschema.json.

   bq update mydataset.mytable /tmp/myschema.json
   

API

Rufen Sie die Methode tables.patch auf und verwenden Sie das Attribut schema, um Ihrer Schemadefinition leere Spalten hinzuzufügen. Da die Methode tables.update die gesamte Tabellenressource ersetzt, ist die Methode tables.patch zu bevorzugen.

Go

import (
	"context"
	"fmt"

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

// updateTableAddColumn demonstrates modifying the schema of a table to append an additional column.
func updateTableAddColumn(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()

	tableRef := client.Dataset(datasetID).Table(tableID)
	meta, err := tableRef.Metadata(ctx)
	if err != nil {
		return err
	}
	newSchema := append(meta.Schema,
		&bigquery.FieldSchema{Name: "phone", Type: bigquery.StringFieldType},
	)
	update := bigquery.TableMetadataToUpdate{
		Schema: newSchema,
	}
	if _, err := tableRef.Update(ctx, update, meta.ETag); err != nil {
		return err
	}
	return nil
}

Java

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Field;
import com.google.cloud.bigquery.FieldList;
import com.google.cloud.bigquery.LegacySQLTypeName;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.StandardTableDefinition;
import com.google.cloud.bigquery.Table;
import java.util.ArrayList;
import java.util.List;

public class AddEmptyColumn {

  public static void runAddEmptyColumn() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableId = "MY_TABLE_NAME";
    String newColumnName = "NEW_COLUMN_NAME";
    addEmptyColumn(newColumnName, datasetName, tableId);
  }

  public static void addEmptyColumn(String newColumnName, String datasetName, String tableId) {
    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();

      Table table = bigquery.getTable(datasetName, tableId);
      Schema schema = table.getDefinition().getSchema();
      FieldList fields = schema.getFields();

      // Create the new field/column
      Field newField = Field.of(newColumnName, LegacySQLTypeName.STRING);

      // Create a new schema adding the current fields, plus the new one
      List<Field> fieldList = new ArrayList<Field>();
      fields.forEach(fieldList::add);
      fieldList.add(newField);
      Schema newSchema = Schema.of(fieldList);

      // Update the table with the new schema
      Table updatedTable =
          table.toBuilder().setDefinition(StandardTableDefinition.of(newSchema)).build();
      updatedTable.update();
      System.out.println("Empty column successfully added to table");
    } catch (BigQueryException e) {
      System.out.println("Empty column was not added. \n" + e.toString());
    }
  }
}

Node.js

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

async function addEmptyColumn() {
  // Adds an empty column to the schema.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = 'my_dataset';
  // const tableId = 'my_table';
  const column = {name: 'size', type: 'STRING'};

  // Retrieve current table metadata
  const table = bigquery.dataset(datasetId).table(tableId);
  const [metadata] = await table.getMetadata();

  // Update table schema
  const schema = metadata.schema;
  const new_schema = schema;
  new_schema.fields.push(column);
  metadata.schema = new_schema;

  const [result] = await table.setMetadata(metadata);
  console.log(result.schema.fields);
}

Python

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 add an empty column.
# table_id = "your-project.your_dataset.your_table_name"

table = client.get_table(table_id)  # Make an API request.

original_schema = table.schema
new_schema = original_schema[:]  # Creates a copy of the schema.
new_schema.append(bigquery.SchemaField("phone", "STRING"))

table.schema = new_schema
table = client.update_table(table, ["schema"])  # Make an API request.

if len(table.schema) == len(original_schema) + 1 == len(new_schema):
    print("A new column has been added.")
else:
    print("The column has not been added.")

Console

Das Einfügen eines neuen verschachtelten Felds in eine vorhandene RECORD-Spalte wird von der Google Cloud Console nicht unterstützt.

SQL

Das Einfügen eines neuen verschachtelten Felds in eine vorhandene RECORD-Spalte mithilfe einer SQL-DDL-Anweisung wird nicht unterstützt.

bq

Führen Sie den Befehl bq update aus und stellen Sie dabei eine JSON-Schemadatei bereit, die das verschachtelte Feld zur Schemadefinition der vorhandenen RECORD-Spalte hinzufügt. Wenn sich die zu aktualisierende Tabelle in einem anderen Projekt als Ihrem Standardprojekt befindet, fügen Sie dem Dataset-Namen die Projekt-ID im folgenden Format hinzu: PROJECT_ID:DATASET.

bq update PROJECT_ID:DATASET.TABLE SCHEMA

Dabei gilt:

• PROJECT_ID ist Ihre Projekt-ID.
• DATASET: der Name des Datasets, das die zu aktualisierende Tabelle enthält.
• TABLE: der Name der zu aktualisierenden Tabelle.
• SCHEMA: der Pfad zur JSON-Schemadatei auf Ihrem lokalen Rechner.

Wenn Sie ein Inline-Schema angeben, können Sie nicht die Spaltenbeschreibung, den Modus und den Typ RECORD (STRUCT) angeben. Alle Spaltenmodi sind standardmäßig auf NULLABLE gesetzt. Wenn Sie also einem RECORD eine neue verschachtelte Spalte hinzufügen, müssen Sie eine JSON-Schemadatei bereitstellen.

So fügen Sie einem RECORD mit einer JSON-Schemadatei eine verschachtelte Spalte hinzu:

1. Führen Sie zuerst den Befehl bq show mit dem Flag --schema aus und schreiben Sie das vorhandene Tabellenschema in eine Datei. Wenn sich die zu aktualisierende Tabelle in einem anderen Projekt als Ihrem Standardprojekt befindet, fügen Sie dem Dataset-Namen die Projekt-ID im folgenden Format hinzu: PROJECT_ID:DATASET.TABLE.

   bq show \
   --schema \
   --format=prettyjson \
   PROJECT_ID:DATASET.TABLE > SCHEMA

   Dabei gilt:

   • PROJECT_ID ist Ihre Projekt-ID.
   • DATASET: der Name des Datasets, das die zu aktualisierende Tabelle enthält.
   • TABLE: der Name der zu aktualisierenden Tabelle.
   • SCHEMA: die Schemadefinitionsdatei, die auf Ihren lokalen Rechner geschrieben wird.

   Wenn Sie beispielsweise die Schemadefinition von mydataset.mytable in eine Datei schreiben möchten, geben Sie den unten aufgeführten Befehl ein. mydataset.mytable befindet sich in Ihrem Standardprojekt.

   bq show \
   --schema \
   --format=prettyjson \
   mydataset.mytable > /tmp/myschema.json
   

2. Öffnen Sie die Schemadatei in einem Texteditor. Das Schema sollte wie unten dargestellt aussehen. In diesem Beispiel ist column3 eine verschachtelte wiederholte Spalte. Die verschachtelten Spalten sind nested1 und nested2. Das Array fields listet die in column3 verschachtelten Felder auf.

   [
     {
       "mode": "REQUIRED",
       "name": "column1",
       "type": "STRING"
     },
     {
       "mode": "REQUIRED",
       "name": "column2",
       "type": "FLOAT"
     },
     {
       "fields": [
         {
           "mode": "NULLABLE",
           "name": "nested1",
           "type": "STRING"
         },
         {
           "mode": "NULLABLE",
           "name": "nested2",
           "type": "STRING"
         }
       ],
       "mode": "REPEATED",
       "name": "column3",
       "type": "RECORD"
     }
   ]
   

3. Fügen Sie die neue verschachtelte Spalte am Ende des Arrays fields hinzu. In diesem Beispiel ist nested3 die neue verschachtelte Spalte.

     [
       {
         "mode": "REQUIRED",
         "name": "column1",
         "type": "STRING"
       },
       {
         "mode": "REQUIRED",
         "name": "column2",
         "type": "FLOAT"
       },
       {
         "fields": [
           {
             "mode": "NULLABLE",
             "name": "nested1",
             "type": "STRING"
           },
           {
             "mode": "NULLABLE",
             "name": "nested2",
             "type": "STRING"
           },
           {
             "mode": "NULLABLE",
             "name": "nested3",
             "type": "STRING"
           }
         ],
         "mode": "REPEATED",
         "name": "column3",
         "type": "RECORD"
       }
     ]
     

   Weitere Informationen zum Arbeiten mit JSON-Schemadateien finden Sie unter JSON-Schemadatei festlegen.

4. Nachdem Sie die Schemadatei aktualisiert haben, führen Sie den folgenden Befehl aus, um die Schemadefinition der Tabelle zu aktualisieren. Wenn sich die zu aktualisierende Tabelle in einem anderen Projekt als Ihrem Standardprojekt befindet, fügen Sie dem Dataset-Namen die Projekt-ID im folgenden Format hinzu: PROJECT_ID:DATASET.

   bq update PROJECT_ID:DATASET.TABLE SCHEMA

   Dabei gilt:

   • PROJECT_ID ist Ihre Projekt-ID.
   • DATASET: der Name des Datasets, das die zu aktualisierende Tabelle enthält.
   • TABLE: der Name der zu aktualisierenden Tabelle.
   • SCHEMA: der Pfad zur JSON-Schemadatei auf Ihrem lokalen Rechner.

   Geben Sie beispielsweise den unten aufgeführten Befehl ein, um die Schemadefinition von mydataset.mytable in Ihrem Standardprojekt zu aktualisieren. Der Pfad zur Schemadatei auf Ihrem lokalen Rechner lautet /tmp/myschema.json.

   bq update mydataset.mytable /tmp/myschema.json
   

API

Rufen Sie die Methode tables.patch auf und verwenden Sie das Attribut schema, um der Schemadefinition die verschachtelten Spalten hinzuzufügen. Da die Methode tables.update die gesamte Tabellenressource ersetzt, ist die Methode tables.patch zu bevorzugen.

bq

Laden Sie Ihre Daten mit dem Befehl bq load und fügen Sie das Flag --noreplace hinzu, um anzugeben, dass Sie die Daten an eine vorhandene Tabelle anfügen.

Wenn die von Ihnen angefügten Daten im CSV-Format oder im JSON-Format mit Zeilenumbrüchen vorliegen, geben Sie das Flag --autodetect für die automatische Schemaerkennung an oder stellen das Schema in einer JSON-Schemadatei bereit. Die hinzugefügten Spalten können automatisch aus Avro- oder Datastore-Exportdateien übernommen werden.

Setzen Sie das Flag --schema_update_option auf ALLOW_FIELD_ADDITION, um anzugeben, dass die von Ihnen angefügten Daten neue Spalten enthalten.

Wenn sich die anzufügende Tabelle in einem Dataset befindet, das in einem anderen Projekt als Ihrem Standardprojekt enthalten ist, geben Sie im Dataset-Namen die Projekt-ID im folgenden Format ein: PROJECT_ID:DATASET.

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

Geben Sie den Befehl load so ein:

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

Dabei gilt:

• LOCATION: Name Ihres Standorts. 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.
• FORMAT: das Format des Schemas. NEWLINE_DELIMITED_JSON, CSV, AVRO, PARQUET, ORC, oder DATASTORE_BACKUP.
• PROJECT_ID ist Ihre Projekt-ID.
• DATASET: der Name des Datasets, das die Tabelle enthält.
• TABLE: der Name der Tabelle, die Sie anhängen.
• PATH_TO_SOURCE ist ein vollständig qualifizierter Cloud Storage-URI, eine Liste von durch Kommas getrennten URIs oder der Pfad zu einer Datendatei auf dem lokalen Rechner.
• SCHEMA: der Pfad zu einer lokalen JSON-Schemadatei Eine Schemadatei ist nur für CSV- und JSON-Dateien erforderlich, wenn --autodetect nicht angegeben wurde. Avro- und Datastore-Schemas werden aus den Quelldaten abgeleitet.

Beispiele:

Geben Sie den folgenden Befehl ein, um eine lokale Avro-Datendatei (/tmp/mydata.avro) mithilfe eines Ladejobs an mydataset.mytable anzufügen. Da Schemas automatisch aus Avro-Daten abgeleitet werden können, müssen Sie das Flag --autodetect nicht verwenden. mydataset befindet sich in Ihrem Standardprojekt.

bq load \
--noreplace \
--schema_update_option=ALLOW_FIELD_ADDITION \
--source_format=AVRO \
mydataset.mytable \
/tmp/mydata.avro

Geben Sie den folgenden Befehl ein, um mithilfe eines Ladejobs eine durch Zeilenumbruch getrennte JSON-Datei in Cloud Storage an mydataset.mytable anzufügen. Das Flag --autodetect wird verwendet, um die neuen Spalten zu erkennen. mydataset befindet sich in Ihrem Standardprojekt.

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

Geben Sie den folgenden Befehl ein, um mithilfe eines Ladejobs eine durch Zeilenumbruch getrennte JSON-Datei in Cloud Storage an mydataset.mytable anzufügen. Das Schema mit den neuen Spalten wird in der lokalen JSON-Schemadatei /tmp/myschema.json angegeben. mydataset befindet sich in myotherproject, nicht in Ihrem Standardprojekt.

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

API

Rufen Sie die Methode jobs.insert auf. Konfigurieren Sie einen Ladejob (load) und legen Sie die folgenden Attribute fest:

• Verweisen Sie mit dem Attribut sourceUris auf Ihre Daten in Cloud Storage.
• Geben Sie das Datenformat an. Legen Sie dazu das Attribut sourceFormat fest.
• Geben Sie das Schema im Attribut schema an.
• Geben Sie die Aktualisierungsoption des Schemas mit dem Attribut schemaUpdateOptions an.
• Legen Sie die Schreibanordnung der Zieltabelle mit dem Attribut writeDisposition als WRITE_APPEND fest.

Go

import (
	"context"
	"fmt"
	"os"

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

// createTableAndWidenLoad demonstrates augmenting a table's schema to add a new column via a load job.
func createTableAndWidenLoad(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()

	sampleSchema := bigquery.Schema{
		{Name: "full_name", Type: bigquery.StringFieldType},
	}
	meta := &bigquery.TableMetadata{
		Schema: sampleSchema,
	}
	tableRef := client.Dataset(datasetID).Table(tableID)
	if err := tableRef.Create(ctx, meta); err != nil {
		return err
	}
	// Now, import data from a local file, but specify field additions are allowed.
	// Because the data has a second column (age), the schema is amended as part of
	// the load.
	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)
	loader.SchemaUpdateOptions = []string{"ALLOW_FIELD_ADDITION"}
	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

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Field;
import com.google.cloud.bigquery.FormatOptions;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobId;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.JobInfo.SchemaUpdateOption;
import com.google.cloud.bigquery.