Carga datos de CSV desde Cloud Storage

Cuando cargas datos de CSV desde Cloud Storage, puedes subirlos en una tabla o una partición nuevas. También puedes adjuntarlos a una tabla o una partición existentes o reemplazar los datos de ellas. Cuando tus datos se cargan en BigQuery, se convierten en formato de columnas para Capacitor (formato de almacenamiento de BigQuery).

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

Para obtener información sobre la carga de datos de CSV desde un archivo local, consulta Carga datos desde una fuente de datos local.

Pruébalo tú mismo

Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de BigQuery en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

Probar BigQuery gratis

Limitaciones

Estás sujeto a las siguientes limitaciones cuando cargas datos en BigQuery desde un bucket de Cloud Storage:

• Si la ubicación de tu conjunto de datos está configurada en un valor diferente a la multirregión US, el bucket de Cloud Storage debe estar en la misma región o multirregión que el conjunto de datos.
• BigQuery no garantiza la coherencia de los datos provenientes de fuentes de datos externas. Los cambios en los datos subyacentes mientras se ejecuta una consulta pueden dar como resultado un comportamiento inesperado.
• BigQuery no es compatible con el control de versiones de objetos de Cloud Storage. Si incluyes un número de generación en el URI de Cloud Storage, el trabajo de carga fallará.

Cuando cargues archivos CSV en BigQuery, ten en cuenta lo siguiente:

• Los archivos CSV no admiten datos anidados o repetidos.
• Quita los caracteres de marca de orden de bytes (BOM). Pueden causar problemas inesperados.
• Si usas la compresión gzip, BigQuery no puede leer los datos en paralelo. Cargar datos de CSV comprimidos en BigQuery es más lento que subir datos sin comprimir. Consulta Cómo cargar datos comprimidos y sin comprimir.
• No puedes incluir archivos comprimidos y descomprimidos en el mismo trabajo de carga.
• El tamaño máximo de un archivo gzip es de 4 GB.
• La carga de datos de CSV con la detección automática de esquemas no detecta automáticamente los encabezados si todas las columnas son tipos de strings. En este caso, agrega una columna numérica a la entrada o declara el esquema de forma explícita.
• Cuando cargues datos CSV o JSON, en los valores de las columnas DATE, se debe usar el separador de guion (-), y la fecha debe estar en el siguiente formato: YYYY-MM-DD (año-mes-día).
• Cuando cargues datos JSON o CSV, en los valores de las columnas TIMESTAMP, se debe usar un separador de guion (-) o barra (/) para la parte de fecha de la marca de tiempo, y la fecha debe tener uno de los siguientes formatos: YYYY-MM-DD (año-mes-día) o YYYY/MM/DD (año/mes/día). En la parte de hh:mm:ss (horas-minutos-segundos) de la marca de tiempo, se debe usar un separador de dos puntos (:).
• Tus archivos deben cumplir con los límites de tamaño de archivo CSV descritos en los límites de trabajos de carga.

Antes de comenzar

Otorga roles de Identity and Access Management (IAM) que otorguen a los usuarios los permisos necesarios para hacer cada tarea de este documento y crea un conjunto de datos para almacenar tus datos.

Permisos necesarios

Si deseas cargar datos en BigQuery, necesitas permisos de IAM para ejecutar un trabajo de carga y subir datos en tablas y particiones de BigQuery. Si cargas datos desde Cloud Storage, también necesitas permisos de IAM para acceder al bucket que contiene tus datos.

Permisos para cargar datos a BigQuery

Para cargar datos en una tabla o partición de BigQuery nueva o bien agregar o reemplazar una tabla o partición existente, necesitas los siguientes permisos de IAM:

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

Cada una de las siguientes funciones predefinidas de IAM incluye los permisos que necesitas para cargar datos en una tabla o partición de BigQuery:

• roles/bigquery.dataEditor
• roles/bigquery.dataOwner
• roles/bigquery.admin (incluye el permiso bigquery.jobs.create)
• bigquery.user (incluye el permiso bigquery.jobs.create)
• bigquery.jobUser (incluye el permiso bigquery.jobs.create)

Además, si tienes el permiso bigquery.datasets.create, puedes crear y actualizar tablas con un trabajo de carga en los conjuntos de datos que crees.

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

Permisos para subir datos desde Cloud Storage

Para obtener los permisos que necesitas para cargar datos desde un bucket de Cloud Storage, pídele a tu administrador que te otorgue el rol de IAM Administrador de almacenamiento (roles/storage.admin) en el bucket. Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

Este rol predefinido contiene los permisos necesarios para cargar datos desde un bucket de Cloud Storage. Para ver los permisos exactos que son necesarios, expande la sección Permisos requeridos:

Permisos necesarios

Los siguientes permisos son necesarios para cargar datos desde un bucket de Cloud Storage:

• storage.buckets.get
• storage.objects.get
• storage.objects.list (required if you are using a URI wildcard)

También puedes obtener estos permisos con roles personalizados o con otros roles predefinidos.

Crea un conjunto de datos

Crea un conjunto de datos de BigQuery para almacenar tus datos.

Compresión de CSV

