Cargar datos JSON desde Cloud Storage

Consola

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

   Ir a BigQuery

2. En el panel Explorador, expande tu proyecto y selecciona un conjunto de datos.
3. En la sección Información del conjunto de datos, haz clic en add_box Crear tabla.
4. En el panel Crear tabla, especifica los siguientes detalles:
1. En la sección Fuente, selecciona Google Cloud Storage en la lista Crear tabla a partir de. A continuación, siga estos pasos:
   1. Selecciona un archivo del segmento de Cloud Storage o introduce el URI de Cloud Storage. No puedes incluir varias URIs en la consola Google Cloud , pero sí caracteres comodín. El segmento de Cloud Storage debe estar en la misma ubicación que el conjunto de datos que contiene la tabla que quieres crear, añadir o sobrescribir.
   2. En Formato de archivo, selecciona JSONL (JSON delimitado por líneas nuevas).
2. En la sección Destino, especifica los siguientes detalles:
   1. En Conjunto de datos, selecciona el conjunto de datos en el que quieras crear la tabla.
   2. En el campo Tabla, introduce el nombre de la tabla que quieras crear.
   3. Verifica que el campo Tipo de tabla sea Tabla nativa.
3. En la sección Schema (Esquema), introduce la definición de schema. Para habilitar la detección automática de un esquema, selecciona Detectar automáticamente. Puede introducir la información del esquema manualmente mediante uno de los siguientes métodos:
   • Opción 1: Haz clic en Editar como texto y pega el esquema en forma de matriz JSON. Cuando usas una matriz JSON, generas el esquema siguiendo el mismo proceso que para crear un archivo de esquema JSON. Para ver el esquema de una tabla en formato JSON, introduce el siguiente comando:

         bq show --format=prettyjson dataset.table
         

   • Opción 2: Haz clic en add_box Añadir campo e introduce el esquema de la tabla. Especifica el Nombre, Tipo y Modo de cada campo.
4. Opcional: Especifica la configuración de partición y clúster. Para obtener más información, consulta los artículos sobre cómo crear tablas con particiones y cómo crear y usar tablas agrupadas en clústeres.
5. Haz clic en Opciones avanzadas y haz lo siguiente:
   • En Write preference (Preferencia de escritura), deja seleccionada la opción Write if empty (Escribir si está vacía). Con esta opción se crea una tabla y se cargan los datos en ella.
   • En Número de errores permitidos, acepta el valor predeterminado 0 o introduce el número máximo de filas que contengan errores que se pueden ignorar. Si el número de filas con errores supera este valor, el trabajo mostrará un mensaje invalid y fallará. Esta opción solo se aplica a los archivos CSV y JSON.
   • En Zona horaria, introduzca la zona horaria predeterminada que se aplicará al analizar los valores de marca de tiempo que no tengan una zona horaria específica. Consulta aquí más nombres de zonas horarias válidos. Si no se incluye este valor, las marcas de tiempo sin una zona horaria específica se analizan con la zona horaria predeterminada UTC. Vista previa.
   • En Formato de fecha, introduce los elementos de formato que definen cómo se formatean los valores DATE en los archivos de entrada. Este campo espera el formato de estilos SQL (por ejemplo, MM/DD/YYYY). Si este valor está presente, este formato es el único compatible con DATE. La detección automática de esquemas también decidirá el tipo de columna DATE en función de este formato en lugar del formato actual. Si no se incluye este valor, el campo DATE se analiza con los formatos predeterminados. Vista previa.
   • En Formato de fecha y hora, introduce los elementos de formato que definen cómo se formatean los valores DATETIME en los archivos de entrada. Este campo espera el formato de estilos SQL (por ejemplo, MM/DD/YYYY HH24:MI:SS.FF3). Si se incluye este valor, este formato será el único compatible con DATETIME. La detección automática de esquemas también decidirá el tipo de columna DATETIME en función de este formato en lugar del formato actual. Si este valor no está presente, el campo DATETIME se analiza con los formatos predeterminados. Vista previa.
   • En Formato de hora, introduzca los elementos de formato que definen cómo se formatean los valores TIME en los archivos de entrada. Este campo espera el formato de estilos SQL (por ejemplo, HH24:MI:SS.FF3). Si se incluye este valor, será el único formato TIME compatible. La detección automática de esquemas también determinará el tipo de columna TIME en función de este formato en lugar del formato actual. Si no se incluye este valor, el campo TIME se analiza con los formatos predeterminados. Vista previa.
   • En Formato de marca de tiempo, introduzca los elementos de formato que definen cómo se formatean los valores TIMESTAMP en los archivos de entrada. Este campo espera el formato de estilos SQL (por ejemplo, MM/DD/YYYY HH24:MI:SS.FF3). Si se incluye este valor, este formato será el único compatible con TIMESTAMP. La detección automática de esquemas también determinará el tipo de columna TIMESTAMP en función de este formato en lugar del formato actual. Si no se incluye este valor, el campo TIMESTAMP se analiza con los formatos predeterminados. Vista previa.
   • Si quieres ignorar los valores de una fila que no estén presentes en el esquema de la tabla, selecciona Valores desconocidos.
   • En Encriptado, haz clic en Clave gestionada por el cliente para usar una clave de Cloud Key Management Service. Si dejas el ajuste Google-managed key, BigQuery cifra los datos en reposo.
