Tabellenschemas ändern

In diesem Dokument wird beschrieben, wie Sie die Schemadefinitionen für vorhandene BigQuery-Tabellen ändern können.

Sie können die meisten in diesem Dokument beschriebenen Schemaänderungen mit DDL-Anweisungen (Data Definition Language, Datendefinitionssprache) vornehmen. Für diese Anweisungen fallen keine Gebühren an.

Sie können ein Tabellenschema auf alle hier beschriebenen Arten ändern. Exportieren Sie Ihre Tabellendaten zuerst nach Cloud Storage, und laden Sie die Daten dann in eine neue Tabelle mit der geänderten Schemadefinition. BigQuery-Lade- und Exportjobs sind kostenlos. Es fallen jedoch Kosten für das Speichern der exportierten Daten in Cloud Storage an. In den folgenden Abschnitten werden andere Möglichkeiten zum Ausführen verschiedener Arten von Schemaänderungen beschrieben.

Spalte hinzufügen

Sie haben folgende Möglichkeiten, Spalten zur Schemadefinition einer vorhandenen Tabelle hinzuzufügen:

Fügen Sie eine neue leere Spalte hinzu.
Überschreiben Sie eine Tabelle mit einem Lade- oder Abfragejob.
Hängen Sie Daten an eine Tabelle mit einem Lade- oder Abfragejob an.

Beim Hinzufügen von Spalten müssen die BigQuery-Regeln für Spaltennamen beachtet werden. Weitere Informationen zum Erstellen von Schemakomponenten finden Sie unter Schema angeben.

Leere Spalte hinzufügen

Wenn Sie einem vorhandenen Tabellenschema neue Spalten hinzufügen, müssen die Spalten den Modus NULLABLE oder REPEATED haben. Sie können einem vorhandenen Tabellenschema keine REQUIRED-Spalte hinzufügen. Das Hinzufügen einer REQUIRED-Spalte zu einem vorhandenen Tabellenschema in der API oder dem -Befehlszeilentool führt zu einem Fehler. Sie können jedoch eine verschachtelte Spalte vom Typ REQUIRED als Teil des neuen RECORD-Felds erstellen. REQUIRED-Spalten können nur hinzugefügt werden, wenn Sie beim Laden von Daten eine Tabelle erstellen oder wenn Sie eine leere Tabelle mit einer Schemadefinition erstellen.

So fügen Sie der Schemadefinition einer Tabelle leere Spalten hinzu:

Console

Rufen Sie in der Google Cloud Console die Seite „BigQuery“ auf.

BigQuery aufrufen
Maximieren Sie im Bereich Explorer Ihr Projekt und das Dataset und wählen Sie dann die Tabelle aus.
Klicken Sie im Detailbereich auf den Tab Schema.
Klicken Sie auf Schema bearbeiten. Eventuell müssen Sie scrollen, um diese Schaltfläche zu sehen.
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.
Wenn Sie die gewünschten Spalten hinzugefügt haben, klicken Sie auf Save (Speichern).

SQL

Verwenden Sie die DDL-Anweisung ALTER TABLE ADD COLUMN:

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

BigQuery aufrufen

Geben Sie im Abfrageeditor die folgende Anweisung ein:

ALTER TABLE mydataset.mytable
ADD COLUMN new_column STRING;

Klicken Sie auf 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:

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

Ö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"
  }
]

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

Einfach loslegen (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

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

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

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

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

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


// Import the Google Cloud client 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

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

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

Fügen Sie an eine Kopie von Table.schema ein neues SchemaField-Objekt an und ersetzen Sie den Wert des Attributs Table.schema durch das aktualisierte Schema.

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

Verschachtelte Spalte einer `RECORD`-Spalte hinzufügen

Zusätzlich zum Einfügen neuer Spalten in das Schema einer Tabelle können Sie einer RECORD-Spalte auch neue verschachtelte Spalten hinzufügen. Der Vorgang zum Einfügen einer neuen verschachtelten Spalte ähnelt dem Vorgang zum Hinzufügen einer neuen Spalte.

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.

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

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

Ö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"
  }
]

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.

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.

Spalten beim Überschreiben oder Anfügen von Daten hinzufügen

Sie können einer vorhandenen Tabelle neue Spalten hinzufügen, wenn Sie Daten in sie laden und die vorhandene Tabelle überschreiben. Wenn Sie eine vorhandene Tabelle überschreiben, wird das dazugehörige Schema mit dem Schema der Daten überschrieben, die Sie laden. Informationen zum Überschreiben einer Tabelle mit einem Ladejob finden Sie im Dokument zu Ihrem Datenformat:

Spalten im Rahmen eines Anfüge-/Ladejobs hinzufügen

Sie können einer Tabelle Spalten hinzufügen, wenn Sie Daten in einem Ladejob an sie anfügen. Das neue Schema wird durch einen der folgenden Aspekte bestimmt:

Automatische Erkennung (für CSV- und JSON-Dateien)
Ein in einer JSON-Schemadatei angegebenes Schema (für CSV- und JSON-Dateien)
Die selbstbeschreibenden Quelldaten für Avro-, ORC-, Parquet- und Datastore-Exportdateien

Wenn Sie das Schema in einer JSON-Datei angeben, müssen die neuen Spalten darin definiert sein. Wenn die neuen Spaltendefinitionen fehlen und Sie versuchen, die Daten anzufügen, wird ein Fehler zurückgegeben.

Wenn Sie während eines Anfügevorgangs neue Spalten hinzufügen, werden die Werte in den neuen Spalten für vorhandene Zeilen auf NULL gesetzt.

Mit einer der folgenden Optionen können Sie eine neue Spalte hinzufügen, wenn Sie während eines Ladejobs einer Tabelle Daten anfügen:

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.

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.