Puedes usar la utilidad gzip para comprimir archivos CSV. Ten en cuenta que gzip realiza la compresión completa de archivos, a diferencia de la compresión de contenido de archivos que realizan los códecs de compresión para otros formatos de archivo, como Avro. El uso de gzip para comprimir los archivos CSV puede tener un impacto en el rendimiento. Para obtener más información sobre las compensaciones, consulta Carga datos comprimidos y sin comprimir.

Carga datos CSV en una tabla

Para cargar datos de CSV desde Cloud Storage en una tabla nueva de BigQuery, selecciona una de las siguientes opciones:

Console

---

Para seguir la guía paso a paso sobre esta tarea directamente en el editor de Cloud Shell, haz clic en Guiarme:

GUIARME

---

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

   Ir a BigQuery

2. En el panel Explorador, expande tu proyecto y, luego, elige un conjunto de datos.
3. En la sección Información del conjunto de datos, haz clic en Crear tabla.
4. En el panel Crear tabla, especifica los siguientes detalles:
1. En la sección Fuente, elige Google Cloud Storage en la lista Crear tabla desde. A continuación, sigue estos pasos:
   1. Elige un archivo del bucket de Cloud Storage o escribe el URI de Cloud Storage. No puedes incluir múltiples URI en la consola de Google Cloud, pero se admiten comodines. El bucket de Cloud Storage debe estar en la misma ubicación que el conjunto de datos que contiene la tabla que deseas crear, agregar o reemplazar.
   2. Para Formato del archivo, selecciona CSV.
2. En la sección Destino, especifica los siguientes detalles:
   1. En Conjunto de datos, elige el conjunto de datos en el que deseas crear la tabla.
   2. En el campo Tabla, escribe el nombre de la tabla que deseas crear.
   3. Verifica que el campo Tipo de tabla esté configurado como Tabla nativa.
3. En la sección Esquema, ingresa la definición del esquema. Para habilitar la detección automática de un esquema, selecciona Detección automática. Puedes ingresar la información del esquema de forma manual mediante uno de los siguientes métodos:
   • Opción 1: Haz clic en Editar como texto y pega el esquema con el formato de un array JSON. Cuando usas un array JSON, generas el esquema mediante el mismo proceso que se usa para crear un archivo de esquema JSON. Puedes ver el esquema de una tabla existente en formato JSON si ingresas el siguiente comando:

         bq show --format=prettyjson dataset.table
         

   • Opción 2: Haz clic en Agregar campo y, luego, ingresa el esquema de la tabla. Especifica el Nombre, el Tipo y el Modo de cada campo.
4. Opcional: Especifica Configuración de particiones y clústeres. Para obtener más información, consulta Crea tablas particionadas y Crea y usa tablas agrupadas en clústeres.
5. Haz clic en Opciones avanzadas y haz lo siguiente:
   • En Preferencia de escritura, deja elegido Escribir si está vacía. Con esta opción, se crea una tabla nueva y se cargan los datos en ella.
   • En Cantidad de errores permitidos, acepta el valor predeterminado de 0 o ingresa la cantidad máxima de filas con errores que pueden ignorarse. Si la cantidad de filas con errores excede este valor, el trabajo generará un mensaje de invalid y fallará. Esta opción se aplica solo a los archivos CSV y JSON.
   • Si deseas 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 en tu archivo CSV: Coma, Tabulador, Barra vertical o Personalizado. Si eliges Personalizado, debes ingresar el delimitador en la casilla Delimitador de campos personalizado. El valor predeterminado es Coma.
   • En Filas del encabezado que se omitirán, ingresa la cantidad de filas de encabezado que se omitirán en la parte superior del archivo CSV. El valor predeterminado es 0.
   • En Saltos de línea en secciones entrecomilladas, marca Permitir saltos de línea en secciones entrecomilladas 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 irregulares, marca Permitir filas irregulares para aceptar filas en archivos CSV a las que les falten columnas opcionales finales. Los valores faltantes se consideran nulos. Si no se marca esta opción, los registros en los que faltan columnas finales se tratan como registros incorrectos y, si hay demasiados, se muestra un error no válido en el resultado del trabajo. El valor predeterminado es false.
   • En Encriptación, haz clic en Clave administrada por el cliente para usar una clave de Cloud Key Management Service. Si dejas establecida la configuración del parámetro Clave administrada por Google, BigQuery encripta los datos en reposo.
6. Haga clic en Create table.

Nota: Cuando se cargan datos en una tabla vacía a través de la consola de Google Cloud, no se puede agregar una etiqueta, descripción ni el vencimiento de una tabla ni partición.

Una vez creada la tabla, con la consola de Google Cloud puedes actualizar el vencimiento, la descripción y las etiquetas de la tabla, pero no se puede agregar un vencimiento de la partición. Para obtener más información, consulta Administra tablas.

SQL

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

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

   Ir a BigQuery

2. En el editor de consultas, escribe la siguiente sentencia:

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

3. Haz clic en Ejecutar.

Si deseas obtener información sobre cómo ejecutar consultas, visita Ejecuta una consulta interactiva.

bq

Usa el comando bq load, especifica CSV con la marca --source_format e incluye un URI de Cloud Storage. Puedes incluir un único URI, una lista de URI separados por comas o un URI que contenga un comodín. Proporciona el esquema intercalado con un archivo de definición de esquema o usa la detección automática de esquemas. Si no especificas un esquema y --autodetect es false, y la tabla de destino existe, se usa el esquema de la tabla de destino.

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

