Carga datos JSON desde Cloud Storage

Carga archivos JSON desde Cloud Storage

Cuando cargas datos JSON delimitados por saltos de línea desde Cloud Storage, puedes cargarlos en una tabla o partición nuevas. También puedes adjuntarlos a una tabla o partición existentes o reemplazar los datos de ellas. Cuando los datos se cargan en BigQuery, se convierten en formato de columnas para Capacitor (formato de almacenamiento de BigQuery).

Cuando cargas datos de Cloud Storage en una tabla de BigQuery, el conjunto de datos que contiene la tabla debe estar en la misma ubicación regional o multirregional que el depósito de Cloud Storage.

El formato JSON delimitado por saltos de línea es el mismo que el formato líneas JSON.

Para obtener información sobre cómo cargar datos JSON desde un archivo local, consulta cómo cargar datos en BigQuery desde una fuente de datos local.

Limitaciones

Cuando cargues datos JSON de Cloud Storage en BigQuery, ten en cuenta lo siguiente:

  • Los datos JSON deben estar delimitados por saltos de línea. Cada objeto JSON debe estar en una línea separada en el archivo.
  • Si usas la compresión gzip, BigQuery no puede leer los datos en paralelo. La carga de datos JSON comprimidos en BigQuery es más lenta que la carga de datos sin comprimir.
  • No puedes incluir archivos comprimidos y descomprimidos en el mismo trabajo de carga.
  • BigQuery no admite asignaciones ni diccionarios en JSON. Por ejemplo, "product_categories": {"my_product": 40.0} no es válido, pero "product_categories": {"column1": "my_product" , "column2": 40.0} sí lo es.
  • Cuando cargues datos CSV o JSON, en los valores de las columnas DATE, se debe usar el separador de guion (-), y la fecha debe estar en el siguiente formato: YYYY-MM-DD (año-mes-día).
  • Cuando cargues datos JSON o CSV, en los valores de las columnas TIMESTAMP, se debe usar un separador de guion (-) para la parte de fecha de la marca de tiempo, y la fecha debe tener el siguiente formato: YYYY-MM-DD (año-mes-día). En la parte de hh:mm:ss (horas-minutos-segundos) de la marca de tiempo, se debe usar un separador de dos puntos (:).

Permisos necesarios

Cuando cargas datos en BigQuery, necesitas permisos para ejecutar un trabajo de carga y cargar datos en tablas y particiones nuevas o existentes de BigQuery. Si cargas datos desde Cloud Storage, también necesitas permisos para acceder al depósito que contiene tus datos.

Permisos de BigQuery

Para cargar datos en BigQuery, se requieren, como mínimo, los siguientes permisos. Estos permisos son obligatorios si los datos se cargan en una tabla o partición nueva, o si se agrega o reemplaza una tabla o partición.

  • bigquery.tables.create
  • bigquery.tables.updateData
  • bigquery.jobs.create

Las siguientes funciones predefinidas de Cloud IAM incluyen los permisos bigquery.tables.create y bigquery.tables.updateData:

  • bigquery.dataEditor
  • bigquery.dataOwner
  • bigquery.admin

Las siguientes funciones predefinidas de Cloud IAM incluyen los permisos bigquery.jobs.create:

  • bigquery.user
  • bigquery.jobUser
  • bigquery.admin

Además, si un usuario tiene permisos bigquery.datasets.create, se le otorga el acceso bigquery.dataOwner cuando crea un conjunto de datos. El acceso bigquery.dataOwner permite que el usuario cree y actualice tablas en el conjunto de datos a través de un trabajo de carga.

Para obtener más información sobre las funciones y los permisos de Cloud IAM en BigQuery, consulta Funciones y permisos predefinidos.

Permisos de Cloud Storage

Para cargar datos desde un depósito de Cloud Storage, debes tener permisos storage.objects.get. Si usas un comodín de URI, también debes tener permisos storage.objects.list.

La función de Cloud IAM predefinida storage.objectViewer puede otorgarse para proporcionar los permisos storage.objects.get y storage.objects.list.

Carga datos JSON en una tabla nueva

Tienes las siguientes opciones para cargar datos JSON delimitados por saltos de línea desde Cloud Storage en una tabla nueva de BigQuery:

  • Usar Cloud Console o la IU web clásica
  • Usar el comando bq load de CLI
  • Realizar una llamada al método jobs.insert de la API y configurar un trabajo de load
  • Usar bibliotecas cliente

Para cargar datos JSON de Cloud Storage en una tabla nueva de BigQuery, sigue estos pasos:

