Exporta datos de tablas

En esta página, se describe cómo exportar o extraer datos de tablas de BigQuery.

Después de cargar tus datos en BigQuery, puedes exportarlos en varios formatos. BigQuery puede exportar hasta 1 GB de datos a un solo archivo. Si necesitas exportar más de 1 GB de datos, debes exportarlos a varios archivos. Cuando exportas tus datos a varios archivos, el tamaño de estos puede variar.

Puedes usar un servicio como Dataflow para leer datos de BigQuery en lugar de exportarlos de forma manual. Si quieres obtener más información sobre cómo usar Dataflow para leer y escribir en BigQuery, consulta E/S de BigQuery en la documentación de Apache Beam.

Permisos necesarios

Si deseas exportar datos a Cloud Storage, necesitas permisos para acceder a la tabla de BigQuery que contiene los datos, permisos para ejecutar un trabajo de exportación y permisos para escribir los datos en el depósito de Cloud Storage.

Permisos de BigQuery

  • Como mínimo, para exportar datos debes tener permisos bigquery.tables.export. Las siguientes funciones predefinidas de IAM tienen permisos bigquery.tables.export:

    • bigquery.dataViewer
    • bigquery.dataOwner
    • bigquery.dataEditor
    • bigquery.admin
  • Como mínimo, para ejecutar un trabajo de exportación, debes tener permisos bigquery.jobs.create. Las siguientes funciones predefinidas de IAM tienen permisos bigquery.jobs.create:

    • bigquery.user
    • bigquery.jobUser
    • bigquery.admin

Permisos de Cloud Storage

  • Para escribir los datos en un depósito de Cloud Storage existente, debes tener los permisos storage.objects.create y storage.objects.delete. Las siguientes funciones predefinidas de IAM otorgan ambos permisos:

    • storage.objectAdmin
    • storage.admin

Exporta limitaciones

Cuando exportes datos desde BigQuery, ten en cuenta esta información:

  • No puedes exportar datos de tabla a un archivo local, a Hojas de cálculo ni a Drive. La única ubicación de exportación admitida es Cloud Storage. Para obtener información sobre cómo guardar resultados de consultas, consulta Cómo descargar y guardar los resultados de las consultas.
  • Puedes exportar hasta 1 GB de datos de tablas a un solo archivo. Si necesitas exportar más de 1 GB de datos, usa un comodín para exportar los datos a varios archivos. Cuando exportas datos a varios archivos, el tamaño de estos puede variar.
  • No puedes exportar datos anidados y repetidos en formato CSV. Las exportaciones Avro y JSON son las que admiten ese tipo de datos.
  • Cuando exportas datos en formato JSON, los tipos de datos INT64 (número entero) se codifican como strings JSON para preservar la precisión de 64 bits cuando otros sistemas leen los datos.
  • No puedes exportar datos de varias tablas en un solo trabajo de exportación.
  • No puedes elegir un tipo de compresión que no sea GZIP cuando exportas datos con Cloud Console o la IU web clásica de BigQuery.

Consideraciones de ubicación

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

  • Ubica los depósitos de Cloud Storage en la misma ubicación para exportar datos.
    • Cuando exportes datos, el depósito de Cloud Storage regional o multirregional debe estar en la misma ubicación que el conjunto de datos de BigQuery. Por ejemplo, si tu conjunto de datos de BigQuery se encuentra en la ubicación multirregional de la UE, el depósito de Cloud Storage que contiene los datos que exportas debe estar en un depósito regional o multirregional en la UE.
    • Si tu conjunto de datos está en una ubicación regional, tu depósito de Cloud Storage debe ser un depósito regional en la misma ubicación. Por ejemplo, si tu conjunto de datos está en la región de Tokio, tu depósito de Cloud Storage debe estar un depósito regional en Tokio.
    • Excepción: Si tu conjunto de datos se encuentra en la ubicación multirregional de los EE.UU., puedes exportar datos desde un depósito de Cloud Storage en cualquier ubicación regional o multirregional.
  • Desarrolla un plan de administración de datos.

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

Traslada datos de BigQuery entre ubicaciones