6. Haz clic en Crear tabla.

SQL

Usa la LOAD DATA instrucción DDL. En el siguiente ejemplo se carga un archivo JSON en la nueva tabla mytable:

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

   Ir a BigQuery

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

   LOAD DATA OVERWRITE mydataset.mytable
   (x INT64,y STRING)
   FROM FILES (
     format = 'JSON',
     uris = ['gs://bucket/path/file.json']);

3. Haz clic en play_circle Ejecutar.

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

bq

Usa el comando bq load, especifica NEWLINE_DELIMITED_JSON con la marca --source_format e incluye un URI de Cloud Storage. Puede incluir un solo URI, una lista de URIs separados por comas o un URI que contenga un comodín. Proporciona el esquema de forma insertada, en un archivo de definición de esquema o usa la detección automática de esquemas.

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

Otras marcas opcionales son:

• --max_bad_records: número entero que especifica el número máximo de registros incorrectos que se permiten antes de que falle todo el trabajo. El valor predeterminado es 0. Se devuelven como máximo cinco errores de cualquier tipo, independientemente del valor de --max_bad_records.
• --ignore_unknown_values: cuando se especifica, permite e ignora los valores adicionales no reconocidos en los datos CSV o JSON.
• --time_zone: (Vista previa) Una zona horaria predeterminada opcional que se aplicará al analizar los valores de marca de tiempo que no tengan una zona horaria específica en los datos CSV o JSON.
• --date_format: (Vista previa) Cadena personalizada opcional que define cómo se formatean los valores DATE en los datos CSV o JSON.
• --datetime_format: (Vista previa) Cadena personalizada opcional que define cómo se formatean los valores DATETIME en los datos CSV o JSON.
• --time_format: (Vista previa) Cadena personalizada opcional que define cómo se formatean los valores de TIME en los datos CSV o JSON.
• --timestamp_format: (Vista previa) Cadena personalizada opcional que define el formato de los valores TIMESTAMP en los datos CSV o JSON.
• --autodetect: Cuando se especifica, habilita la detección automática de esquemas para datos CSV y JSON.
• --time_partitioning_type: habilita la creación de particiones basadas en el tiempo en una tabla y define el tipo de partición. Los valores posibles son HOUR, DAY, MONTH y YEAR. Esta marca es opcional cuando se crea una tabla con particiones en una columna DATE, DATETIME o TIMESTAMP. El tipo de partición predeterminado para la partición basada en tiempo es DAY. No puedes cambiar la especificación de partición de una tabla que ya tengas.
• --time_partitioning_expiration: número entero que especifica (en segundos) cuándo se debe eliminar una partición basada en el tiempo. El tiempo de caducidad se calcula como la fecha UTC de la partición más el valor entero.
• --time_partitioning_field: columna DATE o TIMESTAMP que se usa para crear una tabla con particiones. Si se habilita la creación de particiones basadas en tiempo sin este valor, se creará una tabla con particiones por hora de ingestión.
• --require_partition_filter: cuando se habilita esta opción, los usuarios deben incluir una cláusula WHERE que especifique las particiones que se van a consultar. Si usas este filtro, es posible que rebajes los costes y mejores el rendimiento. Para obtener más información, consulta Requerir un filtro de partición en las consultas.
• --clustering_fields: lista separada por comas de hasta cuatro nombres de columna que se usa para crear una tabla agrupada en clústeres.

