Cargar datos CSV de Cloud Storage

Consola

Para seguir las instrucciones paso a paso de esta tarea directamente en el editor de Cloud Shell, haz clic en Ayúdame:

Guíame

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 CSV.
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 Delimitador de campos, elige el carácter que separa las celdas de tu archivo CSV: Coma, Tabulación, Barra vertical o Personalizado. Si elige Personalizado, introduzca el delimitador en el cuadro Delimitador de campo personalizado. El valor predeterminado es Coma.
   • En Coincidencia de columnas de origen, elija una de las siguientes estrategias para asociar las columnas cargadas al esquema (Vista previa).
   • Default: el comportamiento predeterminado se elige en función de cómo se proporcione el esquema. Si la detección automática está habilitada, el comportamiento predeterminado es hacer coincidir las columnas por nombre. De lo contrario, las columnas se emparejarán por posición de forma predeterminada. Esto se hace para mantener la retrocompatibilidad.
   • Position: hace coincidir las columnas por posición, suponiendo que las columnas están ordenadas de la misma forma que el esquema.
   • Name: se basa en el nombre. Para ello, lee la fila de encabezado como los nombres de las columnas y reordena las columnas para que coincidan con los nombres de los campos del esquema. Los nombres de las columnas se leen de la última fila omitida en función de Filas de encabezado que se van a omitir.
   • En Filas de encabezado que se deben omitir, introduce el número de filas de encabezado que se deben omitir en la parte superior del archivo CSV. El valor predeterminado es 0.
   • En Saltos de línea entrecomillados, marca Permitir saltos de línea entrecomillados para permitir secciones de datos entrecomilladas que contengan caracteres de salto de línea en un archivo CSV. El valor predeterminado es false.
   • En Filas escalonadas, marca Permitir filas escalonadas para aceptar filas en archivos CSV a las que les falten columnas opcionales finales. Los valores que faltan se tratan como nulos. Si no se marca, los registros a los que les faltan columnas finales se tratan como registros incorrectos y, si hay demasiados, se devuelve un error no válido en el resultado del trabajo. El valor predeterminado es false.
   • En Marcadores nulos, introduce una lista de cadenas personalizadas que representen un valor NULL en los datos CSV. Vista previa.
   • 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 CSV 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 = 'CSV',
     uris = ['gs://bucket/path/file.csv']);

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 CSV 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. Si no especifica un esquema, --autodetect es false y la tabla de destino existe, se usará el esquema de la tabla de destino.

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

Otras marcas opcionales son:

• --allow_jagged_rows: cuando se especifica, acepta las filas de los archivos CSV a las que les faltan columnas opcionales finales. Los valores que faltan se tratan como nulos. Si no se marca, los registros a los que les faltan columnas finales se tratan como registros incorrectos y, si hay demasiados registros incorrectos, se devuelve un error no válido en el resultado del trabajo. El valor predeterminado es false.
• --allow_quoted_newlines: cuando se especifica, permite secciones de datos entre comillas que contienen caracteres de salto de línea en un archivo CSV. El valor predeterminado es false.
• --field_delimiter: carácter que indica el límite entre las columnas de los datos. Se pueden usar tanto \t como tab para delimitar las pestañas. El valor predeterminado es ,.
• --null_marker: cadena personalizada opcional que representa un valor NULL en los datos CSV.
• --null_markers: (Vista previa) Lista opcional separada por comas de cadenas personalizadas que representan valores NULL en datos CSV. Esta opción no se puede usar con la marca --null_marker.
• --source_column_match: (Vista previa) Especifica la estrategia utilizada para asociar las columnas cargadas al esquema. Puedes especificar POSITION para que coincidan las columnas cargadas por posición, siempre que las columnas estén ordenadas de la misma forma que el esquema. También puede especificar NAME para que se haga la coincidencia por nombre leyendo la fila de encabezado como los nombres de las columnas y reordenando las columnas para que coincidan con los nombres de los campos del esquema. Si no se especifica ningún valor, el valor predeterminado se basa en cómo se proporciona el esquema. Si --autodetect está habilitada, el comportamiento predeterminado es hacer coincidir las columnas por nombre. De lo contrario, las columnas se emparejarán por posición de forma predeterminada.
• --skip_leading_rows: especifica el número de filas de encabezado que se deben omitir en la parte superior del archivo CSV. El valor predeterminado es 0.
• --quote: carácter de comillas que se usa para delimitar los registros. El valor predeterminado es ". Para indicar que no hay ningún carácter de comillas, usa una cadena vacía.
• --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 Consultar tablas particionadas.
• --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.