No puedes cambiar la ubicación de un conjunto de datos después de crearlo, pero puedes crear una copia del conjunto de datos. No puedes mover un conjunto de datos de una ubicación a otra, pero puedes mover (recrear) un conjunto de datos de forma manual.

Copia conjuntos de datos

Si deseas ver los pasos para copiar un conjunto de datos, incluso entre regiones, consulta Copia conjuntos de datos.

Mueve un conjunto de datos

Para mover un conjunto de datos de una ubicación a otra de forma manual, sigue este proceso:

  1. Exporta los datos desde tus tablas de BigQuery hasta un depósito de Cloud Storage regional o multirregión en la misma ubicación que tu conjunto de datos. Por ejemplo, si tu conjunto de datos se encuentra en la ubicación multirregional de la UE, debes exportar tus datos a un depósito regional o multirregional en la UE.

    No se aplican cargos por exportar datos desde BigQuery, pero sí por almacenar los datos exportados en Cloud Storage. Las exportaciones de BigQuery están sujetas a los límites de los trabajos de exportación.

  2. Copia o mueve los datos de tu depósito de Cloud Storage a un depósito regional o multirregional en la ubicación nueva. Por ejemplo, si trasladas tus datos desde la ubicación multirregional de EE.UU. a la ubicación regional de Tokio, debes transferir los datos a un depósito regional en Tokio. Para obtener más información sobre la transferencia de objetos de Cloud Storage, consulta Renombra, copia y mueve objetos en la documentación de Cloud Storage.

    Ten en cuenta que con la transferencia de datos entre regiones se incurre en cargos de salida de red en Cloud Storage.

  3. Después de transferir los datos a un depósito de Cloud Storage en la ubicación nueva, crea un conjunto de datos nuevo de BigQuery (en la ubicación nueva). Luego, carga tus datos del depósito de Cloud Storage en BigQuery.

    No se te cobrará por cargar los datos en BigQuery, pero sí por almacenar los datos en Cloud Storage hasta que borres los datos o el depósito. También se te cobra por almacenar los datos en BigQuery después de que se carguen. La carga de datos en BigQuery está sujeta a los límites de los trabajos de carga.

También puedes usar Cloud Composer para mover y copiar conjuntos de datos grandes de manera programática.

A fin de obtener más información sobre el uso de Cloud Storage para almacenar y mover conjuntos de datos grandes, consulta Usa Google Cloud Storage con macrodatos.

Exporta formatos y tipos de compresión

BigQuery es compatible con los formatos de datos y tipos de compresión siguientes para datos exportados.

Formato de los datos Tipos de compresión compatibles Detalles
CSV GZIP

Puedes controlar el delimitador CSV en los datos exportados mediante la marca --field_delimiter de la herramienta de línea de comandos bq o la propiedad del trabajo de extracción configuration.extract.fieldDelimiter .

Los datos anidados y repetidos no son compatibles.

JSON GZIP Los datos anidados y repetidos son compatibles.
Avro DEFLATE, SNAPPY

GZIP no es compatible con las exportaciones de Avro.

Los datos anidados y repetidos son compatibles.

Exporta datos almacenados en BigQuery

Puedes exportar datos de tablas de las siguientes maneras:

  • Mediante Cloud Console o la IU web clásica de BigQuery
  • Mediante el comando bq extract en la herramienta de línea de comandos de bq
  • Mediante el envío de un trabajo extract a través de la API o las bibliotecas cliente

Exporta datos de tablas

Para exportar datos desde una tabla de BigQuery, sigue estos pasos:

