Modifica esquemas de tablas

En este documento, se describe cómo modificar las definiciones de esquema para tablas de BigQuery existentes. BigQuery es compatible con las modificaciones de esquema siguientes de forma nativa:

  • Agregar columnas a una definición de esquema
  • Disminuir la rigurosidad del modo de una columna de REQUIRED a NULLABLE

Es válido crear una tabla sin definir un esquema inicial y agregar una definición de esquema a la tabla más adelante.

Todas las demás modificaciones del esquema no son compatibles y requieren soluciones alternativas manuales, que incluyen las opciones siguientes:

  • Cambiar el nombre de una columna
  • Cambiar el tipo de datos de una columna
  • Cambiar el modo de una columna (además de disminuir la rigurosidad de las columnas de REQUIRED a NULLABLE)
  • Borrar una columna

Para obtener más información sobre cambios de esquema no compatibles que requieren soluciones alternativas, consulta Cambia esquemas de una tabla de forma manual.

Agrega columnas a la definición de esquema de una tabla

Puedes agregar columnas a la definición de esquema de una tabla existente de las formas siguientes:

  • De forma manual (crea una columna vacía).
  • Cuando usas un trabajo o consulta de carga para reemplazar una tabla.
  • Cuando adjuntas datos a una tabla con un trabajo de carga o consulta

Toda columna que agregas se debe adherir a las funciones de BigQuery para los nombres de consultas. Para obtener más información sobre cómo crear componentes de esquema, consulta Especifica un esquema.

Agrega una columna vacía de forma manual

Puedes agregar una columna vacía a una tabla existente si usas la IU web de BigQuery, el comando bq update de la herramienta de línea de comandos o si llamas al método de la API tables.patch.

Si agregas columnas nuevas a un esquema de tabla existente, las columnas deben ser NULLABLE o REPEATED. No pueden agregar una columna REQUIRED a un esquema de tabla existente. Si intentas agregar una columna REQUIRED a un esquema de tabla existente en la CLI o la API, se muestra el error siguiente: BigQuery error in update operation: Provided Schema does not match Table [PROJECT_ID]:[DATASET].[TABLE]. Cannot add required columns to an existing schema. Las columnas REQUIRED se pueden agregar solo cuando creas una tabla mientras cargas los datos o cuando creas una tabla vacía con una definición de esquema.

Después de agregar una columna nueva a la definición de esquema de tu tabla, puedes cargar datos en la columna nueva si usas estos elementos:

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

IU web

  1. Selecciona tu tabla en el panel de navegación.

  2. En la página Table Details (Detalles de la tabla), haz clic en Add New Fields (Agregar campos nuevos).

  3. En la sección New Fields (Campos nuevos), sigue estos pasos:

    • Para Name (Nombre), escribe el nombre de la columna.
    • Para Type (Tipo), elige data type (tipo de datos).
    • Para Mode (Modo), elige NULLABLE o REPEATED.

      Actualiza el esquema de tabla

  4. Cuando termines de agregar las columnas, haz clic en Add to Table (Agregar a la tabla).

CLI

Ejecuta el comando bq update y proporciona un archivo de esquema JSON. Si la tabla que actualizas se encuentra en otro proyecto que no es el proyecto predeterminado, agrega el ID del proyecto al nombre del conjunto de datos en el formato siguiente: [PROJECT_ID]:[DATASET].

  bq update [PROJECT_ID]:[DATASET].[TABLE] [SCHEMA]

En el que:

  • [PROJECT_ID] es el ID del proyecto.
  • [DATASET] es el nombre del conjunto de datos que contiene la tabla que actualizas.
  • [TABLE] es el nombre de la tabla que actualizas.
  • [SCHEMA] es la ruta de acceso al archivo de esquema JSON en tu máquina local.

Cuando especificas el esquema en la línea de comandos, no puedes incluir un tipo RECORD (STRUCT) ni una descripción de columna, y no puedes especificar el modo de la columna. Todos los modos predeterminados están establecidos en NULLABLE.

Si intentas agregar columnas con una definición de esquema intercalada, debes suministrar la definición de esquema completa que incluye las columnas nuevas. Debido a que no puedes especificar los modos de columnas con una definición de esquema intercalada, la actualización intentará cambiar cualquier columna REQUIRED existente a NULLABLE. Esto genera el error siguiente: 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 agregar columnas a una tabla existente mediante la CLI es suministrar un archivo de esquema de JSON.