Console

  1. Abre la IU web de BigQuery en Cloud Console.
    Ir a Cloud Console

  2. En el panel de navegación, en la sección Recursos, expande tu proyecto y selecciona un conjunto de datos.

  3. En el lado derecho de la ventana, en el panel de detalles, haz clic en Create table (Crear tabla). El proceso de carga de datos es el mismo que el proceso para crear una tabla vacía.

    Crear tabla

  4. En la sección Source (Fuente) de la página Create table (Crear tabla), haz lo siguiente:

    • En Create table from (Crear tabla desde), selecciona Cloud Storage.

    • En el campo de origen, busca o ingresa el URI de Cloud Storage. Ten en cuenta que no puedes incluir varios URI en Cloud Console, pero se admiten comodines. El depósito de Cloud Storage debe estar en la misma ubicación que el conjunto de datos que contiene la tabla que quieres crear.

      Seleccionar archivo

    • En File format (Formato de archivo), selecciona JSON (delimitado por saltos de línea).

  5. En la sección Destination (Destino) de la página Create table (Crear tabla), haz lo siguiente:

    • En Dataset name (Nombre del conjunto de datos), selecciona el conjunto de datos que corresponda.

      Ver conjunto de datos

    • Verifica que Table type (Tipo de tabla) esté establecido en Native table (Tabla nativa).

    • En el campo Table name (Nombre de tabla), ingresa el nombre de la tabla que quieres crear en BigQuery.

  6. En la sección Esquema, en Detección automática, marca la opción Esquema y parámetros de entrada para habilitar la detección automática de esquemas. También puedes ingresar de forma manual la definición de esquema, como se indica a continuación:

    • Habilita Editar como texto y, luego, ingresa el esquema de la tabla como un arreglo JSON.

      Agregar esquema como arreglo JSON

    • Usa Agregar campo para ingresar el esquema de forma manual.

      Agregar definición de esquema con el botón Agregar campo

  7. Para particionar la tabla, elige las opciones en la Configuración de partición y agrupamiento en clústeres (opcional):

    • Para crear una tabla particionada, haz clic en Sin particionar, selecciona Particionar por campo y elige una columna DATE o TIMESTAMP. Esta opción no estará disponible si el esquema no incluye una columna DATE o TIMESTAMP.
    • Para crear una tabla particionada por tiempo de transferencia, haz clic en Sin particionar y selecciona Particionar por tiempo de transferencia.
  8. Para el Filtro de partición, haz clic en la casilla Exigir filtro de partición a fin de solicitar a los usuarios que incluyan una cláusula WHERE que especifique las particiones que deben consultarse (opcional). Exigir un filtro de partición puede reducir los costos y mejorar el rendimiento. Para obtener más información, lee la sección Cómo consultar tablas particionadas. Esta opción no está disponible si se selecciona Sin particionar.

  9. Para agrupar la tabla, en la casilla Orden de agrupamiento en clústeres, ingresa entre uno y cuatro nombres de campo (opcional). Por el momento, el agrupamiento en clústeres solo es compatible con tablas particionadas.

  10. Haz clic en Opciones avanzadas (opcional).

    • En Preferencia de escritura, deja seleccionado Escribir si está vacía. Esta opción crea una tabla nueva y carga los datos en ella.
    • En Cantidad de errores permitidos, acepta el valor predeterminado de 0 o ingresa la cantidad máxima de filas con errores que pueden ignorarse. Si la cantidad de filas con errores excede este valor, el trabajo generará un mensaje invalid y fallará.
    • En Valores desconocidos, marca Ignorar valores desconocidos para ignorar cualquier valor en una fila que no esté presente en el esquema de la tabla.
    • En Encriptación, haz clic en Clave administrada por el cliente para usar una clave de Cloud Key Management Service. Si dejas establecida la configuración Clave administrada por Google, BigQuery encripta los datos en reposo.
  11. Haz clic en Crear tabla.

IU clásica

  1. Ve a la IU web de BigQuery.
    Ir a la IU web de BigQuery

  2. En el panel de navegación, coloca el cursor sobre un conjunto de datos, haz clic en el ícono de flecha hacia abajo imagen del ícono de flecha hacia abajo y, luego, en Crear tabla nueva. El proceso de carga de datos es el mismo que el proceso para crear una tabla vacía.

  3. En la sección Datos de origen de la página Crear tabla, sigue estos pasos:

    • Haz clic en Crear desde el origen.
    • En Ubicación, selecciona Cloud Storage y, en el campo de origen, ingresa el URI de Cloud Storage. Ten en cuenta que no puedes incluir varios URI en la IU web de BigQuery, pero sí se admiten comodines. El depósito de Cloud Storage debe estar en la misma ubicación que el conjunto de datos que contiene la tabla que quieres crear.
    • En Formato de archivo, selecciona JSON (delimitado por saltos de línea).
  4. En la sección Tabla de destino, haz lo siguiente:

    • En Nombre de tabla, selecciona el conjunto de datos que corresponda y, en el campo de nombre de tabla, ingresa el nombre de la tabla que quieres crear en BigQuery.
    • Verifica que Tipo de tabla esté establecido en Tabla nativa.
  5. En la sección Esquema, en Detección automática, marca la opción Esquema y parámetros de entrada para habilitar la detección automática de esquemas. También puedes ingresar de forma manual la definición de esquema, como se indica a continuación:

    • Haz clic en Editar como texto y, luego, ingresa el esquema de la tabla en forma de arreglo JSON.

      Agregar esquema como arreglo JSON

    • Usa Agregar campo para ingresar el esquema de forma manual:

      Agregar esquema con el botón Agregar campo

  6. En la sección Opciones, realiza los siguientes pasos (opcional):

    • En Cantidad de errores permitidos, acepta el valor predeterminado de 0 o ingresa la cantidad máxima de filas con errores que pueden ignorarse. Si la cantidad de filas con errores excede este valor, el trabajo generará un mensaje invalid y fallará.
    • En Preferencia de escritura, deja seleccionado Escribir si está vacía. Esta opción crea una tabla nueva y carga los datos en ella.
    • Para particionar la tabla, realiza las siguientes acciones:
      • Para Tipo de partición, haz clic en Ninguna y elige Día.
      • En Campo de partición, haz lo siguiente:
      • Para crear una tabla particionada, elige una columna DATE o TIMESTAMP. Esta opción no estará disponible si el esquema no incluye una columna DATE o TIMESTAMP.
      • Para crear una tabla particionada por tiempo de transferencia, deja el valor predeterminado: _PARTITIONTIME.
      • Haz clic en la casilla Exigir filtro de partición para solicitar a los usuarios que incluyan una cláusula WHERE que especifique las particiones que desean consultar. Exigir un filtro de partición puede reducir los costos y mejorar el rendimiento. Para obtener más información, lee la sección Cómo consultar tablas particionadas. Esta opción no estará disponible si el Tipo de partición está configurado como Ninguna.
    • Para agrupar en clústeres la tabla, en la casilla Agrupar campos, ingresa entre uno y cuatro nombres de campo.
    • En Encriptación de destino, elige Encriptación administrada por el cliente para encriptar la tabla con una clave de Cloud Key Management Service. Si dejas la configuración Default, BigQuery encripta los datos en reposo con una clave administrada por Google.
  7. Haz clic en Crear tabla.

CLI

Usa el comando bq load, especifica NEWLINE_DELIMITED_JSON con la marca --source_format y, además, incluye un URI de Cloud Storage. Puedes incluir un único URI, una lista de URI separados por comas o un URI que contenga un comodín. Proporciona el esquema intercalado con un archivo de definición de esquema o usa la detección automática de esquemas.

Proporciona la marca --location y establece el valor de tu ubicación (opcional).