• --destination_kms_key: la clave de Cloud KMS para cifrar los datos de la tabla.

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

  • Crear tablas con particiones

  Para obtener más información sobre las tablas agrupadas en clústeres, consulta los siguientes enlaces:

  • Crear y usar tablas agrupadas en clústeres

  Para obtener más información sobre el cifrado de tablas, consulta los siguientes artículos:

  • Proteger datos con claves de Cloud KMS

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

bq --location=LOCATION load \
--source_format=FORMAT \
DATASET.TABLE \
PATH_TO_SOURCE \
SCHEMA

Haz los cambios siguientes:

• LOCATION: tu ubicación. La marca --location es opcional. Por ejemplo, si usas BigQuery en la región de Tokio, puedes asignar el valor asia-northeast1 a la marca. Puedes definir un valor predeterminado para la ubicación mediante el archivo.bigqueryrc.
• FORMAT: NEWLINE_DELIMITED_JSON.
• DATASET: un conjunto de datos.
• TABLE: el nombre de la tabla en la que vas a cargar los datos.
• PATH_TO_SOURCE: un URI de Cloud Storage completo o una lista de URIs separados por comas. También se admiten comodines.
• SCHEMA: un esquema válido. El esquema puede ser un archivo JSON local o se puede escribir directamente como parte del comando. Si usas un archivo de esquema, no le asignes ninguna extensión. También puedes usar la marca --autodetect en lugar de proporcionar una definición de esquema.

Ejemplos:

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

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

El siguiente comando carga datos de gs://mybucket/mydata.json en una tabla con particiones por tiempo de ingestión llamada mytable en mydataset. El esquema se define en un archivo de esquema local llamado myschema.

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

El siguiente comando carga datos de gs://mybucket/mydata.json en una tabla particionada llamada mytable en mydataset. que cuenta con particiones por la columna mytimestamp. El esquema se define en un archivo de esquema local llamado myschema.

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

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

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

El siguiente comando carga datos de gs://mybucket/mydata.json en una tabla llamada mytable en mydataset. El esquema se define de forma insertada en el formato FIELD:DATA_TYPE, FIELD:DATA_TYPE.

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

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

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

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

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

API

1. Crea una tarea load que apunte a los datos de origen en Cloud Storage.

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

3. La propiedad source URIs debe estar totalmente cualificada y tener el formato gs://BUCKET/OBJECT. Cada URI puede contener un carácter comodín "*".

4. Especifique el formato de datos JSON asignando el valor NEWLINE_DELIMITED_JSON a la propiedad sourceFormat.

5. Para comprobar el estado del trabajo, llama a jobs.get(JOB_ID*), sustituyendo JOB_ID por el ID del trabajo devuelto por la solicitud inicial.

   • Si status.state = DONE, el trabajo se ha completado correctamente.
   • Si la propiedad status.errorResult está presente, significa que se ha producido un error en la solicitud y que el objeto incluye información que describe lo que ha fallado. Si una solicitud falla, no se crea ninguna tabla y no se cargan datos.
   • Si no aparece status.errorResult, significa que el trabajo se ha completado correctamente, aunque es posible que se hayan producido algunos errores no críticos, como problemas al importar algunas filas. Los errores no críticos se indican en la propiedad status.errors del objeto job devuelto.