Console

  1. Abre la página de BigQuery en Cloud Console.

    Ir a la página BigQuery

  2. En el panel de navegación, en la sección Recursos (Resources), expande tu proyecto y haz clic en un conjunto de datos para expandirlo. Busca y haz clic en la tabla que contiene los datos que exportarás.

  3. En el lado derecho de la ventana, haz clic en Export (Exportar) y, luego, selecciona Export to Google Cloud Storage (Exportar a Google Cloud Storage).

    Exporta datos

  4. Realiza estas acciones en el cuadro de diálogo Exportar tabla a Google Cloud Storage:

    • Para Seleccionar una ubicación de Google Cloud Storage, busca el depósito, la carpeta o el archivo en el que deseas exportar los datos.
    • En Exportar formato, selecciona el formato para tus datos exportados: CSV, JSON (delimitado por saltos de línea) o Avro.
    • Para Comprimir, acepta el valor predeterminado None, o elige GZIP. El formato AVRO no se puede usar junto con la compresión GZIP. Para comprimir datos AVRO, usa la herramienta de línea de comandos bq o la API, y especifica uno de los tipos de compresión compatibles con datos AVRO: DEFLATE o SNAPPY.
    • Haz clic en Exportar para exportar la tabla.

Para verificar el progreso del trabajo, busca en la parte superior de la navegación el Historial de trabajo para un trabajo de exportación.

IU clásica

  1. Ve a la IU web de BigQuery.
    Ir a la IU web de BigQuery

  2. En el panel de navegación, haz clic en tu conjunto de datos para expandirlo.

  3. Busca y haz clic en el ícono de flecha hacia abajo imagen del ícono de flecha hacia abajo junto a la tabla que contiene los datos que quieres exportar.

  4. Selecciona Exportar tabla para mostrar el diálogo Exportar a Google Cloud Storage.

  5. Sigue estos pasos en el diálogo Exportar a Google Cloud Storage:

    • En Formato de exportación, selecciona el formato de los datos exportados: CSV, JSON (delimitado por saltos de línea) o Avro.
    • Para Comprimir, acepta el valor predeterminado None, o elige GZIP. El formato AVRO no se puede usar junto con la compresión GZIP. Para comprimir datos AVRO, usa la herramienta de línea de comandos bq o la API, y especifica uno de los tipos de compresión compatibles con datos AVRO: DEFLATE o SNAPPY.
    • En el cuadro de texto del URI de Google Cloud Storage, ingresa un URI válido en el formato gs://bucket_name/filename.ext. En ese formato, bucket_name es el nombre de tu depósito de Cloud Storage y filename.ext es el nombre y la extensión de tu archivo de destino. El conjunto de datos de BigQuery y el depósito de Cloud Storage deben estar en la misma ubicación.
    • Haz clic en Aceptar para exportar la tabla.

Mientras se ejecuta el trabajo, aparece (extrayendo) junto al nombre de la tabla en la navegación. Para verificar el progreso del trabajo, busca un trabajo de extracción en la parte superior de la página, en Historial de trabajo.

bq

Usa el comando bq extract con la marca --destination_format.

Proporciona la marca --location y establece el valor en tu ubicación (opcional).

Las siguientes son otras marcas opcionales:

  • --compression: Es el tipo de compresión que se usará para los archivos exportados.
  • --field_delimiter: Es el carácter que indica el límite entre las columnas en el archivo de salida para las exportaciones de formato CSV. \t y tab pueden ser delimitadores de tabulación.
  • --print_header: Cuando se especifica, imprime las filas de encabezado de los formatos que tienen encabezados, como CSV.
bq --location=location extract \
--destination_format format \
--compression compression_type \
--field_delimiter delimiter \
--print_header=boolean \
project_id:dataset.table \
gs://bucket/filename.ext

Donde:

  • location es el nombre de tu ubicación. La marca --location es opcional. Por ejemplo, si usas BigQuery en la región de Tokio, puedes configurar el valor de la marca como asia-northeast1. Puedes establecer un valor predeterminado para la ubicación con el archivo .bigqueryrc.
  • format es el formato de los datos exportados: CSV, NEWLINE_DELIMITED_JSON o AVRO.
  • compression_type es un tipo de compresión compatible para tu formato de datos. CSV y NEWLINE_DELIMITED_JSON son compatibles con GZIP. AVRO es compatible con DEFLATE y SNAPPY.
  • delimiter es el carácter que indica el límite entre columnas en las exportaciones de CSV. \t y tab son nombres aceptados para la pestaña.
  • boolean es true o false. Cuando se establece en true, las filas del encabezado se imprimen en los datos exportados si el formato de datos admite encabezados. El valor predeterminado es true.
  • project_id es el ID del proyecto.
  • dataset es el nombre del conjunto de datos de origen.
  • table es la tabla que deseas exportar.
  • bucket es el nombre del depósito de Cloud Storage al que deseas exportar los datos. El conjunto de datos de BigQuery y el depósito de Cloud Storage deben estar en la misma ubicación.
  • filename.ext es el nombre y la extensión del archivo de datos exportado. Puedes exportar a varios archivos con un comodín.