Las siguientes son otras marcas opcionales:

  • --max_bad_records: Un número entero que especifica la cantidad máxima de registros incorrectos permitidos antes de que falle todo el trabajo. El valor predeterminado es 0. Como máximo, se muestran cinco errores de cualquier tipo, sin importar el valor --max_bad_records.
  • --ignore_unknown_values: Cuando se especifica, permite y también ignora valores extras no reconocidos en datos CSV o JSON.
  • --autodetect: Cuando se especifica, habilita la detección automática de esquemas para los datos de formato CSV y JSON.
  • --quote: El carácter de comillas que se usará para encerrar registros. El valor predeterminado es ". Para indicar que no hay ningún carácter de comilla, usa una string vacía.
  • --time_partitioning_type: Habilita las particiones basadas en el tiempo en una tabla y establece el tipo de partición. Por el momento el único valor posible es DAY, que genera una partición por día. Esta marca es opcional cuando se crea una tabla particionada en una columna DATE o TIMESTAMP.
  • --time_partitioning_expiration: Un número entero que especifica (en segundos) cuándo se debe borrar una partición basada en el tiempo. La hora de vencimiento se evalúa según la suma de la fecha de la partición en formato UTC más el valor del número entero.
  • --time_partitioning_field: La columna DATE o TIMESTAMP que se usa para crear una tabla particionada. Si la partición basada en el tiempo se habilita sin este valor, se creará una tabla particionada por tiempo de transferencia.
  • --require_partition_filter: Cuando se habilita esta opción, se solicita a los usuarios que incluyan una cláusula WHERE que especifique las particiones que se desean consultar. Exigir un filtro de partición puede reducir los costos y mejorar el rendimiento. Para obtener más información, lee la sección Cómo consultar tablas particionadas.
  • --clustering_fields: Una lista separada por comas de hasta cuatro nombres de columna que se usa para crear una tabla agrupada. Esta marca solo se puede usar con tablas particionadas.
  • --destination_kms_key: La clave de Cloud KMS para la encriptación de los datos de la tabla.

    Para obtener más información sobre las tablas particionadas, consulta los siguientes artículos:

    Para obtener más información sobre tablas agrupadas en clústeres, consulta el siguiente artículo:

    Para obtener más información sobre la encriptación de tablas, consulta el siguiente artículo:

Para cargar datos JSON en BigQuery, ingresa el siguiente comando:

bq --location=location load \
--source_format=format \
dataset.table \
path_to_source \
schema

Donde:

  • location es tu ubicación. La marca --location es opcional. Por ejemplo, si usas BigQuery en la región de Tokio, puedes establecer el valor de la marca como asia-northeast1. Puedes configurar un valor predeterminado para la ubicación con el archivo .bigqueryrc.
  • format es NEWLINE_DELIMITED_JSON.
  • dataset es un conjunto de datos existente.
  • table es el nombre de la tabla en la que cargas los datos.
  • path_to_source es un URI de Cloud Storage completamente calificado o una lista de URI separados por comas. También se admiten comodines.
  • schema es un esquema válido. El esquema puede ser un archivo JSON local o se puede escribir intercalado como parte del comando. También puedes usar la marca --autodetect en lugar de proporcionar una definición de esquema.

Ejemplos:

El siguiente comando carga datos de gs://mybucket/mydata.json a una tabla llamada mytable en mydataset. El esquema se define en un archivo de esquema local llamado myschema.json.

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

El siguiente comando carga datos de gs://mybucket/mydata.json a una tabla particionada por tiempo de transferencia llamada mytable en mydataset. El esquema se define en un archivo de esquema local llamado myschema.json.

    bq load \
    --source_format=NEWLINE_DELIMITED_JSON \
    --time_partitioning_type=DAY \
    mydataset.mytable \
    gs://mybucket/mydata.json \
    ./myschema.json

El siguiente comando carga datos de gs://mybucket/mydata.json a una tabla particionada llamada mytable en mydataset. La tabla está particionada en la columna mytimestamp. El esquema se define en un archivo de esquema local llamado myschema.json.

    bq load \
    --source_format=NEWLINE_DELIMITED_JSON \
    --time_partitioning_field mytimestamp \
    mydataset.mytable \
    gs://mybucket/mydata.json \
    ./myschema.json

El siguiente comando carga datos de gs://mybucket/mydata.json a una tabla llamada mytable en mydataset. El esquema se detecta de forma automática.

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

El siguiente comando carga datos de gs://mybucket/mydata.json a una tabla llamada mytable en mydataset. El esquema se define intercalado en el formato field:data_type, field:data_type.

    bq load \
    --source_format=NEWLINE_DELIMITED_JSON \
    mydataset.mytable \
    gs://mybucket/mydata.json \
    qtr:STRING,sales:FLOAT,year:STRING

El siguiente comando carga datos de varios archivos en gs://mybucket/ en una tabla llamada mytable en mydataset. El URI de Cloud Storage usa un comodín. El esquema se detecta de forma automática.

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

El siguiente comando carga datos de varios archivos en gs://mybucket/ en una tabla llamada mytable en mydataset. El comando incluye una lista separada por comas de URI de Cloud Storage con comodines. El esquema se define en un archivo de esquema local llamado myschema.json.

    bq load \
    --source_format=NEWLINE_DELIMITED_JSON \
    mydataset.mytable \
    "gs://mybucket/00/*.json","gs://mybucket/01/*.json" \
    ./myschema.json

API

  1. Crea un trabajo load que apunte a los datos de origen en Cloud Storage.

  2. Especifica tu ubicación en la propiedad location de la sección jobReference del recurso de trabajo (opcional).

  3. La propiedad source URIs debe estar completamente calificada en el formato gs://bucket/object. Cada URI puede contener un carácter comodín “*”.

  4. Para especificar el formato de datos JSON, configura la propiedad sourceFormat como NEWLINE_DELIMITED_JSON.

  5. Para verificar el estado del trabajo, llama a jobs.get(job_id*), donde job_id es el ID del trabajo que muestra la solicitud inicial.

    • Si se muestra status.state = DONE, el trabajo se completó de forma correcta.
    • Si la propiedad status.errorResult está presente, la solicitud falló, y ese objeto incluirá información que describirá qué salió mal. Cuando una solicitud falla, no se crea ninguna tabla ni se cargan datos.
    • Si status.errorResult está ausente, el trabajo se completó con éxito, aunque puede haber algunos errores recuperables, como problemas cuando se importan algunas filas. Los errores recuperables se enumeran en la propiedad status.errors del objeto de trabajo que se muestra.

