Cargar datos JSON desde Google Cloud Storage

Cómo cargar archivos JSON desde Cloud Storage

Cuando cargas datos JSON delimitados por saltos de línea desde Cloud Storage, puedes cargar los datos en una tabla o partición nuevas, o puedes agregar o reemplazar una tabla o partición existente. Cuando tus 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.

Para obtener información sobre cómo cargar datos JSON desde un archivo local, consulta 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. Cargar datos JSON comprimidos en BigQuery es más lento que cargar datos sin comprimir.
  • BigQuery no es compatible con mapas o 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 cargas datos CSV o JSON, los valores en las columnas DATE deben usar el separador de guion (-) y la fecha debe estar en el siguiente formato: YYYY-MM-DD (año-mes-día).
  • Cuando cargas datos JSON o CSV, los valores en las columnas TIMESTAMP deben usar el separador de guion (-) para la parte de fecha de la marca de tiempo, y la fecha debe estar en el siguiente formato: YYYY-MM-DD (año-mes-día). La parte de hh:mm:ss (horas-minutos-segundos) de la marca de tiempo debe usar el separador de dos puntos (:).

Permisos necesarios

Cuando cargas datos en BigQuery, necesitas permisos de proyecto o de nivel de conjunto de datos que te permitan cargar datos en tablas y particiones de BigQuery nuevas o existentes. Si cargas datos de Cloud Storage, también necesitas acceso al depósito que contiene tus datos.

Permisos de BigQuery

Cuando cargas datos en BigQuery desde Cloud Storage, se te debe otorgar la función bigquery.dataOwner o bigquery.dataEditor a nivel de proyecto o a nivel de conjunto de datos. Ambas funciones otorgan a los usuarios y grupos el permiso para cargar datos en una tabla nueva o agregar o reemplazar una tabla existente.

Otorgar las funciones a nivel de proyecto le da al usuario o al grupo permiso para cargar datos en tablas en cada conjunto de datos del proyecto. Otorgar las funciones a nivel de conjunto de datos le da al usuario o al grupo la capacidad para cargar datos solo en las tablas de ese conjunto de datos.

Para obtener más información sobre cómo configurar el acceso al conjunto de datos, consulta Control de acceso al conjunto de datos. A fin de obtener más información sobre las funciones IAM en BigQuery, consulta Control de acceso.

Permisos de Cloud Storage

Para cargar datos desde un depósito de Cloud Storage, se te deben otorgar permisos de storage.objects.get en el nivel del proyecto o en ese depósito individual. Si usas un comodín URI, también debes tener permisos storage.objects.list.

La función predefinida de IAM storage.objectViewer se puede otorgar para proporcionar permisos storage.objects.get y storage.objects.list.

Cómo cargar datos JSON en una tabla

Sigue los siguientes pasos para cargar datos JSON delimitados por saltos de línea desde Cloud Storage en una tabla nueva de BigQuery, o agregar datos a una tabla existente:

IU web

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

  2. En el panel de navegación, desplázate sobre un conjunto de datos, haz clic en el ícono de flecha hacia abajo imagen del ícono de flecha hacia abajo y haz clic 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 página Crear tabla, en la sección Datos de origen:

    • Para la Ubicación, selecciona Google 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 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 estás creando.
    • Para el Formato de archivo, selecciona JSON (Delimitado por saltos de línea).
  4. En la página Crear tabla, en la sección Tabla de destino:

    • Para el Nombre de tabla, elige el conjunto de datos apropiado. Luego, ingresa el nombre de la tabla que quieres crear en BigQuery en el campo correspondiente.
    • Verifica que el Tipo de tabla esté configurado en Tabla nativa.
  5. En la sección Esquema, ingresa la definición del esquema.

    • Ingresa la información del esquema manualmente de la siguiente manera:

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

        Agregar un esquema como arreglo JSON

      • Usa Agregar campo para ingresar manualmente el esquema:

        Agregar esquema mediante agregar campos

  6. Selecciona los elementos aplicables en la sección Opciones y haz clic en Crear tabla. Para obtener información sobre las opciones disponibles, consulta las Opciones de JSON.