Ejemplos:

Por ejemplo, el siguiente comando exporta mydataset.mytable a un archivo comprimido de gzip llamado myfile.csv. myfile.csv se almacena en un depósito de Cloud Storage llamado example-bucket.

bq extract \
--compression GZIP \
'mydataset.mytable' \
gs://example-bucket/myfile.csv

El formato de destino predeterminado es CSV. Para exportar en JSON o Avro, usa la marca destination_format y configúrala como NEWLINE_DELIMITED_JSON o AVRO. Por ejemplo:

bq extract \
--destination_format NEWLINE_DELIMITED_JSON \
'mydataset.mytable' \
gs://example-bucket/myfile.json

El siguiente comando exporta mydataset.mytable a un archivo Avro comprimido con Snappy. El nombre del archivo es myfile.avro. myfile.avro se exporta a un depósito de Cloud Storage llamado example-bucket.

bq extract \
--destination_format AVRO \
--compression SNAPPY \
'mydataset.mytable' \
gs://example-bucket/myfile.avro

API

Para exportar datos, crea un trabajo extract y propaga la configuración del trabajo.

De forma opcional, puedes especificar la ubicación en la propiedad location, en la sección jobReference del recurso de trabajo.

  1. Crea un trabajo de extracción que haga referencia a los datos de origen de BigQuery y al destino de Cloud Storage.

  2. Especifica la tabla de origen mediante el objeto de configuración sourceTable que contiene el ID del proyecto, el ID del conjunto de datos y el ID de la tabla.

  3. La propiedad destination URI(s) debe estar completamente y calificada en el formato gs://bucket/filename.ext. Cada URI puede contener un carácter comodín “*” y debe aparecer después del nombre del depósito.

  4. Para especificar el formato de datos, configura la propiedad configuration.extract.destinationFormat. Por ejemplo, para exportar un archivo JSON, configura esta propiedad con el valor NEWLINE_DELIMITED_JSON.

  5. Para verificar el estado del trabajo, llama a jobs.get(job_id) con el ID del trabajo que se muestra en 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 describa qué salió mal.
    • Si status.errorResult está ausente, el trabajo finalizó de forma correcta, aunque puede que haya habido algunos errores recuperables. Se enumeran los errores recuperables en la propiedad status.errors del objeto de trabajo que se muestra.

Notas sobre la API:

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

  • Llamar a jobs.insert con un ID de trabajo dado es idempotente. En otras palabras, puedes volver a intentarlo tantas veces como desees con el mismo ID de trabajo y al menos una de las operaciones será correcta.

C#

Antes de probar 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. Si deseas obtener más información, consulta la documentación de referencia de la API de BigQuery para C#.


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

public class BigQueryExtractTable
{
    public void ExtractTable(
        string projectId = "your-project-id",
        string bucketName = "your-bucket-name")
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        // Define a destination URI. Use a single wildcard URI if you think
        // your exported data will be larger than the 1 GB maximum value.
        string destinationUri = $"gs://{bucketName}/shakespeare-*.csv";
        BigQueryJob job = client.CreateExtractJob(
            projectId: "bigquery-public-data",
            datasetId: "samples",
            tableId: "shakespeare",
            destinationUri: destinationUri
        );
        job = job.PollUntilCompleted().ThrowOnAnyError();  // Waits for the job to complete.
        Console.Write($"Exported table to {destinationUri}.");
    }
}

Go

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