Notas sobre la API:

  • Los trabajos de carga son atómicos y coherentes. Si un trabajo de carga falla, ninguno de los datos estará disponible, y si un trabajo de carga se realiza con éxito, todos los datos estarán disponibles.

  • Como práctica recomendada, genera un ID único y pásalo como jobReference.jobId cuando llames a jobs.insert para crear un trabajo de carga. Este enfoque es más resistente al fallo de la red porque el cliente puede sondear o reintentar con el ID de trabajo conocido.

  • Llamar a jobs.insert en un ID de trabajo determinado es idempotente. Puedes intentar tantas veces como desees en el mismo ID de trabajo y, como máximo, una de esas operaciones tendrá éxito.

C#

Antes de probar este ejemplo, sigue las instrucciones de configuración para Go que se encuentran en la Guía de inicio rápido: usa bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de BigQuery para C#.

Usa el método BigQueryClient.CreateLoadJob() para iniciar un trabajo de carga desde Cloud Storage. Para usar JSON delimitado por saltos de línea, crea un objeto CreateLoadJobOptions y establece su propiedad SourceFormat como FileFormat.NewlineDelimitedJson.


using Google.Apis.Bigquery.v2.Data;
using Google.Cloud.BigQuery.V2;
using System;

public class BigQueryLoadTableGcsJson
{
    public void LoadTableGcsJson(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        var gcsURI = "gs://cloud-samples-data/bigquery/us-states/us-states.json";
        var dataset = client.GetDataset(datasetId);
        var schema = new TableSchemaBuilder {
            { "name", BigQueryDbType.String },
            { "post_abbr", BigQueryDbType.String }
        }.Build();
        TableReference destinationTableRef = dataset.GetTableReference(
            tableId: "us_states");
        // Create job configuration
        var jobOptions = new CreateLoadJobOptions()
        {
            SourceFormat = FileFormat.NewlineDelimitedJson
        };
        // Create and run job
        BigQueryJob loadJob = client.CreateLoadJob(
            sourceUri: gcsURI, destination: destinationTableRef,
            schema: schema, options: jobOptions);
        loadJob.PollUntilCompleted();  // Waits for the job to complete.
        // Display the number of rows uploaded
        BigQueryTable table = client.GetTable(destinationTableRef);
        Console.WriteLine(
            $"Loaded {table.Resource.NumRows} rows to {table.FullyQualifiedId}");
    }
}

Go

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

import (
	"context"
	"fmt"

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

// importJSONExplicitSchema demonstrates loading newline-delimited JSON data from Cloud Storage
// into a BigQuery table and providing an explicit schema for the data.
func importJSONExplicitSchema(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)
	}

	gcsRef := bigquery.NewGCSReference("gs://cloud-samples-data/bigquery/us-states/us-states.json")
	gcsRef.SourceFormat = bigquery.JSON
	gcsRef.Schema = bigquery.Schema{
		{Name: "name", Type: bigquery.StringFieldType},
		{Name: "post_abbr", Type: bigquery.StringFieldType},
	}
	loader := client.Dataset(datasetID).Table(tableID).LoaderFrom(gcsRef)
	loader.WriteDisposition = bigquery.WriteEmpty

	job, err := loader.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}

	if status.Err() != nil {
		return fmt.Errorf("job completed with error: %v", status.Err())
	}
	return nil
}

Java

Antes de probar este ejemplo, sigue las instrucciones de configuración de Java incluidas en Guía de inicio rápido: usa bibliotecas cliente. A fin de obtener más información, consulta la documentación de referencia de la API de BigQuery para Java.

Usa el método LoadJobConfiguration.builder(tableId, sourceUri) para iniciar un trabajo de carga desde Cloud Storage. Para usar JSON delimitado por saltos de línea usa LoadJobConfiguration.setFormatOptions(FormatOptions.json()).

String sourceUri = "gs://cloud-samples-data/bigquery/us-states/us-states.json";
TableId tableId = TableId.of(datasetName, tableName);
// Table field definition
Field[] fields =
    new Field[] {
      Field.of("name", LegacySQLTypeName.STRING),
      Field.of("post_abbr", LegacySQLTypeName.STRING)
    };
// Table schema definition
Schema schema = Schema.of(fields);
LoadJobConfiguration configuration =
    LoadJobConfiguration.builder(tableId, sourceUri)
        .setFormatOptions(FormatOptions.json())
        .setCreateDisposition(CreateDisposition.CREATE_IF_NEEDED)
        .setSchema(schema)
        .build();
// Load the table
Job loadJob = bigquery.create(JobInfo.of(configuration));
loadJob = loadJob.waitFor();
// Check the table
System.out.println("State: " + loadJob.getStatus().getState());
return ((StandardTableDefinition) bigquery.getTable(tableId).getDefinition()).getNumRows();

Node.js

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

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

// Instantiate clients
const bigquery = new BigQuery();
const storage = new Storage();

/**
 * This sample loads the json file at
 * https://storage.googleapis.com/cloud-samples-data/bigquery/us-states/us-states.json
 *
 * TODO(developer): Replace the following lines with the path to your file.
 */
const bucketName = 'cloud-samples-data';
const filename = 'bigquery/us-states/us-states.json';