Einfach loslegen (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

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

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.JobInfo.WriteDisposition;
import com.google.cloud.bigquery.LegacySQLTypeName;
import com.google.cloud.bigquery.LoadJobConfiguration;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.TableId;
import com.google.common.collect.ImmutableList;
import java.util.UUID;

public class AddColumnLoadAppend {

  public static void runAddColumnLoadAppend() throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String sourceUri = "/path/to/file.csv";
    addColumnLoadAppend(datasetName, tableName, sourceUri);
  }

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

      TableId tableId = TableId.of(datasetName, tableName);

      // Add a new column to a BigQuery table while appending rows via a load job.
      // 'REQUIRED' fields cannot  be added to an existing schema, so the additional column must be
      // 'NULLABLE'.
      Schema newSchema =
          Schema.of(
              Field.newBuilder("name", LegacySQLTypeName.STRING)
                  .setMode(Field.Mode.REQUIRED)
                  .build(),
              // Adding below additional column during the load job
              Field.newBuilder("post_abbr", LegacySQLTypeName.STRING)
                  .setMode(Field.Mode.NULLABLE)
                  .build());

      LoadJobConfiguration loadJobConfig =
          LoadJobConfiguration.builder(tableId, sourceUri)
              .setFormatOptions(FormatOptions.csv())
              .setWriteDisposition(WriteDisposition.WRITE_APPEND)
              .setSchema(newSchema)
              .setSchemaUpdateOptions(ImmutableList.of(SchemaUpdateOption.ALLOW_FIELD_ADDITION))
              .build();

      // Create a job ID so that we can safely retry.
      JobId jobId = JobId.of(UUID.randomUUID().toString());
      Job loadJob = bigquery.create(JobInfo.newBuilder(loadJobConfig).setJobId(jobId).build());

      // 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 = loadJob.waitFor();

      // Check for errors
      if (completedJob == null) {
        throw new Exception("Job not executed since it no longer exists.");
      } else if (completedJob.getStatus().getError() != null) {
        // You can also look at queryJob.getStatus().getExecutionErrors() for all
        // errors, not just the latest one.
        throw new Exception(
            "BigQuery was unable to load into the table due to an error: \n"
                + loadJob.getStatus().getError());
      }
      System.out.println("Column successfully added during load append job");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Column not added during load append \n" + e.toString());
    }
  }
}

Node.js

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

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

// Instantiate client
const bigquery = new BigQuery();

async function addColumnLoadAppend() {
  // Adds a new column to a BigQuery table while appending rows via a load job.

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

  // In this example, the existing table contains only the 'Name', 'Age',
  // & 'Weight' columns. 'REQUIRED' fields cannot  be added to an existing
  // schema, so the additional column must be 'NULLABLE'.
  const schema = 'Name:STRING, Age:INTEGER, Weight:FLOAT, IsMagic:BOOLEAN';

  // Retrieve destination table reference
  const [table] = await bigquery
    .dataset(datasetId)
    .table(tableId)
    .get();
  const destinationTableRef = table.metadata.tableReference;

  // Set load job options
  const options = {
    schema: schema,
    schemaUpdateOptions: ['ALLOW_FIELD_ADDITION'],
    writeDisposition: 'WRITE_APPEND',
    destinationTable: destinationTableRef,
  };

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

  console.log(`Job ${job.id} completed.`);
  console.log(`New Schema:`);
  console.log(job.configuration.load.schema.fields);

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

Python

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

# from google.cloud import bigquery
# client = bigquery.Client()
# project = client.project
# dataset_ref = bigquery.DatasetReference(project, 'my_dataset')
# filepath = 'path/to/your_file.csv'

# Retrieves the destination table and checks the length of the schema
table_id = "my_table"
table_ref = dataset_ref.table(table_id)
table = client.get_table(table_ref)
print("Table {} contains {} columns.".format(table_id, len(table.schema)))

# Configures the load job to append the data to the destination table,
# allowing field addition
job_config = bigquery.LoadJobConfig()
job_config.write_disposition = bigquery.WriteDisposition.WRITE_APPEND
job_config.schema_update_options = [
    bigquery.SchemaUpdateOption.ALLOW_FIELD_ADDITION
]
# In this example, the existing table contains only the 'full_name' column.
# 'REQUIRED' fields cannot be added to an existing schema, so the
# additional column must be 'NULLABLE'.
job_config.schema = [
    bigquery.SchemaField("full_name", "STRING", mode="REQUIRED"),
    bigquery.SchemaField("age", "INTEGER", mode="NULLABLE"),
]
job_config.source_format = bigquery.SourceFormat.CSV
job_config.skip_leading_rows = 1

with open(filepath, "rb") as source_file:
    job = client.load_table_from_file(
        source_file,
        table_ref,
        location="US",  # Must match the destination dataset location.
        job_config=job_config,
    )  # API request

job.result()  # Waits for table load to complete.
print(
    "Loaded {} rows into {}:{}.".format(
        job.output_rows, dataset_id, table_ref.table_id
    )
)

# Checks the updated length of the schema
table = client.get_table(table)
print("Table {} now contains {} columns.".format(table_id, len(table.schema)))

Spalten im Rahmen eines Abfrage-/Anfügejobs hinzufügen

Sie können einer Tabelle Spalten hinzufügen, wenn Sie Abfrageergebnisse an diese anfügen.

Wenn Sie Spalten über einen Anfügevorgang in einem Abfragejob hinzufügen, wird das Schema der Zieltabelle mit dem Schema der Abfrageergebnisse aktualisiert. Beachten Sie, dass Sie nicht eine Tabelle an einem Standort abfragen und die Ergebnisse in eine Tabelle an einem anderen Standort schreiben können.

Wählen Sie eine der folgenden Optionen, um beim Anfügen von Daten an eine Tabelle während eines Abfragejobs eine neue Spalte hinzuzufügen:

bq

Zum Abfragen Ihrer Daten verwenden Sie den Befehl bq query. Mit dem Flag --destination_table legen Sie dabei fest, an welche Tabelle Sie anfügen.

Mit dem Flag --append_table können Sie angeben, dass Sie Abfrageergebnisse an eine vorhandene Zieltabelle anfügen.

Setzen Sie das Flag --schema_update_option auf ALLOW_FIELD_ADDITION, um anzugeben, dass die angehängten Abfrageergebnisse neue Spalten enthalten.

Geben Sie das Flag use_legacy_sql=false an, um die GoogleSQL-Syntax für die Abfrage zu verwenden.

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. Beachten Sie, dass sich die Tabelle, die Sie abfragen, und die Zieltabelle am selben Standort befinden müssen.

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

bq --location=LOCATION query \
--destination_table PROJECT_ID:DATASET.TABLE \
--append_table \
--schema_update_option=ALLOW_FIELD_ADDITION \
--use_legacy_sql=false \
'QUERY'

Ersetzen Sie Folgendes:

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. Beachten Sie, dass Sie Abfrageergebnisse nicht an eine Tabelle an einem anderen Standort anfügen können.
PROJECT_ID ist Ihre Projekt-ID.
dataset: der Name des Datasets, das die Tabelle enthält, die Sie anfügen.
TABLE: der Name der Tabelle, die Sie anhängen.
QUERY: eine Abfrage in der GoogleSQL-Syntax.

Beispiele:

Geben Sie den folgenden Befehl ein, um mydataset.mytable in Ihrem Standardprojekt abzufragen und die Abfrageergebnisse an mydataset.mytable2 anzufügen. Dies ist auch in Ihrem Standardprojekt möglich.

bq query \
--destination_table mydataset.mytable2 \
--append_table \
--schema_update_option=ALLOW_FIELD_ADDITION \
--use_legacy_sql=false \
'SELECT
   column1,column2
 FROM
   mydataset.mytable'

Geben Sie den folgenden Befehl ein, um mydataset.mytable in Ihrem Standardprojekt abzufragen und die Abfrageergebnisse an mydataset.mytable2 in myotherproject anzufügen.

bq query \
--destination_table myotherproject:mydataset.mytable2 \
--append_table \
--schema_update_option=ALLOW_FIELD_ADDITION \
--use_legacy_sql=false \
'SELECT
   column1,column2
 FROM
   mydataset.mytable'

API

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

Geben Sie die Zieltabelle mit dem Attribut destinationTable an.
Legen Sie die Schreibanordnung der Zieltabelle mit dem Attribut writeDisposition als WRITE_APPEND fest.
Geben Sie die Aktualisierungsoption des Schemas mit dem Attribut schemaUpdateOptions an.
Geben Sie die GoogleSQL-Abfrage mit dem Attribut query an.

Einfach loslegen (Go)

import (
	"context"
	"fmt"

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

// createTableAndWidenQuery demonstrates how the schema of a table can be modified to add columns by appending
// query results that include the new columns.
func createTableAndWidenQuery(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()

	// First, we create a sample table.
	sampleSchema := bigquery.Schema{
		{Name: "full_name", Type: bigquery.StringFieldType, Required: true},
		{Name: "age", Type: bigquery.IntegerFieldType, Required: true},
	}
	original := &bigquery.TableMetadata{
		Schema: sampleSchema,
	}
	tableRef := client.Dataset(datasetID).Table(tableID)
	if err := tableRef.Create(ctx, original); err != nil {
		return err
	}
	// Our table has two columns.  We'll introduce a new favorite_color column via
	// a subsequent query that appends to the table.
	q := client.Query("SELECT \"Timmy\" as full_name, 85 as age, \"Blue\" as favorite_color")
	q.SchemaUpdateOptions = []string{"ALLOW_FIELD_ADDITION"}
	q.QueryConfig.Dst = client.Dataset(datasetID).Table(tableID)
	q.WriteDisposition = bigquery.WriteAppend
	q.Location = "US"
	job, err := q.Run(ctx)
	if err != nil {
		return err
	}
	_, err = job.Wait(ctx)
	if err != nil {
		return err
	}
	return nil
}

Java

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

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.JobInfo.SchemaUpdateOption;
import com.google.cloud.bigquery.JobInfo.WriteDisposition;
import com.google.cloud.bigquery.QueryJobConfiguration;
import com.google.cloud.bigquery.TableId;
import com.google.cloud.bigquery.TableResult;
import com.google.common.collect.ImmutableList;

public class RelaxTableQuery {

  public static void runRelaxTableQuery() throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "MY_PROJECT_ID";
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    relaxTableQuery(projectId, datasetName, tableName);
  }

  // To relax all columns in a destination table when you append data to it during a query job
  public static void relaxTableQuery(String projectId, String datasetName, String tableName)
      throws Exception {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      TableId tableId = TableId.of(datasetName, tableName);

      String sourceTable = "`" + projectId + "." + datasetName + "." + tableName + "`";
      String query = "SELECT word FROM " + sourceTable + " WHERE word like '%is%'";

      QueryJobConfiguration queryConfig =
          QueryJobConfiguration.newBuilder(query)
              // Use standard SQL syntax for queries.
              // See: https://cloud.google.com/bigquery/sql-reference/
              .setUseLegacySql(false)
              .setSchemaUpdateOptions(ImmutableList.of(SchemaUpdateOption.ALLOW_FIELD_RELAXATION))
              .setWriteDisposition(WriteDisposition.WRITE_APPEND)
              .setDestinationTable(tableId)
              .build();

      Job queryJob = bigquery.create(JobInfo.newBuilder(queryConfig).build());

      queryJob = queryJob.waitFor();

      // Check for errors
      if (queryJob == null) {
        throw new Exception("Job no longer exists");
      } else if (queryJob.getStatus().getError() != null) {
        // You can also look at queryJob.getStatus().getExecutionErrors() for all
        // errors, not just the latest one.
        throw new Exception(queryJob.getStatus().getError().toString());
      }

      // Get the results.
      TableResult results = queryJob.getQueryResults();

      // Print all pages of the results.
      results
          .iterateAll()
          .forEach(
              rows -> {
                rows.forEach(row -> System.out.println("row: " + row.toString()));
              });

      System.out.println("Successfully relaxed all columns in destination table during query job");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Columns not relaxed during query job \n" + e.toString());
    }
  }
}