• --column_name_character_map: define el ámbito y la gestión de los caracteres en los nombres de las columnas, con la opción de habilitar nombres de columnas flexibles. Requiere la opción --autodetect para archivos CSV. Para obtener más información, consulta load_option_list.

  Para obtener más información sobre el comando bq load, consulta lo siguiente:

  • Referencia de la línea de comandos

  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 CSV en BigQuery, introduce el siguiente comando:

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

Donde:

• location es tu ubicación. La marca --location es opcional. Por ejemplo, si usas BigQuery en la región de Tokio, puedes definir el valor de la marca como asia-northeast1. Puedes definir un valor predeterminado para la ubicación mediante el archivo.bigqueryrc.
• format es CSV.
• dataset es un conjunto de datos.
• table es el nombre de la tabla en la que se cargan los datos.
• path_to_source es un URI de Cloud Storage completo o una lista de URIs 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 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.csv en una tabla llamada mytable en mydataset. El esquema se define en un archivo de esquema local llamado myschema.json.

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

El siguiente comando carga datos de gs://mybucket/mydata.csv en una tabla llamada mytable en mydataset. El esquema se define en un archivo de esquema local llamado myschema.json. El archivo CSV incluye dos filas de encabezado. Si no se especifica --skip_leading_rows, el comportamiento predeterminado es asumir que el archivo no contiene encabezados.

    bq load \
    --source_format=CSV \
    --skip_leading_rows=2
    mydataset.mytable \
    gs://mybucket/mydata.csv \
    ./myschema.json

El siguiente comando carga datos de gs://mybucket/mydata.csv 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.json.

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

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

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

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

    bq load \
    --autodetect \
    --source_format=CSV \
    mydataset.mytable \
    gs://mybucket/mydata.csv

El siguiente comando carga datos de gs://mybucket/mydata.csv 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=CSV \
    mydataset.mytable \
    gs://mybucket/mydata.csv \
    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=CSV \
    mydataset.mytable \
    gs://mybucket/mydata*.csv

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

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

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. Especifica el formato de los datos CSV asignando el valor CSV a la propiedad sourceFormat.

5. Para comprobar el estado del trabajo, llama a jobs.get(job_id*), donde job_id es 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 incluirá 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 puede que se hayan producido algunos errores no graves, 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.Cloud.BigQuery.V2;
using System;

public class BigQueryLoadTableGcsCsv
{
    public void LoadTableGcsCsv(
        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.csv";
        var dataset = client.GetDataset(datasetId);
        var schema = new TableSchemaBuilder {
            { "name", BigQueryDbType.String },
            { "post_abbr", BigQueryDbType.String }
        }.Build();
        var destinationTableRef = dataset.GetTableReference(
            tableId: "us_states");
        // Create job configuration
        var jobOptions = new CreateLoadJobOptions()
        {
            // The source format defaults to CSV; line below is optional.
            SourceFormat = FileFormat.Csv,
            SkipLeadingRows = 1
        };
        // Create and run job
        var 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"
)

// importCSVExplicitSchema demonstrates loading CSV data from Cloud Storage into a BigQuery
// table and providing an explicit schema for the data.
func importCSVExplicitSchema(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.csv")
	gcsRef.SkipLeadingRows = 1
	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.CsvOptions;
import com.google.cloud.bigquery.Field;
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 CSV data from Cloud Storage into a new BigQuery table
public class LoadCsvFromGcs {

  public static void runLoadCsvFromGcs() throws Exception {
    // 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.csv";
    Schema schema =
        Schema.of(
            Field.of("name", StandardSQLTypeName.STRING),
            Field.of("post_abbr", StandardSQLTypeName.STRING));
    loadCsvFromGcs(datasetName, tableName, sourceUri, schema);
  }

  public static void loadCsvFromGcs(
      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();

      // Skip header row in the file.
      CsvOptions csvOptions = CsvOptions.newBuilder().setSkipLeadingRows(1).build();

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

      // Load data from a GCS CSV 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("CSV from GCS successfully added during load append job");
      } 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 CSV file at
 * https://storage.googleapis.com/cloud-samples-data/bigquery/us-states/us-states.csv
 *
 * TODO(developer): Replace the following lines with the path to your file.
 */
const bucketName = 'cloud-samples-data';
const filename = 'bigquery/us-states/us-states.csv';

async function loadCSVFromGCS() {
  // 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: 'CSV',
    skipLeadingRows: 1,
    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.csv';
$schema = [
    'fields' => [
        ['name' => 'name', 'type' => 'string'],
        ['name' => 'post_abbr', 'type' => 'string']
    ]
];
$loadConfig = $table->loadFromStorage($gcsUri)->schema($schema)->skipLeadingRows(1);
$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"),
    ],
    skip_leading_rows=1,
    # The source format defaults to CSV, so the line below is optional.
    source_format=bigquery.SourceFormat.CSV,
)
uri = "gs://cloud-samples-data/bigquery/us-states/us-states.csv"

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)  # Make an API request.
print("Loaded {} rows.".format(destination_table.num_rows))

Ruby

require "google/cloud/bigquery"

def load_table_gcs_csv 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.csv"
  table_id = "us_states"

