Carga datos de JSON desde 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 cargues datos de 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 desde 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, 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. Para obtener más información sobre las funciones de 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 de URI, también debes tener permisos storage.objects.list.

La función de IAM predefinida 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:

Console

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

  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 página Create table (Crear tabla), en la sección Source (Origen), realiza lo siguiente:

    • En Create table from (Crear tabla desde), selecciona el tipo de origen que desees.

      Crear origen de tabla

    • En el campo de origen, busca el depósito de archivos o de Cloud Storage, o 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 vas a crear.

      Seleccionar archivo

    • En File format (Formato de archivo), selecciona JSON.

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

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

      Seleccionar conjunto de datos

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

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

  6. En la sección Schema (Esquema), ingresa la definición del esquema.

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

      • Habilita la opción Edit as text (Editar como texto) y, luego, ingresa el esquema de la tabla como un arreglo de JSON.

      • Usa la opción Add field (Agregar campo) para ingresar el esquema de forma manual:

  7. Selecciona los elementos aplicables en la sección Advanced options (Opciones avanzadas) y haz clic en Create table (Crear tabla). Para obtener información sobre las opciones disponibles, consulta las Opciones de JSON.

IU clásica

  1. Dirígete a la IU web de BigQuery.
    Ir a la IU web de BigQuery

  2. En el panel de navegación, desplaza 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, 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 Create table (Crear tabla), en la sección Datos de origen, realiza lo siguiente:

    • 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 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 vas a crear.
    • 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:

    • En Table name (Nombre de tabla), selecciona el conjunto de datos apropiado y, en el campo de nombre de tabla, ingresa el nombre de la tabla que vas a crear en BigQuery.
    • Verifica que Table type (Tipo de tabla) esté configurado como Native table (Tabla nativa).
  5. En la sección Schema (Esquema), ingresa la definición del esquema.

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

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

        Agregar un esquema como arreglo de JSON

      • Usa Add Field (Agregar campo) para ingresar el esquema de forma manual:

        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, agrega 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 establece 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 la marca 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 los datos.
  • [PATH_TO_SOURCE] es un URI de Cloud Storage completo 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.

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) o 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 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 Cloud Storage.

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

  3. Los URI de origen deben estar calificados por completo 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 en 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 se muestra status.state = DONE, el trabajo se completó con éxito.
    • Si aparece la propiedad status.errorResult, la solicitud falló y ese objeto incluirá información que describe qué salió mal. Cuando una solicitud falla, no se crea ninguna tabla ni se agregan datos.
    • Si status.errorResult está ausente, el trabajo se completó con éxito, aunque pueden 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 de 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 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# 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 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 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 de 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.

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

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// 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';

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

  // Instantiate clients
  const bigqueryClient = new BigQuery();
  const storageClient = new Storage();

  // 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'},
      ],
    },
    loation: 'US',
  };

  // Load data from a Google Cloud Storage file into the table
  const [job] = await bigqueryClient
    .dataset(datasetId)
    .table(tableId)
    .load(storageClient.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;
  }
}
loadJSONFromGCS();

PHP

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

Console

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

  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 página Create table (Crear tabla), en la sección Source (Origen), realiza lo siguiente:

    • En Create table from (Crear tabla desde), selecciona el tipo de origen que desees.

      Crear origen de tabla

    • En el campo de origen, busca el depósito de archivos o de Cloud Storage, o 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 vas a crear.

      Seleccionar archivo

    • En File format (Formato de archivo), selecciona JSON.

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

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

      Seleccionar conjunto de datos

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

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

  6. En la sección Schema (Esquema), debajo de Auto-detect (Detección automática), marca la opción Parámetros de esquema y entrada para habilitar la detección automática de esquemas.

    auto detect link

  7. Selecciona los elementos aplicables en la sección Advanced options (Opciones avanzadas) y haz clic en Create table (Crear tabla). Para obtener información sobre las opciones disponibles, consulta las Opciones de JSON.

IU clásica

  1. Dirígete a la IU web de BigQuery.
    Ir a la IU web de BigQuery

  2. En el panel de navegación, desplaza 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, 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 Create table (Crear tabla), en la sección Datos de origen, realiza lo siguiente:

    • 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 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 vas a crear.
    • 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:

    • En Table name (Nombre de tabla), selecciona el conjunto de datos apropiado y, en el campo de nombre de tabla, ingresa el nombre de la tabla que vas a crear en BigQuery.
    • Verifica que Table type esté configurado como Native table.
  5. En la sección Schema (Esquema), marca la opción Auto-detect (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, agrega 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 establece 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 la marca 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 los datos.
  • [PATH_TO_SOURCE] es un URI de Cloud Storage completo 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 crean en la ubicación multirregión 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 crean 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. El esquema se define mediante la detección automática de esquemas. mybucket y mydataset se crean 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 Cloud Storage.

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

  3. Los URI de origen deben estar calificados por completo 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 en 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 se muestra status.state = DONE, el trabajo se completó con éxito.
    • Si aparece la propiedad status.errorResult, la solicitud falló y ese objeto incluirá información que describe qué salió mal. Cuando una solicitud falla, no se crea ninguna tabla ni se agregan datos.
    • Si status.errorResult está ausente, el trabajo se completó con éxito, aunque pueden 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 de 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 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 tendrá éxito.

Go

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

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

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// 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';

async function loadJSONFromGCSAutodetect() {
  // Imports a GCS file into a table with autodetected schema.

  // Instantiate clients
  const bigqueryClient = new BigQuery();
  const storageClient = new Storage();

  // 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,
    location: 'US',
  };

  // Load data from a Google Cloud Storage file into the table
  const [job] = await bigqueryClient
    .dataset(datasetId)
    .table(tableId)
    .load(storageClient.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;
  }
}
loadJSONFromGCSAutodetect();