Para agregar columnas vacías al esquema de una tabla con un archivo de esquema de JSON, sigue estos pasos:

  1. Primero, genera el comando bq show con la marca --schema y escribe el esquema de tabla existente en un archivo. Si la tabla que actualizas se encuentra en otro proyecto que no es el proyecto predeterminado, agrega el ID del proyecto al nombre del conjunto de datos en el formato siguiente: [PROJECT_ID]:[DATASET].

    bq show --schema --format=prettyjson [PROJECT_ID]:[DATASET].[TABLE] > [SCHEMA_FILE]
    

    En el que:

    • [PROJECT_ID] es el ID del proyecto.
    • [DATASET] es el nombre del conjunto de datos que contiene la tabla que actualizas.
    • [TABLE] es el nombre de la tabla que actualizas.
    • [SCHEMA_FILE] es el archivo de definición de esquema que se escribe en tu máquina local.

    Por ejemplo, para escribir una definición de esquema de mydataset.mytable en un archivo, ingresa el comando siguiente. mydataset.mytable se encuentra en tu proyecto predeterminado.

    bq show --schema --format=prettyjson mydataset.mytable > /tmp/myschema.json
    
  2. Abre el archivo del esquema en un editor de texto. El esquema debe verse de la manera siguiente:

    [
      {
        "mode": "REQUIRED",
        "name": "column1",
        "type": "STRING"
      },
      {
        "mode": "REQUIRED",
        "name": "column2",
        "type": "FLOAT"
      },
      {
        "mode": "REPEATED",
        "name": "column3",
        "type": "STRING"
      }
    ]
    
  3. Agrega las columnas nuevas al final de la definición del esquema. Si intentas agregar columnas nuevas en otro lugar del arreglo, se muestra el error siguiente: BigQuery error in update operation: Precondition Failed.

    Puedes especificar descripciones con un archivo JSON, modos NULLABLE o REPEATED, y tipos RECORD para columnas nuevas. Por ejemplo, mediante la definición de esquema del paso anterior, tu arreglo JSON nuevo se vería de la manera siguiente. En este ejemplo, a una columna NULLABLE nueva se le agrega el nombre 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 Especifica un archivo de esquema JSON.

  4. Después de actualizar tu archivo de esquema, ejecuta el comando siguiente para actualizar el esquema de la tabla. Si la tabla que actualizas se encuentra en otro proyecto que no es el proyecto predeterminado, agrega el ID del proyecto al nombre del conjunto de datos en el formato siguiente: [PROJECT_ID]:[DATASET].

    bq update [PROJECT_ID]:[DATASET].[TABLE] [SCHEMA]
    

    En el que:

    • [PROJECT_ID] es el ID del proyecto.
    • [DATASET] es el nombre del conjunto de datos que contiene la tabla que actualizas.
    • [TABLE] es el nombre de la tabla que actualizas.
    • [SCHEMA] es la ruta de acceso al archivo de esquema JSON en tu máquina local.

    Por ejemplo, ingresa el comando siguiente a fin de actualizar la definición de 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 agregar las columnas vacías a tu definición de esquema. Debido a que el método tables.update reemplaza todo el recurso de la tabla, se prefiere el método tables.patch.

Go

// To run this sample, you will need to create (or reuse) a context and
// an instance of the bigquery client.  For example:
// import "cloud.google.com/go/bigquery"
// ctx := context.Background()
// client, err := bigquery.NewClient(ctx, "your-project-id")
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
}

Python

Antes de probar esta muestra, sigue las instrucciones de configuración para Python que se encuentran en la Guía de inicio rápido de BigQuery con bibliotecas cliente. Para obtener más información, consulta la Documentación de referencia de la API de Python de BigQuery.

Agrega un objeto SchemaField nuevo a una copia de Table.schema y, a continuación, reemplaza el valor de la propiedad Table.schema con el esquema actualizado.

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

table_ref = client.dataset(dataset_id).table(table_id)
table = client.get_table(table_ref)  # 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'])  # API request

assert len(table.schema) == len(original_schema) + 1 == len(new_schema)

Agrega una columna anidada a un RECORD

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

IU web

Por el momento, agregar un campo anidado nuevo a una columna RECORD existente no es compatible con la IU web de BigQuery.

CLI

Ejecuta el comando bq update y proporciona un archivo de esquema JSON que agregue el campo anidado a la definición de esquema de la columna RECORD existente. Si la tabla que actualizas se encuentra en otro proyecto que no es el proyecto predeterminado, agrega el ID del proyecto al nombre del conjunto de datos en el formato siguiente: [PROJECT_ID]:[DATASET].

  bq update [PROJECT_ID]:[DATASET].[TABLE] [SCHEMA]

En el que:

  • [PROJECT_ID] es el ID del proyecto.
  • [DATASET] es el nombre del conjunto de datos que contiene la tabla que actualizas.
  • [TABLE] es el nombre de la tabla que actualizas.
  • [SCHEMA] es la ruta de acceso al archivo de esquema JSON en tu máquina local.

Cuando especificas el esquema en la línea de comandos, no puedes incluir un tipo RECORD (STRUCT) ni una descripción de columna, y no puedes especificar el modo de la columna. Todos los modos predeterminados se establecen en NULLABLE. Como resultado, si agregas una columna anidada nueva a RECORD, debes suministrar un archivo de esquema JSON.