  load_job = dataset.load_job table_id, gcs_uri, skip_leading: 1 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

Go

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

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

import (
	"context"
	"fmt"
	"time"

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

// importPartitionedTable demonstrates specifing time partitioning for a BigQuery table when loading
// CSV data from Cloud Storage.
func importPartitionedTable(projectID, destDatasetID, destTableID 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-by-date.csv")
	gcsRef.SkipLeadingRows = 1
	gcsRef.Schema = bigquery.Schema{
		{Name: "name", Type: bigquery.StringFieldType},
		{Name: "post_abbr", Type: bigquery.StringFieldType},
		{Name: "date", Type: bigquery.DateFieldType},
	}
	loader := client.Dataset(destDatasetID).Table(destTableID).LoaderFrom(gcsRef)
	loader.TimePartitioning = &bigquery.TimePartitioning{
		Field:      "date",
		Expiration: 90 * 24 * time.Hour,
	}
	loader.WriteDisposition = bigquery.WriteEmpty

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

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

Java

Antes de probar este ejemplo, sigue las Javainstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Java de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

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.JobId;
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;
import com.google.cloud.bigquery.TimePartitioning;
import java.time.Duration;
import java.time.temporal.ChronoUnit;
import java.util.UUID;

public class LoadPartitionedTable {

  public static void runLoadPartitionedTable() throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String sourceUri = "/path/to/file.csv";
    loadPartitionedTable(datasetName, tableName, sourceUri);
  }

  public static void loadPartitionedTable(String datasetName, String tableName, String sourceUri)
      throws Exception {
    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);

      Schema schema =
          Schema.of(
              Field.of("name", StandardSQLTypeName.STRING),
              Field.of("post_abbr", StandardSQLTypeName.STRING),
              Field.of("date", StandardSQLTypeName.DATE));

      // Configure time partitioning. For full list of options, see:
      // https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#TimePartitioning
      TimePartitioning partitioning =
          TimePartitioning.newBuilder(TimePartitioning.Type.DAY)
              .setField("date")
              .setExpirationMs(Duration.of(90, ChronoUnit.DAYS).toMillis())
              .build();

      LoadJobConfiguration loadJobConfig =
          LoadJobConfiguration.builder(tableId, sourceUri)
              .setFormatOptions(FormatOptions.csv())
              .setSchema(schema)
              .setTimePartitioning(partitioning)
              .build();

      // Create a job ID so that we can safely retry.
      JobId jobId = JobId.of(UUID.randomUUID().toString());
      Job loadJob = bigquery.create(JobInfo.newBuilder(loadJobConfig).setJobId(jobId).build());

      // Load data from a GCS parquet file into the table
      // Blocks until this load table job completes its execution, either failing or succeeding.
      Job completedJob = loadJob.waitFor();

      // Check for errors
      if (completedJob == null) {
        throw new Exception("Job not executed since it no longer exists.");
      } else if (completedJob.getStatus().getError() != null) {
        // You can also look at queryJob.getStatus().getExecutionErrors() for all
        // errors, not just the latest one.
        throw new Exception(
            "BigQuery was unable to load into the table due to an error: \n"
                + loadJob.getStatus().getError());
      }
      System.out.println("Data successfully loaded into time partitioned table during load job");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println(
          "Data not loaded into time partitioned table during load job \n" + e.toString());
    }
  }
}

Node.js

Antes de probar este ejemplo, sigue las Node.jsinstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Node.js de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

// 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 CSV file at
 * https://storage.googleapis.com/cloud-samples-data/bigquery/us-states/us-states.csv
 *
 * TODO(developer): Replace the following lines with the path to your file.
 */
const bucketName = 'cloud-samples-data';
const filename = 'bigquery/us-states/us-states-by-date.csv';

