Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Datos de carga por lotes

Puedes cargar datos en BigQuery desde Cloud Storage o desde un archivo local como una operación por lotes. Los datos de origen pueden estar en cualquiera de los siguientes formatos:

  • Avro
  • Valores separados por comas (CSV)
  • JSON (delimitado por saltos de línea)
  • ORC
  • Parquet
  • Exportaciones de Firestore almacenadas en Cloud Storage

También puedes usar el Servicio de transferencia de datos de BigQuery para configurar cargas recurrentes de Cloud Storage a BigQuery.

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

Antes de comenzar

Otorga roles de Identity and Access Management (IAM) que otorguen a los usuarios los permisos necesarios para realizar cada tarea de este documento y crea un conjunto de datos a fin de 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 mediante 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 cargar datos desde Cloud Storage

Para cargar datos desde un bucket de Cloud Storage, necesitas los siguientes permisos de IAM:

  • storage.buckets.get
  • storage.objects.get
  • storage.objects.list (obligatorio si usas un comodín de URI)

Cree un conjunto de datos

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

Carga datos desde Cloud Storage

BigQuery es compatible con la carga de datos desde cualquiera de las siguientes clases de almacenamiento de Cloud Storage:

  • Estándar
  • Nearline
  • Coldline
  • Archivo

Si necesitas información para cargar datos en BigQuery, consulta la página de tu formato de datos:

Si necesitas información para configurar una carga recurrente de Cloud Storage a BigQuery, consulta Transferencias de Cloud Storage.

Consideraciones de ubicación

Cuando elijas una ubicación para tus datos, ten en cuenta esta información:

  • Coloca tus buckets de Cloud Storage en la misma ubicación para cargar datos.
    • Si tu conjunto de datos de BigQuery está en una multirregión, el bucket de Cloud Storage que contiene los datos que cargas debe estar en la misma multirregión o en una ubicación dentro de la multirregión. Por ejemplo, si tu conjunto de datos de BigQuery está en la multirregión `EU`, el bucket de Cloud Storage puede estar ubicado en la región `europe-west1` de Bélgica, que está dentro de EU.
    • Si tu conjunto de datos está en una región, el bucket de Cloud Storage debe estar en la misma región. Por ejemplo, si tu conjunto de datos está en la región `asia-northeast1` de Tokio, tu bucket de Cloud Storage no puede estar en la multirregión `ASIA`.
    • Excepción: Si el conjunto de datos está en la multirregión `US`, puedes cargar datos desde un bucket de Cloud Storage en cualquier ubicación.

Para obtener más información sobre las ubicaciones de Cloud Storage, consulta Ubicaciones de depósitos en la documentación de Cloud Storage.

No puedes cambiar la ubicación de un conjunto de datos después de crearlo, pero puedes hacer una copia de él o moverlo manualmente. Para obtener más información, consulta los siguientes recursos:

Recupera el URI de Cloud Storage

Para cargar los datos desde la fuente de datos de Cloud Storage, debes proporcionar el URI de Cloud Storage.

La ruta de acceso del recurso de Cloud Storage contiene el nombre del bucket y tu objeto (nombre del archivo). Por ejemplo, si el bucket de Cloud Storage se llama mybucket y el archivo de datos se llama myfile.csv, el la ruta a la fuente será gs://mybucket/myfile.csv. Si los datos se separan en varios archivos, puedes usar un comodín en la ruta.

BigQuery no es compatible con las rutas de recursos de Cloud Storage que incluyen múltiples barras consecutivas después de la doble barra inicial. Los nombres de los objetos de Cloud Storage pueden contener varios caracteres de barras consecutivas (“/”). Sin embargo, BigQuery convierte varias barras consecutivas en una sola barra. Por ejemplo, la siguiente ruta de acceso al recurso, aunque es válida en Cloud Storage, no funciona en BigQuery: gs://bucket/my//object//name.

Para recuperar la ruta del recurso de Cloud Storage, sigue estos pasos:

  1. Abre Cloud Storage Console.

    Consola de Cloud Storage

  2. Explora la ubicación del objeto (archivo) que contiene los datos de origen.

  3. Haz clic en el nombre del objeto.

    Se abrirá la página Detalles del objeto.

  4. Copia el valor proporcionado en el campo URI de gsutil, que comienza con gs://.