Para agregar una columna anidada a RECORD mediante un archivo de esquema JSON, haz lo siguiente:

  1. Primero, genera el comando bq show con la marca --schema y escribe el esquema de tabla existente en un archivo. Si la tabla que actualizas se encuentra en otro proyecto que no es el proyecto predeterminado, agrega el ID del proyecto al nombre del conjunto de datos en el formato siguiente: [PROJECT_ID]:[DATASET].

    bq show --schema --format=prettyjson [PROJECT_ID]:[DATASET].[TABLE] > [SCHEMA_FILE]
    

    En el que:

    • [PROJECT_ID] es el ID del proyecto.
    • [DATASET] es el nombre del conjunto de datos que contiene la tabla que actualizas.
    • [TABLE] es el nombre de la tabla que actualizas.
    • [SCHEMA_FILE] es el archivo de definición de esquema que se escribe en tu máquina local.

    Por ejemplo, para escribir una definición de esquema de mydataset.mytable en un archivo, ingresa el comando siguiente. mydataset.mytable se encuentra en tu proyecto predeterminado.

    bq show --schema --format=prettyjson mydataset.mytable > /tmp/myschema.json
    
  2. Abre el archivo del esquema en un editor de texto. El esquema debe verse de la manera siguiente. En este ejemplo, column3 es una columna repetida anidada. Las columnas anidadas son nested1 y nested2. El arreglo fields enumera 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"
      }
    ]
    
  3. Agrega la columna anidada nueva en el final del arreglo fields. En este ejemplo, nested3 es la columna anidada nueva.

      [
        {
          "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 Especifica un archivo de esquema JSON.

  4. Después de actualizar tu archivo de esquema, ejecuta el comando siguiente para actualizar el esquema de la tabla. Si la tabla que actualizas se encuentra en otro proyecto que no es el proyecto predeterminado, agrega el ID del proyecto al nombre del conjunto de datos en el formato siguiente: [PROJECT_ID]:[DATASET].

    bq update [PROJECT_ID]:[DATASET].[TABLE] [SCHEMA]
    

    En el que:

    • [PROJECT_ID] es el ID del proyecto.
    • [DATASET] es el nombre del conjunto de datos que contiene la tabla que actualizas.
    • [TABLE] es el nombre de la tabla que actualizas.
    • [SCHEMA] es la ruta de acceso al archivo de esquema JSON en tu máquina local.

    Por ejemplo, ingresa el comando siguiente a fin de actualizar la definición de 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 agregar las columnas anidadas a tu definición de esquema. Debido a que el método tables.update reemplaza todo el recurso de la tabla, se prefiere el método tables.patch.

Agrega una columna cuando reemplazas o agregas datos

Puedes agregar columnas nuevas a una tabla existente cuando cargas datos en esta y eliges reemplazar la tabla existente. Cuando reemplazas una tabla existente, el esquema de los datos que cargaste, se usa para reemplazar el esquema de la tabla existente. Para obtener información sobre cómo reemplazar una tabla con un trabajo de carga, consulta:

También puedes agregar columnas nuevas a una tabla existente cuando agregas datos a esta con un trabajo de carga o consulta.

Agrega una columna en un trabajo de carga de anexo

Para agregar columnas a una tabla mientras agregas datos a esta en un trabajo de carga, puedes usar el comando bq load de la herramienta de línea de comandos o puedes llamar al método jobs.insert de la API y configurar un trabajo de carga. Agregar una columna a una tabla existente durante una operación de anexo no es compatible con la IU web de BigQuery en este momento.

Cuando agregas columnas con una operación de anexo en un trabajo de carga, el esquema actualizado puede encontrarse de la manera siguiente:

  • Detectado de forma automática (para archivos CSV y JSON)
  • Especificado en un archivo de esquema JSON (para archivos CSV y JSON)
  • Inferido de forma automática a partir de los datos para los archivos de exportación de Avro y Cloud Datastore

Si especificas el esquema en un archivo JSON, las columnas nuevas se deben definir en él. Si faltan las definiciones nuevas de la columna, se muestra el error siguiente cuando intentas anexar los datos: Error while reading data, error message: parsing error in row starting at position [INT]: No such field: [FIELD].

Cuando agregas columnas nuevas durante una operación de anexo, los valores en las columnas nuevas se establecen en NULL para las filas existentes.

Para agregar una columna nueva cuando anexas datos en una tabla durante un trabajo de carga, ten en cuenta esta información:

IU web

No puedes agregar columnas nuevas a una tabla existente cuando cargas datos con la IU web de BigQuery.

CLI

Usa el comando bq load para cargar tus datos y especifica la marca --noreplace a fin de indicar que agregas los datos en una tabla existente.

Si los datos que agregas están en formato CSV o JSON delimitado por saltos de línea, especifica la marca --autodetect para usar la detección automática de esquemas o suministrar el esquema en un archivo de esquema JSON. Las columnas agregadas se pueden inferir de forma automática desde los archivos de exportación Avro o Cloud Datastore.

Establece la marca --schema_update_option en ALLOW_FIELD_ADDITION para indicar que los datos que agregas contienen columnas nuevas.

Si la tabla que agregas se encuentra en un conjunto de datos en un proyecto que no es el predeterminado, agrega el ID del proyecto al nombre del conjunto de datos en el formato siguiente: [PROJECT_ID]:[DATASET].

Proporciona la marca --location y establece el valor en tu ubicación.

Ingresa el comando load de la manera siguiente:

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

En el que:

  • [LOCATION] es el nombre de tu ubicación. La marca --location es opcional si tus datos están en US o en la ubicación multirregional EU. Por ejemplo, si usas BigQuery en la región de Tokio, establece el valor de la marca en asia-northeast1. Puedes establecer un valor predeterminado para la ubicación con el .bigqueryrc file.
  • [FORMAT] es NEWLINE_DELIMITED_JSON, CSV, AVRO o DATASTORE_BACKUP.
  • [PROJECT_ID] es el ID del proyecto.
  • [DATASET] es el nombre del conjunto de datos que contiene la tabla.
  • [TABLE] es el nombre de la tabla que agregas.
  • [PATH_TO_SOURCE] es un URI de Cloud Storage calificado en su totalidad, una lista separada por comas de URI o la ruta a un archivo de datos en tu máquina local.
  • [SCHEMA] es la ruta a un archivo de esquema JSON local. Solo se requiere un archivo de esquema para los archivos CSV y JSON cuando --autodetect no se especifica. Los esquemas de Avro y Cloud Datastore se infieren de los datos de origen.

Ejemplos:

Ingresa el comando siguiente para adjuntar un archivo de datos Avro local /tmp/mydata.avro a mydataset.mytable con un trabajo de carga. Dado que las columnas agregadas se pueden inferir de forma automática desde los datos de Avro, no debes usar la marca --autodetect. mydataset se encuentra en tu proyecto predeterminado y se creó en la ubicación multirregional US.

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

Ingresa el comando siguiente para anexar un archivo de datos JSON delimitado por saltos de línea en Cloud Storage a mydataset.mytable con un trabajo de carga. La marca --autodetect se usa para detectar las columnas nuevas. mydataset está en tu proyecto predeterminado y se creó en la ubicación multirregional US.

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

Ingresa el comando siguiente para anexar un archivo de datos JSON delimitado por saltos de línea en Cloud Storage a mydataset.mytable con un trabajo de carga. El esquema que contiene las columnas nuevas se especifica en un archivo de esquema JSON local /tmp/myschema.json. mydataset se encuentra en myotherproject, no en tu proyecto predeterminado. mydataset se creó en la ubicación multirregional US.

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

Ingresa el comando siguiente para anexar un archivo de datos JSON delimitado por saltos de línea en Cloud Storage a mydataset.mytable con un trabajo de carga. La marca --autodetect se usa para detectar las columnas nuevas. mydataset está en tu proyecto predeterminado y se creó en la región asia-northeast1.

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

API

Llama al método jobs.insert. Especifica tu región en la propiedad location en la sección jobReference del recurso de trabajo.

Configura un trabajo de carga y establece las propiedades siguientes:

Go

// To run this sample, you will need to create (or reuse) a context and
// an instance of the bigquery client.  For example:
// import "cloud.google.com/go/bigquery"
// ctx := context.Background()
// client, err := bigquery.NewClient(ctx, "your-project-id")
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
}

Python

Antes de probar esta muestra, sigue las instrucciones de configuración para Python que se encuentran en la Guía de inicio rápido de BigQuery con bibliotecas cliente. Para obtener más información, consulta la Documentación de referencia de la API de Python de BigQuery.

# from google.cloud import bigquery
# client = bigquery.Client()
# dataset_ref = client.dataset('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)))

Agrega una columna en un trabajo de anexo de consulta

Para agregar columnas a una tabla mientras le agregas los resultados de la consulta, puedes usar el comando bq query de la herramienta de línea de comandos o puedes llamar al método jobs.insert de la API y configurar un trabajo de consulta. Agregar una columna durante la operación de anexo no es compatible con la IU web de BigQuery en la actualidad.

Cuando agregas columnas con una operación de anexo a un trabajo de consulta, el esquema de los resultados de la consulta se usa para actualizar el esquema de la tabla de destino.

Para agregar una columna nueva cuando anexas datos a una tabla durante un trabajo de consulta, ten en cuenta esta información:

IU web

No puedes agregar columnas nuevas a una tabla existente cuando anexas los resultados de la consulta con la IU web de BigQuery.

CLI

Usa el comando bq query para consultar tus datos y especificar la marca --destination_table a fin de indicar qué tabla agregas.

Para especificar que agregas los resultados de la consulta a una tabla de destino existente, especifica la marca --append_table.

Establece la marca --schema_update_option en ALLOW_FIELD_ADDITION para indicar que los resultados de la consulta que agregas contienen las columnas nuevas.

Especifica la marca use_legacy_sql=false a fin de usar la sintaxis de SQL estándar para la consulta.

Si la tabla que agregas se encuentra en un conjunto de datos en un proyecto que no es el predeterminado, agrega el ID del proyecto al nombre del conjunto de datos en el formato siguiente: [PROJECT_ID]:[DATASET].

Proporciona la marca --location y establece el valor en tu ubicación.

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

En el que:

  • [LOCATION] es el nombre de tu ubicación. La marca --location es opcional si tus datos están en US o en la ubicación multirregional EU. Por ejemplo, si usas BigQuery en la región de Tokio, establece el valor de la marca en asia-northeast1. Puedes establecer un valor predeterminado para la ubicación con el .bigqueryrc file.
  • [PROJECT_ID] es el ID del proyecto.
  • [DATASET] es el nombre del conjunto de datos que contiene la tabla que anexas.
  • [TABLE] es el nombre de la tabla que agregas.
  • [QUERY] es una consulta en la sintaxis de SQL estándar.

Ejemplos:

Ingresa la consulta de comando siguiente mydataset.mytable en tu proyecto predeterminado y anexa los resultados de la consulta en mydataset.mytable2 (también en tu proyecto predeterminado). mydataset se creó en la ubicación multirregional US.

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

Ingresa la consulta de comando mydataset.mytable siguiente en tu proyecto predeterminado y anexa los resultados de la consulta a mydataset.mytable2 en myotherproject. mydataset se creó en la ubicación multirregional US.

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

Ingresa la consulta de comando mydataset.mytable siguiente en tu proyecto predeterminado y anexa los resultados de la consulta en mydataset.mytable2 (también en tu proyecto predeterminado). mydataset se creó en la región asia-northeast1.

bq --location=asia-northeast1 query --destination_table 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. Especifica tu región en la propiedad location en la sección jobReference del recurso de trabajo.

Configura un trabajo de consulta y establece las propiedades siguientes:

Go

// To run this sample, you will need to create (or reuse) a context and
// an instance of the bigquery client.  For example:
// import "cloud.google.com/go/bigquery"
// ctx := context.Background()
// client, err := bigquery.NewClient(ctx, "your-project-id")
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
}