Las siguientes son otras marcas opcionales:

• --allow_jagged_rows: Cuando se especifica, se aceptan filas de archivos CSV a las que les faltan columnas opcionales finales. Los valores faltantes se consideran nulos. Si no se marca esta opción, los registros en los que faltan columnas finales se tratan como registros incorrectos y, si hay demasiados, se muestra un error no válido en el resultado del trabajo. El valor predeterminado es false.
• --allow_quoted_newlines: cuando se especifica, permite secciones de datos entrecomillados que contienen caracteres de salto de línea en un archivo CSV. El valor predeterminado es false.
• --field_delimiter: el carácter que indica el límite entre las columnas en los datos. \t y tab pueden ser delimitadores de tabulación. El valor predeterminado es ,.
• --null_marker: una string personalizada opcional que representa un valor NULL en los datos de CSV.
• --skip_leading_rows: especifica la cantidad de filas de encabezado que se omiten en la parte superior del archivo CSV. El valor predeterminado es 0.
• --quote: El carácter de comillas que se usará para encerrar registros. El valor predeterminado es ". Para indicar que no hay ningún carácter de comilla, usa una string vacía.
• --max_bad_records: Un número entero que especifica la cantidad máxima de registros incorrectos permitidos antes de que falle todo el trabajo. El valor predeterminado es 0. Como máximo, se muestran cinco errores de cualquier tipo, sin importar el valor --max_bad_records.
• --ignore_unknown_values: Cuando se especifica, permite y también ignora valores extras no reconocidos en datos CSV o JSON.
• --autodetect: Cuando se especifica, se habilita la detección automática de esquemas para los datos de formato CSV y JSON.
• --time_partitioning_type: Habilita las particiones basadas en el tiempo en una tabla y establece el tipo de partición. Los valores posibles son HOUR, DAY, MONTH y YEAR. Esta marca es opcional cuando se crea una tabla particionada en una columna DATE, DATETIME o TIMESTAMP. El tipo de partición predeterminado para la partición basada en el tiempo es DAY. No puedes cambiar la especificación de partición de una tabla existente.
• --time_partitioning_expiration: Un número entero que especifica (en segundos) cuándo se debe borrar una partición basada en el tiempo. La hora de vencimiento se evalúa según la suma de la fecha de la partición en formato UTC más el valor del número entero.
• --time_partitioning_field: La columna DATE o TIMESTAMP que se usa para crear una tabla particionada. Si la partición basada en el tiempo se habilita sin este valor, se creará una tabla particionada por tiempo de transferencia.
• --require_partition_filter: Cuando se habilita esta opción, se solicita a los usuarios que incluyan una cláusula WHERE que especifique las particiones que se desean consultar. Exigir un filtro de partición puede reducir los costos y mejorar el rendimiento. Para obtener más información, lee Consulta tablas particionadas.
• --clustering_fields: Una lista separada por comas de hasta cuatro nombres de columna que se usa para crear una tabla agrupada en clústeres.
• --destination_kms_key: Es la clave de Cloud KMS para la encriptación de los datos de la tabla.

• --column_name_character_map: Define el alcance y el manejo 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 los archivos CSV. Para obtener más información, consulta load_option_list.

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

  • Referencia de la línea de comandos

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

  • Crea tablas particionadas

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

  • Crea y usa tablas agrupadas

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

  • Protege datos con claves de Cloud KMS

Para cargar datos de CSV en BigQuery, ingresa el siguiente comando:

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

Aquí:

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

Ejemplos:

El siguiente comando carga datos de gs://mybucket/mydata.csv a 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 a 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 suponer 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 a una tabla particionada por tiempo de transferencia llamada mytable en mydataset. El esquema se define en un archivo de esquema local llamado myschema.json.

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

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

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

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

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

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

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

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

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

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

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

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

API

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

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

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

4. Configura la propiedad sourceFormat como CSV para especificar el formato de datos de CSV.

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

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

Notas de API:

• Los trabajos de carga son atómicos y coherentes. Es decir, si falla uno, ninguno de los datos estará disponible y si uno se hace con éxito, todos los datos estarán disponibles.

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

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

C#

Antes de probar este ejemplo, sigue las instrucciones de configuración para C# incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para C#.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

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

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

Antes de probar este ejemplo, sigue las instrucciones de configuración para Java incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Java.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

Antes de probar este ejemplo, sigue las instrucciones de configuración para Node.js incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Node.js.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas 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.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

Antes de probar este ejemplo, sigue las instrucciones de configuración para PHP incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para PHP.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

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

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

Usa el método Client.load_table_from_uri() para cargar datos desde un archivo de CSV a Cloud Storage. Proporciona una definición de esquema explícita. Para ello, define la propiedad LoadJobConfig.schema en una lista de objetos SchemaField.

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

Antes de probar este ejemplo, sigue las instrucciones de configuración para Ruby incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Ruby.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

Carga datos CSV en una tabla que usa partición de tiempo basada en columnas

Para cargar datos CSV de Cloud Storage en una tabla de BigQuery que usa partición de tiempo basada en columnas, haz lo siguiente:

Go

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

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas 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 instrucciones de configuración para Java incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Java.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas 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 instrucciones de configuración para Node.js incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Node.js.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas 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 instrucciones de configuración para Python incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Python.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas 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))

Anexa o reemplaza una tabla con datos CSV

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

En la consola de Google Cloud, usa la opción de Preferencia de escritura para especificar qué acción se debe tomar cuando cargues datos desde un archivo de origen o desde el resultado de una consulta.

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

Opción de Console	Marca de la herramienta de bq	Propiedad de la API de BigQuery	Descripción
Realiza la operación de escritura si la tabla está vacía.	No compatible	WRITE_EMPTY	Solo escribe los datos si la tabla está vacía.
Adjuntar a la tabla	--noreplace o --replace=false; si no se especifica --[no]replace, la opción predeterminada es agregar	WRITE_APPEND	Agrega los datos al final de la tabla (predeterminado).
Reemplazar tabla	--replace o --replace=true.	WRITE_TRUNCATE	Borra todos los datos existentes de una tabla antes de escribir los datos nuevos. Esta acción también borra el esquema de la tabla, la seguridad a nivel de las filas y quita cualquier clave de Cloud KMS.

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

Nota: En esta página, no se explica cómo reemplazar tablas particionadas ni cómo agregarles datos. Para obtener información sobre cómo agregar y reemplazar tablas particionadas, consulta Anexa y reemplaza datos de tablas particionadas.

Console

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

   Ir a BigQuery

2. En el panel Explorador, expande tu proyecto y, luego, elige un conjunto de datos.
3. En la sección Información del conjunto de datos, haz clic en Crear tabla.
4. En el panel Crear tabla, especifica los siguientes detalles:
1. En la sección Fuente, elige Google Cloud Storage en la lista Crear tabla desde. A continuación, sigue estos pasos:
   1. Elige un archivo del bucket de Cloud Storage o escribe el URI de Cloud Storage. No puedes incluir múltiples URI en la consola de Google Cloud, pero se admiten comodines. El bucket de Cloud Storage debe estar en la misma ubicación que el conjunto de datos que contiene la tabla que deseas crear, agregar o reemplazar.
   2. Para Formato del archivo, selecciona CSV.
Nota: Es posible modificar el esquema de la tabla cuando le agregas datos o la reemplazas. Para obtener más información sobre los cambios de esquema admitidos durante una operación de carga, consulta Modifica esquemas de tablas.
2. En la sección Destino, especifica los siguientes detalles:
   1. En Conjunto de datos, elige el conjunto de datos en el que deseas crear la tabla.
   2. En el campo Tabla, escribe el nombre de la tabla que deseas crear.
   3. Verifica que el campo Tipo de tabla esté configurado como Tabla nativa.
3. En la sección Esquema, ingresa la definición del esquema. Para habilitar la detección automática de un esquema, selecciona Detección automática. Puedes ingresar la información del esquema de forma manual mediante uno de los siguientes métodos:
   • Opción 1: Haz clic en Editar como texto y pega el esquema con el formato de un array JSON. Cuando usas un array JSON, generas el esquema mediante el mismo proceso que se usa para crear un archivo de esquema JSON. Puedes ver el esquema de una tabla existente en formato JSON si ingresas el siguiente comando:

         bq show --format=prettyjson dataset.table
         

   • Opción 2: Haz clic en Agregar campo y, luego, ingresa el esquema de la tabla. Especifica el Nombre, el Tipo y el Modo de cada campo.
   Nota: Es posible modificar el esquema de la tabla cuando le agregas datos o la reemplazas. Para obtener más información sobre los cambios de esquema admitidos durante una operación de carga, consulta Modifica esquemas de tablas.
4. Opcional: Especifica Configuración de particiones y clústeres. Para obtener más información, consulta Crea tablas particionadas y Crea y usa tablas agrupadas en clústeres. No puedes agregar datos a una tabla ni reemplazarla para convertirla en una tabla particionada o agrupada en clústeres. La consola de Google Cloud no admite agregar datos a tablas particionadas o agrupadas en clústeres ni reemplazarlas en un trabajo de carga.
5. Haz clic en Opciones avanzadas y haz lo siguiente:
   • En Preferencia de escritura, elige Agregar a la tabla o Reemplazar tabla.
   • En Cantidad de errores permitidos, acepta el valor predeterminado de 0 o ingresa la cantidad máxima de filas con errores que pueden ignorarse. Si la cantidad de filas con errores excede este valor, el trabajo generará un mensaje de invalid y fallará. Esta opción se aplica solo a los archivos CSV y JSON.
   • Si deseas 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 en tu archivo CSV: Coma, Tabulador, Barra vertical o Personalizado. Si eliges Personalizado, debes ingresar el delimitador en la casilla Delimitador de campos personalizado. El valor predeterminado es Coma.
   • En Filas del encabezado que se omitirán, ingresa la cantidad de filas de encabezado que se omitirán en la parte superior del archivo CSV. El valor predeterminado es 0.
   • En Saltos de línea en secciones entrecomilladas, marca Permitir saltos de línea en secciones entrecomilladas 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 irregulares, marca Permitir filas irregulares para aceptar filas en archivos CSV a las que les falten columnas opcionales finales. Los valores faltantes se consideran nulos. Si no se marca esta opción, los registros en los que faltan columnas finales se tratan como registros incorrectos y, si hay demasiados, se muestra un error no válido en el resultado del trabajo. El valor predeterminado es false.
   • En Encriptación, haz clic en Clave administrada por el cliente para usar una clave de Cloud Key Management Service. Si dejas establecida la configuración del parámetro Clave administrada por Google, BigQuery encripta los datos en reposo.