async function loadTablePartitioned() {
  // Load data into a table that uses column-based time partitioning.

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

  // Configure the load job. For full list of options, see:
  // https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#JobConfigurationLoad
  const partitionConfig = {
    type: 'DAY',
    expirationMs: '7776000000', // 90 days
    field: 'date',
  };

  const metadata = {
    sourceFormat: 'CSV',
    skipLeadingRows: 1,
    schema: {
      fields: [
        {name: 'name', type: 'STRING'},
        {name: 'post_abbr', type: 'STRING'},
        {name: 'date', type: 'DATE'},
      ],
    },
    location: 'US',
    timePartitioning: partitionConfig,
  };

  // 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.`);
}

Python

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

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

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"),
        bigquery.SchemaField("date", "DATE"),
    ],
    skip_leading_rows=1,
    time_partitioning=bigquery.TimePartitioning(
        type_=bigquery.TimePartitioningType.DAY,
        field="date",  # Name of the column to use for partitioning.
        expiration_ms=7776000000,  # 90 days.
    ),
)
uri = "gs://cloud-samples-data/bigquery/us-states/us-states-by-date.csv"

load_job = client.load_table_from_uri(
    uri, table_id, job_config=job_config
)  # Make an API request.

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

table = client.get_table(table_id)
print("Loaded {} rows to table {}".format(table.num_rows, table_id))

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 CSV.
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 Delimitador de campos, elige el carácter que separa las celdas de tu archivo CSV: Coma, Tabulación, Barra vertical o Personalizado. Si elige Personalizado, introduzca el delimitador en el cuadro Delimitador de campo personalizado. El valor predeterminado es Coma.
   • En Coincidencia de columnas de origen, elija una de las siguientes estrategias para asociar las columnas cargadas al esquema (Vista previa).
   • Default: el comportamiento predeterminado se elige en función de cómo se proporcione el esquema. Si la detección automática está habilitada, el comportamiento predeterminado es hacer coincidir las columnas por nombre. De lo contrario, las columnas se emparejarán por posición de forma predeterminada. Esto se hace para mantener la retrocompatibilidad.
   • Position: hace coincidir las columnas por posición, suponiendo que las columnas están ordenadas de la misma forma que el esquema.
   • Name: se basa en el nombre. Para ello, lee la fila de encabezado como los nombres de las columnas y reordena las columnas para que coincidan con los nombres de los campos del esquema. Los nombres de las columnas se leen de la última fila omitida en función de Filas de encabezado que se van a omitir.
   • En Filas de encabezado que se deben omitir, introduce el número de filas de encabezado que se deben omitir en la parte superior del archivo CSV. El valor predeterminado es 0.
   • En Saltos de línea entrecomillados, marca Permitir saltos de línea entrecomillados para permitir secciones de datos entrecomilladas que contengan caracteres de salto de línea en un archivo CSV. El valor predeterminado es false.
   • En Filas escalonadas, marca Permitir filas escalonadas para aceptar filas en archivos CSV a las que les falten columnas opcionales finales. Los valores que faltan se tratan como nulos. Si no se marca, los registros a los que les faltan columnas finales se tratan como registros incorrectos y, si hay demasiados, se devuelve un error no válido en el resultado del trabajo. El valor predeterminado es false.
   • En Marcadores nulos, introduce una lista de cadenas personalizadas que representen un valor NULL en los datos CSV. Vista previa.
   • 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 CSV 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 = 'CSV',
     uris = ['gs://bucket/path/file.csv']);

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 CSV 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. Si no especifica un esquema, --autodetect es false y la tabla de destino existe, se usará el esquema de la tabla de destino.

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:

• --allow_jagged_rows: cuando se especifica, acepta las filas de los archivos CSV a las que les faltan columnas opcionales finales. Los valores que faltan se tratan como nulos. Si no se marca, los registros a los que les faltan columnas finales se tratan como registros incorrectos y, si hay demasiados registros incorrectos, se devuelve un error no válido en el resultado del trabajo. El valor predeterminado es false.
• --allow_quoted_newlines: cuando se especifica, permite secciones de datos entre comillas que contienen caracteres de salto de línea en un archivo CSV. El valor predeterminado es false.
• --field_delimiter: carácter que indica el límite entre las columnas de los datos. Se pueden usar tanto \t como tab para delimitar las pestañas. El valor predeterminado es ,.
• --null_marker: cadena personalizada opcional que representa un valor NULL en los datos CSV.
• --null_markers: (Vista previa) Lista opcional separada por comas de cadenas personalizadas que representan valores NULL en datos CSV. Esta opción no se puede usar con la marca --null_marker.
• --source_column_match: (Vista previa) Especifica la estrategia utilizada para asociar las columnas cargadas al esquema. Puedes especificar POSITION para que coincidan las columnas cargadas por posición, siempre que las columnas estén ordenadas de la misma forma que el esquema. También puede especificar NAME para que se haga la coincidencia por nombre leyendo la fila de encabezado como los nombres de las columnas y reordenando las columnas para que coincidan con los nombres de los campos del esquema. Si no se especifica ningún valor, el valor predeterminado se basa en cómo se proporciona el esquema. Si --autodetect está habilitada, el comportamiento predeterminado es hacer coincidir las columnas por nombre. De lo contrario, las columnas se emparejarán por posición de forma predeterminada.
• --skip_leading_rows: especifica el número de filas de encabezado que se deben omitir en la parte superior del archivo CSV. El valor predeterminado es 0.
• --quote: carácter de comillas que se usa para delimitar los registros. El valor predeterminado es ". Para indicar que no hay ningún carácter de comillas, usa una cadena vacía.
• --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