import (
	"context"
	"fmt"

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

// exportTableAsCompressedCSV demonstrates using an export job to
// write the contents of a table into Cloud Storage as CSV.
func exportTableAsCSV(projectID, gcsURI string) error {
	// projectID := "my-project-id"
	// gcsUri := "gs://mybucket/shakespeare.csv"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	srcProject := "bigquery-public-data"
	srcDataset := "samples"
	srcTable := "shakespeare"

	gcsRef := bigquery.NewGCSReference(gcsURI)
	gcsRef.FieldDelimiter = ","

	extractor := client.DatasetInProject(srcProject, srcDataset).Table(srcTable).ExtractorTo(gcsRef)
	extractor.DisableHeader = true
	// You can choose to run the job in a specific location for more complex data locality scenarios.
	// Ex: In this example, source dataset and GCS bucket are in the US.
	extractor.Location = "US"

	job, err := extractor.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 que se encuentran en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de BigQuery para Java.

import com.google.cloud.RetryOption;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.Table;
import com.google.cloud.bigquery.TableId;
import org.threeten.bp.Duration;

public class ExtractTableToCsv {

  public static void runExtractTableToCsv() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "bigquery-public-data";
    String datasetName = "samples";
    String tableName = "shakespeare";
    String bucketName = "my-bucket";
    String destinationUri = "gs://" + bucketName + "/path/to/file";
    // For more information on export formats available see:
    // https://cloud.google.com/bigquery/docs/exporting-data#export_formats_and_compression_types
    // For more information on Job see:
    // https://googleapis.dev/java/google-cloud-clients/latest/index.html?com/google/cloud/bigquery/package-summary.html

    String dataFormat = "CSV";
    extractTableToCsv(projectId, datasetName, tableName, destinationUri, dataFormat);
  }

  // Exports datasetName:tableName to destinationUri as raw CSV
  public static void extractTableToCsv(
      String projectId,
      String datasetName,
      String tableName,
      String destinationUri,
      String dataFormat) {
    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(projectId, datasetName, tableName);
      Table table = bigquery.getTable(tableId);

      Job job = table.extract(dataFormat, destinationUri);

      // Blocks until this job completes its execution, either failing or succeeding.
      Job completedJob =
          job.waitFor(
              RetryOption.initialRetryDelay(Duration.ofSeconds(1)),
              RetryOption.totalTimeout(Duration.ofMinutes(3)));
      if (completedJob == null) {
        System.out.println("Job not executed since it no longer exists.");
        return;
      } else if (completedJob.getStatus().getError() != null) {
        System.out.println(
            "BigQuery was unable to extract due to an error: \n" + job.getStatus().getError());
        return;
      }
      System.out.println(
          "Table export successful. Check in GCS bucket for the " + dataFormat + " file.");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Table extraction job was interrupted. \n" + e.toString());
    }
  }
}

Node.js

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

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

const bigquery = new BigQuery();
const storage = new Storage();