Compatibilidad con comodines para los URI de Cloud Storage

Si tus datos de Cloud Storage están separados en varios archivos que comparten un nombre base común, puedes usar un comodín en el URI cuando cargues los datos.

Para agregar un comodín al URI de Cloud Storage, debes agregar un asterisco (*) al nombre base.

Ejemplos:

  • El siguiente URI comodín selecciona todos los archivos en todas las carpetas que comienzan con el prefijo gs://mybucket/fed-samples/fed-sample:

    gs://mybucket/fed-samples/fed-sample*
    
  • El siguiente URI de comodín solo selecciona archivos con una extensión .csv en la carpeta llamada fed-samples y cualquier subcarpeta de fed-samples:

    gs://mybucket/fed-samples/*.csv
    
  • El siguiente URI de comodín selecciona archivos con un patrón de nombres de fed-sample*.csv en la carpeta llamada fed-samples. En este ejemplo, no se seleccionan archivos en subcarpetas de fed-samples.

    gs://mybucket/fed-samples/fed-sample*.csv
    

Cuando usas la herramienta de línea de comandos de bq, es posible que debas descartar el asterisco en algunas plataformas.

Solo puedes usar un comodín para los objetos (nombres de archivos) dentro de tu bucket. El comodín puede aparecer dentro o al final del nombre del objeto. No se admite la adición de un comodín al nombre del bucket. No se admiten varios comodines en el URI de origen. Por ejemplo, la ruta gs://mybucket/fed-*/temp/*.csv no es válida.

Para las exportaciones de Google Datastore, solo se puede especificar un URI, que debe terminar con .backup_info o .export_metadata.

No se permite el carácter comodín de asterisco en los siguientes casos:

  • Cuando creas tablas externas vinculadas a exportaciones de Datastore o Firestore.
  • Cuando cargas datos de exportación de Datastore o Firestore desde Cloud Storage.

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 ubicació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á.

Según el formato de tus datos de origen de Cloud Storage, puede haber limitaciones adicionales. Para obtener más información, consulta los siguientes recursos:

Carga datos de archivos locales

Puedes cargar datos desde una fuente de datos legible (como tu máquina local) mediante una de las siguientes opciones:

  • Google Cloud Console
  • El comando bq load de la herramienta de línea de comandos de bq
  • La API
  • Las bibliotecas cliente

Cuando cargas datos mediante la consola de Google Cloud o la herramienta de línea de comandos de bq, se crea un trabajo de carga de forma automática.

Para cargar datos desde una fuente de datos local, sigue los pasos que se detallan a continuación:

Console

  1. Abre la página BigQuery en la consola de Google Cloud.

    Ir a la página de BigQuery

  2. En el panel Explorador, expande tu proyecto y selecciona un conjunto de datos.

  3. Expande la opción Acciones y haz clic en Abrir.

  4. En el panel de detalles, haz clic en Crear tabla  (Create table).

  5. En la página Create table (Crear tabla), en la sección Source (Fuente), haz lo siguiente:

    • Para Crear tabla desde (Create table from), selecciona Subir (Upload).
    • En Seleccionar archivo, haz clic en Explorar.
    • Busca el archivo y haz clic en Abrir. Ten en cuenta que los comodines y las listas separadas por comas no son compatibles con archivos locales.
    • En Formato de archivo (File format), selecciona CSV, JSON (delimitado por saltos de línea) (JSON [newline delimited]), Avro, ORC o Parquet.
  6. En la sección Destination (Destino) de la página Create table (Crear tabla), haz lo siguiente:

    • En Proyecto, elige el proyecto adecuado.
    • En Conjunto de datos, elige el conjunto de datos apropiado.
    • En el campo Nombre de tabla, ingresa el nombre de la tabla que quieres crear en BigQuery.
    • Verifica que Table type (Tipo de tabla) esté establecido en Native table (Tabla nativa).
  7. En la sección Esquema, ingresa la definición del esquema.

    • Para los archivos CSV y JSON, puedes marcar la opción Detección automática (Automatically detect) a fin de habilitar la detección automática del esquema. La información del esquema se describe de forma automática en los datos de origen para otros tipos de archivos compatibles.

    • También puedes ingresar la información del esquema de forma manual, como se indica a continuación:

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

      • Usa la opción Agregar campo para ingresar el esquema de forma manual.

  8. Selecciona los elementos aplicables en la sección Opciones avanzadas. Para obtener información sobre las opciones disponibles, consulta Opciones de CSV y Opciones de JSON.

  9. En Opciones avanzadas, elige la disposición de escritura (opcional):

    • Escribir si está vacía: Escribe los datos solo si la tabla está vacía.
    • Agregar a la tabla: agrega los datos al final de la tabla. Esta configuración es la predeterminada.
    • Reemplazar tabla: Borra todos los datos existentes en la tabla antes de escribir los datos nuevos.
  10. Haz clic en Crear tabla.