donde:

• location es tu ubicación. La marca --location es opcional. Puedes definir un valor predeterminado para la ubicación mediante el archivo.bigqueryrc.
• format es CSV.
• dataset es un conjunto de datos.
• table es el nombre de la tabla en la que se cargan los datos.
• path_to_source es un URI de Cloud Storage completo o una lista de URIs 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 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.csv 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=CSV \
    mydataset.mytable \
    gs://mybucket/mydata.csv

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

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

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. Ten en cuenta que también se admiten comodines.

4. Especifica el formato de los datos asignando el valor CSV 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"
)

// importCSVTruncate demonstrates loading data from CSV data in Cloud Storage and overwriting/truncating
// data in the existing table.
func importCSVTruncate(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.csv")
	gcsRef.SourceFormat = bigquery.CSV
	gcsRef.AutoDetect = true
	gcsRef.SkipLeadingRows = 1
	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.FormatOptions;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.JobInfo.WriteDisposition;
import com.google.cloud.bigquery.LoadJobConfiguration;
import com.google.cloud.bigquery.TableId;

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

  public static void runLoadCsvFromGcsTruncate() throws Exception {
    // 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.csv";
    loadCsvFromGcsTruncate(datasetName, tableName, sourceUri);
  }

  public static void loadCsvFromGcsTruncate(String datasetName, String tableName, String sourceUri)
      throws Exception {
    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 configuration =
          LoadJobConfiguration.builder(tableId, sourceUri)
              .setFormatOptions(FormatOptions.csv())
              // Set the write disposition to overwrite existing table data
              .setWriteDisposition(WriteDisposition.WRITE_TRUNCATE)
              .build();

      // For more information on Job see:
      // https://googleapis.dev/java/google-cloud-clients/latest/index.html?com/google/cloud/bigquery/package-summary.html
      // Load the table
      Job loadJob = bigquery.create(JobInfo.of(configuration));

      // Load data from a GCS parquet file into the table
      // Blocks until this load table job completes its execution, either failing or succeeding.
      Job completedJob = loadJob.waitFor();

      // Check for errors
      if (completedJob == null) {
        throw new Exception("Job not executed since it no longer exists.");
      } else if (completedJob.getStatus().getError() != null) {
        // You can also look at queryJob.getStatus().getExecutionErrors() for all
        // errors, not just the latest one.
        throw new Exception(
            "BigQuery was unable to load into the table due to an error: \n"
                + loadJob.getStatus().getError());
      }
      System.out.println("Table is successfully overwritten by CSV file loaded from GCS");
    } 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 CSV file at
 * https://storage.googleapis.com/cloud-samples-data/bigquery/us-states/us-states.csv
 *
 * TODO(developer): Replace the following lines with the path to your file.
 */
const bucketName = 'cloud-samples-data';
const filename = 'bigquery/us-states/us-states.csv';

async function loadCSVFromGCSTruncate() {
  /**
   * 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: 'CSV',
    skipLeadingRows: 1,
    schema: {
      fields: [
        {name: 'name', type: 'STRING'},
        {name: 'post_abbr', type: 'STRING'},
      ],
    },
    // Set the write disposition to overwrite existing table data.
    writeDisposition: 'WRITE_TRUNCATE',
    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;
  }
}

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.csv';
$loadConfig = $table->loadFromStorage($gcsUri)->skipLeadingRows(1)->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

import six

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 = six.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.CSV,
    skip_leading_rows=1,
)

uri = "gs://cloud-samples-data/bigquery/us-states/us-states.csv"
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))