PHP

Antes de probar esta muestra, sigue las instrucciones de configuración de PHP 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 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';
$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 como 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 para Ruby 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 Ruby.

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 Especifica 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 agregues o reemplaces los datos.

Si actualizas el esquema cuando agregas datos, BigQuery te permitirá realizar las siguientes acciones:

  • Agregar campos nuevos
  • Cambiar los campos REQUIRED por 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 y en la IU web clásica de BigQuery, usa la opción de Write preference (Preferencia de escritura) para especificar qué acción realizar cuando cargues datos desde un archivo de origen o desde un resultado de consulta. La CLI y la API incluyen las siguientes opciones:

Opción de Console Opción de la IU clásica Marcador 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.
Adjuntar a la tabla Adjuntar a la tabla --noreplace o --replace=false; si --[no]replace no se especifica, la opción predeterminada es adjuntar WRITE_APPEND (Predeterminado) Adjunta los datos al final de la tabla.
Reemplazar tabla Reemplazar tabla --replace o --replace=true WRITE_TRUNCATE Borra todos los datos existentes de una tabla antes de escribir los datos nuevos.

De manera predeterminada, los trabajos de carga adjuntará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:

Console

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

  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 página Create table (Crear tabla), en la sección Source (Origen), realiza lo siguiente:

    • En Create table from (Crear tabla desde), selecciona el tipo de origen que desees.

      Crear origen de tabla

    • En el campo de origen, busca el depósito de archivos o de Cloud Storage, o 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 vas a crear.

      Ver conjunto de datos

    • En File format (Formato de archivo), selecciona JSON.

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

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

      Seleccionar conjunto de datos

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

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

  6. En la sección Schema (Esquema), ingresa la definición del esquema.

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

      • Habilita la opción Edit as text (Editar como texto) y, luego, ingresa el esquema de la tabla como un arreglo de JSON.

      • Usa la opción Add field (Agregar campo) para ingresar el esquema de forma manual:

  7. En la sección Advanced Options (Opciones avanzadas), en Write preference (Preferencia de escritura), elige Write if empty (Escribir si está vacía), Append to table (Agregar a la tabla), o bien Overwrite table (Reemplazar tabla).

    Reemplazar tabla

  8. Haz clic en Create table (Crear tabla).

    1. Haz clic en Create table (Crear tabla).

IU clásica

  1. Dirígete a la IU web de BigQuery.
    Ir a la IU web de BigQuery

  2. En el panel de navegación, desplaza 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, 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 Create table (Crear tabla), en la sección Datos de origen, realiza lo siguiente:

    • En Ubicación, selecciona Cloud Storage y, en el campo de origen, ingresa el URI de Cloud Storage. Ten en cuenta que no puedes ingresar 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 creas o reemplazas.
    • 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:

    • En 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 creas o reemplazas.
    • Verifica que Table type esté configurado como Native table.
  5. En la sección Schema (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 marcar la opción Auto-detect (Detección automática) 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 manualmente de la siguiente manera:

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

        Agregar un esquema como arreglo de JSON

      • Usa Add Field para ingresar el esquema de forma manual:

        Agregar esquema con agregar campos

  6. En la sección Options, para Write preference, elige Write if empty, Append to table, o bien, Overwrite table.

    Agregar esquema con agregar campos

  7. Haz clic en Create Table (Crear tabla).

Línea de comandos

Ingresa el comando bq load con el marcador --replace para reemplazar la tabla. Proporciona la marca --location y establece 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: cambia los campos obligatorios a nulos. 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 los datos.
  • [PATH_TO_SOURCE] es un URI de Cloud Storage completo 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.

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 con un archivo de detección automática de esquemas. mybucket y mydataset se crearon 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. mybucket y mydataset se crean 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 en 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. mybucket y mydataset se crean 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 Cloud Storage.

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

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

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

  5. Especifica la preferencia de escritura mediante la configuración de la propiedad configuration.load.writeDisposition como WRITE_TRUNCATE, WRITE_APPEND o WRITE_EMPTY.

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

Go

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

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

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// 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';

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

  // Instantiate clients
  const bigqueryClient = new BigQuery();
  const storageClient = new Storage();

  // 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',
  };

  // Load data from a Google Cloud Storage file into the table
  const [job] = await bigqueryClient
    .dataset(datasetId)
    .table(tableId)
    .load(storageClient.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 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 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 remplazar las filas en una tabla existente, configura la propiedad LoadJobConfig.write_disposition 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. A fin de 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 en una tabla existente, configura el parámetro write de Table.load_job() como "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. 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

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 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 (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 ha resultado útil esta página? Enviar comentarios:

Enviar comentarios sobre...

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