Python

Antes de probar esta muestra, sigue las instrucciones de configuración para Python que se encuentran en la Guía de inicio rápido de BigQuery con bibliotecas cliente. Para obtener más información, consulta la Documentación de referencia de la API de Python de BigQuery.

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

# 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 query to append the results to a destination table,
# allowing field addition
job_config = bigquery.QueryJobConfig()
job_config.schema_update_options = [
    bigquery.SchemaUpdateOption.ALLOW_FIELD_ADDITION,
]
job_config.destination = table_ref
job_config.write_disposition = bigquery.WriteDisposition.WRITE_APPEND

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;',
    # Location must match that of the dataset(s) referenced in the query
    # and of the destination table.
    location='US',
    job_config=job_config
)  # API request - starts the query

query_job.result()  # Waits for the query to finish
print("Query job {} complete.".format(query_job.job_id))

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

Disminuye la rigurosidad del modo de una columna

Por el momento, la única modificación que puedes hacer al modo de una columna es cambiar de REQUIRED a NULLABLE. Cambiar el modo de una columna de REQUIRED a NULLABLE también se llama columna de relajación. Puedes disminuir la rigurosidad de las columnas REQUIRED:

  • De forma manual
  • Cuando reemplazas una tabla con un trabajo de carga o consulta.
  • Cuando anexas datos a una tabla con un trabajo de consulta.