Notas sobre la API:

• Las tareas de carga son atómicas y coherentes: si una tarea de carga falla, no habrá datos disponibles, y si se completa correctamente, todos los datos estarán disponibles.

• Como práctica recomendada, genera un ID único y pásalo como jobReference.jobId al llamar a jobs.insert para crear un trabajo de carga. Este enfoque es más sólido ante fallos de red, ya que el cliente puede sondear o volver a intentar la operación con el ID de trabajo conocido.

• Llamar a jobs.insert en un ID de trabajo determinado es idempotente. Puedes volver a intentarlo tantas veces como quieras con el mismo ID de trabajo y, como máximo, una de esas operaciones se completará correctamente.

C#

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 = loadJob.PollUntilCompleted().ThrowOnAnyError();  // 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

import (
	"context"
	"fmt"

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

// importJSONExplicitSchema demonstrates loading newline-delimited JSON data from Cloud Storage
// into a BigQuery table and providing an explicit schema for the data.
func importJSONExplicitSchema(projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// tableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

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

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

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

Java

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Field;
import com.google.cloud.bigquery.FormatOptions;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.LoadJobConfiguration;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.StandardSQLTypeName;
import com.google.cloud.bigquery.TableId;

// Sample to load JSON data from Cloud Storage into a new BigQuery table
public class LoadJsonFromGCS {

  public static void runLoadJsonFromGCS() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String sourceUri = "gs://cloud-samples-data/bigquery/us-states/us-states.json";
    Schema schema =
        Schema.of(
            Field.of("name", StandardSQLTypeName.STRING),
            Field.of("post_abbr", StandardSQLTypeName.STRING));
    loadJsonFromGCS(datasetName, tableName, sourceUri, schema);
  }

  public static void loadJsonFromGCS(
      String datasetName, String tableName, String sourceUri, Schema schema) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      TableId tableId = TableId.of(datasetName, tableName);
      LoadJobConfiguration loadConfig =
          LoadJobConfiguration.newBuilder(tableId, sourceUri)
              .setFormatOptions(FormatOptions.json())
              .setSchema(schema)
              .build();

      // Load data from a GCS JSON file into the table
      Job job = bigquery.create(JobInfo.of(loadConfig));
      // Blocks until this load table job completes its execution, either failing or succeeding.
      job = job.waitFor();
      if (job.isDone()) {
        System.out.println("Json from GCS successfully loaded in a table");
      } else {
        System.out.println(
            "BigQuery was unable to load into the table due to an error:"
                + job.getStatus().getError());
      }
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Column not added during load append \n" + e.toString());
    }
  }
}

Node.js

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

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

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

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

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

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

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

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

PHP

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

from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Set table_id to the ID of the table to create.
# table_id = "your-project.your_dataset.your_table_name"

job_config = bigquery.LoadJobConfig(
    schema=[
        bigquery.SchemaField("name", "STRING"),
        bigquery.SchemaField("post_abbr", "STRING"),
    ],
    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_id,
    location="US",  # Must match the destination dataset location.
    job_config=job_config,
)  # Make an API request.

load_job.result()  # Waits for the job to complete.

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

Ruby

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

Consola

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

   Ir a BigQuery

2. En el panel Explorador, expande tu proyecto y selecciona un conjunto de datos.
3. En la sección Información del conjunto de datos, haz clic en add_box Crear tabla.
4. En el panel Crear tabla, especifica los siguientes detalles:
1. En la sección Fuente, selecciona Google Cloud Storage en la lista Crear tabla a partir de. A continuación, siga estos pasos:
   1. Selecciona un archivo del segmento de Cloud Storage o introduce el URI de Cloud Storage. No puedes incluir varias URIs en la consola Google Cloud , pero sí caracteres comodín. El segmento de Cloud Storage debe estar en la misma ubicación que el conjunto de datos que contiene la tabla que quieres crear, añadir o sobrescribir.
   2. En Formato de archivo, selecciona JSONL (JSON delimitado por líneas nuevas).