6. Haga clic en Create table.

SQL

Usa la declaración DDL LOAD DATA. En el siguiente ejemplo, se agrega un archivo CSV a la tabla mytable:

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

   Ir a BigQuery

2. En el editor de consultas, escribe la siguiente sentencia:

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

3. Haz clic en Ejecutar.

Si deseas obtener información sobre cómo ejecutar consultas, visita Ejecuta una consulta interactiva.

bq

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

Proporciona el esquema intercalado con un archivo de definición de esquema o usa la detección automática de esquemas. Si no especificas un esquema y --autodetect es false, y la tabla de destino existe, se usa el esquema de la tabla de destino.

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

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

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

Las siguientes son otras marcas opcionales:

• --allow_jagged_rows: Cuando se especifica, se aceptan filas de archivos CSV a las que les faltan columnas opcionales finales. Los valores faltantes se consideran nulos. Si no se marca esta opción, los registros en los que faltan columnas finales se tratan como registros incorrectos y, si hay demasiados, se muestra un error no válido en el resultado del trabajo. El valor predeterminado es false.
• --allow_quoted_newlines: cuando se especifica, permite secciones de datos entrecomillados que contienen caracteres de salto de línea en un archivo CSV. El valor predeterminado es false.
• --field_delimiter: el carácter que indica el límite entre las columnas en los datos. \t y tab pueden ser delimitadores de tabulación. El valor predeterminado es ,.
• --null_marker: una string personalizada opcional que representa un valor NULL en los datos de CSV.
• --skip_leading_rows: especifica la cantidad de filas de encabezado que se omiten en la parte superior del archivo CSV. El valor predeterminado es 0.
• --quote: El carácter de comillas que se usará para encerrar registros. El valor predeterminado es ". Para indicar que no hay ningún carácter de comilla, usa una string vacía.
• --max_bad_records: Un número entero que especifica la cantidad máxima de registros incorrectos permitidos antes de que falle todo el trabajo. El valor predeterminado es 0. Como máximo, se muestran cinco errores de cualquier tipo, sin importar el valor --max_bad_records.
• --ignore_unknown_values: Cuando se especifica, permite y también ignora valores extras no reconocidos en datos CSV o JSON.
• --autodetect: Cuando se especifica, se habilita la detección automática de esquemas para los datos de formato CSV y JSON.
• --destination_kms_key: Es la clave de Cloud KMS para la encriptación de los datos de la tabla.

bq --location=location load \
--[no]replace \
--source_format=format \
dataset.table \
path_to_source \
schema

aquí:

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

Ejemplos:

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

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

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

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

API

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

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

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

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

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

Go

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

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

Antes de probar este ejemplo, sigue las instrucciones de configuración para Java incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Java.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

Antes de probar este ejemplo, sigue las instrucciones de configuración para Node.js incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Node.js.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

Para reemplazar las filas en una tabla existente, establece el valor writeDisposition en el parámetro metadata en 'WRITE_TRUNCATE'.

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

Antes de probar este ejemplo, sigue las instrucciones de configuración para PHP incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para PHP.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

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

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

Para reemplazar las filas de una tabla existente, configura la propiedad LoadJobConfig.write_disposition como la constante WRITE_TRUNCATE de SourceFormat.

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

Carga datos CSV con particiones de subárbol

BigQuery admite la carga de datos de CSV con particiones de subárbol almacenados en Cloud Storage y propagará las columnas de partición de subárbol como columnas en la tabla administrada de BigQuery de destino. Para obtener más información, consulta Carga datos particionados de forma externa de Cloud Storage.

Detalles de la carga de datos de CSV

En esta sección, se describe cómo BigQuery maneja varias opciones de formato CSV.

Codificación

BigQuery espera que los datos CSV estén codificados en UTF-8. Si tienes archivos CSV con otros tipos de codificación compatibles, debes especificar la codificación de forma explícita para que BigQuery pueda convertir los datos en UTF-8 de manera correcta.

BigQuery es compatible con los siguientes tipos de codificación para los archivos CSV:

• UTF-8
• ISO-8859-1
• UTF-16BE (UTF-16 Big Endian)
• UTF-16LE (UTF-16 Little Endian)
• UTF-32BE (UTF-32 Big Endian)
• UTF-32LE (UTF-32 Little Endian)

Si no especificas una codificación o si especificas la codificación UTF-8 cuando el archivo CSV no está codificado en UTF-8, BigQuery intentará convertir los datos en UTF-8. Por lo general, si el archivo CSV está codificado en ISO-8859-1, los datos se cargarán con éxito, pero es posible que no coincidan exactamente con lo que esperas. Si el archivo CSV está codificado en UTF-16BE, UTF-16LE, UTF-32BE o UTF-32LE, es posible que la carga falle. Para evitar fallas inesperadas, especifica la codificación correcta con la marca --encoding.