Cambia las columnas REQUIRED a NULLABLE de forma manual

Puedes cambiar de forma manual el modo de una columna de REQUIRED a NULLABLE si usas la IU web de BigQuery, el comando bq update de la herramienta de línea de comandos o si llamas al método de API tables.patch.

Para cambiar de forma manual el modo de una columna de REQUIRED a NULLABLE, haz lo siguiente:

IU web

  1. Expande tu conjunto de datos y selecciona tu tabla.

  2. En la página Table Details (Detalles de la tabla), haz clic en la pestaña Schema (Esquema).

  3. Haz clic en la flecha hacia abajo a la derecha de la columna requerida y elige las opciones siguientes:

    • Make NULLABLE: disminuye la rigurosidad del modo de columna individual.
    • All REQUIRED to NULLABLE: cambia todas las columnas REQUIRED en la definición del esquema a NULLABLE.

      Disminuye la rigurosidad del modo de la columna

  4. En el cuadro de diálogo Confirm Mode Change (Confirmar cambio de modo), haz clic en OK (Aceptar) para cambiar el modo a NULLABLE. Ten en cuenta que este cambio no se puede deshacer.

CLI

  1. Primero, genera el comando bq show con la marca --schema y escribe el esquema de tabla existente en un archivo. Si la tabla que actualizas se encuentra en otro proyecto que no es el proyecto predeterminado, agrega el ID del proyecto al nombre del conjunto de datos en el formato siguiente: [PROJECT_ID]:[DATASET].

    bq show --schema --format=prettyjson [PROJECT_ID]:[DATASET].[TABLE] > [SCHEMA_FILE]
    

    En el que:

    • [PROJECT_ID] es el ID del proyecto.
    • [DATASET] es el nombre del conjunto de datos que contiene la tabla que actualizas.
    • [TABLE] es el nombre de la tabla que actualizas.
    • [SCHEMA_FILE] es el archivo de definición de esquema que se escribe en tu máquina local.

    Por ejemplo, para escribir una definición de esquema de mydataset.mytable en un archivo, ingresa el comando siguiente. mydataset.mytable se encuentra en tu proyecto predeterminado.

    bq show --schema --format=prettyjson mydataset.mytable > /tmp/myschema.json
    
  2. Abre el archivo del esquema en un editor de texto. El esquema debe verse de la manera siguiente:

    [
      {
        "mode": "REQUIRED",
        "name": "column1",
        "type": "STRING"
      },
      {
        "mode": "REQUIRED",
        "name": "column2",
        "type": "FLOAT"
      },
      {
        "mode": "REPEATED",
        "name": "column3",
        "type": "STRING"
      }
    ]
    
  3. Cambia el modo de una columna existente de REQUIRED a NULLABLE. En este ejemplo, el modo para column1 es flexible.

    [
      {
        "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 Especifica un archivo de esquema JSON.

  4. Después de actualizar tu archivo de esquema, ejecuta el comando siguiente para actualizar el esquema de la tabla. Si la tabla que actualizas se encuentra en otro proyecto que no es el proyecto predeterminado, agrega el ID del proyecto al nombre del conjunto de datos en el formato siguiente: [PROJECT_ID]:[DATASET].

    bq update [PROJECT_ID]:[DATASET].[TABLE] [SCHEMA]
    

    En el que:

    • [PROJECT_ID] es el ID del proyecto.
    • [DATASET] es el nombre del conjunto de datos que contiene la tabla que actualizas.
    • [TABLE] es el nombre de la tabla que actualizas.
    • [SCHEMA] es la ruta de acceso al archivo de esquema JSON en tu máquina local.

    Por ejemplo, ingresa el comando siguiente a fin de actualizar la definición de 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 tu definición de esquema. Debido a que el método tables.update reemplaza todo el recurso de la tabla, se prefiere el método tables.patch.

Go

// To run this sample, you will need to create (or reuse) a context and
// an instance of the bigquery client.  For example:
// import "cloud.google.com/go/bigquery"
// ctx := context.Background()
// client, err := bigquery.NewClient(ctx, "your-project-id")
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
}

Python

Antes de probar esta muestra, sigue las instrucciones de configuración para Python que se encuentran en la Guía de inicio rápido de BigQuery con bibliotecas cliente. Para obtener más información, consulta la Documentación de referencia de la API de Python de BigQuery.

Reemplaza la propiedad Table.schema con una lista de objetos SchemaField con la propiedad de modo establecida en 'NULLABLE'

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

original_schema = [
    bigquery.SchemaField('full_name', 'STRING', mode='REQUIRED'),
    bigquery.SchemaField('age', 'INTEGER', mode='REQUIRED'),
]
table_ref = client.dataset(dataset_id).table(table_id)
table = bigquery.Table(table_ref, schema=original_schema)
table = client.create_table(table)
assert all(field.mode == 'REQUIRED' for field in table.schema)

# SchemaField properties cannot be edited after initialization.
# To make changes, construct new SchemaField objects.
relaxed_schema = [
    bigquery.SchemaField('full_name', 'STRING', mode='NULLABLE'),
    bigquery.SchemaField('age', 'INTEGER', mode='NULLABLE'),
]
table.schema = relaxed_schema
table = client.update_table(table, ['schema'])

assert all(field.mode == 'NULLABLE' for field in table.schema)

Cambia REQUIRED a NULLABLE en un trabajo de carga o consulta

Puedes disminuir la rigurosidad de las columnas REQUIRED a NULLABLE en un esquema de tabla existente cuando cargas datos en ella y eliges reemplazar la tabla existente. Cuando reemplazas una tabla existente, el esquema de los datos que cargaste, se usa para reemplazar el esquema de la tabla existente. Para obtener información sobre cómo reemplazar una tabla con un trabajo de carga, consulta:

También puedes disminuir la rigurosidad de las columnas REQUIRED a NULLABLE en un esquema de tabla existente cuando agregas datos a estas con un trabajo de consulta.

Cambia REQUIRED a NULLABLE en un trabajo agregado de carga

Para disminuir el modo de una columna mientras agregas datos a una tabla en un trabajo de carga, puedes usar el comando bq load de la herramienta de línea de comandos o puedes llamar al método jobs.insert de la API y configurar un trabajo de carga. Cambiar el modo de una columna durante la operación de anexo no es compatible con la IU web de BigQuery en la actualidad.

Cuando disminuyes la rigurosidad del modo de una columna con una operación de anexo en un trabajo de carga, puedes hacer estas acciones:

  • Disminuir la rigurosidad del modo para las columnas individuales mediante la especificación de un archivo de esquema JSON (cuando agregas datos de los archivos CSV y JSON).
  • Disminuir la rigurosidad de las columnas a null en tu esquema Avro y permitir la inferencia del esquema para detectar las columnas flexibles.

A la hora disminuir la rigurosidad de una columna de REQUIRED a NULLABLE cuando agregas datos a una tabla durante un trabajo de carga, ten en cuenta esta información:

IU web

No puedes disminuir la rigurosidad del modo de una columna existente cuando agregas datos a una tabla en un trabajo de carga con la IU web de BigQuery.

CLI

Usa el comando bq load para cargar tus datos y especifica la marca --noreplace a fin de indicar que agregas los datos en una tabla existente.

Si los datos que agregas 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 a fin de usar la detección del esquema para detectar las columnas flexibles en los datos de origen. Para obtener más información sobre cómo disminuir la rigurosidad de los modos de columna con el archivo de esquema JSON, consulta Cambia las columnas REQUIRED a NULLABLE de forma manual.

Las columnas flexibles se pueden inferir de forma automática desde los archivos Avro. La relajación de columnas no se aplica a los anexos de exportación de Cloud Datastore. Las columnas en las tablas creadas mediante la carga de archivos de exportación de Cloud Datastore siempre son NULLABLE.

Establece la marca --schema_update_option en ALLOW_FIELD_RELAXATION para indicar que los datos que agregas contienen columnas flexibles.

Si la tabla que agregas se encuentra en un conjunto de datos en un proyecto que no es el predeterminado, agrega el ID del proyecto al nombre del conjunto de datos en el formato siguiente: [PROJECT_ID]:[DATASET].

Proporciona la marca --location y establece el valor en tu ubicación.

Ingresa el comando load de la manera siguiente:

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

En el que:

  • [LOCATION] es el nombre de tu ubicación. La marca --location es opcional si tus datos están en US o en la ubicación multirregional EU. Por ejemplo, si usas BigQuery en la región de Tokio, establece el valor de la marca en asia-northeast1. Puedes establecer un valor predeterminado para la ubicación con el .bigqueryrc file.
  • [FORMAT] es NEWLINE_DELIMITED_JSON, CSV o AVRO. Los archivos DATASTORE_BACKUP no necesitan disminución de rigurosidad de columna. Las columnas en las tablas que se crearon desde los archivos de exportación de Cloud Datastore siempre son NULLABLE.
  • [PROJECT_ID] es el ID del proyecto.
  • [DATASET] es el nombre del conjunto de datos que contiene la tabla.
  • [TABLE] es el nombre de la tabla que agregas.
  • [PATH_TO_SOURCE] es un URI de Cloud Storage calificado en su totalidad, una lista separada por comas de URI o la ruta a un archivo de datos en tu máquina local.
  • [SCHEMA] es la ruta a un archivo de esquema JSON local. Esta opción se usa solo para los archivos CSV y JSON. Las columnas flexibles se infieren de forma automática desde los archivos Avro.

Ejemplos:

Ingresa el comando siguiente para adjuntar un archivo de datos Avro local /tmp/mydata.avro a mydataset.mytable con un trabajo de carga. Dado que las columnas agregadas se pueden inferir de forma automática desde los datos de Avro, no debes especificar un archivo de esquema. mydataset se encuentra en tu proyecto predeterminado y se creó en la ubicación multirregional US.

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

Ingresa el comando siguiente para agregar datos de un archivo JSON delimitado por saltos de línea en Cloud Storage en mydataset.mytable con un trabajo de carga. El esquema que contiene las columnas flexibles se encuentra en un archivo de esquema JSON local: /tmp/myschema.json. mydataset se encuentra en tu proyecto predeterminado y se creó en la ubicación multirregional US.

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

Ingresa el comando siguiente para agregar datos de un archivo CSV en tu máquina local en mydataset.mytable con un trabajo de carga. El comando usa la detección automática de esquemas para detectar las columnas flexibles en los datos de origen. mydataset se encuentra en myotherproject, no en tu proyecto predeterminado. mydataset se creó en la ubicación multirregional US.

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

Ingresa el comando siguiente para agregar datos de un archivo JSON delimitado por saltos de línea en Cloud Storage en mydataset.mytable con un trabajo de carga. El esquema que contiene las columnas flexibles se encuentra en un archivo de esquema JSON local: /tmp/myschema.json. mydataset se encuentra en tu proyecto predeterminado y se creó en la región asia-northeast1.

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

API

Llama al método jobs.insert. Especifica tu región en la propiedad location en la sección jobReference del recurso de trabajo. Configura un trabajo de carga y establece las propiedades siguientes:

Go

// To run this sample, you will need to create (or reuse) a context and
// an instance of the bigquery client.  For example:
// import "cloud.google.com/go/bigquery"
// ctx := context.Background()
// client, err := bigquery.NewClient(ctx, "your-project-id")
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
}