bq

Usa el comando bq load y especifica el valor source_format y la ruta de acceso al archivo local.

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

Para cargar datos a un proyecto que no sea el predeterminado, agrega el ID del proyecto al conjunto de datos en el siguiente formato: PROJECT_ID:DATASET.

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

Reemplaza lo siguiente:

  • LOCATION: Es tu ubicación. La marca --location es opcional. Por ejemplo, si usas BigQuery en la región de Tokio, establece el valor de la marca en asia-northeast1. Puedes configurar un valor predeterminado para la ubicación con el archivo .bigqueryrc.
  • FORMAT: Es CSV, AVRO, PARQUET, ORC, o NEWLINE_DELIMITED_JSON.
  • project_id: Es el ID del proyecto.
  • dataset: Es un conjunto de datos existente.
  • table: Es el nombre de la tabla en la que se están cargando los datos.
  • path_to_source: Es la ruta del archivo local.
  • schema: Es un esquema válido. El esquema puede ser un archivo JSON local o se puede escribir intercalado como parte del comando. También puedes usar la marca --autodetect en lugar de proporcionar una definición de esquema.

Además, puedes agregar marcas para las opciones que te permiten controlar cómo BigQuery analiza los datos. Por ejemplo, puedes usar la marca --skip_leading_rows para ignorar las filas del encabezado en un archivo CSV. Si deseas obtener más información, consulta Opciones de CSV y Opciones de JSON.

Ejemplos:

El siguiente comando carga un archivo JSON local delimitado por saltos de línea (mydata.json) en una tabla llamada mytable almacenada en mydataset en tu proyecto predeterminado. El esquema se define en un archivo de esquema local llamado myschema.json.

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

Con el siguiente comando, se carga un archivo CSV local (mydata.csv) en una tabla llamada mytable almacenada en mydataset en myotherproject. El esquema se define intercalado en el formato FIELD:DATA_TYPE, FIELD:DATA_TYPE.

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

Con el siguiente comando, se carga un archivo CSV local (mydata.csv) en una tabla llamada mytable almacenada en mydataset en tu proyecto predeterminado. El esquema se define mediante la detección automática de esquemas.

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

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

El siguiente código demuestra cómo cargar un archivo CSV local en una tabla de BigQuery nueva. Si deseas cargar un archivo local con otro formato, usa la clase de opciones de actualización para el formato adecuado desde la clase de base JobCreationOptions en vez de UploadCsvOptions.


using Google.Cloud.BigQuery.V2;
using System;
using System.IO;