Node.js

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

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

// Instantiate client
const bigquery = new BigQuery();

async function addColumnQueryAppend() {
  // Adds a new column to a BigQuery table while appending rows via a query job.

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

  // Retrieve destination table reference
  const [table] = await bigquery
    .dataset(datasetId)
    .table(tableId)
    .get();
  const destinationTableRef = table.metadata.tableReference;

  // In this example, the existing table contains only the 'name' column.
  // 'REQUIRED' fields cannot  be added to an existing schema,
  // so the additional column must be 'NULLABLE'.
  const query = `SELECT name, year
    FROM \`bigquery-public-data.usa_names.usa_1910_2013\`
    WHERE state = 'TX'
    LIMIT 10`;

  // Set load job options
  const options = {
    query: query,
    schemaUpdateOptions: ['ALLOW_FIELD_ADDITION'],
    writeDisposition: 'WRITE_APPEND',
    destinationTable: destinationTableRef,
    // Location must match that of the dataset(s) referenced in the query.
    location: 'US',
  };

  const [job] = await bigquery.createQueryJob(options);
  console.log(`Job ${job.id} started.`);

  // Wait for the query to finish
  const [rows] = await job.getQueryResults();
  console.log(`Job ${job.id} completed.`);

  // Print the results
  console.log('Rows:');
  rows.forEach(row => console.log(row));
}

Python

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

from google.cloud import bigquery

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

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

# Retrieves the destination table and checks the length of the schema.
table = client.get_table(table_id)  # Make an API request.
print("Table {} contains {} columns".format(table_id, len(table.schema)))

# Configures the query to append the results to a destination table,
# allowing field addition.
job_config = bigquery.QueryJobConfig(
    destination=table_id,
    schema_update_options=[bigquery.SchemaUpdateOption.ALLOW_FIELD_ADDITION],
    write_disposition=bigquery.WriteDisposition.WRITE_APPEND,
)