Línea de comandos

Usa el comando bq load, especifica NEWLINE_DELIMITED_JSON como el source_format, y luego incluye un URI de Cloud Storage. Puedes incluir un solo URI, una lista de URI separados por comas o un URI que contenga un comodín.

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

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 configurar el valor de las marcas en 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 datos.
  • [PATH_TO_SOURCE] es un URI de Cloud Storage totalmente 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 entre líneas como parte del comando. También puedes usar la marca --autodetect en lugar de proporcionar una definición de esquema.

Además, puedes agregar marcas para las opciones JSON que te permiten controlar cómo BigQuery analiza tus datos.

Ejemplos:

  • El siguiente comando carga datos de gs://mybucket/mydata.json en una tabla llamada mytable en mydataset. El esquema se define en un archivo de esquema local llamado myschema.json. Se crean mybucket y mydataset en la ubicación multirregión US.

    bq --location=US load --source_format=NEWLINE_DELIMITED_JSON mydataset.mytable gs://mybucket/mydata.json ./myschema.json
    
  • El siguiente comando carga datos de gs://mybucket/mydata.json en una tabla llamada mytable en mydataset. El esquema se define entre líneas en el formato [FIELD]:[DATA_TYPE], [FIELD]:[DATA_TYPE]. Se crean mybucket y mydataset en la ubicación multirregión US.

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

    Nota: Cuando especificas el esquema en la línea de comandos, no puedes incluir un tipo de RECORD (STRUCT), incluir una descripción de campo ni especificar el modo de campo. Todos los modos de campo están predeterminados en NULLABLE. Para incluir descripciones de campo, modos y tipos de RECORD proporciona en su lugar un archivo de esquema JSON.

API

Configura las siguientes propiedades para cargar datos JSON delimitados por saltos de línea con la API.

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

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

  3. Los URI de origen deben estar completamente calificados en el formato gs://[BUCKET]/[OBJECT]. Cada URI puede contener un carácter comodín '*'.

  4. Especifica el formato de datos mediante la configuración de la propiedad configuration.load.sourceFormat a NEWLINE_DELIMITED_JSON.

  5. Para verificar el estado del trabajo, llama jobs.get([JOB_ID]*), en el que [JOB_ID] es el ID del trabajo mostrado por la solicitud inicial.

    • Si el estado es status.state = DONE, el trabajo se completó correctamente.
    • Si la propiedad status.errorResult está presente, la solicitud falló y ese objeto incluirá información que describe lo que salió mal. Cuando falla una solicitud, no se crea ninguna tabla ni se agregan datos.
    • Si status.errorResult está ausente, el trabajo finalizó correctamente, aunque puede haber algunos errores no fatales, como problemas cuando se importan algunas filas. Los errores no fatales se enumeran en la propiedad status.errors del objeto de trabajo mostrado.

Notas API:

  • Los trabajos de carga son atómicos y coherentes, si un trabajo de carga falla, ninguno de los datos está disponible, y si un trabajo de carga es correcto, todos los datos están disponibles.

  • Como recomendación, 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() con un ID de trabajo dado es idempotente, en otras palabras, puedes volver a intentarlo tantas veces como desees con el mismo ID de trabajo y al menos una de las operaciones será correcta.

C#

Antes de probar esta muestra, sigue las instrucciones de configuración para C# de la Guía de inicio rápido de BigQuery: Usa bibliotecas cliente. Para 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 configura sus propiedades SourceFormat en 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 esta muestra, sigue las instrucciones de configuración para Go 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 Go de BigQuery.

// 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")
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())
}

Java

