Esta página se ha traducido con Cloud Translation API.

Modificar los esquemas de tabla

En este documento se describe cómo modificar las definiciones de esquema de las tablas de BigQuery.

Puedes hacer la mayoría de las modificaciones de esquemas descritas en este documento mediante instrucciones del lenguaje de definición de datos (DDL) de SQL. Estas declaraciones no conllevan ningún cargo.

Puede modificar el esquema de una tabla de todas las formas descritas en esta página exportando los datos de la tabla a Cloud Storage y, a continuación, cargando los datos en una tabla nueva con la definición del esquema modificado. Las tareas de carga y exportación de BigQuery son gratuitas, pero se te cobrará por almacenar los datos exportados en Cloud Storage. En las siguientes secciones se describen otras formas de realizar varios tipos de modificaciones de esquemas.

Añadir una columna

Puede añadir columnas a la definición de esquema de una tabla que ya tenga una de las siguientes opciones:

Añade una columna vacía.
Sobrescribir una tabla con una tarea de carga o de consulta.
Añadir datos a una tabla con una tarea de carga o de consulta.

Las columnas que añadas deben cumplir las reglas de BigQuery para los nombres de columnas. Para obtener más información sobre cómo crear componentes de esquema, consulta Especificar un esquema.

Añadir una columna vacía

Si añades columnas a un esquema de tabla, estas deben ser NULLABLE o REPEATED. No puedes añadir una columna REQUIRED a un esquema de tabla que ya tengas. Si añades una columna REQUIRED a un esquema de tabla en la API o en la herramienta de línea de comandos bq, se producirá un error. Sin embargo, puedes crear una columna REQUIREDanidada como parte de un nuevo campo RECORD. Las columnas REQUIRED solo se pueden añadir cuando creas una tabla al cargar datos o cuando creas una tabla vacía con una definición de esquema.

Para añadir columnas vacías a la definición de esquema de una tabla, sigue estos pasos:

Consola

En la Google Cloud consola, ve a la página BigQuery.

Ir a BigQuery
En el panel Explorador, expande tu proyecto y tu conjunto de datos, y selecciona la tabla.
En el panel de detalles, haz clic en la pestaña Esquema.
Haz clic en Editar esquema. Puede que tengas que desplazarte para ver este botón.
En la página Esquema actual, en Campos nuevos, haga clic en Añadir campo.
- En Nombre, escriba el nombre de la columna.
- En Tipo, elige el tipo de datos.
- En Modo, elige NULLABLE o REPEATED.
Cuando hayas terminado de añadir columnas, haz clic en Guardar.

SQL

Usa la ALTER TABLE ADD COLUMNdeclaración de DDL:

En la Google Cloud consola, ve a la página BigQuery.

Ir a BigQuery

En el editor de consultas, introduce la siguiente instrucción:

ALTER TABLE mydataset.mytable
ADD COLUMN new_column STRING;

Haz clic en Ejecutar.

Para obtener más información sobre cómo ejecutar consultas, consulta Ejecutar una consulta interactiva.

bq

Ejecuta el comando bq update y proporciona un archivo de esquema JSON. Si la tabla que quieres actualizar está en un proyecto que no es el predeterminado, añade el ID del proyecto al nombre del conjunto de datos con el siguiente formato: PROJECT_ID:DATASET.

bq update PROJECT_ID:DATASET.TABLE SCHEMA

Haz los cambios siguientes:

PROJECT_ID: tu ID de proyecto.
DATASET: el nombre del conjunto de datos que contiene la tabla que quieres actualizar.
TABLE: el nombre de la tabla que vas a actualizar.
SCHEMA: la ruta al archivo de esquema JSON en tu máquina local.

Si especifica un esquema insertado, no podrá especificar la descripción, el modo y el tipo RECORD (STRUCT) de la columna. Todos los modos de columna tienen el valor predeterminado NULLABLE. Por lo tanto, si añades una columna anidada a un RECORD, debes proporcionar un archivo de esquema JSON.

Si intenta añadir columnas mediante una definición de esquema insertada, debe proporcionar la definición de esquema completa, incluidas las nuevas columnas. Como no puede especificar modos de columna mediante una definición de esquema insertada, la actualización cambia cualquier columna REPEATED a NULLABLE, lo que genera el siguiente error: BigQuery error in update operation: Provided Schema does not match Table PROJECT_ID:dataset.table. Field field has changed mode from REPEATED to NULLABLE..

El método preferido para añadir columnas a una tabla con la herramienta de línea de comandos bq es proporcionar un archivo de esquema JSON.

Para añadir columnas vacías al esquema de una tabla mediante un archivo de esquema JSON, sigue estos pasos:

Primero, ejecuta el comando bq show con la marca --schema y escribe el esquema de la tabla en un archivo. Si la tabla que quieres actualizar está en un proyecto que no es el predeterminado, añade el ID del proyecto al nombre del conjunto de datos con el siguiente formato: PROJECT_ID:DATASET.
```
bq show \
--schema \
--format=prettyjson \
PROJECT_ID:DATASET.TABLE > SCHEMA
```
Haz los cambios siguientes:
- PROJECT_ID: tu ID de proyecto.
- DATASET: el nombre del conjunto de datos que contiene la tabla que quieres actualizar.
- TABLE: el nombre de la tabla que vas a actualizar.
- SCHEMA: el archivo de definición de esquema escrito en tu máquina local.
Por ejemplo, para escribir la definición del esquema de mydataset.mytable en un archivo, introduce el siguiente comando. mydataset.mytable está en tu proyecto predeterminado.
```
   bq show \
   --schema \
   --format=prettyjson \
   mydataset.mytable > /tmp/myschema.json
```