# Start the query, passing in the extra configuration.
query_job = client.query(
    # In this example, the existing table contains only the 'full_name' and
    # 'age' columns, while the results of this query will contain an
    # additional 'favorite_color' column.
    'SELECT "Timmy" as full_name, 85 as age, "Blue" as favorite_color;',
    job_config=job_config,
)  # Make an API request.
query_job.result()  # Wait for the job to complete.

# Checks the updated length of the schema.
table = client.get_table(table_id)  # Make an API request.
print("Table {} now contains {} columns".format(table_id, len(table.schema)))

Name einer Spalte ändern

Mit der DDL-Anweisung ALTER TABLE RENAME COLUMN können Sie eine Spalte in einer Tabelle umbenennen. Im folgenden Beispiel wird die Spalte old_name für mytable in new_name umbenannt:

ALTER TABLE mydataset.mytable
  RENAME COLUMN old_name TO new_name;

Weitere Informationen zu ALTER TABLE RENAME COLUMN-Anweisungen finden Sie unter DDL-Details.

Datentyp einer Spalte ändern

Das Ändern des Datentyps einer Spalte wird von der Google Cloud Console, dem bq-Befehlszeilentool und der BigQuery API nicht unterstützt. Beim Versuch, eine Tabelle durch Anwenden eines Schemas zu aktualisieren, in dem ein neuer Datentyp für eine Spalte angegeben wird, wird ein Fehler zurückgegeben:

Datentyp einer Spalte erzwingen

Verwenden Sie die DDL-Anweisung ALTER COLUMN SET DATA TYPE, um den Datentyp einer Spalte in einen erzwingbaren Typ zu ändern. Informationen zu unterstützten Datentypkonvertierungen finden Sie unter Details.

Im folgenden Beispiel wird eine Tabelle mit einer Spalte vom Typ INT64 erstellt. Anschließend wird der Typ auf NUMERIC aktualisiert:

CREATE TABLE mydataset.mytable(c1 INT64);

ALTER TABLE mydataset.mytable
ALTER COLUMN c1 SET DATA TYPE NUMERIC;

Datentyp einer Spalte umwandeln

Wenn Sie den Datentyp einer Spalte in einen umwandelbaren Typ ändern möchten, verwenden Sie eine SQL-Abfrage, um die Tabellendaten auszuwählen, wandeln die relevante Spalte um, und überschreiben die Tabelle. Umwandeln und Überschreiben wird für sehr große Tabellen nicht empfohlen, da dafür ein vollständiger Tabellenscan erforderlich ist.

Im folgenden Beispiel sehen Sie eine SQL-Abfrage, mit der alle Daten aus column_two und column_three in mydataset.mytable ausgewählt werden und column_one von DATE in STRING umgewandelt wird. Die vorhandene Tabelle wird mit dem Abfrageergebnis überschrieben. In der überschriebenen Tabelle wird column_one als Datentyp STRING gespeichert.

Eine Abfrage mit CAST kann fehlschlagen, wenn BigQuery die Umwandlung nicht ausführen kann. Weitere Informationen zu Umwandlungsregeln in GoogleSQL finden Sie unter Umwandeln.

Console

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

BigQuery aufrufen
Geben Sie im Abfrageeditor die folgende Abfrage ein, um alle Daten aus column_two und column_three in mydataset.mytable auszuwählen und column_one von DATE in STRING umzuwandeln. In der Abfrage wird ein Alias verwendet, um column_one mit demselben Namen umzuwandeln. mydataset.mytable befindet sich in Ihrem Standardprojekt.
```
SELECT
 column_two,
 column_three,
 CAST(column_one AS STRING) AS column_one
FROM
 mydataset.mytable;
```
Klicken Sie auf More (Mehr) und wählen Sie Query settings (Abfrageeinstellungen) aus.
Führen Sie im Abschnitt Ziel folgende Schritte aus:
1. Wählen Sie Zieltabelle für Abfrageergebnisse festlegen.
2. Behalten Sie für Projektname das Standardprojekt als Wert bei. Dies ist das Projekt, das mydataset.mytable enthält.
3. Wählen Sie für Dataset die Option mydataset aus.
4. Geben Sie im Feld Tabllen-ID den Wert mytable ein.
5. Wählen Sie für Schreibeinstellung für Zieltabelle die Option Tabelle überschreiben. Diese Option überschreibt mytable mit den Abfrageergebnissen.
Optional: Wählen Sie den Standort Ihrer Daten aus.
Klicken Sie zum Aktualisieren der Einstellungen auf Speichern.
Klicken Sie auf Ausführen.

Wenn der Abfragejob abgeschlossen ist, hat column_one den Datentyp STRING.

bq

Geben Sie den folgenden bq query-Befehl ein, um alle Daten aus column_two und column_three in mydataset.mytable auszuwählen und column_one von DATE in STRING umzuwandeln. In der Abfrage wird ein Alias verwendet, um column_one mit demselben Namen umzuwandeln. mydataset.mytable befindet sich in Ihrem Standardprojekt.

Die Abfrageergebnisse werden mit dem Flag --destination_table in mydataset.mytable geschrieben. Das Flag --replace wird verwendet, um mytable zu überschreiben. Mit dem Flag use_legacy_sql=false legen Sie die GoogleSQL-Syntax fest.

Optional können Sie das Flag --location angeben und Ihren Standort als dessen Wert festlegen.

bq query \
    --destination_table mydataset.mytable \
    --replace \
    --use_legacy_sql=false \
'SELECT
  column_two,
  column_three,
  CAST(column_one AS STRING) AS column_one
FROM
  mydataset.mytable'

API

Rufen Sie die Methode jobs.insert auf und konfigurieren Sie einen query-Job, um alle Daten aus column_two und column_three in mydataset.mytable auszuwählen und column_one von DATE in STRING umzuwandeln. Optional: Geben Sie im Abschnitt jobReference im Attribut location Ihren Standort an.

Die im Abfragejob verwendete SQL-Abfrage würde so lauten: SELECT column_two, column_three, CAST(column_one AS STRING) AS column_one FROM mydataset.mytable. In der Abfrage wird ein Alias verwendet, um column_one mit demselben Namen umzuwandeln.

Fügen Sie mydataset.mytable im Attribut configuration.query.destinationTable hinzu und geben Sie WRITE_TRUNCATE im Attribut configuration.query.writeDisposition an, um mytable mit den Abfrageergebnissen zu überschreiben.

Modus einer Spalte ändern

Derzeit können Sie den Modus einer Spalte nur von REQUIRED in NULLABLE ändern. Das Ändern des Spaltenmodus von REQUIRED zu NULLABLE wird auch als Spaltenlockerung bezeichnet. Sie können eine Spalte auch lockern, wenn Sie Daten laden, um eine vorhandene Tabelle zu überschreiben, oder wenn Sie Daten an eine vorhandene Tabelle anfügen. Sie können den Modus einer Spalte nicht von NULLABLE zu REQUIRED ändern.