async function loadJSONFromGCS() {
  // Imports a GCS file into a table with manually defined schema.

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

  // Configure the load job. For full list of options, see:
  // https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad
  const metadata = {
    sourceFormat: 'NEWLINE_DELIMITED_JSON',
    schema: {
      fields: [
        {name: 'name', type: 'STRING'},
        {name: 'post_abbr', type: 'STRING'},
      ],
    },
    location: 'US',
  };

  // Load data from a Google Cloud Storage file into the table
  const [job] = await bigquery
    .dataset(datasetId)
    .table(tableId)
    .load(storage.bucket(bucketName).file(filename), metadata);
  // load() waits for the job to finish
  console.log(`Job ${job.id} completed.`);

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

PHP

Antes de probar este ejemplo, sigue las instrucciones de configuración de PHP incluidas en Guía de inicio rápido: usa bibliotecas cliente. A fin de obtener más información, consulta la documentación de referencia de la API de BigQuery para PHP.

use Google\Cloud\BigQuery\BigQueryClient;
use Google\Cloud\Core\ExponentialBackoff;

/** Uncomment and populate these variables in your code */
// $projectId  = 'The Google project ID';
// $datasetId  = 'The BigQuery dataset ID';

// instantiate the bigquery table service
$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$table = $dataset->table('us_states');

// create the import job
$gcsUri = 'gs://cloud-samples-data/bigquery/us-states/us-states.json';
$schema = [
    'fields' => [
        ['name' => 'name', 'type' => 'string'],
        ['name' => 'post_abbr', 'type' => 'string']
    ]
];
$loadConfig = $table->loadFromStorage($gcsUri)->schema($schema)->sourceFormat('NEWLINE_DELIMITED_JSON');
$job = $table->runJob($loadConfig);
// poll the job until it is complete
$backoff = new ExponentialBackoff(10);
$backoff->execute(function () use ($job) {
    print('Waiting for job to complete' . PHP_EOL);
    $job->reload();
    if (!$job->isComplete()) {
        throw new Exception('Job has not yet completed', 500);
    }
});
// check if the job has errors
if (isset($job->info()['status']['errorResult'])) {
    $error = $job->info()['status']['errorResult']['message'];
    printf('Error running job: %s' . PHP_EOL, $error);
} else {
    print('Data imported successfully' . PHP_EOL);
}

Python

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

Usa el método Client.load_table_from_uri() para iniciar un trabajo de carga desde Cloud Storage. Para usar JSON delimitado por saltos de línea, configura la propiedad LoadJobConfig.source_format en la string NEWLINE_DELIMITED_JSON y pasa la configuración del trabajo como el argumento job_config del método load_table_from_uri().

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

dataset_ref = client.dataset(dataset_id)
job_config = bigquery.LoadJobConfig()
job_config.schema = [
    bigquery.SchemaField("name", "STRING"),
    bigquery.SchemaField("post_abbr", "STRING"),
]
job_config.source_format = bigquery.SourceFormat.NEWLINE_DELIMITED_JSON
uri = "gs://cloud-samples-data/bigquery/us-states/us-states.json"

load_job = client.load_table_from_uri(
    uri,
    dataset_ref.table("us_states"),
    location="US",  # Location must match that of the destination dataset.
    job_config=job_config,
)  # API request
print("Starting job {}".format(load_job.job_id))

load_job.result()  # Waits for table load to complete.
print("Job finished.")

destination_table = client.get_table(dataset_ref.table("us_states"))
print("Loaded {} rows.".format(destination_table.num_rows))

Ruby

Antes de probar este ejemplo, sigue las instrucciones de configuración de Ruby incluidas en Guía de inicio rápido: usa bibliotecas cliente. A fin de obtener más información, consulta la documentación de referencia de la API de BigQuery para Ruby.

Usa el método Dataset.load_job() para iniciar un trabajo de carga desde Cloud Storage. Para usar JSON delimitado por saltos de línea, establece el parámetro format como "json".

require "google/cloud/bigquery"

def load_table_gcs_json dataset_id = "your_dataset_id"
  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id
  gcs_uri  = "gs://cloud-samples-data/bigquery/us-states/us-states.json"
  table_id = "us_states"

  load_job = dataset.load_job table_id, gcs_uri, format: "json" do |schema|
    schema.string "name"
    schema.string "post_abbr"
  end
  puts "Starting job #{load_job.job_id}"

  load_job.wait_until_done!  # Waits for table load to complete.
  puts "Job finished."

  table = dataset.table(table_id)
  puts "Loaded #{table.rows_count} rows to table #{table.id}"
end

Carga datos JSON anidados y repetidos

BigQuery admite la carga de datos anidados y repetidos de formatos de origen que admiten esquemas basados en objetos, como JSON, Avro, ORC, Parquet, Firestore y Datastore.

Debe aparecer un objeto JSON, lo que incluye los campos anidados o repetidos en cada línea.

El siguiente ejemplo presenta datos anidados o repetidos de muestra. Esta tabla contiene información sobre las personas. Consta de los siguientes campos:

  • id
  • first_name
  • last_name
  • dob (fecha de nacimiento)
  • addresses (un campo repetido y anidado)
    • addresses.status (actual o anterior)
    • addresses.address
    • addresses.city
    • addresses.state
    • addresses.zip
    • addresses.numberOfYears (años en la dirección)

El archivo de datos JSON debería ser similar a lo que se muestra a continuación. Observa que el campo de dirección contiene un arreglo de valores (indicado por [ ]).

{"id":"1","first_name":"John","last_name":"Doe","dob":"1968-01-22","addresses":[{"status":"current","address":"123 First Avenue","city":"Seattle","state":"WA","zip":"11111","numberOfYears":"1"},{"status":"previous","address":"456 Main Street","city":"Portland","state":"OR","zip":"22222","numberOfYears":"5"}]}
{"id":"2","first_name":"Jane","last_name":"Doe","dob":"1980-10-16","addresses":[{"status":"current","address":"789 Any Avenue","city":"New York","state":"NY","zip":"33333","numberOfYears":"2"},{"status":"previous","address":"321 Main Street","city":"Hoboken","state":"NJ","zip":"44444","numberOfYears":"3"}]}

El esquema para esta tabla se vería como el siguiente:

[
    {
        "name": "id",
        "type": "STRING",
        "mode": "NULLABLE"
    },
    {
        "name": "first_name",
        "type": "STRING",
        "mode": "NULLABLE"
    },
    {
        "name": "last_name",
        "type": "STRING",
        "mode": "NULLABLE"
    },
    {
        "name": "dob",
        "type": "DATE",
        "mode": "NULLABLE"
    },
    {
        "name": "addresses",
        "type": "RECORD",
        "mode": "REPEATED",
        "fields": [
            {
                "name": "status",
                "type": "STRING",
                "mode": "NULLABLE"
            },
            {
                "name": "address",
                "type": "STRING",
                "mode": "NULLABLE"
            },
            {
                "name": "city",
                "type": "STRING",
                "mode": "NULLABLE"
            },
            {
                "name": "state",
                "type": "STRING",
                "mode": "NULLABLE"
            },
            {
                "name": "zip",
                "type": "STRING",
                "mode": "NULLABLE"
            },
            {
                "name": "numberOfYears",
                "type": "STRING",
                "mode": "NULLABLE"
            }
        ]
    }
]

Para obtener más información sobre cómo especificar un esquema anidado y repetido, consulta Especifica columnas anidadas y repetidas.

Adjunta datos JSON a una tabla o reemplázala

Puedes cargar datos adicionales en una tabla desde archivos de origen o cuando adjuntas resultados de consultas.

En la consola y en la IU web clásica de BigQuery, usa la opción de Preferencia de escritura para especificar qué acción tomar cuando cargues datos desde un archivo de origen o desde un resultado de consulta.

Cuando cargas datos adicionales en una tabla, tienes las siguientes opciones:

Opción de Console Opción de IU web clásica Marca CLI Propiedad de la API de BigQuery Descripción
Escribir si está vacía Escribir si está vacía Ninguno WRITE_EMPTY Solo escribe los datos si la tabla está vacía.
Agregar a la tabla Agregar a la tabla --noreplace o --replace=false; si no se especifica --[no]replace, la opción predeterminada es agregar WRITE_APPEND Agrega los datos al final de la tabla (predeterminado).
Reemplazar tabla Reemplazar tabla --replace o --replace=true WRITE_TRUNCATE Borra todos los datos existentes de una tabla antes de escribir los datos nuevos.

Si cargas datos en una tabla existente, el trabajo de carga puede agregar los datos o reemplazar la tabla.

Tienes las siguientes opciones para reemplazar una tabla o agregarle datos:

  • Usar Cloud Console o la IU web clásica
  • Usar el comando bq load de CLI
  • Realizar una llamada al método jobs.insert de la API y configurar un trabajo de load
  • Usar bibliotecas cliente

Console

  1. Abre la IU web de BigQuery en Cloud Console.
    Ir a Cloud Console

  2. En el panel de navegación, en la sección Recursos, expande tu proyecto y selecciona un conjunto de datos.

  3. En el lado derecho de la ventana, en el panel de detalles, haz clic en Create table (Crear tabla). El proceso para agregar y reemplazar datos en un trabajo de carga es el mismo que el de crear una tabla en un trabajo de carga.

    Crear tabla

  4. En la sección Source (Fuente) de la página Create table (Crear tabla), haz lo siguiente:

    • En Create table from (Crear tabla desde), selecciona Cloud Storage.

    • En el campo de origen, busca o ingresa el URI de Cloud Storage. Ten en cuenta que no puedes incluir varios URI en la IU web de BigQuery, pero sí se admiten comodines. El depósito de Cloud Storage debe encontrarse en la misma ubicación que el conjunto de datos que contiene la tabla que agregas o reemplazas.

      Seleccionar archivo

    • En File format (Formato de archivo), selecciona JSON (delimitado por saltos de línea).

  5. En la sección Destination (Destino) de la página Create table (Crear tabla), haz lo siguiente:

    • En Dataset name (Nombre del conjunto de datos), selecciona el conjunto de datos que corresponda.

      Seleccionar conjunto de datos

    • En el campo Nombre de tabla, ingresa el nombre de la tabla a la que quieres agregar datos o que quieres reemplazar en BigQuery.

    • Verifica que Table type (Tipo de tabla) esté establecido en Native table (Tabla nativa).

  6. En la sección Esquema, en Detección automática, marca la opción Esquema y parámetros de entrada para habilitar la detección automática de esquemas. También puedes ingresar de forma manual la definición de esquema, como se indica a continuación:

    • Habilita Editar como texto y, luego, ingresa el esquema de la tabla como un arreglo JSON.

      Agregar esquema como arreglo JSON

    • Usa Agregar campo para ingresar el esquema de forma manual.

      Agregar definición de esquema con el botón Agregar campo

  7. En Configuración de partición y agrupamiento en clústeres, deja los valores predeterminados. No se puede agregar ni reemplazar una tabla para convertirla en una tabla particionada o agrupada en clústeres; Cloud Console no admite que se agreguen ni reemplacen tablas particionadas o agrupadas en un trabajo de carga.

  8. Haz clic en Advanced options (Opciones avanzadas).

    • En Write preference (Preferencia de escritura), elige Append to table (Agregar a la tabla) o Overwrite table (Reemplazar tabla).
    • En Number of errors allowed (Cantidad de errores permitidos), acepta el valor predeterminado de 0 o ingresa la cantidad máxima de filas con errores que pueden ignorarse. Si la cantidad de filas con errores excede este valor, el trabajo generará un mensaje invalid y fallará.
    • En Valores desconocidos, marca Ignorar valores desconocidos para ignorar cualquier valor en una fila que no esté presente en el esquema de la tabla.
    • En Encriptación, haz clic en Clave administrada por el cliente para usar una clave de Cloud Key Management Service. Si dejas establecida la configuración Clave administrada por Google, BigQuery encripta los datos en reposo.

      Reemplazar tabla

  9. Haz clic en Crear tabla.

IU clásica

  1. Ve a la IU web de BigQuery.
    Ir a la IU web de BigQuery

  2. En el panel de navegación, coloca el cursor sobre un conjunto de datos, haz clic en el ícono de flecha hacia abajo imagen del ícono de flecha hacia abajo y, luego, en Crear tabla nueva. El proceso para agregar y reemplazar datos en un trabajo de carga es el mismo que el de crear una tabla en un trabajo de carga.

  3. En la sección Datos de origen de la página Crear tabla, sigue estos pasos:

    • En Ubicación, selecciona Cloud Storage y, en el campo de origen, ingresa el URI de Cloud Storage. Ten en cuenta que no puedes incluir varios URI en la IU, pero sí se admiten comodines. El depósito de Cloud Storage debe encontrarse en la misma ubicación que el conjunto de datos que contiene la tabla que adjuntas o reemplazas.
    • En Formato de archivo, selecciona JSON (Delimitado por saltos de línea).
  4. En la sección Destination table (Tabla de destino) de la página Create Table (Crear tabla), sigue estos pasos:

    • En Nombre de la tabla, selecciona el conjunto de datos que corresponda y, en el campo de nombre de tabla, ingresa el nombre de la tabla que quieres agregar o reemplazar.
    • Verifica que Table type (Tipo de tabla) esté establecido en Native table (Tabla nativa).
  5. En la sección Schema (Esquema), ingresa la definición del esquema.

    • Para los archivos JSON, puedes marcar la opción Detección automática (Automatically detect) a fin de habilitar la detección automática de esquemas.

      vínculo de detección automática

    • También puedes ingresar la información del esquema de forma manual como se indica a continuación:

      • Haz clic en Editar como texto y, luego, ingresa el esquema de la tabla como un arreglo JSON:

        Agregar esquema como arreglo JSON

      • Usa Agregar campo para ingresar el esquema de forma manual:

        Agregar esquema con el botón Agregar campo

  6. En la sección Opciones, sigue estos pasos:

    • En Cantidad de errores permitidos, acepta el valor predeterminado de 0 o ingresa la cantidad máxima de filas con errores que pueden ignorarse. Si la cantidad de filas con errores excede este valor, el trabajo generará un mensaje invalid y fallará.
    • En Preferencia de escritura, elige Agregar a la tabla o Reemplazar tabla.
    • Deja los valores predeterminados en Tipo de partición, Campos de partición, Exigir filtro de partición y Campos de agrupamiento en clústeres. No puedes agregar ni reemplazar una tabla para convertirla en una tabla particionada o agrupada; la IU web no admite agregar ni reemplazar tablas particionadas o agrupadas en un trabajo de carga.
    • En Encriptación de destino, elige Encriptación administrada por el cliente para encriptar la tabla con una clave de Cloud Key Management Service. Si dejas la configuración Default, BigQuery encripta los datos en reposo con una clave administrada por Google.
  7. Haz clic en Crear tabla.

CLI

Usa el comando bq load, especifica NEWLINE_DELIMITED_JSON con la marca --source_format y, además, incluye un URI de Cloud Storage. Puedes incluir un único URI, una lista de URI separados por comas o un URI que contenga un comodín.

Proporciona el esquema intercalado con un archivo de definición de esquema o usa la detección automática de esquemas.

Especifica la marca --replace para reemplazar la tabla. Usa la marca --noreplace para adjuntar datos a la tabla. Si no se especifica ninguna marca, se agregan datos de manera predeterminada.

Es posible modificar el esquema de la tabla cuando adjuntas datos a ella o la reemplazas. Para obtener más información sobre los cambios de esquema admitidos durante una operación de carga, consulta Modifica esquemas de tablas.

Proporciona la marca --location y establece el valor de tu ubicación (opcional).

Las siguientes son otras marcas opcionales:

  • --max_bad_records: Un número entero que especifica la cantidad máxima de registros incorrectos permitidos antes de que falle todo el trabajo. El valor predeterminado es 0. Como máximo, se muestran cinco errores de cualquier tipo, sin importar el valor --max_bad_records.
  • --ignore_unknown_values: Cuando se especifica, permite y también ignora valores extras no reconocidos en datos CSV o JSON.
  • --autodetect: Cuando se especifica, habilita la detección automática de esquemas para los datos de formato CSV y JSON.
  • --destination_kms_key: La clave de Cloud KMS para la encriptación de los datos de la tabla.
bq --location=location load \
--[no]replace \
--source_format=format \
dataset.table \
path_to_source \
schema

Donde:

  • location es tu ubicación. La marca --location es opcional. Puedes configurar un valor predeterminado para la ubicación con el archivo .bigqueryrc.
  • format es NEWLINE_DELIMITED_JSON.
  • dataset es un conjunto de datos existente.
  • table es el nombre de la tabla en la que cargas los datos.
  • path_to_source es un URI de Cloud Storage completamente calificado o una lista de URI separados por comas. También se admiten comodines.
  • schema es un esquema válido. El esquema puede ser un archivo JSON local o se puede escribir intercalado como parte del comando. También puedes usar la marca --autodetect en lugar de proporcionar una definición de esquema.

Ejemplos:

Con el siguiente comando, se cargan datos de gs://mybucket/mydata.json y se reemplazan los datos de una tabla llamada mytable en mydataset. El esquema se define mediante la detección automática de esquemas.

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

Con el siguiente comando, se cargan datos de gs://mybucket/mydata.json y se adjuntan datos a una tabla llamada mytable en mydataset. El esquema se define mediante un archivo de esquema JSON: myschema.json.

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

API

  1. Crea un trabajo load que apunte a los datos de origen en Cloud Storage.

  2. Especifica tu ubicación en la propiedad location de la sección jobReference del recurso de trabajo (opcional).

  3. La propiedad source URIs debe estar completamente calificada en el formato gs://bucket/object. Puedes incluir varios URI en una lista separada por comas. Ten en cuenta que también se admiten comodines.

  4. Para especificar el formato de los datos, establece la propiedad configuration.load.sourceFormat en NEWLINE_DELIMITED_JSON.

  5. Para especificar la preferencia de escritura, configura la propiedad configuration.load.writeDisposition como WRITE_TRUNCATE o WRITE_APPEND.

Go

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

import (
	"context"
	"fmt"

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

// importJSONTruncate demonstrates loading data from newline-delimeted JSON data in Cloud Storage
// and overwriting/truncating data in the existing table.
func importJSONTruncate(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)
	}

	gcsRef := bigquery.NewGCSReference("gs://cloud-samples-data/bigquery/us-states/us-states.json")
	gcsRef.SourceFormat = bigquery.JSON
	gcsRef.AutoDetect = true
	loader := client.Dataset(datasetID).Table(tableID).LoaderFrom(gcsRef)
	loader.WriteDisposition = bigquery.WriteTruncate

	job, err := loader.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}

	if status.Err() != nil {
		return fmt.Errorf("job completed with error: %v", status.Err())
	}

	return nil
}