2. En la sección Destino, especifica los siguientes detalles:
   1. En Conjunto de datos, selecciona el conjunto de datos en el que quieras crear la tabla.
   2. En el campo Tabla, introduce el nombre de la tabla que quieras crear.
   3. Verifica que el campo Tipo de tabla sea Tabla nativa.
3. En la sección Schema (Esquema), introduce la definición de schema. Para habilitar la detección automática de un esquema, selecciona Detectar automáticamente. Puede introducir la información del esquema manualmente mediante uno de los siguientes métodos:
   • Opción 1: Haz clic en Editar como texto y pega el esquema en forma de matriz JSON. Cuando usas una matriz JSON, generas el esquema siguiendo el mismo proceso que para crear un archivo de esquema JSON. Para ver el esquema de una tabla en formato JSON, introduce el siguiente comando:

         bq show --format=prettyjson dataset.table
         

   • Opción 2: Haz clic en add_box Añadir campo e introduce el esquema de la tabla. Especifica el Nombre, Tipo y Modo de cada campo.
4. Opcional: Especifica la configuración de partición y clúster. Para obtener más información, consulta los artículos sobre cómo crear tablas con particiones y cómo crear y usar tablas agrupadas en clústeres. No puedes convertir una tabla en una tabla particionada o agrupada añadiéndole datos o sobrescribiéndola. La consola de Google Cloud no admite añadir datos a tablas particionadas o agrupadas, ni sobrescribirlas, en una tarea de carga.
5. Haz clic en Opciones avanzadas y haz lo siguiente:
   • En Preferencia de escritura, elija Añadir a la tabla o Sobrescribir tabla.
   • En Número de errores permitidos, acepta el valor predeterminado 0 o introduce el número máximo de filas que contengan errores que se pueden ignorar. Si el número de filas con errores supera este valor, el trabajo mostrará un mensaje invalid y fallará. Esta opción solo se aplica a los archivos CSV y JSON.
   • En Zona horaria, introduzca la zona horaria predeterminada que se aplicará al analizar los valores de marca de tiempo que no tengan una zona horaria específica. Consulta aquí más nombres de zonas horarias válidos. Si no se incluye este valor, las marcas de tiempo sin una zona horaria específica se analizan con la zona horaria predeterminada UTC. Vista previa.
   • En Formato de fecha, introduce los elementos de formato que definen cómo se formatean los valores DATE en los archivos de entrada. Este campo espera el formato de estilos SQL (por ejemplo, MM/DD/YYYY). Si este valor está presente, este formato es el único compatible con DATE. La detección automática de esquemas también decidirá el tipo de columna DATE en función de este formato en lugar del formato actual. Si no se incluye este valor, el campo DATE se analiza con los formatos predeterminados. Vista previa.
   • En Formato de fecha y hora, introduce los elementos de formato que definen cómo se formatean los valores DATETIME en los archivos de entrada. Este campo espera el formato de estilos SQL (por ejemplo, MM/DD/YYYY HH24:MI:SS.FF3). Si se incluye este valor, este formato será el único compatible con DATETIME. La detección automática de esquemas también decidirá el tipo de columna DATETIME en función de este formato en lugar del formato actual. Si este valor no está presente, el campo DATETIME se analiza con los formatos predeterminados. Vista previa.
   • En Formato de hora, introduzca los elementos de formato que definen cómo se formatean los valores TIME en los archivos de entrada. Este campo espera el formato de estilos SQL (por ejemplo, HH24:MI:SS.FF3). Si se incluye este valor, será el único formato TIME compatible. La detección automática de esquemas también determinará el tipo de columna TIME en función de este formato en lugar del formato actual. Si no se incluye este valor, el campo TIME se analiza con los formatos predeterminados. Vista previa.
   • En Formato de marca de tiempo, introduzca los elementos de formato que definen cómo se formatean los valores TIMESTAMP en los archivos de entrada. Este campo espera el formato de estilos SQL (por ejemplo, MM/DD/YYYY HH24:MI:SS.FF3). Si se incluye este valor, este formato será el único compatible con TIMESTAMP. La detección automática de esquemas también determinará el tipo de columna TIMESTAMP en función de este formato en lugar del formato actual. Si no se incluye este valor, el campo TIMESTAMP se analiza con los formatos predeterminados. Vista previa.
   • Si quieres ignorar los valores de una fila que no estén presentes en el esquema de la tabla, selecciona Valores desconocidos.
   • En Encriptado, haz clic en Clave gestionada por el cliente para usar una clave de Cloud Key Management Service. Si dejas el ajuste Google-managed key, BigQuery cifra los datos en reposo.
