Como exportar dados de tabelas

Esta página ensina como exportar e extrair dados de tabelas do BigQuery.

Depois de carregar os dados no BigQuery, eles podem ser exportados em diferentes formatos. O BigQuery pode exportar até 1 GB de dados para um único arquivo. Se estiver exportando mais de 1 GB de dados, será preciso exportá-los para vários arquivos. Ao fazer isso, o tamanho dos arquivos será variado.

Use serviços como o Dataflow para ler dados no BigQuery em vez de exportá-los manualmente. Para ver mais informações sobre como usar o Dataflow para ler e gravar no BigQuery, consulte E/S do BigQuery (em inglês) na documentação do Apache Beam.

Permissões obrigatórias

Para exportar dados ao Cloud Storage, você precisa de permissões para acessar a tabela do BigQuery que contém os dados para gerar um job de exportação e as permissões para gravá-los no bucket do Cloud Storage.

Permissões do BigQuery

  • Para exportar dados, é necessário ter, no mínimo, as permissões bigquery.tables.export. Estes papéis predefinidos do Cloud IAM incluem permissões bigquery.tables.export:

    • bigquery.dataViewer
    • bigquery.dataOwner
    • bigquery.dataEditor
    • bigquery.admin
  • Para gerar um job de exportação, é necessário ter, no mínimo, as permissões bigquery.jobs.create. Estes papéis predefinidos do Cloud IAM incluem permissões bigquery.jobs.create:

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

Permissões do Cloud Storage

  • Para gravar dados em um bucket do Cloud Storage, é necessário ter permissões storage.objects.create. Estes papéis predefinidos do Cloud IAM incluem permissões storage.objects.create:

    • storage.objectCreator
    • storage.objectAdmin
    • storage.admin

Limitações de exportação

Ao exportar dados do BigQuery, observe os itens a seguir:

  • Não é possível exportar dados de tabela para arquivos locais, para o Planilhas Google nem para o Google Drive. O único local de exportação aceito é o Cloud Storage. Para ver mais informações sobre como salvar resultados de consulta, acesse Como fazer o download e salvar resultados de consulta.
  • Exporte até 1 GB de dados da tabela para um único arquivo. Se exportar mais de 1 GB, use um caractere curinga para exportar os dados para vários arquivos. Ao exportar dados para vários arquivos, o tamanho dos arquivos varia.
  • Não é possível exportar dados aninhados e repetidos no formato CSV. Os dados aninhados e repetidos são compatíveis com as exportações para Avro e JSON.
  • Ao exportar dados no formato JSON, os tipos de dados INT64 (números inteiros) são codificados como strings JSON para preservar a precisão de 64 bits quando os dados são lidos por outros sistemas.
  • Não é possível exportar dados de várias tabelas em um único job de exportação.
  • Ao exportar dados de tabelas particionadas, não é possível fazer isso com partições específicas.
  • Só dá para escolher o tipo de compactação GZIP ao exportar dados usando o Console do Cloud ou a versão clássica da IU do BigQuery para a Web.

Questões sobre o local

Ao escolher um local para os dados, leve em consideração os seguintes itens:

  • Selecione os buckets do Cloud Storage para a exportação de dados.
    • Ao exportar dados, o bucket regional ou multirregional do Cloud Storage precisa estar no mesmo local do conjunto de dados do BigQuery. Por exemplo, se o conjunto de dados do BigQuery estiver no local multirregional da UE, o bucket do Cloud Storage que contém os dados sendo exportados precisará estar em um local regional ou multirregional na UE.
    • Se o conjunto de dados estiver em um local regional, o bucket do Cloud Storage precisará ser um regional no mesmo local. Por exemplo, se o conjunto de dados estiver na região de Tóquio, o bucket do Cloud Storage precisará ser um regional em Tóquio.
    • Exceção: se o conjunto de dados estiver no local multirregional dos EUA, exporte os dados para um bucket do Cloud Storage em qualquer local regional ou multirregional.
  • Crie um plano de gerenciamento de dados.

Para ver mais informações sobre os locais do Cloud Storage, consulte Locais de buckets na documentação do Cloud Storage.

Como mover dados do BigQuery entre locais

Não é possível alterar o local dos conjuntos de dados após a criação, mas sim fazer uma cópia deles. Não é possível mover conjuntos de dados de um local para outro, mas sim mover (recriar) conjuntos de dados manualmente.

Como copiar conjuntos de dados