Spalte in einer vorhandenen Tabelle als `NULLABLE` deklarieren

Wählen Sie eine der folgenden Optionen aus, um den Modus einer Spalte von REQUIRED zu NULLABLE zu ändern:

Console

Rufen Sie die Seite BigQuery auf.

BigQuery aufrufen
Maximieren Sie im Bereich Explorer Ihr Projekt und das Dataset und wählen Sie dann die Tabelle aus.
Klicken Sie im Detailbereich auf den Tab Schema.
Klicken Sie auf Schema bearbeiten. Eventuell müssen Sie scrollen, um diese Schaltfläche zu sehen.
Suchen Sie auf der Seite Aktuelles Schema das Feld, das Sie ändern möchten.
Wählen Sie in der Drop-down-Liste Modus für das Feld NULLABLE aus.
Klicken Sie zum Aktualisieren der Einstellungen auf Speichern.

SQL

Verwenden Sie die DDL-Anweisung ALTER COLUMN DROP NOT NULL. Im folgenden Beispiel wird der Modus der Spalte mycolumn von REQUIRED in NULLABLE geändert:

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

BigQuery aufrufen

Geben Sie im Abfrageeditor die folgende Anweisung ein:

ALTER TABLE mydataset.mytable
ALTER COLUMN mycolumn
DROP NOT NULL;

Klicken Sie auf Ausführen.

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

bq

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_FILE
```
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_FILE: die Schemadefinitionsdatei, die auf Ihren lokalen Rechner geschrieben wurde.
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
```

Ö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"
  }
]

Ändern Sie den Modus einer vorhandenen Spalte von REQUIRED zu NULLABLE. In diesem Beispiel wird der Modus für column1 gelockert.

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

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

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 eine REQUIRED-Spalte in Ihrer Schemadefinition in NULLABLE zu ändern. Da die Methode tables.update die gesamte Tabellenressource ersetzt, ist die Methode tables.patch zu bevorzugen.

Einfach loslegen (Go)