public class BigQueryLoadFromFile
{
    public void LoadFromFile(
        string projectId = "your-project-id",
        string datasetId = "your_dataset_id",
        string tableId = "your_table_id",
        string filePath = "path/to/file.csv"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        // Create job configuration
        var uploadCsvOptions = new UploadCsvOptions()
        {
            SkipLeadingRows = 1,  // Skips the file headers
            Autodetect = true
        };
        using (FileStream stream = File.Open(filePath, FileMode.Open))
        {
            // Create and run job
            // Note that there are methods available for formats other than CSV
            BigQueryJob job = client.UploadCsv(
                datasetId, tableId, null, stream, uploadCsvOptions);
            job.PollUntilCompleted();  // Waits for the job to complete.
            // Display the number of rows uploaded
            BigQueryTable table = client.GetTable(datasetId, tableId);
            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.

El siguiente código demuestra cómo cargar un archivo CSV local en una tabla de BigQuery nueva. Para cargar un archivo local con otro formato, configura la propiedad DataFormat de NewReaderSource con el formato adecuado.

import (
	"context"
	"fmt"
	"os"

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

// importCSVFromFile demonstrates loading data into a BigQuery table using a file on the local filesystem.
func importCSVFromFile(projectID, datasetID, tableID, filename 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()

	f, err := os.Open(filename)
	if err != nil {
		return err
	}
	source := bigquery.NewReaderSource(f)
	source.AutoDetect = true   // Allow BigQuery to determine schema.
	source.SkipLeadingRows = 1 // CSV has a single header line.

	loader := client.Dataset(datasetID).Table(tableID).LoaderFrom(source)

	job, err := loader.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}
	if err := status.Err(); err != nil {
		return 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.

El siguiente código demuestra cómo cargar un archivo CSV local en una tabla de BigQuery nueva. Para cargar un archivo local con otro formato, configura la propiedad FormatOptions con el formato adecuado.

TableId tableId = TableId.of(datasetName, tableName);
WriteChannelConfiguration writeChannelConfiguration =
    WriteChannelConfiguration.newBuilder(tableId).setFormatOptions(FormatOptions.csv()).build();
// The location must be specified; other fields can be auto-detected.
JobId jobId = JobId.newBuilder().setLocation(location).build();
TableDataWriteChannel writer = bigquery.writer(jobId, writeChannelConfiguration);
// Write data to writer
try (OutputStream stream = Channels.newOutputStream(writer)) {
  Files.copy(csvPath, stream);
}
// Get load job
Job job = writer.getJob();
job = job.waitFor();
LoadStatistics stats = job.getStatistics();
return stats.getOutputRows();

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.

El siguiente código demuestra cómo cargar un archivo CSV local en una tabla de BigQuery nueva. Para cargar un archivo local con otro formato, configura el parámetro metadata de la función subir con el formato adecuado.

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

async function loadLocalFile() {
  // Imports a local file into a table.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const filename = '/path/to/file.csv';
  // const datasetId = 'my_dataset';
  // const tableId = 'my_table';

  // Load data from a local file into the table
  const [job] = await bigquery
    .dataset(datasetId)
    .table(tableId)
    .load(filename);

  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.

El siguiente código demuestra cómo cargar un archivo CSV local en una tabla de BigQuery nueva. Para cargar un archivo local con otro formato, configura la propiedad sourceFormat con el formato adecuado.

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';
// $source     = 'The path to the CSV source file to import';

// instantiate the bigquery table service
$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$table = $dataset->table($tableId);
// create the import job
$loadConfig = $table->load(fopen($source, 'r'))->sourceFormat('CSV');

$job = $table->runJob($loadConfig);
// poll the job until it is complete
$backoff = new ExponentialBackoff(10);
$backoff->execute(function () use ($job) {
    printf('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.

El siguiente código demuestra cómo cargar un archivo CSV local en una tabla de BigQuery nueva. Para cargar un archivo local con otro formato, configura la propiedad LoadJobConfig.source_format con el formato adecuado.

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(
    source_format=bigquery.SourceFormat.CSV, skip_leading_rows=1, autodetect=True,
)

with open(file_path, "rb") as source_file:
    job = client.load_table_from_file(source_file, table_id, job_config=job_config)

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

table = client.get_table(table_id)  # Make an API request.
print(
    "Loaded {} rows and {} columns to {}".format(
        table.num_rows, len(table.schema), table_id
    )
)

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.

El siguiente código demuestra cómo cargar un archivo CSV local en una tabla de BigQuery nueva. Para cargar un archivo local con otro formato, configura el parámetro format del método Table#load_job con el formato adecuado.

require "google/cloud/bigquery"

def load_from_file dataset_id = "your_dataset_id",
                   file_path  = "path/to/file.csv"

  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id
  table_id = "new_table_id"

  # Infer the config.location based on the location of the referenced dataset.
  load_job = dataset.load_job table_id, file_path do |config|
    config.skip_leading = 1
    config.autodetect   = true
  end
  load_job.wait_until_done! # Waits for table load to complete.

  table = dataset.table table_id
  puts "Loaded #{table.rows_count} rows into #{table.id}"
end

Limitaciones

La carga de datos desde una fuente de datos local está sujeta a las siguientes limitaciones:

  • Los comodines y las listas separadas por comas no son compatibles cuando cargas archivos desde una fuente de datos local. Los archivos se deben cargar por separado.
  • Cuando usas la consola de Google Cloud, los archivos cargados desde una fuente de datos local no pueden exceder los 10 MB. Si necesitas cargar archivos más grandes, hazlo desde Cloud Storage.

Carga datos comprimidos y sin comprimir

Se prefiere el formato binario Avro para cargar datos comprimidos y sin comprimir. Los datos Avro se cargan más rápido, porque pueden leerse en paralelo, incluso cuando los bloques de datos están comprimidos. Los archivos Avro comprimidos no son compatibles, pero los bloques de datos comprimidos sí lo son. Consulta Compresión de Avro.

El formato binario Parquet también es una buena opción, ya que brinda una codificación eficiente y por columna que suele generar un mejor índice de compresión y archivos más pequeños. Además, los archivos Parquet usan técnicas de compresión que permiten cargar archivos en paralelo. Los archivos comprimidos Parquet no son compatibles, pero los bloques de datos comprimidos sí lo son. Consulta Compresión de Parquet.

El formato binario ORC ofrece beneficios similares a los del formato Parquet. Los datos en los archivos ORC se cargan rápido, ya que las franjas de datos se pueden leer en paralelo. Las filas en cada franja de datos se cargan de manera secuencial. A fin de optimizar el tiempo de carga, usa franjas de datos con un tamaño aproximado de 256 MB o menos. Los archivos ORC comprimidos no son compatibles, pero las franjas y pies de página de archivos comprimidos sí lo son. Consulta Compresión de ORC.

Para otros formatos de datos, como CSV y JSON, BigQuery puede cargar archivos sin comprimir mucho más rápido que archivos comprimidos, ya que los no comprimidos se pueden leer en paralelo. Debido a que los archivos sin comprimir son más grandes, su uso puede llevar a limitaciones en el ancho de banda y a mayores costos de Cloud Storage para los datos almacenados en Cloud Storage antes de su carga en BigQuery. Ten en cuenta que el orden de las líneas no está garantizado para archivos comprimidos o sin comprimir. Es importante considerar estas cuestiones según tu caso práctico.

En general, si el ancho de banda es limitado, debes comprimir tus archivos CSV y JSON mediante gzip antes de subirlos a Cloud Storage. En la actualidad, cuando se cargan datos en BigQuery, gzip es el único tipo de compresión de archivos compatible con archivos CSV y JSON. Si la velocidad de carga es importante en tu app y tienes mucho ancho de banda para cargar tus datos, no comprimas los archivos.

Anexa o reemplaza una tabla

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

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

  • Agregar campos nuevos
  • Cambiar los campos REQUIRED por NULLABLE

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

En la consola 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. La herramienta de línea de comandos de bq y la API incluyen las siguientes opciones:

Opción de Console Marca de la herramienta de bq Propiedad de la API de BigQuery Descripción
Escribir si está vacía Ninguna WRITE_EMPTY Solo escribe los datos si la tabla está vacía.
Agregar a la tabla --noreplace o --replace=false; si --replace no está especificado, la opción predeterminada es agregar WRITE_APPEND (Predeterminado) Adjunta los datos al final de la tabla.
Reemplazar tabla --replace o --replace=true WRITE_TRUNCATE Borra todos los datos existentes de una tabla antes de escribir los datos nuevos.

Política de cuotas

Si necesitas información sobre la política de cuotas para cargar datos por lotes, consulta Trabajos de carga en la página Cuotas y límites.

Precios

Subir datos en BigQuery no tiene costo. Para obtener más información, consulta Precios por transferencia de datos.