Note: Si el archivo CSV está codificado en UTF-16BE, UTF-16LE, UTF-32BE o UTF-32LE, y la marca --allow_quoted_newlines se configura como true, y el archivo CSV tiene un límite de tamaño máximo de 1 GB.

Note: De forma predeterminada, si el archivo CSV contiene el carácter ASCII 0 (NULL), no puedes cargar los datos en BigQuery. Si deseas permitir el carácter ASCII 0 y otros caracteres de control ASCII, configura --preserve_ascii_control_characters=true en tus trabajos de carga.

Si BigQuery no puede convertir un carácter que no sea el carácter ASCII 0, BigQuery convierte el carácter en el carácter de reemplazo estándar de Unicode: �.

Delimitadores de campo

Los delimitadores en archivos CSV pueden ser cualquier carácter de un solo byte. Si el archivo de origen usa la codificación ISO-8859-1, cualquier carácter puede ser un delimitador. Si el archivo de origen usa la codificación UTF-8, se puede usar cualquier carácter en el rango decimal 1-127 (U+0001-U+007F) sin modificaciones. Puedes insertar un carácter ISO-8859-1 fuera de este rango como delimitador y BigQuery lo interpretará de forma correcta. Sin embargo, si usas un carácter de varios bytes como delimitador, algunos de los bytes se interpretarán de manera incorrecta como parte del valor del campo.

Por lo general, se recomienda usar un delimitador estándar, como una tabulación, una barra vertical o una coma. El valor predeterminado es una coma.

Tipos de datos

Booleano. BigQuery puede analizar cualquiera de los siguientes pares para datos booleanos: 1 o 0, true o false, t o f, yes o no, y o n (todos distinguen entre mayúsculas y minúsculas). La detección automática de esquemas detecta de forma automática cualquiera de estas opciones, excepto 0 y 1.

Bytes. Las columnas con tipos BYTES deben codificarse como Base64.

Fecha. Las columnas con tipos DATE deben tener el formato YYYY-MM-DD.

Fecha y hora. Las columnas con tipos DATETIME deben tener el formato YYYY-MM-DD HH:MM:SS[.SSSSSS].

Geográficos. Las columnas con tipos GEOGRAPHY deben contener strings en uno de los siguientes formatos:

• Texto conocido (WKT)
• Objeto binario conocido (WKB)
• GeoJSON

Si usas WKB, el valor debe estar codificado en hexadecimal.

En la siguiente lista, se muestran ejemplos de datos válidos:

• WKT: POINT(1 2)
• GeoJSON: { "type": "Point", "coordinates": [1, 2] }
• WKB codificado en hexadecimal: 0101000000feffffffffffef3f0000000000000040

Antes de cargar datos de GEOGRAPHY, también consulta Carga datos geoespaciales.

Intervalo. Las columnas con tipos INTERVAL deben tener el formato Y-M D H:M:S[.F], en el que:

• Y = Año. El rango admitido es de 0 a 10,000.
• M = Mes. El rango admitido es de 1 a 12.
• D = Día. El rango admitido es de 1 a [último día del mes indicado].
• H = Hora.
• M = Minuto.
• S = Segundo.
• [.F] = Fracciones de un segundo hasta seis dígitos, con precisión de microsegundos.

Puedes indicar un valor negativo si antepones un guion (-).

En la siguiente lista, se muestran ejemplos de datos válidos:

• 10-6 0 0:0:0
• 0-0 -5 0:0:0
• 0-0 0 0:0:1.25

Para cargar datos de INTERVAL, debes usar el comando bq load y la marca --schema a fin de especificar un esquema. No puedes subir datos de INTERVAL mediante la consola.

JSON. Las comillas se evitan mediante la secuencia de dos caracteres "". Para obtener más información, consulta un ejemplo en la página sobre cómo cargar datos JSON desde un archivo CSV.

Hora. Las columnas con tipos TIME deben tener el formato HH:MM:SS[.SSSSSS].

Timestamp. BigQuery acepta varios formatos de marca de tiempo. La marca de tiempo debe incluir una parte de la fecha y una de la hora.

• La parte de la fecha puede tener el formato YYYY-MM-DD o YYYY/MM/DD.

• La parte de la marca de tiempo debe tener el formato HH:MM[:SS[.SSSSSS]] (los segundos y las fracciones de segundos son opcionales).

• La fecha y la hora deben estar separadas por un espacio o “T”.

• De forma opcional, la fecha y la hora pueden estar seguidas por una compensación UTC o el designador de zona UTC (Z). Para obtener más información, consulta Zonas horarias.

Por ejemplo, cualquiera de los siguientes son valores de marca de tiempo válidos:

• 2018-08-19 12:11
• 2018-08-19 12:11:35
• 2018-08-19 12:11:35.22
• 2018/08/19 12:11
• 2018-07-05 12:54:00 UTC
• 2018-08-19 07:11:35.220 -05:00
• 2018-08-19T12:11:35.220Z

Si proporcionas un esquema, BigQuery también acepta el tiempo Unix para los valores de marca de tiempo. Sin embargo, la detección automática de esquemas no detecta este caso y trata el valor como un tipo numérico o de string.