import (
	"context"
	"fmt"

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

// relaxTableAPI demonstrates modifying the schema of a table to remove the requirement that columns allow
// no NULL values.
func relaxTableAPI(projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydatasetid"
	// tableID := "mytableid"
	ctx := context.Background()

	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	// Setup: We first create a table with a schema that's restricts NULL values.
	sampleSchema := bigquery.Schema{
		{Name: "full_name", Type: bigquery.StringFieldType, Required: true},
		{Name: "age", Type: bigquery.IntegerFieldType, Required: true},
	}
	original := &bigquery.TableMetadata{
		Schema: sampleSchema,
	}
	if err := client.Dataset(datasetID).Table(tableID).Create(ctx, original); err != nil {
		return err
	}

	tableRef := client.Dataset(datasetID).Table(tableID)
	meta, err := tableRef.Metadata(ctx)
	if err != nil {
		return err
	}
	// Iterate through the schema to set all Required fields to false (nullable).
	var relaxed bigquery.Schema
	for _, v := range meta.Schema {
		v.Required = false
		relaxed = append(relaxed, v)
	}
	newMeta := bigquery.TableMetadataToUpdate{
		Schema: relaxed,
	}
	if _, err := tableRef.Update(ctx, newMeta, meta.ETag); err != nil {
		return err
	}
	return nil
}

Java

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

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.LegacySQLTypeName;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.StandardTableDefinition;
import com.google.cloud.bigquery.Table;

public class RelaxColumnMode {

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

  public static void relaxColumnMode(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);

      // Create new relaxed schema based on the existing table schema
      Schema relaxedSchema =
          Schema.of(
              // The only supported modification you can make to a column's mode is changing it from
              // REQUIRED to NULLABLE
              // Changing a column's mode from REQUIRED to NULLABLE is also called column relaxation
              // INFO: LegacySQLTypeName will be updated to StandardSQLTypeName in release 1.103.0
              Field.newBuilder("word", LegacySQLTypeName.STRING)
                  .setMode(Field.Mode.NULLABLE)
                  .build(),
              Field.newBuilder("word_count", LegacySQLTypeName.STRING)
                  .setMode(Field.Mode.NULLABLE)
                  .build(),
              Field.newBuilder("corpus", LegacySQLTypeName.STRING)
                  .setMode(Field.Mode.NULLABLE)
                  .build(),
              Field.newBuilder("corpus_date", LegacySQLTypeName.STRING)
                  .setMode(Field.Mode.NULLABLE)
                  .build());

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

Node.js

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

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

async function relaxColumn() {
  /**
   * Changes columns from required to nullable.
   * Assumes existing table with the following schema:
   * [{name: 'Name', type: 'STRING', mode: 'REQUIRED'},
   * {name: 'Age', type: 'INTEGER'},
   * {name: 'Weight', type: 'FLOAT'},
   * {name: 'IsMagic', type: 'BOOLEAN'}];
   */

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

  const newSchema = [
    {name: 'Name', type: 'STRING', mode: 'NULLABLE'},
    {name: 'Age', type: 'INTEGER'},
    {name: 'Weight', type: 'FLOAT'},
    {name: 'IsMagic', type: 'BOOLEAN'},
  ];

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

  // Update schema
  metadata.schema = newSchema;
  const [apiResponse] = await table.setMetadata(metadata);

  console.log(apiResponse.schema.fields);
}

Python

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

Überschreiben Sie das Attribut Table.schema mit einer Liste von SchemaField-Objekten. Dabei muss für das Attribut mode der Wert 'NULLABLE' festgelegt sein.

from google.cloud import bigquery

client = bigquery.Client()

# TODO(dev): Change table_id to full name of the table you want to create.
table_id = "your-project.your_dataset.your_table"

table = client.get_table(table_id)
new_schema = []
for field in table.schema:
    if field.mode != "REQUIRED":
        new_schema.append(field)
    else:
        # SchemaField properties cannot be edited after initialization.
        # To make changes, construct new SchemaField objects.
        new_field = field.to_api_repr()
        new_field["mode"] = "NULLABLE"
        relaxed_field = bigquery.SchemaField.from_api_repr(new_field)
        new_schema.append(relaxed_field)

table.schema = new_schema
table = client.update_table(table, ["schema"])

print(f"Updated {table_id} schema: {table.schema}.")

Spalte mit einem Anfüge-Ladejob als `NULLABLE` deklarieren

Sie können den Modus einer Spalte lockern, wenn Sie Daten an eine Tabelle in einem Ladejob anhängen. Wählen Sie je nach Dateityp eine der folgenden Optionen aus:

Wenn Sie Daten aus CSV- und JSON-Dateien anhängen können Sie eine JSON-Schemadatei angeben, um den Modus für einzelne Spalten zu lockern.
Wenn Sie Daten aus Avro-, ORC- oder Parquet-Dateien anhängen, lockern Sie die Spalten in Ihrem Schema auf NULL und lassen die Schemainferenz die gelockerten Spalten erkennen.

Wählen Sie eine der folgenden Optionen, um eine Spalte von REQUIRED zu NULLABLE zu lockern, wenn Sie während eines Ladejobs Daten an eine Tabelle anfügen:

Console

Sie können den Modus einer Spalte nicht mit der Google Cloud Console lockern.

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 die gelockerten Spalten in einer lokalen JSON-Schemadatei an oder verwenden das Flag --autodetect, um gelockerte Spalten in den Quelldaten mit der Schemaerkennung zu ermitteln.

Gelockerte Spalten können automatisch aus Avro-, ORC- und Parquet-Dateien abgeleitet werden. Das Lockern von Spalten gilt nicht für das Anfügen von Exportdaten aus Datastore. Die Spalten in Tabellen, die beim Laden aus Datastore-Exportdateien erstellt wurden, sind immer NULLABLE.

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

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 \
--schema_update_option=ALLOW_FIELD_RELAXATION \
--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: NEWLINE_DELIMITED_JSON, CSV, PARQUET, ORC oder AVRO. DATASTORE_BACKUP-Dateien erfordern keine Spaltenlockerung. Die Spalten in Tabellen, die aus Datastore-Exportdateien erstellt wurden, haben immer den Modus NULLABLE.
PROJECT_ID ist Ihre Projekt-ID.
dataset ist 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 Diese Option wird nur für CSV- und JSON-Dateien verwendet. Aus Avro-Dateien werden gelockerte Spalten automatisch 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 gelockerte Spalten automatisch aus Avro-Daten abgeleitet werden können, müssen Sie keine Schemadatei angeben. mydataset befindet sich in Ihrem Standardprojekt.

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

Geben Sie den folgenden Befehl ein, um Daten aus einer durch Zeilenumbrüche getrennten JSON-Datei in Cloud Storage mithilfe eines Ladejobs an mydataset.mytable anzufügen. Das Schema mit den gelockerten Spalten befindet sich in einer lokalen JSON-Schemadatei – /tmp/myschema.json. mydataset befindet sich in Ihrem Standardprojekt.

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

Geben Sie den folgenden Befehl ein, um Daten aus einer CSV-Datei auf Ihrem lokalen Rechner mithilfe eines Ladejobs an mydataset.mytable anzufügen. Der Befehl verwendet die automatische Schemaerkennung, um gelockerte Spalten in den Quelldaten zu ermitteln. mydataset befindet sich in myotherproject, nicht in Ihrem Standardprojekt.

bq load \
--noreplace \
--schema_update_option=ALLOW_FIELD_RELAXATION \
--source_format=CSV \
--autodetect \
myotherproject:mydataset.mytable \
mydata.csv

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.

Einfach loslegen (Go)

import (
	"context"
	"fmt"
	"os"

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

// relaxTableImport demonstrates amending the schema of a table to relax columns from
// not allowing NULL values to allowing them.
func relaxTableImport(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, Required: true},
		{Name: "age", Type: bigquery.IntegerFieldType, Required: true},
	}
	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 relaxation of required
	// fields as a side effect while the data is appended.
	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_RELAXATION"}
	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

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

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.CsvOptions;
import com.google.cloud.bigquery.Field;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.LoadJobConfiguration;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.StandardSQLTypeName;
import com.google.cloud.bigquery.Table;
import com.google.cloud.bigquery.TableId;
import com.google.common.collect.ImmutableList;

// Sample to append relax column in a table.
public class RelaxColumnLoadAppend {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String sourceUri = "gs://cloud-samples-data/bigquery/us-states/us-states.csv";
    relaxColumnLoadAppend(datasetName, tableName, sourceUri);
  }

  public static void relaxColumnLoadAppend(String datasetName, String tableName, String sourceUri) {
    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();

      // Retrieve destination table reference
      Table table = bigquery.getTable(TableId.of(datasetName, tableName));

      // column as a 'REQUIRED' field.
      Field name =
          Field.newBuilder("name", StandardSQLTypeName.STRING).setMode(Field.Mode.REQUIRED).build();
      Field postAbbr =
          Field.newBuilder("post_abbr", StandardSQLTypeName.STRING)
              .setMode(Field.Mode.REQUIRED)
              .build();
      Schema schema = Schema.of(name, postAbbr);

      // Skip header row in the file.
      CsvOptions csvOptions = CsvOptions.newBuilder().setSkipLeadingRows(1).build();

      // Set job options
      LoadJobConfiguration loadConfig =
          LoadJobConfiguration.newBuilder(table.getTableId(), sourceUri)
              .setSchema(schema)
              .setFormatOptions(csvOptions)
              .setSchemaUpdateOptions(
                  ImmutableList.of(JobInfo.SchemaUpdateOption.ALLOW_FIELD_RELAXATION))
              .setWriteDisposition(JobInfo.WriteDisposition.WRITE_APPEND)
              .build();

      // Create a load job and wait for it to complete.
      Job job = bigquery.create(JobInfo.of(loadConfig));
      job = job.waitFor();
      // Check the job's status for errors
      if (job.isDone() && job.getStatus().getError() == null) {
        System.out.println("Relax column append successfully loaded in a table");
      } else {
        System.out.println(
            "BigQuery was unable to load into the table due to an error:"
                + job.getStatus().getError());
      }
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Column not added during load append \n" + e.toString());
    }
  }
}

Node.js

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

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

// Instantiate client
const bigquery = new BigQuery();

async function relaxColumnLoadAppend() {
  // Changes required column to nullable in load append job.

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

  // In this example, the existing table contains the 'Name'
  // column as a 'REQUIRED' field.
  const schema = 'Age:INTEGER, Weight:FLOAT, IsMagic:BOOLEAN';

  // Retrieve destination table reference
  const [table] = await bigquery
    .dataset(datasetId)
    .table(tableId)
    .get();
  const destinationTableRef = table.metadata.tableReference;

  // Set load job options
  const options = {
    schema: schema,
    schemaUpdateOptions: ['ALLOW_FIELD_RELAXATION'],
    writeDisposition: 'WRITE_APPEND',
    destinationTable: destinationTableRef,
  };

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

  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;
  }
}

Python

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

# from google.cloud import bigquery
# client = bigquery.Client()
# project = client.project
# dataset_ref = bigquery.DatasetReference(project, 'my_dataset')
# filepath = 'path/to/your_file.csv'