Node.js

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

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

// Instantiate clients
const bigquery = new BigQuery();
const storage = new Storage();

/**
 * This sample loads the JSON file at
 * https://storage.googleapis.com/cloud-samples-data/bigquery/us-states/us-states.json
 *
 * TODO(developer): Replace the following lines with the path to your file.
 */
const bucketName = 'cloud-samples-data';
const filename = 'bigquery/us-states/us-states.json';

async function loadJSONFromGCSTruncate() {
  /**
   * Imports a GCS file into a table and overwrites
   * table data if table already exists.
   */

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

  // Configure the load job. For full list of options, see:
  // https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad
  const metadata = {
    sourceFormat: 'NEWLINE_DELIMITED_JSON',
    schema: {
      fields: [
        {name: 'name', type: 'STRING'},
        {name: 'post_abbr', type: 'STRING'},
      ],
    },
    // Set the write disposition to overwrite existing table data.
    writeDisposition: 'WRITE_TRUNCATE',
  };

  // Load data from a Google Cloud Storage file into the table
  const [job] = await bigquery
    .dataset(datasetId)
    .table(tableId)
    .load(storage.bucket(bucketName).file(filename), metadata);
  // load() waits for the job to finish
  console.log(`Job ${job.id} completed.`);

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

PHP

Antes de probar este ejemplo, sigue las instrucciones de configuración de PHP incluidas en Guía de inicio rápido: usa bibliotecas cliente. A fin de obtener más información, consulta la documentación de referencia de la API de BigQuery para PHP.

use Google\Cloud\BigQuery\BigQueryClient;
use Google\Cloud\Core\ExponentialBackoff;

/** Uncomment and populate these variables in your code */
// $projectId = 'The Google project ID';
// $datasetId = 'The BigQuery dataset ID';
// $tableID = 'The BigQuery table ID';

// instantiate the bigquery table service
$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$table = $bigQuery->dataset($datasetId)->table($tableId);

// create the import job
$gcsUri = 'gs://cloud-samples-data/bigquery/us-states/us-states.json';
$loadConfig = $table->loadFromStorage($gcsUri)->sourceFormat('NEWLINE_DELIMITED_JSON')->writeDisposition('WRITE_TRUNCATE');
$job = $table->runJob($loadConfig);

// poll the job until it is complete
$backoff = new ExponentialBackoff(10);
$backoff->execute(function () use ($job) {
    print('Waiting for job to complete' . PHP_EOL);
    $job->reload();
    if (!$job->isComplete()) {
        throw new Exception('Job has not yet completed', 500);
    }
});

// check if the job has errors
if (isset($job->info()['status']['errorResult'])) {
    $error = $job->info()['status']['errorResult']['message'];
    printf('Error running job: %s' . PHP_EOL, $error);
} else {
    print('Data imported successfully' . PHP_EOL);
}

Python

Para reemplazar las filas de una tabla existente, configura la propiedad LoadJobConfig.write_disposition en la string WRITE_TRUNCATE.

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

# from google.cloud import bigquery
# client = bigquery.Client()
# table_ref = client.dataset('my_dataset').table('existing_table')

job_config = bigquery.LoadJobConfig()
job_config.write_disposition = bigquery.WriteDisposition.WRITE_TRUNCATE
job_config.source_format = bigquery.SourceFormat.NEWLINE_DELIMITED_JSON
uri = "gs://cloud-samples-data/bigquery/us-states/us-states.json"
load_job = client.load_table_from_uri(
    uri, table_ref, job_config=job_config
)  # API request
print("Starting job {}".format(load_job.job_id))

load_job.result()  # Waits for table load to complete.
print("Job finished.")

destination_table = client.get_table(table_ref)
print("Loaded {} rows.".format(destination_table.num_rows))

Ruby

Para reemplazar las filas de una tabla existente, establece el parámetro write de Table.load_job() como "WRITE_TRUNCATE".

Antes de probar este ejemplo, sigue las instrucciones de configuración de Ruby incluidas en Guía de inicio rápido: usa bibliotecas cliente. A fin de obtener más información, consulta la documentación de referencia de la API de BigQuery para Ruby.

require "google/cloud/bigquery"

def load_table_gcs_json_truncate(
    dataset_id = "your_dataset_id",
    table_id   = "your_table_id"
  )
  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id
  gcs_uri  = "gs://cloud-samples-data/bigquery/us-states/us-states.json"

  load_job = dataset.load_job table_id,
                              gcs_uri,
                              format: "json",
                              write:  "truncate"
  puts "Starting job #{load_job.job_id}"

  load_job.wait_until_done!  # Waits for table load to complete.
  puts "Job finished."

  table = dataset.table(table_id)
  puts "Loaded #{table.rows_count} rows to table #{table.id}"
end

Carga datos JSON con partición de subárbol

BigQuery admite la carga de datos JSON con partición de subárbol almacenados en Cloud Storage y propagará las columnas con partición de subárbol en la tabla administrada de destino de BigQuery. Para obtener más información, consulta la página sobre cómo cargar datos particionados de forma externa de Cloud Storage.

Opciones JSON

Para cambiar la forma en la que BigQuery analiza los datos JSON, especifica otras opciones en Console, la IU clásica, la CLI, la API o las bibliotecas cliente.

Opción JSON Opción de Console Opción de la IU clásica Marcador CLI Propiedad de la API de BigQuery Descripción
Cantidad de registros incorrectos permitidos Cantidad de errores permitidos Cantidad de errores permitidos --max_bad_records maxBadRecords La cantidad máxima de registros erróneos que BigQuery puede ignorar cuando ejecuta el trabajo (opcional). Si la cantidad de registros incorrectos excede este valor, se muestra un error no válido en el resultado del trabajo. El valor predeterminado es 0, por lo que es obligatorio que todos los registros sean válidos.
Valores desconocidos Ignorar valores desconocidos Ignorar valores desconocidos --ignore_unknown_values ignoreUnknownValues Indica si BigQuery debe permitir valores adicionales que no estén representados en el esquema de la tabla (opcional). Si es verdadero, los valores adicionales se ignoran. Si es falso, los registros con columnas adicionales se tratan como registros incorrectos y, si hay demasiados, se muestra un error no válido en el resultado del trabajo. El valor predeterminado es falso. La propiedad sourceFormat determina qué trata BigQuery como un valor adicional; CSV: columnas finales, JSON: valores con nombres que no coinciden con ningún nombre de columna.
¿Te sirvió esta página? Envíanos tu opinión:

Enviar comentarios sobre…

¿Necesitas ayuda? Visita nuestra página de asistencia.