Python

Antes de probar esta muestra, sigue las instrucciones de configuración para Python que se encuentran en la Guía de inicio rápido de BigQuery con bibliotecas cliente. Para obtener más información, consulta la Documentación de referencia de la API de Python de BigQuery.

# from google.cloud import bigquery
# client = bigquery.Client()
# dataset_ref = client.dataset('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))

Cambia REQUIRED a NULLABLE en un trabajo de anexo de consulta

Para disminuir la rigurosidad de todas las columnas en una tabla mientras agregas los resultados de la consulta a esta, puedes usar el comando bq query de la herramienta de línea de comandos o puedes llamar al método jobs.insert de la API y configurar una trabajo de consulta. La disminución de rigurosidad de las columnas durante una operación de anexo no es compatibles con la IU web de BigQuery por el momento.

Cuando disminuyes la rigurosidad de las columnas con una operación de anexo en un trabajo de consulta, puedes disminuir la rigurosidad de todos los campos requeridos en la tabla de destino si configuras la marca --schema_update_option en ALLOW_FIELD_RELAXATION. No puedes disminuir la rigurosidad de columnas individuales en una tabla de destino con un anexo de consulta.

Para disminuir la rigurosidad de todas las columnas en una tabla de destino cuando agregas los datos a esta durante un trabajo de consulta, haz lo siguiente:

IU web

No puedes disminuir la rigurosidad de las columnas en una tabla de destino cuando agregas los resultados de la consulta con la IU web de BigQuery.

CLI

Usa el comando bq query para consultar tus datos y especificar la marca --destination_table a fin de indicar qué tabla agregas.

Para especificar que agregas los resultados de la consulta a una tabla de destino existente, especifica la marca --append_table.

Establece la marca --schema_update_option en ALLOW_FIELD_RELAXATION para indicar que todas las columnas REQUIRED en la tabla que agregas se deben cambiar a NULLABLE.

Especifica la marca use_legacy_sql=false a fin de usar la sintaxis de SQL estándar para la consulta.

Si la tabla que agregas se encuentra en un conjunto de datos en un proyecto que no es el predeterminado, agrega el ID del proyecto al nombre del conjunto de datos en el formato siguiente: [PROJECT_ID]:[DATASET].

Proporciona la marca --location y establece el valor en tu ubicación.

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

En el que:

  • [LOCATION] es el nombre de tu ubicación. La marca --location es opcional si tus datos están en US o en la ubicación multirregional EU. Por ejemplo, si usas BigQuery en la región de Tokio, establece el valor de la marca en asia-northeast1. Puedes establecer un valor predeterminado para la ubicación con el .bigqueryrc file.
  • [PROJECT_ID] es el ID del proyecto.
  • [DATASET] es el nombre del conjunto de datos que contiene la tabla que anexas.
  • [TABLE] es el nombre de la tabla que agregas.
  • [QUERY] es una consulta en la sintaxis de SQL estándar.