Se quiser ver as etapas de como copiar conjuntos de dado, inclusive entre regiões, consulte Como copiar conjuntos de dados.

Como mover conjuntos de dados

Para mover manualmente um conjunto de dados de um local para outro, siga estas instruções:

  1. Exporte os dados das tabelas do BigQuery para um bucket regional ou multirregional do Cloud Storage no mesmo local do conjunto de dados. Por exemplo, se o conjunto de dados estiver no local multirregional da UE, exporte os dados para um bucket regional ou multirregional na UE.

    Não há cobrança pela exportação de dados do BigQuery, mas são cobradas taxas pelo armazenamento dos dados exportados no Cloud Storage. As exportações do BigQuery estão sujeitas aos limites dos jobs de exportação.

  2. Copie ou mova os dados do bucket do Cloud Storage para um bucket regional ou multirregional no local novo. Por exemplo, se mover os dados do local multirregional dos EUA para o local regional de Tóquio, será necessário transferi-los para um bucket regional em Tóquio. Para ver mais informações sobre como transferir objetos do Cloud Storage, consulte Como renomear, copiar e mover objetos na documentação do Cloud Storage.

    A transferência de dados entre regiões gera cobranças de saída de rede no Cloud Storage.

  3. Depois de transferir os dados para um bucket do Cloud Storage no local novo, crie outro conjunto de dados do BigQuery nele. Em seguida, carregue os dados do bucket do Cloud Storage no BigQuery.

    Não haverá cobranças pelo carregamento dos dados no BigQuery, mas sim pelo armazenamento dos dados no Cloud Storage até que os dados ou o bucket sejam excluídos. Também haverá cobrança pelo armazenamento de dados no BigQuery depois que forem carregados. O carregamento de dados no BigQuery está sujeito aos limites de jobs de carregamento.

Para ver mais informações sobre como usar o Cloud Storage para armazenar e mover grandes conjuntos de dados, consulte Como usar o Cloud Storage com Big Data.

Formatos de exportação e tipos de compactação

O BigQuery é compatível com os seguintes formatos de dados e tipos de compactação dos dados exportados.

Formato de dados Tipos de compactação compatíveis Detalhes
CSV GZIP

Use a sinalização --field_delimiter da CLI ou a propriedade do job de extração configuration.extract.fieldDelimiter para controlar o delimitador CSV nos dados exportados.

Dados aninhados e repetidos não são compatíveis.

JSON GZIP Dados aninhados e repetidos são compatíveis.
Avro DEFLATE, SNAPPY

GZIP não é aceito para exportações do Avro.

Dados aninhados e repetidos são compatíveis.

Como exportar dados armazenados no BigQuery

Para exportar dados de tabela:

  • Use o Console do Cloud ou a IU da Web clássica do BigQuery;
  • Use o comando da CLI bq extract
  • Envie um job extract por meio da API ou das bibliotecas cliente

Como exportar dados de tabelas

Para exportar dados de uma tabela do BigQuery, siga estas etapas:

Console

  1. Abra a IU do BigQuery para Web no Console do Cloud.
    Acessar o Console do Cloud

  2. Na seção Recursos do painel de navegação, expanda o projeto e selecione um conjunto de dados para expandi-lo. Procure a tabela com os dados que você está exportando e clique nela.

  3. No lado direito da janela, clique em Exportar e selecione Exportar para o Google Cloud Storage

    Exportar dados

  4. Na caixa de diálogo Exportar tabela para o Google Cloud Storage, siga estas instruções:

    • Em Selecionar local do Google Cloud Storage, procure o bucket, a pasta ou o arquivo para o qual quer exportar os dados.
    • Em Formato de exportação, selecione o formato dos dados exportados: CSV, JSON (delimitado por nova linha) ou Avro.
    • Em Compactação, aceite o valor padrão, None, ou selecione GZIP. O formato Avro não pode ser usado com a compactação GZIP. Para compactar dados Avro, use a ferramenta de linha de comando bq ou a API e especifique um dos tipos de compactação compatíveis com os dados Avro: DEFLATE ou SNAPPY.
    • Clique em Exportar para exportar a tabela.

Para verificar o andamento do job, procure um job de Exportação no Histórico de jobs, na parte superior da navegação.