Abre el archivo de esquema en un editor de texto. El esquema debería tener el siguiente aspecto:

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

Añade las nuevas columnas al final de la definición del esquema. Si intentas añadir nuevas columnas en otra parte de la matriz, se devolverá el siguiente error: BigQuery error in update operation: Precondition Failed.

Con un archivo JSON, puede especificar descripciones, modos NULLABLE o REPEATED y tipos RECORD para las columnas nuevas. Por ejemplo, si usas la definición de esquema del paso anterior, tu nueva matriz JSON sería similar a la siguiente. En este ejemplo, se añade una nueva columna NULLABLE llamada column4. column4 incluye una descripción.
```
  [
    {
      "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"
    }
  ]
  
```
Para obtener más información sobre cómo trabajar con archivos de esquema JSON, consulta Especificar un archivo de esquema JSON.
Después de actualizar el archivo de esquema, ejecuta el siguiente comando para actualizar el esquema de la tabla. Si la tabla que vas a actualizar está en un proyecto que no es el predeterminado, añade el ID del proyecto al nombre del conjunto de datos con el siguiente formato: PROJECT_ID:DATASET.
```
bq update PROJECT_ID:DATASET.TABLE SCHEMA
```
Haz los cambios siguientes:
- PROJECT_ID: tu ID de proyecto.
- DATASET: el nombre del conjunto de datos que contiene la tabla que quieres actualizar.
- TABLE: el nombre de la tabla que vas a actualizar.
- SCHEMA: el archivo de definición de esquema escrito en tu máquina local.
Por ejemplo, introduce el siguiente comando para actualizar la definición del esquema de mydataset.mytable en tu proyecto predeterminado. La ruta al archivo de esquema en tu máquina local es /tmp/myschema.json.
```
bq update mydataset.mytable /tmp/myschema.json
```

API

Llama al método tables.patch y usa la propiedad schema para añadir columnas vacías a la definición de tu esquema. Como el método tables.update sustituye a todo el recurso de la tabla, es preferible usar el método tables.patch.

Go

Antes de probar este ejemplo, sigue las Goinstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Go de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

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

Antes de probar este ejemplo, sigue las Javainstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Java de BigQuery.

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

Antes de probar este ejemplo, sigue las Node.jsinstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Node.js de BigQuery.


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

Antes de probar este ejemplo, sigue las Pythoninstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Python de BigQuery.

Añade un nuevo objeto SchemaField a una copia de Table.schema y, a continuación, sustituye el valor de la propiedad Table.schema por el esquema actualizado.

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

Añadir una columna anidada a una columna `RECORD`

Además de añadir columnas a un esquema de tabla, también puedes añadir columnas anidadas a una columna RECORD. El proceso para añadir una nueva columna anidada es similar al proceso para añadir una nueva columna.

Consola

La consola Google Cloud no admite la adición de un nuevo campo anidado a una columna RECORD.

SQL

No se admite la adición de un nuevo campo anidado a una columna RECORD que ya exista mediante una instrucción DDL de SQL.

bq

Ejecuta el comando bq update y proporciona un archivo de esquema JSON que añada el campo anidado a la definición del esquema de la columna RECORD. Si la tabla que vas a actualizar está en un proyecto que no es el predeterminado, añade el ID del proyecto al nombre del conjunto de datos con el siguiente formato: PROJECT_ID:DATASET.

bq update PROJECT_ID:DATASET.TABLE SCHEMA

Haz los cambios siguientes:

PROJECT_ID: tu ID de proyecto.
DATASET: el nombre del conjunto de datos que contiene la tabla que quieres actualizar.
TABLE: el nombre de la tabla que vas a actualizar.
SCHEMA : la ruta al archivo de esquema JSON en tu máquina local.

Para añadir una columna anidada a un RECORD mediante un archivo de esquema JSON, sigue estos pasos:

Primero, ejecuta el comando bq show con la marca --schema y escribe el esquema de la tabla en un archivo. Si la tabla que quieres actualizar está en un proyecto que no es el predeterminado, añade el ID del proyecto al nombre del conjunto de datos con el siguiente formato: PROJECT_ID:DATASET.TABLE.
```
bq show \
--schema \
--format=prettyjson \
PROJECT_ID:DATASET.TABLE > SCHEMA
```
Haz los cambios siguientes:
- PROJECT_ID: tu ID de proyecto.
- DATASET: el nombre del conjunto de datos que contiene la tabla que quieres actualizar.
- TABLE: el nombre de la tabla que vas a actualizar.
- SCHEMA: el archivo de definición de esquema escrito en tu máquina local.
Por ejemplo, para escribir la definición del esquema de mydataset.mytable en un archivo, introduce el siguiente comando. mydataset.mytable está en tu proyecto predeterminado.
```
bq show \
--schema \
--format=prettyjson \
mydataset.mytable > /tmp/myschema.json
```

Abre el archivo de esquema en un editor de texto. El esquema debería tener el siguiente aspecto. En este ejemplo, column3 es una columna repetida anidada. Las columnas anidadas son nested1 y nested2. La matriz fields muestra los campos anidados en column3.

[
  {
    "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"
  }
]

Añade la nueva columna anidada al final de la matriz fields. En este ejemplo, nested3 es la nueva columna anidada.

  [
    {
      "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"
    }
  ]

Para obtener más información sobre cómo trabajar con archivos de esquema JSON, consulta Especificar un archivo de esquema JSON.