Ejemplos:

Ingresa la consulta de comando mydataset.mytable en tu proyecto predeterminado y anexa los resultados de la consulta en mydataset.mytable2 (también en tu proyecto predeterminado). Con el comando, se cambian todas las columnas REQUIRED en la tabla de destino a NULLABLE. mydataset se creó en la ubicación multirregional US.

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

Ingresa la consulta de comando mydataset.mytable en tu proyecto predeterminado y anexa los resultados de la consulta a mydataset.mytable2 en myotherproject. Con el comando, se cambian todas las columnas REQUIRED en la tabla de destino a NULLABLE. mydataset se creó en la ubicación multirregional US.

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

Ingresa la consulta de comando mydataset.mytable en tu proyecto predeterminado y anexa los resultados de la consulta en mydataset.mytable2 (también en tu proyecto predeterminado). Con el comando, se cambian todas las columnas REQUIRED en la tabla de destino a NULLABLE. mydataset se creó en la región asia-northeast1.

bq --location=asia-northeast1 query --destination_table 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. Especifica tu región en la propiedad location en la sección jobReference del recurso de trabajo.

Configura un trabajo de consulta y establece las propiedades siguientes:

Go

// To run this sample, you will need to create (or reuse) a context and
// an instance of the bigquery client.  For example:
// import "cloud.google.com/go/bigquery"
// ctx := context.Background()
// client, err := bigquery.NewClient(ctx, "your-project-id")
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
}

Python

Antes de probar esta muestra, sigue las instrucciones de configuración para Python que se encuentran en la Guía de inicio rápido de BigQuery con bibliotecas cliente. Para obtener más información, consulta la Documentación de referencia de la API de Python de BigQuery.

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

# 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 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()
job_config.schema_update_options = [
    bigquery.SchemaUpdateOption.ALLOW_FIELD_RELAXATION,
]
job_config.destination = table_ref
job_config.write_disposition = bigquery.WriteDisposition.WRITE_APPEND

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;',
    # Location must match that of the dataset(s) referenced in the query
    # and of the destination table.
    location='US',
    job_config=job_config
)  # API request - starts the query

query_job.result()  # Waits for the query to finish
print("Query job {} complete.".format(query_job.job_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))
¿Te ha resultado útil esta página? Enviar comentarios:

Enviar comentarios sobre...

Si necesitas ayuda, visita nuestra página de asistencia.