IU clássica

  1. Acesse a IU do BigQuery para Web.
    Acessar IU do BigQuery para Web

  2. Na navegação, clique no conjunto de dados para expandi-lo.

  3. Procure e clique no ícone de seta para baixo imagem do ícone de seta para baixo ao lado da tabela com os dados que você está exportando.

  4. Selecione Export table para exibir a caixa de diálogo Export to Google Cloud Storage.

  5. Na caixa de diálogo Export to Google Cloud Storage, siga estas etapas:

    • Em Export format, selecione o formato dos dados exportados: CSV, JSON (delimitado por nova linha) ou Avro.
    • Em Compression, aceite o valor padrão, None, ou selecione GZIP. O formato Avro não pode ser usado com a compactação GZIP. Para compactar dados Avro, use a ferramenta de linha de comando bq ou a API e especifique um dos tipos de compactação compatíveis com os dados Avro: DEFLATE ou SNAPPY.
    • Na caixa de texto Google Cloud Storage URI, digite um URI válido no formato gs://bucket_name/filename.ext, em que bucket_name é o nome do bucket do Cloud Storage, e filename.ext é o nome e a extensão do arquivo de destino. O conjunto de dados do BigQuery e o bucket do Cloud Storage precisam estar no mesmo local.
    • Clique em OK para exportar a tabela.

Enquanto o job está em execução, a informação (extraindo) é exibida ao lado do nome da tabela na navegação. Para verificar o andamento do job, procure um job Extraction em Job History, na parte superior da navegação.

CLI

Use o comando bq extractcom a sinalização --destination_format.

Há, também, a opção de digitar a sinalização --location e definir o valor do local.

Estas são outras sinalizações opcionais:

  • --compression: o tipo de compactação a ser usado para arquivos exportados.
  • --field_delimiter: o caractere que indica o limite entre as colunas no arquivo de saída para exportações de CSV. \t e tab são permitidos como delimitadores de tabulação.
  • --print_header: quando especificado, esse objeto exibe linhas de cabeçalho para formatos, como CSV, com cabeçalhos.
    bq --location=location extract \
    --destination_format format \
    --compression compression_type \
    --field_delimiter delimiter \
    --print_header=boolean \
    project_id:dataset.table \
    gs://bucket/filename.ext
    

Em que:

  • location é o nome do local. A sinalização --location é opcional. Por exemplo, se usar o BigQuery na região de Tóquio, defina o valor da sinalização como asia-northeast1. Defina um valor padrão para a unidade usando o arquivo .bigqueryrc.
  • format é o formato dos dados exportados: CSV, NEWLINE_DELIMITED_JSON ou AVRO.
  • compression_type é um tipo de compactação compatível com o formato dos dados. CSV e NEWLINE_DELIMITED_JSON são compatíveis com GZIP. AVRO é compatível com DEFLATE e SNAPPY.
  • delimiter é o caractere que indica o limite entre as colunas nas exportações de CSV. \t e tab são nomes aceitos para a tabulação.
  • boolean é true ou false. Quando definida como true, as linhas de cabeçalho são exibidas nos dados exportados se o formato de dados for compatível com cabeçalhos. O valor padrão é true.
  • project_id é o código do projeto.
  • dataset é o nome do conjunto de dados de origem.
  • table é a tabela que você está exportando.
  • bucket é o nome do bucket do Cloud Storage ao qual você está exportando os dados. O conjunto de dados do BigQuery e o bucket do Cloud Storage precisam estar no mesmo local.
  • filename.ext é o nome e extensão do arquivo de dados exportado. Exporte para vários arquivos com um caractere curinga.

Exemplos:

Por exemplo, o comando a seguir exporta mydataset.mytable para um arquivo gzip compactado chamado myfile.csv. myfile.csv é armazenado em um bucket do Cloud Storage chamado example-bucket.

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

O formato de destino padrão é CSV. Para exportar para JSON ou Avro, use a sinalização destination_format, que precisa ser definida como NEWLINE_DELIMITED_JSON ou AVRO. Por exemplo:

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

O comando a seguir exporta mydataset.mytable em um arquivo Avro, que é compactado usando o Snappy. O nome do arquivo é myfile.avro. myfile.avro é exportado para um bucket do Cloud Storage chamado example-bucket.

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

API

Para exportar dados, crie um job extract e preencha a configuração do job.