# Retrieves the destination table and checks the number of required fields
table_id = "my_table"
table_ref = dataset_ref.table(table_id)
table = client.get_table(table_ref)
original_required_fields = sum(field.mode == "REQUIRED" for field in table.schema)
# In this example, the existing table has 3 required fields.
print("{} fields in the schema are required.".format(original_required_fields))

# Configures the load job to append the data to a destination table,
# allowing field relaxation
job_config = bigquery.LoadJobConfig()
job_config.write_disposition = bigquery.WriteDisposition.WRITE_APPEND
job_config.schema_update_options = [
    bigquery.SchemaUpdateOption.ALLOW_FIELD_RELAXATION
]
# In this example, the existing table contains three required fields
# ('full_name', 'age', and 'favorite_color'), while the data to load
# contains only the first two fields.
job_config.schema = [
    bigquery.SchemaField("full_name", "STRING", mode="REQUIRED"),
    bigquery.SchemaField("age", "INTEGER", mode="REQUIRED"),
]
job_config.source_format = bigquery.SourceFormat.CSV
job_config.skip_leading_rows = 1

with open(filepath, "rb") as source_file:
    job = client.load_table_from_file(
        source_file,
        table_ref,
        location="US",  # Must match the destination dataset location.
        job_config=job_config,
    )  # API request

job.result()  # Waits for table load to complete.
print(
    "Loaded {} rows into {}:{}.".format(
        job.output_rows, dataset_id, table_ref.table_id
    )
)

# Checks the updated number of required fields
table = client.get_table(table)
current_required_fields = sum(field.mode == "REQUIRED" for field in table.schema)
print("{} fields in the schema are now required.".format(current_required_fields))

Alle Spalten mit einem Anfügejob als `NULLABLE` deklarieren

Sie können alle Spalten in einer Tabelle lockern, wenn Sie Abfrageergebnisse an diese anfügen. Sie können alle Pflichtfelder in der Zieltabelle lockern. Setzen Sie dazu das Flag --schema_update_option auf ALLOW_FIELD_RELAXATION. Einzelne Spalten in einer Zieltabelle können nicht mit einem Abfrage-/Anfügejob gelockert werden. Informationen zum Lockern einzelner Spalten mit einem Anfüge-/Ladejob finden Sie unter Spalte NULLABLE mit einem Anfügejob erstellen.

Wählen Sie eine der folgenden Optionen, um alle Spalten beim Anfügen von Abfrageergebnissen an eine Zieltabelle zu lockern:

Console

Sie können den Modus einer Spalte nicht mit der Google Cloud Console lockern.

bq

Zum Abfragen Ihrer Daten verwenden Sie den Befehl bq query. Mit dem Flag --destination_table legen Sie dabei fest, an welche Tabelle Sie anfügen.

Mit dem Flag --append_table können Sie angeben, dass Sie Abfrageergebnisse an eine vorhandene Zieltabelle anfügen.

Setzen Sie das Flag --schema_update_option auf ALLOW_FIELD_RELAXATION, um anzugeben, dass alle REQUIRED-Spalten in der Tabelle, die Sie anfügen, in NULLABLE geändert werden müssen.

Geben Sie das Flag use_legacy_sql=false an, um die GoogleSQL-Syntax für die Abfrage zu verwenden.

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

bq --location=LOCATION query \
--destination_table PROJECT_ID:DATASET.TABLE \
--append_table \
--schema_update_option=ALLOW_FIELD_RELAXATION \
--use_legacy_sql=false \
'QUERY'

Ersetzen Sie Folgendes:

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.
PROJECT_ID ist Ihre Projekt-ID.
DATASET: der Name des Datasets, das die Tabelle enthält, die Sie anfügen.
TABLE: der Name der Tabelle, die Sie anhängen.
QUERY: eine Abfrage in der GoogleSQL-Syntax.

Beispiele:

bq query \
    --destination_table mydataset.mytable2 \
    --append_table \
    --schema_update_option=ALLOW_FIELD_RELAXATION \
    --use_legacy_sql=false \
    'SELECT
       column1,column2
     FROM
       mydataset.mytable'

Geben Sie den folgenden Befehl ein, um mydataset.mytable in Ihrem Standardprojekt abzufragen und die Abfrageergebnisse an mydataset.mytable2 in myotherproject anzufügen. Der Befehl ändert alle REQUIRED-Spalten in der Zieltabelle zu NULLABLE.

bq query \
--destination_table myotherproject:mydataset.mytable2 \
--append_table \
--schema_update_option=ALLOW_FIELD_RELAXATION \
--use_legacy_sql=false \
'SELECT
   column1,column2
 FROM
   mydataset.mytable'

API

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

Geben Sie die Zieltabelle mit dem Attribut destinationTable an.
Legen Sie die Schreibanordnung der Zieltabelle mit dem Attribut writeDisposition als WRITE_APPEND fest.
Geben Sie die Aktualisierungsoption des Schemas mit dem Attribut schemaUpdateOptions an.
Geben Sie die GoogleSQL-Abfrage mit dem Attribut query an.

Einfach loslegen (Go)