6. Haz clic en Crear tabla.

SQL

Usa la LOAD DATA instrucción DDL. En el siguiente ejemplo se añade un archivo JSON a la tabla mytable:

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

   Ir a BigQuery

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

   LOAD DATA INTO mydataset.mytable
   FROM FILES (
     format = 'JSON',
     uris = ['gs://bucket/path/file.json']);

3. Haz clic en play_circle Ejecutar.

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

bq

Usa el comando bq load, especifica NEWLINE_DELIMITED_JSON con la marca --source_format e incluye un URI de Cloud Storage. Puede incluir un solo URI, una lista de URIs separados por comas o un URI que contenga un comodín.

Proporciona el esquema de forma insertada, en un archivo de definición de esquema o usa la detección automática de esquemas.

Especifica la marca --replace para sobrescribir la tabla. Usa la marca --noreplace para añadir datos a la tabla. Si no se especifica ninguna marca, el valor predeterminado es añadir datos.

Es posible modificar el esquema de la tabla cuando la añades o la sobrescribes. Para obtener más información sobre los cambios de esquema admitidos durante una operación de carga, consulta Modificar esquemas de tabla.

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

Otras marcas opcionales son:

• --max_bad_records: número entero que especifica el número máximo de registros incorrectos que se permiten antes de que falle todo el trabajo. El valor predeterminado es 0. Se devuelven como máximo cinco errores de cualquier tipo, independientemente del valor de --max_bad_records.
• --ignore_unknown_values: cuando se especifica, permite e ignora los valores adicionales no reconocidos en los datos CSV o JSON.
• --time_zone: (Vista previa) Una zona horaria predeterminada opcional que se aplicará al analizar los valores de marca de tiempo que no tengan una zona horaria específica en los datos CSV o JSON.
• --date_format: (Vista previa) Cadena personalizada opcional que define cómo se formatean los valores DATE en los datos CSV o JSON.
• --datetime_format: (Vista previa) Cadena personalizada opcional que define cómo se formatean los valores DATETIME en los datos CSV o JSON.
• --time_format: (Vista previa) Cadena personalizada opcional que define cómo se formatean los valores de TIME en los datos CSV o JSON.
• --timestamp_format: (Vista previa) Cadena personalizada opcional que define el formato de los valores TIMESTAMP en los datos CSV o JSON.
• --autodetect: Cuando se especifica, habilita la detección automática de esquemas para datos CSV y JSON.
• --destination_kms_key: la clave de Cloud KMS para cifrar los datos de la tabla.

bq --location=LOCATION load \
--[no]replace \
--source_format=FORMAT \
DATASET.TABLE \
PATH_TO_SOURCE \
SCHEMA

Haz los cambios siguientes:

• LOCATION: tu ubicación. La marca --location es opcional. Puedes definir un valor predeterminado para la ubicación mediante el archivo.bigqueryrc.
• FORMAT: NEWLINE_DELIMITED_JSON.
• DATASET: un conjunto de datos.
• TABLE: el nombre de la tabla en la que vas a cargar los datos.
• PATH_TO_SOURCE: un URI de Cloud Storage completo o una lista de URIs separados por comas. También se admiten comodines.
• SCHEMA: un esquema válido. El esquema puede ser un archivo JSON local o se puede escribir directamente como parte del comando. También puedes usar la marca --autodetect en lugar de proporcionar una definición de esquema.