Ejemplos de valores de marca de tiempo de hora de Unix:

• 1534680695
• 1.534680695e11

RANGO. Se representa en archivos CSV en el formato [LOWER_BOUND, UPPER_BOUND), en el que LOWER_BOUND y UPPER_BOUND son cadenas DATE, DATETIME o TIMESTAMP válidas. NULL y UNBOUNDED representan valores de inicio o finalización no delimitados.

Nota: Dado que el formato CSV del rango contiene una coma, si el delimitador CSV es una coma, debe estar entre comillas dobles para que el archivo CSV sea válido.

Los siguientes son ejemplos de valores CSV para RANGE<DATE>:

• "[2020-01-01, 2021-01-01)"
• "[UNBOUNDED, 2021-01-01)"
• "[2020-03-01, NULL)"
• "[UNBOUNDED, UNBOUNDED)"

Detección automática de esquemas

En esta sección, se describe el comportamiento de la detección automática de esquema cuando se cargan archivos CSV.

Delimitador CSV

BigQuery detecta los siguientes delimitadores:

• coma ( , )
• barra vertical ( | )
• tabulador ( \t )

Encabezado CSV

BigQuery infiere los encabezados mediante la comparación de la primera fila del archivo con otras filas en el archivo. Si la primera línea solo contiene cadenas y las otras contienen otros tipos de datos, BigQuery supone que la primera fila es una fila de encabezado. BigQuery asigna nombres de columnas según los nombres de campo en la fila del encabezado. Los nombres pueden modificarse a fin de cumplir con las reglas de nomenclatura para las columnas en BigQuery. Por ejemplo, los espacios se reemplazarán con guiones bajos.

De lo contrario, BigQuery supone que la primera fila es una fila de datos y asigna nombres de columnas genéricos como string_field_1. Ten en cuenta que, después de que se crea una tabla, los nombres de las columnas no se pueden actualizar en el esquema, pero puedes cambiar los nombres de forma manual después de que se crea la tabla. Otra opción es proporcionar un esquema explícito, en lugar de usar la detección automática.

Es posible que tengas un archivo CSV con una fila de encabezado, en la que todos los campos de datos sean strings. En ese caso, BigQuery no detectará de manera automática que la primera fila es un encabezado. Usa la opción --skip_leading_rows para omitir la fila de encabezado. De lo contrario, el encabezado se importará como datos. También considera proporcionar un esquema explícito en este caso para que puedas asignar nombres de columnas.

Saltos de línea con comillas en CSV

BigQuery detecta los caracteres de línea nueva con comillas dentro de un campo CSV y no interpreta el carácter con comillas de la línea nueva como un límite de fila.

Soluciona errores de análisis

Si hay un problema cuando se analizan tus archivos CSV, el recurso errors del trabajo de carga se propaga con los detalles del error.

En general, estos errores identifican el inicio de la línea problemática con un desplazamiento de bytes. Para los archivos sin comprimir, puedes usar gcloud storage con el argumento --recursive así puedes acceder a la línea relevante.

Por ejemplo, ejecuta el comando bq load y recibe un error:

bq load
    --skip_leading_rows=1 \
    --source_format=CSV \
    mydataset.mytable \
    gs://my-bucket/mytable.csv \
    'Number:INTEGER,Name:STRING,TookOffice:STRING,LeftOffice:STRING,Party:STRING'

El error en el resultado es similar al siguiente:

Waiting on bqjob_r5268069f5f49c9bf_0000018632e903d7_1 ... (0s)
Current status: DONE
BigQuery error in load operation: Error processing job
'myproject:bqjob_r5268069f5f49c9bf_0000018632e903d7_1': Error while reading
data, error message: Error detected while parsing row starting at position: 1405.
Error: Data between close quote character (") and field separator.
File: gs://my-bucket/mytable.csv
Failure details:
- gs://my-bucket/mytable.csv: Error while reading data,
error message: Error detected while parsing row starting at
position: 1405. Error: Data between close quote character (") and
field separator. File: gs://my-bucket/mytable.csv
- Error while reading data, error message: CSV processing encountered
too many errors, giving up. Rows: 22; errors: 1; max bad: 0; error
percent: 0

Según el error anterior, hay un error de formato en el archivo. Para ver el contenido del archivo, ejecuta el comando gcloud storage cat:

gcloud storage cat 1405-1505 gs://my-bucket/mytable.csv --recursive

El resultado es similar a este:

16,Abraham Lincoln,"March 4, 1861","April 15, "1865,Republican
18,Ulysses S. Grant,"March 4, 1869",
...

Según el resultado del archivo, el problema es una cita mal ubicada en "April 15, "1865.

Archivos CSV comprimidos

La depuración de los errores de análisis es más difícil para los archivos CSV comprimidos, ya que el desplazamiento de bytes informado se refiere a la ubicación en el archivo sin comprimir. En el siguiente comando gcloud storage cat se transmite el archivo desde Cloud Storage, descomprime el archivo, identifica el desplazamiento de bytes adecuado y, luego, imprime la línea con el error de formato:

gcloud storage cat gs://my-bucket/mytable.csv.gz | gunzip - | tail -c +1406 | head -n 1

El resultado es similar a este:

16,Abraham Lincoln,"March 4, 1861","April 15, "1865,Republican

Opciones de CSV

Para cambiar la forma en que BigQuery analiza los datos de CSV, especifica opciones adicionales en la consola de Google Cloud, la herramienta de línea de comandos de bq o la API.

Para obtener más información sobre el formato CSV, consulta RFC 4180.

Opción CSV	Opción de Console	Marca de la herramienta de bq	Propiedad de la API de BigQuery	Descripción
Delimitador de campos	Delimitador de campos: coma, tabulador, barra vertical, o uno personalizado	-F o --field_delimiter.	fieldDelimiter (Java, Python)	El separador de campos de un archivo CSV (opcional). El separador puede ser cualquier carácter ISO-8859-1 de un solo byte. BigQuery convierte la string en codificación ISO-8859-1 y usa el primer byte de la string codificada para dividir los datos en su estado binario sin procesar. BigQuery también admite la secuencia de escape “\t” para especificar un separador de tabulador. El valor predeterminado es una coma (“,”).
Filas del encabezado	Filas del encabezado que se omitirán	--skip_leading_rows	skipLeadingRows (Java, Python)	Un número entero que indica la cantidad de filas de encabezado en los datos de origen (opcional).
Cantidad de registros incorrectos permitidos	Cantidad de errores permitidos	--max_bad_records	maxBadRecords (Java, Python)	El número máximo de registros erróneos que BigQuery puede ignorar cuando ejecuta el trabajo (opcional). Si la cantidad de registros incorrectos excede este valor, se muestra un error no válido en el resultado del trabajo. El valor predeterminado es 0, por lo que es obligatorio que todos los registros sean válidos.
Caracteres de saltos de línea	Permitir saltos de línea en secciones entrecomilladas	--allow_quoted_newlines	allowQuotedNewlines (Java, Python)	Indica si se deben permitir las secciones de datos entrecomillados que contienen caracteres de saltos de línea en un archivo CSV (opcional). El valor predeterminado es falso.
Valores nulos personalizados	Ninguno	--null_marker	nullMarker (Java, Python)	Especifica una string que representa un valor nulo en un archivo CSV (opcional). Por ejemplo, si especificas “\N”, BigQuery interpreta “\N” como un valor nulo cuando se carga un archivo CSV. El valor predeterminado es una string vacía. Si estableces esta propiedad como un valor personalizado, BigQuery muestra un error si hay una string vacía para todos los tipos de datos, excepto STRING y BYTE. Para las columnas STRING y BYTE, BigQuery interpreta la string vacía como un valor vacío.
Columnas opcionales finales	Permitir filas irregulares	--allow_jagged_rows	allowJaggedRows (Java, Python)	Acepta las filas que no contienen columnas opcionales finales (opcional). Los valores que faltan se consideran nulos. Si es falso, los registros en los que faltan columnas finales se tratan como registros incorrectos, y si hay demasiados, se muestra un error no válido en el resultado del trabajo. El valor predeterminado es falso. Aplica solo a CSV, se ignora para otros formatos.
Valores desconocidos	Ignorar valores desconocidos	--ignore_unknown_values	ignoreUnknownValues (Java, Python)	Indica si BigQuery debe permitir valores adicionales que no estén representados en el esquema de la tabla (opcional). Si es verdadero, los valores adicionales se ignoran. Si es falso, los registros con columnas adicionales se tratan como registros incorrectos, y si hay demasiados, se muestra un error no válido en el resultado del trabajo. El valor predeterminado es falso. Con la propiedad sourceFormat, se determina qué es lo que BigQuery trata como un valor adicional: CSV: columnas finales JSON: valores con nombre que no coinciden con ningún nombre de columna
Cotización	Carácter de comilla: Comillas dobles, Comillas simples, Ninguna, Personalizada	--quote	quote (Java, Python)	El valor que se usa para entrecomillar secciones de datos en un archivo CSV (opcional). BigQuery convierte la string en codificación ISO-8859-1 y, luego, usa el primer byte de la string codificada para dividir los datos en su estado binario sin procesar. El valor predeterminado es una comilla doble (“”). Si tus datos no contienen secciones entrecomilladas, establece el valor de la propiedad en una string vacía. Si los datos contienen caracteres de salto de línea entrecomillados, también debes establecer la propiedad allowQuotedNewlines en true. Para incluir el carácter de comillas específico dentro de un valor entrecomillado, coloca un carácter de comillas que coincida antes de él. Por ejemplo, si deseas escapar del carácter predeterminado ‘ " ’, usa ‘ "" ’.
Codificación	Ninguno	-E o --encoding.	encoding (Java, Python)	La codificación de caracteres de los datos (opcional). Los valores admitidos son UTF-8, ISO-8859-1, UTF-16BE, UTF-16LE, UTF-32BE o UTF-32LE. El valor predeterminado es UTF-8. BigQuery decodifica los datos luego de la división de los datos binarios sin procesar mediante los valores de las propiedades quote y fieldDelimiter.
Carácter de control ASCII	Ninguno	--preserve_ascii_control_characters	Ninguno	Si deseas permitir ASCII 0 y otros caracteres de control ASCII, configura --preserve_ascii_control_characters como true en tus trabajos de carga (opcional).