Há, também, a opção de especificar o local na propriedade location, na seção jobReference do recurso do job.

  1. Crie um job de extração que aponte para os dados de origem do BigQuery e para o destino do Cloud Storage.

  2. Especifique a tabela de origem usando o objeto de configuração sourceTable, que contém o código do projeto, do conjunto de dados e da tabela.

  3. A property destination URI(s) precisa estar totalmente qualificada no formato gs://bucket/filename.ext. ada URI pode conter um caractere curinga '*' e precisa vir depois do nome do bucket.

  4. Especifique o formato de dados definindo a property configuration.extract.destinationFormat. Por exemplo, para exportar um arquivo JSON, defina essa property com o valor NEWLINE_DELIMITED_JSON.

  5. Para verificar o status do job, chame jobs.get(job_id) com o código do job retornado pela solicitação inicial.

    • status.state = DONE indica que o job foi concluído.
    • A property status.errorResult indica que houve um erro na solicitação, e o objeto incluirá informações sobre o que deu errado.
    • Se status.errorResult não for exibido, o job foi concluído, mesmo que haja erros não fatais. Os erros não fatais são listados na property status.errors do objeto do job retornado.

Observações da API:

  • Como prática recomendada, gere um código exclusivo e transmita-o como jobReference.jobId, ao chamar jobs.insert para criar um job. Esse método é mais resistente a erros de rede porque o cliente pode pesquisar ou tentar novamente com o código do job conhecido.

  • Chamar jobs.insert em determinado código de job é idempotente, ou seja, é possível repetir o processo quantas vezes quiser com o mesmo código e, no máximo, uma das operações será bem-sucedida.

C#

Antes de testar esta amostra, siga as instruções de configuração do C# no Guia de início rápido: como usar bibliotecas de cliente do BigQuery. Para ver mais informações, consulte a documentação de referência da API C# do BigQuery (em inglês).


    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 testar esta amostra, siga as instruções de configuração do Go no Guia de início rápido: como usar bibliotecas de cliente do BigQuery. Para ver mais informações, consulte a documentação de referência da API Go do BigQuery (em inglês).

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 testar esta amostra, siga as instruções de configuração do Java no Guia de início rápido: como usar bibliotecas de cliente do BigQuery. Para ver mais informações, consulte a documentação de referência da API Java do BigQuery (em inglês).

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 ExtractTableToJson {

      public static void runExtractTableToJson() {
        // 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";
        extractTableToJson(projectId, datasetName, tableName, destinationUri);
      }

      // Exports datasetName:tableName to destinationUri as raw CSV
      public static void extractTableToJson(
          String projectId, String datasetName, String tableName, String destinationUri) {
        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);

          // 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
          Job job = table.extract("CSV", 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 CSV file.");
        } catch (BigQueryException | InterruptedException e) {
          System.out.println("Table extraction job was interrupted. \n" + e.toString());
        }
      }
    }

Node.js

Antes de testar esta amostra, siga as instruções de configuração do Node.js no Guia de início rápido: como usar bibliotecas de cliente do BigQuery. Para ver mais informações, consulte a documentação de referência da API Node.js do BigQuery (em inglês).

// 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);
      // 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 testar esta amostra, siga as instruções de configuração de PHP no Guia de início rápido: como usar bibliotecas de cliente do BigQuery. Para ver mais informações, consulte a documentação de referência da API PHP do BigQuery (em inglês).

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 testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido: como usar bibliotecas de cliente do BigQuery. Para ver mais informações, consulte a documentação de referência da API Python do BigQuery (em inglês).

# 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 = client.dataset(dataset_id, project=project)
    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 testar este exemplo, siga as instruções de configuração do Ruby no Guia de início rápido: como usar bibliotecas de cliente do BigQuery. Para ver mais informações, consulte a documentação de referência da API Ruby do BigQuery (em inglês).

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

Detalhes da exportação em Avro

No BigQuery, os dados formatados em Avro são expressos das seguintes maneiras:

  • Os arquivos de exportação resultantes são de contêiner Avro.
  • Cada linha do BigQuery é representada como um registro Avro. Os dados aninhados são representados por objetos de registro aninhados.
  • Os campos REQUIRED são representados como tipos Avro correspondentes. Por exemplo, um tipo INTEGER do BigQuery é mapeado para um tipo Avro LONG.
  • Os campos NULLABLE são representados como uma união Avro do tipo correspondente e "null" (nulo, em inglês).
  • Os campos REPEATED são representados como matrizes Avro.
  • Os tipos de dados TIMESTAMP são representados como tipos lógicos Avro timestamp-micros.
  • Os tipos de dados DATE são representados como tipos Avro INT por padrão ou tipos lógicos Avro date se a sinalização --use_avro_logical_types for especificada.
  • Os tipos de dados TIME são representados como tipos Avro LONG por padrão ou tipos lógicos Avro time-micros se a sinalização --use_avro_logical_types for especificada.
  • Os tipos de dados DATETIME são representados como tipos Avro STRING. A codificação segue as especificações RFC 3339 da Internet Engineering Task Force.