Después de actualizar el archivo de esquema, ejecuta el siguiente comando para actualizar el esquema de la tabla. Si la tabla que vas a actualizar está en un proyecto que no es el predeterminado, añade el ID del proyecto al nombre del conjunto de datos con el siguiente formato: PROJECT_ID:DATASET.
```
bq update PROJECT_ID:DATASET.TABLE SCHEMA
```
Haz los cambios siguientes:
- PROJECT_ID: tu ID de proyecto.
- DATASET: el nombre del conjunto de datos que contiene la tabla que quieres actualizar.
- TABLE: el nombre de la tabla que vas a actualizar.
- SCHEMA: la ruta al archivo de esquema JSON en tu máquina local.
Por ejemplo, introduce el siguiente comando para actualizar la definición del esquema de mydataset.mytable en tu proyecto predeterminado. La ruta al archivo de esquema en tu máquina local es /tmp/myschema.json.
```
bq update mydataset.mytable /tmp/myschema.json
```

API

Llama al método tables.patch y usa la propiedad schema para añadir las columnas anidadas a la definición de tu esquema. Como el método tables.update sustituye todo el recurso de tabla, es preferible usar el método tables.patch.

Añadir columnas al sobrescribir o añadir datos

Puedes añadir columnas a una tabla cuando cargues datos en ella y elijas sobrescribir la tabla. Cuando sobrescribes una tabla, el esquema de los datos que estás cargando se usa para sobrescribir el esquema de la tabla. Para obtener información sobre cómo sobrescribir una tabla mediante una tarea de carga, consulta el documento correspondiente al formato de tus datos:

Añadir columnas en una tarea de adición de cargas

Puede añadir columnas a una tabla cuando le añade datos en una tarea de carga. El nuevo esquema se determina de una de las siguientes formas:

Detección automática (para archivos CSV y JSON)
Un esquema especificado en un archivo de esquema JSON (para archivos CSV y JSON)
Los datos de origen autodescriptivos de los archivos de exportación de Avro, ORC, Parquet y Datastore

Si especificas el esquema en un archivo JSON, las nuevas columnas deben definirse en él. Si faltan las nuevas definiciones de columna, se devuelve un error cuando intentas añadir los datos.

Cuando añades columnas durante una operación de anexión, los valores de las nuevas columnas se definen como NULL en las filas que ya había.

Para añadir una columna al añadir datos a una tabla durante una tarea de carga, utilice una de las siguientes opciones:

bq

Usa el comando bq load para cargar los datos y especifica la marca --noreplace para indicar que vas a añadir los datos a una tabla ya creada.

Si los datos que vas a añadir están en formato CSV o JSON delimitado por líneas nuevas, especifica la marca --autodetect para usar la detección automática de esquemas o proporciona el esquema en un archivo de esquema JSON. Las columnas añadidas se pueden inferir automáticamente a partir de archivos de exportación de Avro o Datastore.

Asigna el valor ALLOW_FIELD_ADDITION a la marca --schema_update_option para indicar que los datos que vas a añadir contienen columnas nuevas.

(Opcional) Proporcione la marca --location y asigne el valor a su ubicación.

Introduce el comando load de la siguiente manera:

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

Haz los cambios siguientes:

LOCATION: el nombre de tu ubicación. La marca --location es opcional. Por ejemplo, si usas BigQuery en la región de Tokio, asigna el valor asia-northeast1 a la marca. Puedes definir un valor predeterminado para la ubicación mediante el archivo.bigqueryrc.
FORMAT: el formato del esquema. NEWLINE_DELIMITED_JSON, CSV, AVRO, PARQUET, ORC o DATASTORE_BACKUP.
PROJECT_ID: tu ID de proyecto.
DATASET: el nombre del conjunto de datos que contiene la tabla.
TABLE: el nombre de la tabla que vas a añadir.
PATH_TO_SOURCE: un URI de Cloud Storage completo, una lista de URIs separados por comas o la ruta a un archivo de datos en tu máquina local.
SCHEMA: la ruta a un archivo de esquema JSON local. Solo se necesita un archivo de esquema para los archivos CSV y JSON cuando --autodetect no se especifica. Los esquemas de Avro y Datastore se infieren a partir de los datos de origen.

Ejemplos:

Introduce el siguiente comando para añadir un archivo de datos Avro local, /tmp/mydata.avro, a mydataset.mytable mediante una tarea de carga. Como los esquemas se pueden inferir automáticamente a partir de los datos de Avro, no es necesario que use la marca --autodetect. mydataset está en tu proyecto predeterminado.

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

Introduce el siguiente comando para añadir un archivo de datos JSON delimitado por saltos de línea en Cloud Storage a mydataset.mytable mediante una tarea de carga. La marca --autodetect se usa para detectar las nuevas columnas. mydataset está en tu proyecto predeterminado.

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

Introduce el siguiente comando para añadir un archivo de datos JSON delimitado por saltos de línea en Cloud Storage a mydataset.mytable mediante una tarea de carga. El esquema que contiene las nuevas columnas se especifica en un archivo de esquema JSON local, /tmp/myschema.json. mydataset está en myotherproject, no en tu proyecto predeterminado.

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

Llama al método jobs.insert. Configura una tarea load y define las siguientes propiedades:

Haz referencia a tus datos en Cloud Storage mediante la propiedad sourceUris.
Especifica el formato de los datos definiendo la propiedad sourceFormat.
Especifica el esquema en la propiedad schema.
Especifica la opción de actualización del esquema mediante la propiedad schemaUpdateOptions.
Asigna el valor WRITE_APPEND a la disposición de escritura de la tabla de destino mediante la propiedad writeDisposition.

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

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

# 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)))

Añadir columnas en una tarea de adición de consultas