Ejemplos:

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

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

El siguiente comando carga datos de gs://mybucket/mydata.json y añade datos a una tabla llamada mytable en mydataset. El esquema se define mediante un archivo de esquema JSON: myschema.

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

API

1. Crea una tarea load que apunte a los datos de origen en Cloud Storage.

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

3. La propiedad source URIs debe estar completa y tener el formato gs://BUCKET/OBJECT. Puedes incluir varios URIs en una lista separada por comas. También se admiten comodines.

4. Especifica el formato de los datos asignando el valor NEWLINE_DELIMITED_JSON a la propiedad configuration.load.sourceFormat.

5. Especifica la preferencia de escritura asignando el valor WRITE_TRUNCATE o WRITE_APPEND a la propiedad configuration.load.writeDisposition.

Go

import (
	"context"
	"fmt"

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

// importJSONTruncate demonstrates loading data from newline-delimeted JSON data in Cloud Storage
// and overwriting/truncating data in the existing table.
func importJSONTruncate(projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// tableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

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

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

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

	return nil
}

Java

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Field;
import com.google.cloud.bigquery.FormatOptions;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.LoadJobConfiguration;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.StandardSQLTypeName;
import com.google.cloud.bigquery.TableId;

// Sample to overwrite the BigQuery table data by loading a JSON file from GCS
public class LoadJsonFromGCSTruncate {

  public static void runLoadJsonFromGCSTruncate() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String sourceUri = "gs://cloud-samples-data/bigquery/us-states/us-states.json";
    Schema schema =
        Schema.of(
            Field.of("name", StandardSQLTypeName.STRING),
            Field.of("post_abbr", StandardSQLTypeName.STRING));
    loadJsonFromGCSTruncate(datasetName, tableName, sourceUri, schema);
  }

  public static void loadJsonFromGCSTruncate(
      String datasetName, String tableName, String sourceUri, Schema schema) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      TableId tableId = TableId.of(datasetName, tableName);
      LoadJobConfiguration loadConfig =
          LoadJobConfiguration.newBuilder(tableId, sourceUri)
              .setFormatOptions(FormatOptions.json())
              // Set the write disposition to overwrite existing table data
              .setWriteDisposition(JobInfo.WriteDisposition.WRITE_TRUNCATE)
              .setSchema(schema)
              .build();

      // Load data from a GCS JSON file into the table
      Job job = bigquery.create(JobInfo.of(loadConfig));
      // Blocks until this load table job completes its execution, either failing or succeeding.
      job = job.waitFor();
      if (job.isDone()) {
        System.out.println("Table is successfully overwritten by JSON file loaded from GCS");
      } else {
        System.out.println(
            "BigQuery was unable to load into the table due to an error:"
                + job.getStatus().getError());
      }
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Column not added during load append \n" + e.toString());
    }
  }
}

Node.js

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

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

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

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

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

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

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

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

PHP

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 sustituir las filas de una tabla, defina la propiedad LoadJobConfig.write_disposition en la cadena WRITE_TRUNCATE.

import io

from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Set table_id to the ID of the table to create.
# table_id = "your-project.your_dataset.your_table_name

job_config = bigquery.LoadJobConfig(
    schema=[
        bigquery.SchemaField("name", "STRING"),
        bigquery.SchemaField("post_abbr", "STRING"),
    ],
)

body = io.BytesIO(b"Washington,WA")
client.load_table_from_file(body, table_id, job_config=job_config).result()
previous_rows = client.get_table(table_id).num_rows
assert previous_rows > 0

job_config = bigquery.LoadJobConfig(
    write_disposition=bigquery.WriteDisposition.WRITE_TRUNCATE,
    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_id, job_config=job_config
)  # Make an API request.

load_job.result()  # Waits for the job to complete.

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

Ruby

Para sustituir las filas de una tabla, defina el parámetro write de Table.load_job() en "WRITE_TRUNCATE".

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