O formato Avro não pode ser usado com a compactação GZIP. Para compactar dados Avro, use a ferramenta de linha de comando bq ou a API e especifique um dos tipos de compactação compatíveis com os dados Avro: DEFLATE ou SNAPPY.

Como exportar dados para um ou mais arquivos

A propriedade destinationUris indica os locais e os nomes dos arquivos para onde o BigQuery exportará seus arquivos.

O BigQuery aceita apenas um operador de caractere curinga (*) para cada URI. O caractere pode ser usado em qualquer posição do URI, exceto como parte do nome do bucket. O uso do operador de caractere curinga faz com que o BigQuery crie diversos arquivos fragmentados com base no padrão fornecido. Esse operador é substituído por um número de 12 dígitos preenchido à esquerda, começando por 0. Por exemplo, um URI com caractere curinga no fim do nome do arquivo gera arquivos com 000000000000 anexado ao primeiro arquivo, 000000000001 anexado ao segundo e assim por diante.

Na tabela abaixo, há várias opções possíveis para a property destinationUris:

opções para `destinationUris`
URI único

Use só um URI se exportar dados de tabela com 1 GB ou menos. Essa opção é o caso de uso mais comum porque os dados exportados, no geral, são menores do que o valor máximo de 1 GB.

Definição da propriedade:

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

Gera:


gs://my-bucket/file-name.json
URI único com caractere curinga

Use um URI com só um caractere coringa para exportar dados maiores do que o valor máximo de 1 GB. Os dados são fragmentados pelo BigQuery entre diversos arquivos com base no padrão fornecido. O tamanho dos arquivos exportados varia.

Se usar um caractere curinga em um componente do URI diferente do nome do arquivo, verifique se o componente do caminho não existe antes de exportar os dados.

Definição da propriedade:

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

Gera:


gs://my-bucket/file-name-000000000000.json
    gs://my-bucket/file-name-000000000001.json
    gs://my-bucket/file-name-000000000002.json
    ...
Vários URIs com caracteres curinga

Para particionar a saída da exportação, use vários URIs com caracteres curinga. Essa opção pode ser útil se gerar um job de processamento em paralelo com um serviço como o Dataproc. Determine quantos workers estarão disponíveis para processar o job e crie um URI para cada um deles. Cada local do URI no BigQuery é tratado como partição, e um processamento paralelo é usado para fragmentar os dados entre diversos arquivos para cada local. Use o padrão que quiser no nome do arquivo, desde que haja um único operador de caractere curinga em cada URI, que cada URI seja exclusivo e que a quantidade de URIs não exceda a política de cotas.

Quando você transmite mais de um URI com caractere curinga, o BigQuery cria um arquivo especial no final de cada partição que indica o arquivo final no conjunto. O nome desse arquivo indica o número de fragmentos criados pelo BigQuery.

Por exemplo, se o URI com caractere curinga for gs://my-bucket/file- name-<worker number>-*.json e o BigQuery criar 80 arquivos fragmentados, o nome do arquivo de registro zero será gs://my-bucket/file-name-<worker number>-000000000080.json. Com esse nome de arquivo, você determina que foram criados 80 arquivos fragmentados no BigQuery (com nome 000000000000-000000000079).

Os arquivos de registro zero podem conter mais de 0 byte dependendo do formato de dados. Isso ocorre, por exemplo, quando dados no formato CSV são exportados com um cabeçalho de coluna.

Padrão de string:

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

Definição da propriedade:


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

Gera:

Neste exemplo, presume-se que foram criados 80 arquivos fragmentados no BigQuery para cada partição.


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

Política de cotas

Para ver mais informações sobre cotas de jobs de exportação, consulte Exportar jobs na página Cotas e limites.

Preços

No momento, não há cobrança pela exportação de dados do BigQuery, mas as exportações estão sujeitas às Cotas e limites do BigQuery. Para ver mais informações sobre os preços do BigQuery, consulte a página Preços do BigQuery.

Depois que os dados forem exportados, você receberá uma cobrança pelo armazenamento deles no Cloud Storage. Para ver mais informações sobre preços do Cloud Storage, consulte a página Preços do Cloud Storage.

A seguir