Puedes añadir columnas a una tabla cuando le añades resultados de una consulta.

Cuando añades columnas mediante una operación de anexión en una tarea de consulta, el esquema de los resultados de la consulta se usa para actualizar el esquema de la tabla de destino. Ten en cuenta que no puedes consultar una tabla de una ubicación y escribir los resultados en una tabla de otra ubicación.

Para añadir una columna al añadir datos a una tabla durante una tarea de consulta, selecciona una de las siguientes opciones:

bq

Usa el comando bq query para consultar tus datos y especifica la marca --destination_table para indicar a qué tabla vas a añadir datos.

Para especificar que vas a añadir los resultados de la consulta a una tabla de destino, indica la marca --append_table.

Define la marca --schema_update_option como ALLOW_FIELD_ADDITION para indicar que los resultados de la consulta que estás añadiendo contienen columnas nuevas.

Especifica la marca use_legacy_sql=false para usar la sintaxis de GoogleSQL en la consulta.

Si la tabla que vas a añadir está en un conjunto de datos de un proyecto que no es el predeterminado, añade el ID del proyecto al nombre del conjunto de datos con el siguiente formato: PROJECT_ID:DATASET. Ten en cuenta que la tabla que consultas y la tabla de destino deben estar en la misma ubicación.

(Opcional) Proporcione la marca --location y asigne el valor a su ubicación.

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

Haz los cambios siguientes:

LOCATION: el nombre de tu ubicación. La marca --location es opcional. Por ejemplo, si usas BigQuery en la región de Tokio, asigna el valor asia-northeast1 a la marca. Puedes definir un valor predeterminado para la ubicación mediante el archivo.bigqueryrc. Ten en cuenta que no puedes añadir resultados de consultas a una tabla de otra ubicación.
PROJECT_ID: tu ID de proyecto.
dataset: el nombre del conjunto de datos que contiene la tabla a la que vas a añadir datos.
TABLE: el nombre de la tabla que vas a añadir.
QUERY: una consulta con sintaxis de GoogleSQL.

Ejemplos:

Introduce el siguiente comando para consultar mydataset.mytable en tu proyecto predeterminado y añadir los resultados de la consulta a mydataset.mytable2 (también en tu proyecto predeterminado).

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

Introduce el siguiente comando para consultar mydataset.mytable en tu proyecto predeterminado y añadir los resultados de la consulta a mydataset.mytable2 en myotherproject.

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

Llama al método jobs.insert. Configura una tarea query y define las siguientes propiedades:

Especifica la tabla de destino mediante la propiedad destinationTable.
Asigna el valor WRITE_APPEND a la disposición de escritura de la tabla de destino mediante la propiedad writeDisposition.
Especifica la opción de actualización del esquema mediante la propiedad schemaUpdateOptions.
Especifica la consulta de GoogleSQL mediante la propiedad query.

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

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

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

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.
client.query_and_wait(
    # 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 and wait for 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)))

Cambiar el nombre de una columna

Para cambiar el nombre de una columna de una tabla, usa la declaración de DDL ALTER TABLE RENAME COLUMN. En el siguiente ejemplo se cambia el nombre de la columna old_name a new_name en mytable:

ALTER TABLE mydataset.mytable
  RENAME COLUMN old_name TO new_name;

Para obtener más información sobre las instrucciones ALTER TABLE RENAME COLUMN, consulta los detalles de DDL.

Cambiar el tipo de datos de una columna

No se puede cambiar el tipo de datos de una columna en la consola de Google Cloud , la herramienta de línea de comandos bq ni la API de BigQuery. Si intentas actualizar una tabla aplicando un esquema que especifica un nuevo tipo de datos para una columna, se devuelve un error.

Cambiar el tipo de datos de una columna con una instrucción DDL

Puedes usar GoogleSQL para hacer ciertos cambios en el tipo de datos de una columna. Para obtener más información y una lista completa de las conversiones de tipos de datos admitidas, consulta la instrucción DDL ALTER COLUMN SET DATA TYPE.

En el siguiente ejemplo se crea una tabla con una columna de tipo INT64 y, a continuación, se actualiza el tipo a NUMERIC:

CREATE TABLE mydataset.mytable(c1 INT64);

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

En el ejemplo siguiente se crea una tabla con una columna anidada con dos campos y, a continuación, se actualiza el tipo de una de las columnas de INT a NUMERIC:

CREATE TABLE mydataset.mytable(s1 STRUCT<a INT64, b STRING>);

ALTER TABLE mydataset.mytable ALTER COLUMN s1
SET DATA TYPE STRUCT<a NUMERIC, b STRING>;

Modificar tipos de columnas anidadas

Para los cambios complejos en esquemas anidados, como modificar un campo dentro de una matriz de STRUCTs, no se admite la sentencia DDL ALTER TABLE. Como solución alternativa, puede usar la instrucción CREATE OR REPLACE TABLE con una instrucción SELECT para transformar los cambios del esquema anidado.

En el siguiente ejemplo se muestra cómo transformar una columna de una matriz de STRUCTS:

Supongamos que tenemos una tabla samples.test con el siguiente esquema y datos:

CREATE OR REPLACE TABLE
  samples.test(D STRUCT <L ARRAY<STRUCT<R STRING, U STRING, V STRING>>, F STRING>);

INSERT INTO
  samples.test(D)
VALUES
  (STRUCT([STRUCT("r1", "u1", "v1"), STRUCT("r2", "u2", "v2")], "f1"));

El resultado es similar al siguiente:

+----------------------------------------------------------------------------+
|                                     D                                      |
+----------------------------------------------------------------------------+
| {"L":[{"R":"r1","U":"u1","V":"v1"},{"R":"r2","U":"u2","V":"v2"}],"F":"f1"} |
+----------------------------------------------------------------------------+

Supongamos que necesitas cambiar el tipo de campo U de la matriz anidada de STRUCTs a STRUCT<W STRING>. La siguiente instrucción SQL muestra cómo hacerlo:

CREATE OR REPLACE TABLE
  samples.new_table AS
SELECT
  STRUCT(ARRAY(
    SELECT
      STRUCT(tmp.R,
        STRUCT(tmp.U AS W) AS U,
        tmp.V)
    FROM
      UNNEST(t.D.L) AS tmp) AS L,
    t.D.F) AS D
FROM
  samples.test AS t

Esta instrucción crea una tabla, samples.new_table, con el esquema de destino. La función UNNEST amplía la matriz de STRUCTs dentro de t.D.L. La expresión STRUCT(tmp.U AS W) AS U construye el nuevo STRUCT con el campo W, que se rellena con el valor del campo U original. La tabla resultante, samples.new_table, tiene el siguiente esquema y datos:

+----------------------------------------------------------------------------------------+
|                                           D                                            |
+----------------------------------------------------------------------------------------+
| {"L":[{"R":"r1","U":{"W":"u1"},"V":"v1"},{"R":"r2","U":{"W":"u2"},"V":"v2"}],"F":"f1"} |
+----------------------------------------------------------------------------------------+

Convertir el tipo de datos de una columna

Para cambiar el tipo de datos de una columna a un tipo convertible, usa una consulta SQL para seleccionar los datos de la tabla, convertir la columna correspondiente y sobrescribir la tabla. No se recomienda convertir y sobrescribir tablas muy grandes porque requiere un análisis completo de la tabla.

En el siguiente ejemplo se muestra una consulta SQL que selecciona todos los datos de column_two y column_three en mydataset.mytable y convierte column_one de DATE a STRING. El resultado de la consulta se usa para sobrescribir la tabla. La tabla sobrescrita almacena column_one como tipo de datos STRING.

Cuando se usa CAST, una consulta puede fallar si BigQuery no puede realizar la conversión. Para obtener información sobre las reglas de conversión en GoogleSQL, consulta Conversión.

Consola

En la Google Cloud consola, ve a la página BigQuery.

Ir a BigQuery
En el editor de consultas, introduce la siguiente consulta para seleccionar todos los datos de column_two y column_three en mydataset.mytable y para convertir column_one de DATE a STRING. La consulta usa un alias para convertir column_one con el mismo nombre. mydataset.mytable está en tu proyecto predeterminado.
```
SELECT
 column_two,
 column_three,
 CAST(column_one AS STRING) AS column_one
FROM
 mydataset.mytable;
```
Haz clic en Más y selecciona Configuración de la consulta.
En la sección Destino, haga lo siguiente:
1. Selecciona Definir una tabla de destino para los resultados de las consultas.
2. En Project name (Nombre del proyecto), deje el valor predeterminado. Este es el proyecto que contiene mydataset.mytable.
3. En Conjunto de datos, elija mydataset.
4. En el campo Table Id, introduce mytable.
5. En Preferencia de escritura de la tabla de destino, seleccione Sobrescribir tabla. Esta opción sobrescribe mytable con los resultados de la consulta.
También puedes elegir la ubicación de tus datos.
Para actualizar los ajustes, haz clic en Guardar.
Haz clic en Ejecutar.

Cuando se completa el trabajo de consulta, el tipo de datos de column_one es STRING.

bq

Introduce el siguiente comando bq query para seleccionar todos los datos de column_two y column_three en mydataset.mytable y para enviar column_one de DATE a STRING. La consulta usa un alias para convertir column_one con el mismo nombre. mydataset.mytable está en tu proyecto predeterminado.

Los resultados de la consulta se escriben en mydataset.mytable mediante la marca --destination_table, y la marca --replace se usa para sobrescribir mytable. Especifica la marca use_legacy_sql=false para usar la sintaxis de GoogleSQL.

También puedes proporcionar la marca --location y asignarle el valor de tu ubicación.

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

Para seleccionar todos los datos de column_two y column_three en mydataset.mytable y convertir column_one de DATE a STRING, llama al método jobs.insert y configura un trabajo query. De forma opcional, especifica tu ubicación en la propiedad location de la sección jobReference.

La consulta SQL utilizada en la tarea de consulta sería SELECT column_two, column_three, CAST(column_one AS STRING) AS column_one FROM mydataset.mytable. La consulta usa un alias para convertir column_one con el mismo nombre.

Para sobrescribir mytable con los resultados de la consulta, incluye mydataset.mytable en la propiedad configuration.query.destinationTable y especifica WRITE_TRUNCATE en la propiedad configuration.query.writeDisposition.

Cambiar el modo de una columna

La única modificación que puedes hacer en el modo de una columna es cambiarlo de REQUIRED a NULLABLE. Cambiar el modo de una columna de REQUIRED a NULLABLE también se denomina "relajación de la columna". También puedes relajar una columna cuando cargues datos para sobrescribir una tabla o cuando añadas datos a una tabla. No puedes cambiar el modo de una columna de NULLABLE a REQUIRED.

Crear una columna `NULLABLE` en una tabla

Para cambiar el modo de una columna de REQUIRED a NULLABLE, selecciona una de las siguientes opciones:

Consola

Ve a la página BigQuery.

Ir a BigQuery
En el panel Explorador, expande tu proyecto y tu conjunto de datos, y selecciona la tabla.
En el panel de detalles, haz clic en la pestaña Esquema.
Haz clic en Editar esquema. Puede que tengas que desplazarte para ver este botón.
En la página Esquema actual, busca el campo que quieras cambiar.
En la lista desplegable Mode de ese campo, selecciona NULLABLE.
Para actualizar los ajustes, haz clic en Guardar.

SQL

Usa la ALTER COLUMN DROP NOT NULL instrucción DDL. En el siguiente ejemplo se cambia el modo de la columna mycolumn de REQUIRED a NULLABLE:

En la Google Cloud consola, ve a la página BigQuery.

Ir a BigQuery

En el editor de consultas, introduce la siguiente instrucción:

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

Haz clic en Ejecutar.

Para obtener más información sobre cómo ejecutar consultas, consulta Ejecutar una consulta interactiva.

bq

Primero, ejecuta el comando bq show con la marca --schema y escribe el esquema de la tabla en un archivo. Si la tabla que quieres actualizar está en un proyecto que no es el predeterminado, añade el ID del proyecto al nombre del conjunto de datos con el siguiente formato: PROJECT_ID:DATASET.
```
bq show \
--schema \
--format=prettyjson \
PROJECT_ID:DATASET.TABLE > SCHEMA_FILE
```
Haz los cambios siguientes:
- PROJECT_ID: tu ID de proyecto.
- DATASET: el nombre del conjunto de datos que contiene la tabla que quieres actualizar.
- TABLE: el nombre de la tabla que vas a actualizar.
- SCHEMA_FILE: el archivo de definición de esquema escrito en tu máquina local.
Por ejemplo, para escribir la definición del esquema de mydataset.mytable en un archivo, introduce el siguiente comando. mydataset.mytable está en tu proyecto predeterminado.
```
  bq show \
  --schema \
  --format=prettyjson \
  mydataset.mytable > /tmp/myschema.json
```

Abre el archivo de esquema en un editor de texto. El esquema debería tener el siguiente aspecto:

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

Cambiar el modo de una columna de REQUIRED a NULLABLE. En este ejemplo, el modo de column1 es relajado.

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

Para obtener más información sobre cómo trabajar con archivos de esquema JSON, consulta Especificar un archivo de esquema JSON.

Después de actualizar el archivo de esquema, ejecuta el siguiente comando para actualizar el esquema de la tabla. Si la tabla que vas a actualizar está en un proyecto que no es el predeterminado, añade el ID del proyecto al nombre del conjunto de datos con el siguiente formato: PROJECT_ID:DATASET.
```
bq update PROJECT_ID:DATASET.TABLE SCHEMA
```
Haz los cambios siguientes:
- PROJECT_ID: tu ID de proyecto.
- DATASET: el nombre del conjunto de datos que contiene la tabla que quieres actualizar.
- TABLE: el nombre de la tabla que vas a actualizar.
- SCHEMA: la ruta al archivo de esquema JSON en tu máquina local.
Por ejemplo, introduce el siguiente comando para actualizar la definición del esquema de mydataset.mytable en tu proyecto predeterminado. La ruta al archivo de esquema en tu máquina local es /tmp/myschema.json.
```
  bq update mydataset.mytable /tmp/myschema.json
```

API

Llama a tables.patch y usa la propiedad schema para cambiar una columna REQUIRED a NULLABLE en la definición de tu esquema. Como el método tables.update sustituye a todo el recurso de tabla, se recomienda usar el método tables.patch.

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

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

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

Sobrescribe la propiedad Table.schema con una lista de objetos SchemaField con la propiedad mode definida como 'NULLABLE'.

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

Crear una columna `NULLABLE` con una tarea de carga de adición

Puedes ajustar la rigurosidad de una columna cuando añades datos a una tabla en una tarea de carga. Selecciona una de las siguientes opciones en función del tipo de archivo:

Cuando añadas datos de archivos CSV y JSON, relaja el modo de columnas concretas especificando un archivo de esquema JSON.
Cuando añadas datos de archivos Avro, ORC o Parquet, relaja las columnas a NULL en tu esquema y deja que la inferencia de esquemas detecte las columnas relajadas.

Para cambiar el modo de una columna de REQUIRED a NULLABLE al añadir datos a una tabla durante un trabajo de carga, seleccione una de las siguientes opciones:

Consola

No puedes cambiar el modo de una columna con la consola Google Cloud .

bq

Usa el comando bq load para cargar los datos y especifica la marca --noreplace para indicar que vas a añadir los datos a una tabla ya creada.

Si los datos que vas a añadir están en formato CSV o JSON delimitado por saltos de línea, especifica las columnas flexibles en un archivo de esquema JSON local o usa la marca --autodetect para usar la detección de esquemas y descubrir las columnas flexibles de los datos de origen.

Las columnas relajadas se pueden inferir automáticamente de los archivos Avro, ORC y Parquet. La relajación de columnas no se aplica a las anexiones de exportación de Datastore. Las columnas de las tablas creadas al cargar archivos de exportación de Datastore siempre son NULLABLE.

Define la marca --schema_update_option como ALLOW_FIELD_RELAXATION para indicar que los datos que vas a añadir contienen columnas flexibles.

(Opcional) Proporcione la marca --location y asigne el valor a su ubicación.

Introduce el comando load de la siguiente manera:

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

Haz los cambios siguientes:

LOCATION: el nombre de tu ubicación. La marca --location es opcional. Por ejemplo, si usas BigQuery en la región de Tokio, asigna el valor asia-northeast1 a la marca. Puedes definir un valor predeterminado para la ubicación mediante el archivo.bigqueryrc.
FORMAT: NEWLINE_DELIMITED_JSON, CSV, PARQUET, ORC o AVRO. Los archivos DATASTORE_BACKUP no requieren que se relajen las columnas. Las columnas de las tablas creadas a partir de archivos de exportación de Datastore siempre son NULLABLE.
PROJECT_ID: tu ID de proyecto.
dataset es el nombre del conjunto de datos que contiene la tabla.
TABLE: el nombre de la tabla que vas a añadir.
PATH_TO_SOURCE: un URI de Cloud Storage completo, una lista de URIs separados por comas o la ruta a un archivo de datos en tu máquina local.
SCHEMA: la ruta a un archivo de esquema JSON local. Esta opción solo se usa en archivos CSV y JSON. Las columnas flexibles se infieren automáticamente a partir de los archivos Avro.

Ejemplos:

Introduce el siguiente comando para añadir un archivo de datos Avro local, /tmp/mydata.avro, a mydataset.mytable mediante una tarea de carga. Como las columnas flexibles se pueden inferir automáticamente a partir de los datos de Avro, no es necesario que especifiques un archivo de esquema. mydataset está en tu proyecto predeterminado.

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

Introduce el siguiente comando para añadir datos de un archivo JSON delimitado por saltos de línea en Cloud Storage a mydataset.mytable mediante una tarea de carga. El esquema que contiene las columnas flexibles se encuentra en un archivo de esquema JSON local: /tmp/myschema.json. mydataset está en tu proyecto predeterminado.

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

Introduce el siguiente comando para añadir datos de un archivo CSV de tu máquina local a mydataset.mytable mediante un trabajo de carga. El comando usa la detección automática de esquemas para descubrir columnas flexibles en los datos de origen. mydataset está en myotherproject, no en tu proyecto predeterminado.

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

API

Llama al método jobs.insert. Configura una tarea load y define las siguientes propiedades:

Haz referencia a tus datos en Cloud Storage mediante la propiedad sourceUris.
Especifica el formato de los datos definiendo la propiedad sourceFormat.
Especifica el esquema en la propiedad schema.
Especifica la opción de actualización del esquema mediante la propiedad schemaUpdateOptions.
Asigna el valor WRITE_APPEND a la disposición de escritura de la tabla de destino mediante la propiedad writeDisposition.

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

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

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

# 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))

Crear todas las columnas `NULLABLE` con una tarea de adición

Puedes ajustar la rigurosidad de todas las columnas de una tabla cuando le añadas resultados de consultas. Puede relajar todos los campos obligatorios de la tabla de destino asignando el valor ALLOW_FIELD_RELAXATION a la marca --schema_update_option. No puedes ajustar la rigurosidad de columnas concretas de una tabla de destino mediante una adición de consultas. Para ajustar la rigurosidad de columnas concretas con una tarea de adición de cargas, consulta Ajustar la rigurosidad de una columna NULLABLE con una tarea de adición.

Para relajar todas las columnas al añadir los resultados de una consulta a una tabla de destino, selecciona una de las siguientes opciones:

Consola

No puedes cambiar el modo de una columna con la consola Google Cloud .

bq

Usa el comando bq query para consultar tus datos y especifica la marca --destination_table para indicar a qué tabla vas a añadir datos.

Para especificar que vas a añadir los resultados de la consulta a una tabla de destino, indica la marca --append_table.

Asigna el valor ALLOW_FIELD_RELAXATION a la marca --schema_update_option para indicar que todas las columnas REQUIRED de la tabla que vas a añadir deben cambiar a NULLABLE.

Especifica la marca use_legacy_sql=false para usar la sintaxis de GoogleSQL en la consulta.

(Opcional) Proporcione la marca --location y asigne el valor a su ubicación.

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

Haz los cambios siguientes:

LOCATION: el nombre de tu ubicación. La marca --location es opcional. Por ejemplo, si usas BigQuery en la región de Tokio, asigna el valor asia-northeast1 a la marca. Puedes definir un valor predeterminado para la ubicación mediante el archivo.bigqueryrc.
PROJECT_ID: tu ID de proyecto.
DATASET: el nombre del conjunto de datos que contiene la tabla a la que vas a añadir datos.
TABLE: el nombre de la tabla que vas a añadir.
QUERY: una consulta con sintaxis de GoogleSQL.

Ejemplos:

Introduce la siguiente consulta de comando mydataset.mytable en tu proyecto predeterminado para añadir los resultados de la consulta a mydataset.mytable2 (también en tu proyecto predeterminado). El comando cambia todas las columnas REQUIRED de la tabla de destino a NULLABLE.

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

Introduce la siguiente consulta de comando mydataset.mytable en tu proyecto predeterminado para añadir los resultados de la consulta a mydataset.mytable2 en myotherproject. El comando cambia todas las columnas REQUIRED de la tabla de destino a 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

Llama al método jobs.insert. Configura una tarea query y define las siguientes propiedades:

Especifica la tabla de destino mediante la propiedad destinationTable.
Asigna el valor WRITE_APPEND a la disposición de escritura de la tabla de destino mediante la propiedad writeDisposition.
Especifica la opción de actualización del esquema mediante la propiedad schemaUpdateOptions.
Especifica la consulta de GoogleSQL mediante la propiedad query.

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

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

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.
client.query_and_wait(
    # 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 and wait for 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))

Cambiar el valor predeterminado de una columna

Para cambiar el valor predeterminado de una columna, selecciona una de las siguientes opciones:

Consola

En la Google Cloud consola, ve a la página BigQuery.

Ir a BigQuery
En el panel Explorador, expande tu proyecto y tu conjunto de datos, y selecciona la tabla.
En el panel de detalles, haz clic en la pestaña Esquema.
Haz clic en Editar esquema. Puede que tengas que desplazarte para ver este botón.
En la página Esquema actual, busca el campo de nivel superior que quieras cambiar.
Introduce el valor predeterminado de ese campo.
Haz clic en Guardar.

SQL

Usa la ALTER COLUMN SET DEFAULT instrucción DDL.

En la Google Cloud consola, ve a la página BigQuery.

Ir a BigQuery

En el editor de consultas, introduce la siguiente instrucción:

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

Haz clic en Ejecutar.

Para obtener más información sobre cómo ejecutar consultas, consulta Ejecutar una consulta interactiva.

Cambiar la descripción de una columna

Para cambiar la descripción de una columna, selecciona una de las siguientes opciones:

Consola

En la Google Cloud consola, ve a la página BigQuery.

Ir a BigQuery
En el panel Explorador, expande tu proyecto y tu conjunto de datos, y selecciona la tabla.
En el panel de detalles, haz clic en la pestaña Esquema.
Haz clic en Editar esquema. Puede que tengas que desplazarte para ver este botón.
En la página Esquema actual, busca el campo que quieras cambiar.
Introduce la descripción de ese campo.
Haz clic en Guardar.

SQL

Usa la ALTER COLUMN SET OPTIONS instrucción DDL.

En la Google Cloud consola, ve a la página BigQuery.

Ir a BigQuery

En el editor de consultas, introduce la siguiente instrucción:

ALTER TABLE mydataset.mytable
ALTER COLUMN column_name
SET OPTIONS (description = 'This is a column description.');

Haz clic en Ejecutar.

Para obtener más información sobre cómo ejecutar consultas, consulta Ejecutar una consulta interactiva.

Gemini

Puedes generar descripciones de columnas con Gemini en BigQuery usando estadísticas de datos. Información valiosa es una forma automatizada de explorar, comprender y organizar tus datos.

Para obtener más información sobre las estadísticas de datos, incluidos los pasos de configuración, los roles de gestión de identidades y accesos necesarios y las prácticas recomendadas para mejorar la precisión de las estadísticas generadas, consulta Generar estadísticas de datos en BigQuery.

En la Google Cloud consola, ve a la página BigQuery.

Ir a BigQuery
En el panel Explorador, expande tu proyecto y tu conjunto de datos, y selecciona la tabla.
En el panel de detalles, haz clic en la pestaña Esquema.
Haz clic en Generar.

Nota: Si no ves el botón Generar, haz clic en Describe los datos. Puede que tengas que desplazarte para ver este botón.

Gemini genera descripciones de las columnas e información valiosa sobre la tabla. La información tarda unos minutos en rellenarse. Puedes ver las estadísticas generadas en la pestaña Estadísticas de la tabla.
Para editar y guardar las descripciones de las columnas generadas, siga estos pasos:
1. Haz clic en Ver descripciones de las columnas.
2. En la sección Column descriptions (Descripciones de las columnas), haga clic en Save to schema (Guardar en el esquema).
  
  Las descripciones de las columnas generadas se rellenan en el campo Nueva descripción de cada columna.
3. Edite las descripciones de las columnas según sea necesario y, a continuación, haga clic en Guardar.
  
  Las descripciones de las columnas se actualizan al instante.
4. Para cerrar el panel Vista previa de las descripciones, haz clic en Cerrar.

Eliminar una columna

Puedes eliminar una columna de una tabla que ya tengas con la declaración de DDL ALTER TABLE DROP COLUMN.

La instrucción no libera inmediatamente el almacenamiento asociado a la columna eliminada. Para obtener más información sobre el impacto en el almacenamiento cuando se elimina una columna del almacenamiento, consulta los detalles de la instrucción ALTER TABLE DROP COLUMN. Hay dos opciones para recuperar espacio de almacenamiento inmediatamente:

Sobrescribir una tabla con una SELECT * EXCEPT consulta:

CREATE OR REPLACE TABLE mydataset.mytable AS (
  SELECT * EXCEPT (column_to_delete) FROM mydataset.mytable
);

Exporta los datos a Cloud Storage, elimina las columnas que no quieras y, a continuación, carga los datos en una tabla nueva con el esquema correcto.

Modificar los esquemas de tabla

Añadir una columna

Añadir una columna vacía

Consola

SQL

bq

API

Go

Java

Node.js

Python

Añadir una columna anidada a una columna RECORD

Consola

SQL

bq

API

Añadir columnas al sobrescribir o añadir datos

Añadir columnas en una tarea de adición de cargas

bq

API

Go

Java

Node.js

Python

Añadir columnas en una tarea de adición de consultas

bq

API

Go

Java

Node.js

Python

Cambiar el nombre de una columna

Cambiar el tipo de datos de una columna

Cambiar el tipo de datos de una columna con una instrucción DDL

Modificar tipos de columnas anidadas

Convertir el tipo de datos de una columna

Consola

bq

API

Cambiar el modo de una columna

Crear una columna NULLABLE en una tabla

Consola

SQL

bq

API

Go

Java

Node.js

Python

Crear una columna NULLABLE con una tarea de carga de adición

Consola

bq

API

Go

Java

Node.js

Python

Crear todas las columnas NULLABLE con una tarea de adición

Consola

bq

API

Go

Java

Python

Cambiar el valor predeterminado de una columna

Consola

SQL

Cambiar la descripción de una columna

Consola

SQL

Gemini

Eliminar una columna

Añadir una columna anidada a una columna `RECORD`

Crear una columna `NULLABLE` en una tabla

Crear una columna `NULLABLE` con una tarea de carga de adición

Crear todas las columnas `NULLABLE` con una tarea de adición