Antes de probar esta muestra, sigue las instrucciones de configuración de Java 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 Java de BigQuery.

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 el 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 de Node.js 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 Node.js de BigQuery.

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

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

/**
 * 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';

// Instantiates clients
const bigquery = new BigQuery({
  projectId: projectId,
});

const storage = new Storage({
  projectId: projectId,
});

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

// Loads 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 esta muestra, sigue las instrucciones de configuración de PHP 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 PHP de BigQuery.

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

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 a la string NEWLINE_DELIMITED_JSON y pasa la configuración del trabajo como el argumento job_config al 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 esta muestra, sigue las instrucciones de configuración de Ruby 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 Ruby de BigQuery.

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, usa el parámetro format en "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

Cómo cargar datos JSON con detección automática de esquemas

IU web

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

  2. En el panel de navegación, desplázate sobre un conjunto de datos, haz clic en el ícono de flecha hacia abajo imagen del ícono de flecha hacia abajo y haz clic 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 página Crear tabla, en la sección Datos de origen:

    • Para la Ubicación, selecciona Google 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 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 estás creando.
    • Para el Formato de archivo, selecciona JSON (Delimitado por saltos de línea).
  4. En la página Crear tabla, en la sección Tabla de destino:

    • Para el Nombre de tabla, elige el conjunto de datos apropiado. Luego, ingresa el nombre de la tabla que quieres crear en BigQuery en el campo correspondiente.
    • Verifica que el Tipo de tabla esté configurado en Tabla nativa.
  5. En la sección de esquema, comprueba la opción de detección automática para habilitar la detección automática de esquemas.

    auto detect link

  6. Selecciona los elementos aplicables en la sección Opciones y haz clic en Crear tabla. Para obtener información sobre las opciones disponibles, consulta las Opciones de JSON.

Línea de comandos

Usa el comando bq load, especifica NEWLINE_DELIMITED_JSON como el source_format, y luego incluye un URI de Cloud Storage. Puedes incluir un solo URI, una lista de URI separados por comas o un URI que contenga un comodín.

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

bq --location=[LOCATION] load --autodetect --source_format=[FORMAT] [DATASET].[TABLE] [PATH_TO_SOURCE]

Donde:

  • [LOCATION] es tu ubicación. La marca --location es opcional. Por ejemplo, si usas BigQuery en la región de Tokio, puedes configurar el valor de las marcas en asia-northeast1. Puedes configurar un valor predeterminado para la ubicación con el archivo .bigqueryrc.
  • La marca --autodetect habilita la detección automática de esquemas.
  • [FORMAT] es NEWLINE_DELIMITED_JSON.
  • [DATASET] es un conjunto de datos existente.
  • [TABLE] es el nombre de la tabla en la que cargas datos.
  • [PATH_TO_SOURCE] es un URI de Cloud Storage totalmente calificado o una lista de URI separados por comas. También se admiten Comodines.

Además, puedes agregar marcas para las opciones JSON que te permiten controlar cómo BigQuery analiza tus datos.

Ejemplos:

  • El siguiente comando carga datos de gs://mybucket/mydata.json en una tabla llamada mytable en mydataset. El esquema se define mediante la detección automática de esquemas. mybucket y mydataset se crearon en la ubicación de varias regiones de US.

    bq --location=US 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 URI de Cloud Storage usa un comodín y el esquema se define mediante la detección automática de esquemas. mybucket y mydataset se crearon en la región asia-northeast1.

    bq --location=asia-northeast1 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, y el esquema se define mediante la detección automática de esquemas. mybucket y mydataset se crearon en la región asia-northeast1.

    bq --location=asia-northeast1 load --autodetect --source_format=NEWLINE_DELIMITED_JSON mydataset.mytable "gs://mybucket/myfile.json,gs://mybucket/myfile2.json"
    

API

Configura las siguientes propiedades para cargar datos JSON delimitados por saltos de línea con la API.

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

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

  3. Los URI de origen deben estar completamente calificados en el formato gs://[BUCKET]/[OBJECT]. Cada URI puede contener un carácter comodín '*'.

  4. Especifica el formato de datos mediante la configuración de la propiedad configuration.load.sourceFormat a NEWLINE_DELIMITED_JSON.

  5. Para verificar el estado del trabajo, llama jobs.get([JOB_ID]*), en el que [JOB_ID] es el ID del trabajo mostrado por la solicitud inicial.

    • Si el estado es status.state = DONE, el trabajo se completó correctamente.
    • Si la propiedad status.errorResult está presente, la solicitud falló y ese objeto incluirá información que describe lo que salió mal. Cuando falla una solicitud, no se crea ninguna tabla ni se agregan datos.
    • Si status.errorResult está ausente, el trabajo finalizó correctamente, aunque puede haber algunos errores no fatales, como problemas cuando se importan algunas filas. Los errores no fatales se enumeran en la propiedad status.errors del objeto de trabajo mostrado.

Notas API:

  • Los trabajos de carga son atómicos y coherentes, si un trabajo de carga falla, ninguno de los datos está disponible, y si un trabajo de carga es correcto, todos los datos están disponibles.

  • Como recomendación, 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() con un ID de trabajo dado es idempotente, en otras palabras, puedes volver a intentarlo tantas veces como desees con el mismo ID de trabajo y al menos una de las operaciones será correcta.

Go

Antes de probar esta muestra, sigue las instrucciones de configuración para Go 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 Go de BigQuery.

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

Node.js

Antes de probar esta muestra, sigue las instrucciones de configuración de Node.js 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 Node.js de BigQuery.

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

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

/**
 * 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';

// Instantiates clients
const bigquery = new BigQuery({
  projectId: projectId,
});

const storage = new Storage({
  projectId: projectId,
});

// Configure the load job. For full list of options, see:
// https://cloud.google.com/bigquery/docs/reference/rest/v2/jobs#configuration.load
const metadata = {
  sourceFormat: 'NEWLINE_DELIMITED_JSON',
  autodetect: true,
};

// Loads 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 esta muestra, sigue las instrucciones de configuración de PHP 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 PHP de BigQuery.

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';
$loadConfig = $table->loadFromStorage($gcsUri)->autodetect(true)->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 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.

Para habilitar la detección automática de esquemas, configura la LoadJobConfig.autodetect property en True.

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

dataset_ref = client.dataset(dataset_id)
job_config = bigquery.LoadJobConfig()
job_config.autodetect = True
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'),
    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 esta muestra, sigue las instrucciones de configuración de Ruby 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 Ruby de BigQuery.

require "google/cloud/bigquery"

def load_table_gcs_json_autodetect 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",
                              autodetect: true
  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

Cómo cargar datos JSON anidados y repetidos

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

Un objeto JSON, incluidos los campos anidados/repetidos, debe aparecer en cada línea.

Ejemplo

El siguiente ejemplo presenta datos anidados/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 anidado y repetido)
    • 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 se vería como el siguiente. 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 Especificación de campos anidados y repetidos.

Cómo reemplazar una tabla con datos JSON

Puedes cargar datos adicionales en una tabla desde los archivos de origen o cuando agregas los resultados de la consulta. Si el esquema de los datos no coincide con el esquema de la tabla o partición de destino, puedes actualizar el esquema cuando lo agregues o lo reemplaces.

Si actualizas el esquema cuando agregas datos, BigQuery te permite:

  • Agregar campos nuevos
  • Disminuir los campos REQUIRED a NULLABLE

Si reemplazas una tabla, el esquema siempre se reemplaza. Las actualizaciones de esquema no están restringidas cuando reemplazas una tabla.

En la consola o 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. El CLI y la API incluyen las siguientes opciones:

Opción de Console Opción de IU 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 Escribe los datos solo si la tabla está vacía.
Agregar a la tabla Agregar a la tabla --noreplace o --replace=false, si --[no]replace no está especificado, el valor predeterminado es agregar WRITE_APPEND (Predeterminado) Agrega los datos al final de la tabla.
Reemplazar tabla Reemplazar tabla --replace o --replace=true WRITE_TRUNCATE Borra todos los datos existentes en una tabla antes de escribir los datos nuevos.

De forma predeterminada, los trabajos de carga agregarán datos a una tabla, a menos que se altere la disposición de escritura. Si, en cambio, deseas reemplazar los datos con los datos de un trabajo de carga, puedes optar por reemplazar los datos en una tabla de BigQuery:

IU web

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

  2. En el panel de navegación, desplázate sobre un conjunto de datos, haz clic en el ícono de flecha hacia abajo imagen del ícono de flecha hacia abajo y haz clic 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 página Crear tabla, en la sección Datos de origen:

    • Para la Ubicación, selecciona Google 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 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 estás creando o reemplazando.
    • Para el Formato de archivo, selecciona JSON (Delimitado por saltos de línea).
  4. En la página Crear tabla, en la sección Tabla de destino:

    • Para Nombre de la tabla, elige el conjunto de datos apropiado y, en el campo de nombre de la tabla, ingresa el nombre de la tabla que estás creando o reemplazando.
    • Verifica que el Tipo de tabla esté configurado en Tabla nativa.
  5. En la sección Esquema, ingresa la definición del esquema. Para actualizar el esquema, puedes agregar campos nuevos o cambiar (disminuir) campos de REQUIRED a NULLABLE.

    • Para los archivos JSON, puedes comprobar la opción de Detección automática a fin de habilitar el esquema detección automática.

      auto detect link

    • También puedes ingresar la información del esquema manualmente de la siguiente manera:

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

        Agregar un esquema como arreglo JSON

      • Usa Agregar campo para ingresar manualmente el esquema:

        Agregar esquema mediante agregar campos

  6. En la sección Opciones, para la Preferencia de escritura, elige Escribir si está vacío, Agregar a la tabla o Reemplazar tabla.

    Agregar esquema mediante agregar campos

  7. Haz clic en Crear tabla.

Línea de comandos

Ingresa el comando bq load con la marca --replace para reemplazar la tabla. Proporciona la marca --location y configura el valor en tu ubicación. Usa la marca --noreplace para agregar datos a una tabla. Si no se especifica ninguna marca, se agregan datos de manera predeterminada.

Cuando agregas o reemplazas una tabla, puedes usar la marca --schema_update_option para actualizar el esquema de la tabla de destino con el esquema de los datos nuevos. Se pueden usar las siguientes opciones con la marca --schema_update_option:

  • ALLOW_FIELD_ADDITION: Agrega campos nuevos al esquema, los campos nuevos no pueden ser REQUIRED.
  • ALLOW_FIELD_RELAXATION: Disminuye los campos obligatorios a nulos y repite esta opción para especificar una lista de valores.
bq --location=[LOCATION] load --[no]replace [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.
  • [DATASET] es un conjunto de datos existente.
  • [TABLE] es el nombre de la tabla en la que cargas datos.
  • [PATH_TO_SOURCE] es un URI de Cloud Storage totalmente 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 entre líneas como parte del comando. También puedes usar la marca --autodetect en lugar de proporcionar una definición de esquema.

Además, puedes agregar marcas para las opciones JSON que te permiten controlar cómo BigQuery analiza tus datos.

Ejemplos:

  • El siguiente comando carga datos de gs://mybucket/mydata.json y reemplaza una tabla llamada mytable en mydataset. El esquema se define usando un archivo de detección automática de esquemas. Se crean mybucket y mydataset en la ubicación multirregión US.

    bq --location=US load --autodetect --replace --source_format=NEWLINE_DELIMITED_JSON mydataset.mytable gs://mybucket/mydata.json
    
  • El siguiente comando carga datos de gs://mybucket/mydata.json y agrega los datos en una tabla llamada mytable en mydataset. El esquema se define usando un archivo de esquema JSON: myschema.json. Se crean mybucket y mydataset en la ubicación multirregión US.

    bq --location=US load --autodetect --noreplace --source_format=NEWLINE_DELIMITED_JSON mydataset.mytable gs://mybucket/mydata.json ./myschema.json
    
  • El siguiente comando carga datos de gs://mybucket/mydata.json y agrega los datos en una tabla llamada mytable en mydataset. Se usa un archivo de esquema JSON local llamado myschema.json. La definición del esquema contiene campos nuevos que no están presentes en la tabla de destino. Se crean mybucket y mydataset en la región asia-northeast1.

    bq --location=asia-northeast1 load --noreplace --schema_update_option=ALLOW_FIELD_ADDITION --source_format=NEWLINE_DELIMITED_JSON mydataset.mytable gs://mybucket/mydata.json ./myschema.json
    
  • El siguiente comando carga datos de gs://mybucket/mydata.csv y agrega los datos a una tabla llamada mytable en mydataset. Se usa un archivo de esquema JSON local llamado myschema.json. La definición del esquema cambia (disminuye) dos campos REQUIRED a NULLABLE. Se crean mybucket y mydataset 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 ./myschema.json
    

API

Configura las siguientes propiedades para cargar datos JSON usando la API.

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

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

  3. Los URI de origen deben estar completamente calificados en el formato gs://[BUCKET]/[OBJECT]. Puedes incluir varios URI como una lista separada por comas. Ten en cuenta que los comodines también son compatibles cuando se cargan datos CSV desde Google Cloud Storage.

  4. Especifica el formato de datos mediante la configuración de la propiedad configuration.load.sourceFormat a NEWLINE_DELIMITED_JSON.

  5. Especifica la preferencia de escritura configurando la propiedad configuration.load.writeDisposition en WRITE_TRUNCATE, WRITE_APPEND o WRITE_EMPTY.

  6. Para actualizar el esquema en tu trabajo de carga, configura la propiedad configuration.load.schemaUpdateOptions en ALLOW_FIELD_ADDITION o ALLOW_FIELD_RELAXATION.

Go

Antes de probar esta muestra, sigue las instrucciones de configuración para Go 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 Go de BigQuery.

// 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")
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())
}

Node.js

Antes de probar esta muestra, sigue las instrucciones de configuración de Node.js 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 Node.js de BigQuery.

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

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

/**
 * 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';

// Instantiates clients
const bigquery = new BigQuery({
  projectId: projectId,
});

const storage = new Storage({
  projectId: projectId,
});

// Configure the load job. For full list of options, see:
// https://cloud.google.com/bigquery/docs/reference/rest/v2/jobs#configuration.load
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',
};

// Loads 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 esta muestra, sigue las instrucciones de configuración de PHP 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 PHP de BigQuery.

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 remplazar las filas en una tabla existente, configura la LoadJobConfig.write_disposition property en la string WRITE_TRUNCATE.

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()
# table_ref = client.dataset('my_dataset').table('existing_table')

previous_rows = client.get_table(table_ref).num_rows
assert previous_rows > 0

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 en una tabla existente, configura el parámetro write de Table.load_job() en "WRITE_TRUNCATE".

Antes de probar esta muestra, sigue las instrucciones de configuración de Ruby 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 Ruby de BigQuery.

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

Opciones JSON

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

Opción JSON Opción de Console Opción de IU clásica Marca 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 (Opcional) La cantidad máxima de registros erróneos que BigQuery puede ignorar cuando ejecuta el trabajo. 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 (Opcional) Indica si BigQuery debe permitir valores adicionales que no estén representados en el esquema de la tabla. 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 registros incorrectos, 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 nombre 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.