async function extractTableToGCS() {
  // Exports my_dataset:my_table to gcs://my-bucket/my-file as raw CSV.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = "my_dataset";
  // const tableId = "my_table";
  // const bucketName = "my-bucket";
  // const filename = "file.csv";

  // Location must match that of the source table.
  const options = {
    location: 'US',
  };

  // Export data from the table into a Google Cloud Storage file
  const [job] = await bigquery
    .dataset(datasetId)
    .table(tableId)
    .extract(storage.bucket(bucketName).file(filename), options);

  console.log(`Job ${job.id} created.`);

  // 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. Si deseas obtener más información, consulta la documentación de referencia de la API de BigQuery para PHP.

use Google\Cloud\BigQuery\BigQueryClient;

/** Uncomment and populate these variables in your code */
// $projectId  = 'The Google project ID';
// $datasetId  = 'The BigQuery dataset ID';
// $tableId    = 'The BigQuery table ID';
// $bucketName = 'The Cloud Storage bucket Name';

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$dataset = $bigQuery->dataset($datasetId);
$table = $dataset->table($tableId);
$destinationUri = "gs://{$bucketName}/{$tableId}.json";
// Define the format to use. If the format is not specified, 'CSV' will be used.
$format = 'NEWLINE_DELIMITED_JSON';
// Create the extract job
$extractConfig = $table->extract($destinationUri)->destinationFormat($format);
// Run the job
$job = $table->runJob($extractConfig);  // Waits for the job to complete
printf('Exported %s to %s' . PHP_EOL, $table->id(), $destinationUri);

Python

Antes de probar esta muestra, 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. Si deseas obtener más información, consulta la documentación de referencia de la API de BigQuery para Python.

# from google.cloud import bigquery
# client = bigquery.Client()
# bucket_name = 'my-bucket'
project = "bigquery-public-data"
dataset_id = "samples"
table_id = "shakespeare"

destination_uri = "gs://{}/{}".format(bucket_name, "shakespeare.csv")
dataset_ref = bigquery.DatasetReference(project, dataset_id)
table_ref = dataset_ref.table(table_id)

extract_job = client.extract_table(
    table_ref,
    destination_uri,
    # Location must match that of the source table.
    location="US",
)  # API request
extract_job.result()  # Waits for job to complete.

print(
    "Exported {}:{}.{} to {}".format(project, dataset_id, table_id, destination_uri)
)

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. A fin de obtener más información, consulta la documentación de referencia de la API de BigQuery para Ruby.

require "google/cloud/bigquery"

def extract_table bucket_name = "my-bucket",
                  dataset_id  = "my_dataset_id",
                  table_id    = "my_table_id"

  bigquery = Google::Cloud::Bigquery.new
  dataset  = bigquery.dataset dataset_id
  table    = dataset.table    table_id

  # Define a destination URI. Use a single wildcard URI if you think
  # your exported data will be larger than the 1 GB maximum value.
  destination_uri = "gs://#{bucket_name}/output-*.csv"

  extract_job = table.extract_job destination_uri do |config|
    # Location must match that of the source table.
    config.location = "US"
  end
  extract_job.wait_until_done! # Waits for the job to complete

  puts "Exported #{table.id} to #{destination_uri}"
end

Detalles de exportación de Avro

BigQuery expresa datos en formato Avro de las maneras siguientes:

  • Los archivos de exportación resultantes son archivos de contenedor Avro.
  • Cada fila de BigQuery se representa como un registro Avro. Los datos anidados se representan con objetos de registro anidados.
  • Los campos REQUIRED se representan como los tipos Avro correspondientes. Por ejemplo, un tipo INTEGER de BigQuery asigna a un tipo LONG de Avro.
  • Los campos NULLABLE se representan como una unión Avro del tipo correspondiente y “nulo”.
  • Los campos REPEATED se representan como arreglos de Avro.
  • Los tipos de datos TIMESTAMP se representan como tipos lógicos timestamp-micros de Avro.
  • Los tipos de datos DATE se representan como tipos INT de Avro de forma predeterminada o como tipos lógicos de Avro date si se especifica la marca --use_avro_logical_types.
  • Los tipos de datos TIME se representan como tipos LONG de Avro de forma predeterminada o como tipos lógicos de Avro time-micros si se especifica la marca --use_avro_logical_types.
  • Los tipos de datos DATETIME se representan como tipos STRING de Avro. La codificación sigue la especificación RFC 3339 del Grupo de trabajo de ingeniería de Internet.

El formato AVRO no se puede usar junto con la compresión GZIP. Para comprimir datos AVRO, usa la herramienta de línea de comandos bq o la API, y especifica uno de los tipos de compresión compatibles con datos AVRO: DEFLATE o SNAPPY.

Exporta datos a uno o más archivos

La propiedad destinationUris indica una o más ubicaciones y nombres de archivo en los que BigQuery debería exportar los archivos.

BigQuery admite un solo operador de comodín (*) en cada URI. El comodín puede aparecer en cualquier lugar del URI, excepto como parte del nombre del depósito. El uso del operador de comodín le indica a BigQuery que cree varios archivos fragmentados según el patrón suministrado. El operador de comodín se reemplaza con un número (que comienza en 0) y se rellena a la izquierda con 12 dígitos. Por ejemplo, un URI con un comodín al final del nombre del archivo crearía archivos con 000000000000 adjuntado al primer archivo, 000000000001 adjuntado al segundo archivo, etcétera.

En la siguiente tabla, se describen varias opciones posibles para la propiedad destinationUris:

Opciones de `destinationUris`
Un solo URI

Usa un solo URI si exportas una cantidad de datos de tabla igual o inferior a 1 GB. Esta opción es el caso práctico más común, ya que los datos exportados suelen ser inferiores al valor máximo de 1 GB.

Definición de la propiedad:

['gs://my-bucket/file-name.json']

Crea:


gs://my-bucket/file-name.json
URI de un solo comodín

Usa un URI de un solo comodín si piensas que tus datos exportados serán superiores al valor máximo de 1 GB. BigQuery fragmenta tus datos en varios archivos según el patrón proporcionado. El tamaño de los archivos exportados variará.

Si usas un comodín en un componente del URI que no sea el nombre del archivo, asegúrate de que la ruta de acceso del componente no exista antes de exportar los datos.

Definición de la propiedad:

['gs://my-bucket/file-name-*.json']

Crea:


gs://my-bucket/file-name-000000000000.json
gs://my-bucket/file-name-000000000001.json
gs://my-bucket/file-name-000000000002.json
...
URI de varios comodines

Usa URI de varios comodines si quieres particionar el resultado de la exportación. Usa esta opción si ejecutas un trabajo de procesamiento paralelo con un servicio como Cloud Dataproc. Determina cuántos trabajadores estarán disponibles para procesar el trabajo y crea un URI por trabajador. BigQuery trata cada ubicación de URI como una partición y usa procesamiento paralelo para fragmentar tus datos en varios archivos en cada ubicación. Puedes usar cualquier patrón que quieras en el nombre de archivo, suponiendo que hay un solo operador de comodín en cada URI, que cada URI es único y que el número de URI no supera la política de cuotas.

Cuando pasas más de un URI de comodín, BigQuery crea un archivo especial al final de cada partición que indica el archivo final en el conjunto. Este nombre de archivo indica cuántos fragmentos creó BigQuery.

Por ejemplo, si tu URI de comodín es gs://my-bucket/file- name-<worker number>-*.json y BigQuery crea 80 archivos fragmentados, el nombre del archivo del registro cero es gs://my-bucket/file-name-<worker number>-000000000080.json. Puedes usar este nombre de archivo para determinar que BigQuery creó 80 archivos fragmentados (llamados 000000000000-000000000079).

Ten en cuenta que un archivo de registro cero puede contener más de 0 bytes según el formato de datos, como cuando se exportan datos en formato CSV con un encabezado de columna.

Patrón de la string:

gs://my-bucket/file-name-<worker number>-*.json

Definición de la propiedad:


['gs://my-bucket/file-name-1-*.json',
'gs://my-bucket/file-name-2-*.json',
'gs://my-bucket/file-name-3-*.json']

Crea:

En este ejemplo, se supone que BigQuery creará 80 archivos fragmentados en cada partición.


gs://my-bucket/file-name-1-000000000000.json
gs://my-bucket/file-name-1-000000000001.json
...
gs://my-bucket/file-name-1-000000000080.json
gs://my-bucket/file-name-2-000000000000.json
gs://my-bucket/file-name-2-000000000001.json
...
gs://my-bucket/file-name-2-000000000080.json
gs://my-bucket/file-name-3-000000000000.json
gs://my-bucket/file-name-3-000000000001.json
...
gs://my-bucket/file-name-3-000000000080.json

Extrae la tabla comprimida

Go

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

import (
	"context"
	"fmt"

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

// exportTableAsCompressedCSV demonstrates using an export job to
// write the contents of a table into Cloud Storage as compressed CSV.
func exportTableAsCompressedCSV(projectID, gcsURI string) error {
	// projectID := "my-project-id"
	// gcsUri := "gs://mybucket/shakespeare.csv"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	srcProject := "bigquery-public-data"
	srcDataset := "samples"
	srcTable := "shakespeare"

	gcsRef := bigquery.NewGCSReference(gcsURI)
	gcsRef.Compression = bigquery.Gzip

	extractor := client.DatasetInProject(srcProject, srcDataset).Table(srcTable).ExtractorTo(gcsRef)
	extractor.DisableHeader = true
	// You can choose to run the job in a specific location for more complex data locality scenarios.
	// Ex: In this example, source dataset and GCS bucket are in the US.
	extractor.Location = "US"

	job, err := extractor.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 que se encuentran en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de BigQuery para Java.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.ExtractJobConfiguration;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.TableId;

// Sample to extract a compressed table
public class ExtractTableCompressed {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String projectName = "MY_PROJECT_NAME";
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String bucketName = "MY-BUCKET-NAME";
    String destinationUri = "gs://" + bucketName + "/path/to/file";
    // For more information on export formats available see:
    // https://cloud.google.com/bigquery/docs/exporting-data#export_formats_and_compression_types
    String compressed = "gzip";
    // For more information on Job see:
    // https://googleapis.dev/java/google-cloud-clients/latest/index.html?com/google/cloud/bigquery/package-summary.html
    String dataFormat = "CSV";

    extractTableCompressed(
        projectName, datasetName, tableName, destinationUri, dataFormat, compressed);
  }

  public static void extractTableCompressed(
      String projectName,
      String datasetName,
      String tableName,
      String destinationUri,
      String dataFormat,
      String compressed) {
    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(projectName, datasetName, tableName);

      ExtractJobConfiguration extractConfig =
          ExtractJobConfiguration.newBuilder(tableId, destinationUri)
              .setCompression(compressed)
              .setFormat(dataFormat)
              .build();

      Job job = bigquery.create(JobInfo.of(extractConfig));

      // Blocks until this job completes its execution, either failing or succeeding.
      Job completedJob = job.waitFor();
      if (completedJob == null) {
        System.out.println("Job not executed since it no longer exists.");
        return;
      } else if (completedJob.getStatus().getError() != null) {
        System.out.println(
            "BigQuery was unable to extract due to an error: \n" + job.getStatus().getError());
        return;
      }
      System.out.println("Table extract compressed successful");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Table extraction job was interrupted. \n" + e.toString());
    }
  }
}

Node.js

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

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

const bigquery = new BigQuery();
const storage = new Storage();

async function extractTableCompressed() {
  // Exports my_dataset:my_table to gcs://my-bucket/my-file as a compressed file.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = "my_dataset";
  // const tableId = "my_table";
  // const bucketName = "my-bucket";
  // const filename = "file.csv";

  // Location must match that of the source table.
  const options = {
    location: 'US',
    gzip: true,
  };

  // Export data from the table into a Google Cloud Storage file
  const [job] = await bigquery
    .dataset(datasetId)
    .table(tableId)
    .extract(storage.bucket(bucketName).file(filename), options);

  console.log(`Job ${job.id} created.`);

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

Python

Antes de probar esta muestra, 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. Si deseas obtener más información, consulta la documentación de referencia de la API de BigQuery para Python.

# from google.cloud import bigquery
# client = bigquery.Client()
# bucket_name = 'my-bucket'

destination_uri = "gs://{}/{}".format(bucket_name, "shakespeare.csv.gz")
dataset_ref = bigquery.DatasetReference(project, dataset_id)
table_ref = dataset_ref.table("shakespeare")
job_config = bigquery.job.ExtractJobConfig()
job_config.compression = bigquery.Compression.GZIP

extract_job = client.extract_table(
    table_ref,
    destination_uri,
    # Location must match that of the source table.
    location="US",
    job_config=job_config,
)  # API request
extract_job.result()  # Waits for job to complete.

Política de cuotas

Para obtener información sobre las cuotas de un trabajo de exportación, consulta Trabajos de exportación en la página Cuotas y límites.

Precios

Por el momento, no se cobran las exportaciones de datos desde BigQuery, pero están sujetas a las Cuotas y límites de BigQuery. Para obtener más información sobre los precios de BigQuery, consulta Precios de BigQuery.

Una vez que se exportan los datos, se te cobra por almacenarlos en Cloud Storage. Para obtener más información sobre los precios de Cloud Storage, consulta Precios de Cloud Storage.

Pasos siguientes