import (
	"context"
	"fmt"

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

// relaxTableQuery demonstrates relaxing the schema of a table by appending query results to
// enable the table to allow NULL values.
func relaxTableQuery(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()

	sampleSchema := bigquery.Schema{
		{Name: "full_name", Type: bigquery.StringFieldType, Required: true},
		{Name: "age", Type: bigquery.IntegerFieldType, Required: true},
	}
	meta := &bigquery.TableMetadata{
		Schema: sampleSchema,
	}
	tableRef := client.Dataset(datasetID).Table(tableID)
	if err := tableRef.Create(ctx, meta); err != nil {
		return err
	}
	// Now, append a query result that includes nulls, but allow the job to relax
	// all required columns.
	q := client.Query("SELECT \"Beyonce\" as full_name")
	q.QueryConfig.Dst = client.Dataset(datasetID).Table(tableID)
	q.SchemaUpdateOptions = []string{"ALLOW_FIELD_RELAXATION"}
	q.WriteDisposition = bigquery.WriteAppend
	q.Location = "US"
	job, err := q.Run(ctx)
	if err != nil {
		return err
	}
	_, err = job.Wait(ctx)
	if err != nil {
		return err
	}
	return nil
}

Java

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

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.JobInfo.SchemaUpdateOption;
import com.google.cloud.bigquery.JobInfo.WriteDisposition;
import com.google.cloud.bigquery.QueryJobConfiguration;
import com.google.cloud.bigquery.TableId;
import com.google.cloud.bigquery.TableResult;
import com.google.common.collect.ImmutableList;

public class RelaxTableQuery {

  public static void runRelaxTableQuery() throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "MY_PROJECT_ID";
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    relaxTableQuery(projectId, datasetName, tableName);
  }

  // To relax all columns in a destination table when you append data to it during a query job
  public static void relaxTableQuery(String projectId, String datasetName, String tableName)
      throws Exception {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      TableId tableId = TableId.of(datasetName, tableName);

      String sourceTable = "`" + projectId + "." + datasetName + "." + tableName + "`";
      String query = "SELECT word FROM " + sourceTable + " WHERE word like '%is%'";

      QueryJobConfiguration queryConfig =
          QueryJobConfiguration.newBuilder(query)
              // Use standard SQL syntax for queries.
              // See: https://cloud.google.com/bigquery/sql-reference/
              .setUseLegacySql(false)
              .setSchemaUpdateOptions(ImmutableList.of(SchemaUpdateOption.ALLOW_FIELD_RELAXATION))
              .setWriteDisposition(WriteDisposition.WRITE_APPEND)
              .setDestinationTable(tableId)
              .build();

      Job queryJob = bigquery.create(JobInfo.newBuilder(queryConfig).build());

      queryJob = queryJob.waitFor();

      // Check for errors
      if (queryJob == null) {
        throw new Exception("Job no longer exists");
      } else if (queryJob.getStatus().getError() != null) {
        // You can also look at queryJob.getStatus().getExecutionErrors() for all
        // errors, not just the latest one.
        throw new Exception(queryJob.getStatus().getError().toString());
      }

      // Get the results.
      TableResult results = queryJob.getQueryResults();

      // Print all pages of the results.
      results
          .iterateAll()
          .forEach(
              rows -> {
                rows.forEach(row -> System.out.println("row: " + row.toString()));
              });

      System.out.println("Successfully relaxed all columns in destination table during query job");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Columns not relaxed during query job \n" + e.toString());
    }
  }
}

Python

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

from google.cloud import bigquery

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

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

# Retrieves the destination table and checks the number of required fields.
table = client.get_table(table_id)  # Make an API request.
original_required_fields = sum(field.mode == "REQUIRED" for field in table.schema)

# In this example, the existing table has 2 required fields.
print("{} fields in the schema are required.".format(original_required_fields))

# Configures the query to append the results to a destination table,
# allowing field relaxation.
job_config = bigquery.QueryJobConfig(
    destination=table_id,
    schema_update_options=[bigquery.SchemaUpdateOption.ALLOW_FIELD_RELAXATION],
    write_disposition=bigquery.WriteDisposition.WRITE_APPEND,
)

# Start the query, passing in the extra configuration.
query_job = client.query(
    # In this example, the existing table contains 'full_name' and 'age' as
    # required columns, but the query results will omit the second column.
    'SELECT "Beyonce" as full_name;',
    job_config=job_config,
)  # Make an API request.
query_job.result()  # Wait for the job to complete.

# Checks the updated number of required fields.
table = client.get_table(table_id)  # Make an API request.
current_required_fields = sum(field.mode == "REQUIRED" for field in table.schema)
print("{} fields in the schema are now required.".format(current_required_fields))

Standardwert einer Spalte ändern

Wählen Sie eine der folgenden Optionen aus, um den Standardwert für eine Spalte zu ändern:

Console

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

BigQuery aufrufen
Maximieren Sie im Bereich Explorer Ihr Projekt und das Dataset und wählen Sie dann die Tabelle aus.
Klicken Sie im Detailbereich auf den Tab Schema.
Klicken Sie auf Schema bearbeiten. Eventuell müssen Sie scrollen, um diese Schaltfläche zu sehen.
Suchen Sie auf der Seite Aktuelles Schema das Feld auf oberster Ebene, das Sie ändern möchten.
Geben Sie den Standardwert für dieses Feld ein.
Klicken Sie auf Speichern.

SQL

Verwenden Sie die DDL-Anweisung ALTER COLUMN SET DEFAULT.

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

BigQuery aufrufen

Geben Sie im Abfrageeditor die folgende Anweisung ein:

ALTER TABLE mydataset.mytable
ALTER COLUMN column_name SET DEFAULT default_expression;

Klicken Sie auf Ausführen.

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

Spalte löschen

Mit der DDL-Anweisung ALTER TABLE DROP COLUMN können Sie eine Spalte aus einer vorhandenen Tabelle löschen.

Durch die Anweisung wird der Speicher, der der verworfenen Spalte zugeordnet ist, nicht sofort freigegeben. Weitere Informationen zu den Auswirkungen auf den Speicher, wenn Sie eine Spalte im Speicher löschen, finden Sie unter ALTER TABLE DROP COLUMN-Anweisungsdetails. Es gibt zwei Möglichkeiten, sofort den Speicher zurückzugewinnen:

Eine Tabelle mit einer SELECT * EXCEPT-Abfrage überschreiben.
Die Daten in Cloud Storage exportieren, die unerwünschten Spalten löschen und die Daten dann in eine neue Tabelle mit dem richtigen Schema laden.

Tabellenschemas ändern

Spalte hinzufügen

Leere Spalte hinzufügen

Console

SQL

bq

API

Einfach loslegen (Go)

Java

Node.js

Python

Verschachtelte Spalte einer RECORD-Spalte hinzufügen

Console

SQL

bq

API

Spalten beim Überschreiben oder Anfügen von Daten hinzufügen

Spalten im Rahmen eines Anfüge-/Ladejobs hinzufügen

bq

API

Einfach loslegen (Go)

Java

Node.js

Python

Spalten im Rahmen eines Abfrage-/Anfügejobs hinzufügen

bq

API

Einfach loslegen (Go)

Java

Node.js

Python

Name einer Spalte ändern

Datentyp einer Spalte ändern

Datentyp einer Spalte erzwingen

Datentyp einer Spalte umwandeln

Console

bq

API

Modus einer Spalte ändern

Spalte in einer vorhandenen Tabelle als NULLABLE deklarieren

Console

SQL

bq

API

Einfach loslegen (Go)

Java

Node.js

Python

Spalte mit einem Anfüge-Ladejob als NULLABLE deklarieren

Console

bq

API

Einfach loslegen (Go)

Java

Node.js

Python

Alle Spalten mit einem Anfügejob als NULLABLE deklarieren

Console

bq

API

Einfach loslegen (Go)

Java

Python

Standardwert einer Spalte ändern

Console

SQL

Spalte löschen

Verschachtelte Spalte einer `RECORD`-Spalte hinzufügen

Spalte in einer vorhandenen Tabelle als `NULLABLE` deklarieren

Spalte mit einem Anfüge-Ladejob als `NULLABLE` deklarieren

Alle Spalten mit einem Anfügejob als `NULLABLE` deklarieren