Como gravar resultados de consulta

Neste documento, você verá como gravar ou salvar resultados de consulta.

Tabelas temporárias e permanentes

O BigQuery salva todos os resultados de consulta em uma tabela, que pode ser permanente ou temporária.

• O BigQuery usa tabelas temporárias para armazenar em cache os resultados da consulta que não são gravados em uma tabela permanente. As tabelas são criadas em um conjunto de dados especial e nomeadas aleatoriamente. Também é possível criar tabelas temporárias para uso próprio nas consultas de várias instruções e sessões.

• Após o término de uma consulta, a tabela temporária existirá por até 24 horas. Para ver os dados e a estrutura da tabela, acesse o console do BigQuery, clique em Histórico pessoal e escolha a consulta que criou a tabela temporária. Depois, na linha Tabela de destino, clique em Tabela temporária.

• O acesso aos dados da tabela temporária é restrito ao usuário ou à conta de serviço que criou o job de consulta.

• Não é possível compartilhar tabelas temporárias, e elas não são visíveis usando listas padrões ou outros métodos de manipulação de tabela. Não há cobrança pelo armazenamento de tabelas temporárias. Tabelas temporárias são criadas na mesma região que a tabela ou as tabelas que estão sendo consultadas.

• Uma tabela permanente pode ser uma tabela nova ou atual em qualquer conjunto de dados a que você tenha acesso. Se você gravar os resultados da consulta em uma tabela nova, será cobrado pelo armazenamento dos dados. Quando você grava os resultados da consulta em uma tabela permanente, as tabelas consultadas precisam estar no mesmo local que o conjunto de dados que contém a tabela de destino.

Permissões necessárias

Para gravar resultados de consulta em uma tabela, é necessário ter, no mínimo, as seguintes permissões:

• bigquery.tables.create para criar uma nova tabela
• bigquery.tables.updateData para gravar dados em uma nova tabela, substituir uma tabela ou anexar dados a uma tabela
• bigquery.jobs.create para executar um job de consulta

Outras permissões, como bigquery.tables.getData, podem ser necessárias para acessar os dados que você está consultando.

Os seguintes papéis predefinidos do IAM incluem as permissões bigquery.tables.create e bigquery.tables.updateData:

• bigquery.dataEditor
• bigquery.dataOwner
• bigquery.admin

Os seguintes papéis predefinidos do IAM incluem as permissões bigquery.jobs.create:

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

Além disso, quando um usuário tem permissões bigquery.datasets.create e cria um conjunto de dados, ele recebe o acesso bigquery.dataOwner ao conjunto. O acesso bigquery.dataOwner permite que o usuário crie e atualize tabelas no conjunto de dados.

Para mais informações sobre papéis e permissões do IAM no BigQuery, consulte Papéis e permissões predefinidos.

Como gravar resultados de consulta em uma tabela permanente

Ao gravar resultados de consulta em uma tabela permanente, é possível criar uma tabela nova, anexar os resultados a uma atual ou substituí-la. Grave os resultados da consulta em uma tabela permanente das seguintes maneiras:

• Usando o Console do Google Cloud.
• usando o comando bq da ferramenta de linha de comando bq query;
• chame o método de API jobs.insert e configure um job query;
• usando bibliotecas de cliente;

Como gravar resultados de consulta

Use o procedimento a seguir para gravar os resultados da consulta em uma tabela permanente. Para ajudar a controlar custos, é possível visualizar os dados antes de executar a consulta.

Console

1. Abra a página do BigQuery no console do Google Cloud.

   Acesse a página do BigQuery

2. No painel Explorer, expanda o projeto e selecione um conjunto de dados.

3. Insira uma consulta SQL válida.

4. Clique em Mais e selecione Configurações de consulta.

   

5. Selecione a opção Definir uma tabela de destino para os resultados da consulta.

   

6. Na seção Destino, selecione o Conjunto de dados em que você quer criar a tabela e escolha um ID de tabela.

7. Na seção Preferência de gravação na tabela de destino, escolha uma das seguintes opções:

   • Gravar apenas se a tabela estiver vazia: grava os resultados da consulta na tabela apenas se ela estiver vazia.
   • Anexar à tabela: anexa os resultados da consulta a uma tabela atual.
   • Substituir tabela: usa os resultados da consulta para substituir uma tabela atual com o mesmo nome.

8. Opcional: em Local dos dados, escolha o local.

9. Para atualizar as configurações de consulta, clique em Salvar.

10. Clique em Executar. Isso cria um job de consulta que grava os resultados da consulta na tabela que você especificou.

Como alternativa, se você esquecer de especificar uma tabela de destino antes de executar a consulta, clique no botão Salvar resultados acima do editor para copiar a tabela de resultados em cache para uma tabela permanente.

SQL

O exemplo a seguir usa a instrução CREATE TABLE para criar a tabela trips a partir de dados na tabela pública bikeshare_trips:

1. No Console do Google Cloud, acesse a página BigQuery.

   Ir para o BigQuery

2. No editor de consultas, digite a seguinte instrução:

   CREATE TABLE mydataset.trips AS (
     SELECT
       bikeid,
       start_time,
       duration_minutes
     FROM
       bigquery-public-data.austin_bikeshare.bikeshare_trips
   );
   

3. Clique em Executar.

Para informações sobre como executar consultas, consulte Como executar consultas interativas.

Para mais informações, consulte Como criar uma nova tabela a partir de uma existente.

bq

Insira o comando bq query e especifique a sinalização --destination_table para criar uma tabela permanente com base nos resultados da consulta. Especifique a sinalização use_legacy_sql=false para usar a sintaxe SQL padrão. Para gravar os resultados da consulta em uma tabela que não esteja em seu projeto padrão, adicione o ID do projeto ao nome do conjunto de dados no seguinte formato: project_id:dataset.

Opcional: forneça a sinalização --location e defina o valor para seu local.

Para controlar a disposição de gravação de uma tabela de destino atual, especifique uma das seguintes sinalizações opcionais:

• --append_table: se a tabela de destino existir, os resultados da consulta serão anexados a ela.
• --replace: se a tabela de destino existir, ela será substituída pelos resultados da consulta.

bq --location=location query \
--destination_table project_id:dataset.table \
--use_legacy_sql=false 'query'

Substitua:

• location é o nome do local usado para processar a consulta. A sinalização --location é opcional. Por exemplo, se estiver usando o BigQuery na região de Tóquio, é possível definir o valor da sinalização como asia-northeast1. É possível definir um valor padrão para o local usando o arquivo .bigqueryrc.
• project_id é o ID do projeto.
• dataset é o nome do conjunto de dados que contém a tabela na qual você está gravando os resultados da consulta.
• table é o nome da tabela na qual você está gravando os resultados da consulta.
• query é uma consulta na sintaxe SQL padrão.

Se nenhuma sinalização de disposição de gravação for especificada, o comportamento padrão será gravar os resultados na tabela somente se ela estiver vazia. Se a tabela existir e não estiver vazia, o seguinte erro será retornado: "BigQuery error in query operation: Error processing job project_id:bqjob_123abc456789_00000e1234f_1': Already Exists: Table project_id:dataset.table".

Exemplos:

Observação: nestes exemplos, consultamos um conjunto de dados públicos localizado nos EUA. Como o conjunto de dados público é armazenado no local multirregional dos EUA, o conjunto de dados que contém a tabela de destino também precisa estar nesse país. Não é possível consultar um conjunto de dados em um local e gravar os resultados em uma tabela de destino em outro local.

Digite o comando a seguir para gravar resultados de consulta em uma tabela de destino chamada mytable em mydataset. O conjunto de dados está no projeto padrão. Como nenhuma sinalização de disposição de gravação está especificada no comando, a tabela precisa ser nova ou estar vazia. Caso contrário, é retornado um erro Already exists. A consulta recupera dados do conjunto de dados público USA Name Data (link em inglês).

bq query \
--destination_table mydataset.mytable \
--use_legacy_sql=false \
'SELECT
  name,
  number
FROM
  `bigquery-public-data`.usa_names.usa_1910_current
WHERE
  gender = "M"
ORDER BY
  number DESC'

Digite o comando a seguir para usar resultados da consulta e substituir uma tabela de destino chamada mytable em mydataset. O conjunto de dados está no projeto padrão. O comando usa a sinalização --replace para substituir a tabela de destino.

bq query \
--destination_table mydataset.mytable \
--replace \
--use_legacy_sql=false \
'SELECT
   name,
   number
 FROM
   `bigquery-public-data`.usa_names.usa_1910_current
 WHERE
   gender = "M"
 ORDER BY
   number DESC'
 

Digite o comando a seguir para anexar resultados de consulta a uma tabela de destino chamada mytable em mydataset. O conjunto de dados está em my-other-project, e não no projeto padrão. O comando usa a sinalização --append_table para anexar os resultados da consulta na tabela de destino.

bq query \
--append_table \
--use_legacy_sql=false \
--destination_table my-other-project:mydataset.mytable \
'SELECT
   name,
   number
 FROM
   `bigquery-public-data`.usa_names.usa_1910_current
 WHERE
   gender = "M"
 ORDER BY
   number DESC'
 

A saída de cada um desses exemplos será semelhante ao seguinte. Para facilitar a leitura, ocultamos parte do resultado.

Waiting on bqjob_r123abc456_000001234567_1 ... (2s) Current status: DONE
+---------+--------+
|  name   | number |
+---------+--------+
| Robert  |  10021 |
| John    |   9636 |
| Robert  |   9297 |
| ...              |
+---------+--------+

API

Para salvar resultados de consulta em uma tabela permanente, chame o método jobs.insert, configure um job query e inclua um valor para a property destinationTable. Para controlar a disposição de gravação de uma tabela de destino atual, configure a property writeDisposition.

Para controlar o local de processamento do job de consulta, especifique a property location na seção jobReference do recurso do job.

Go

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

bigquery/snippets/querying/bigquery_query_destination_table.go

Ver no GitHub Feedback

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigquery"
	"google.golang.org/api/iterator"
)

// queryWithDestination demonstrates saving the results of a query to a specific table by setting the destination
// via the API properties.
func queryWithDestination(w io.Writer, projectID, destDatasetID, destTableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// tableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	q := client.Query("SELECT 17 as my_col")
	q.Location = "US" // Location must match the dataset(s) referenced in query.
	q.QueryConfig.Dst = client.Dataset(destDatasetID).Table(destTableID)
	// Run the query and print results when the query job is completed.
	job, err := q.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
	}
	it, err := job.Read(ctx)
	for {
		var row []bigquery.Value
		err := it.Next(&row)
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintln(w, row)
	}
	return nil
}

Java

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

Para salvar os resultados de consulta em uma tabela permanente, defina a tabela de destino como o TableId desejado em uma QueryJobConfiguration.

Ver no GitHub

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.QueryJobConfiguration;
import com.google.cloud.bigquery.TableId;

public class SaveQueryToTable {

  public static void runSaveQueryToTable() {
    // TODO(developer): Replace these variables before running the sample.
    String query = "SELECT corpus FROM `bigquery-public-data.samples.shakespeare` GROUP BY corpus;";
    String destinationTable = "MY_TABLE";
    String destinationDataset = "MY_DATASET";

    saveQueryToTable(destinationDataset, destinationTable, query);
  }

  public static void saveQueryToTable(
      String destinationDataset, String destinationTableId, String query) {
    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();

      // Identify the destination table
      TableId destinationTable = TableId.of(destinationDataset, destinationTableId);

      // Build the query job
      QueryJobConfiguration queryConfig =
          QueryJobConfiguration.newBuilder(query).setDestinationTable(destinationTable).build();

      // Execute the query.
      bigquery.query(queryConfig);

      // The results are now saved in the destination table.

      System.out.println("Saved query ran successfully");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Saved query did not run \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 do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery Node.js.

Ver no GitHub Feedback

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

async function queryDestinationTable() {
  // Queries the U.S. given names dataset for the state of Texas
  // and saves results to permanent table.

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

  // Create destination table reference
  const dataset = bigquery.dataset(datasetId);
  const destinationTable = dataset.table(tableId);

  const query = `SELECT name
    FROM \`bigquery-public-data.usa_names.usa_1910_2013\`
    WHERE state = 'TX'
    LIMIT 100`;

  // For all options, see https://cloud.google.com/bigquery/docs/reference/v2/tables#resource
  const options = {
    query: query,
    // Location must match that of the dataset(s) referenced in the query.
    location: 'US',
    destination: destinationTable,
  };

  // Run the query as a job
  const [job] = await bigquery.createQueryJob(options);

  console.log(`Job ${job.id} started.`);
  console.log(`Query results loaded to table ${destinationTable.id}`);
}

Python

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

Para salvar resultados de consulta em uma tabela permanente, crie um QueryJobConfig e defina o destino como a TableReference desejada. Transmita a configuração do job para o método de consulta (links em inglês).

Ver no GitHub Feedback

from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Set table_id to the ID of the destination table.
# table_id = "your-project.your_dataset.your_table_name"

job_config = bigquery.QueryJobConfig(destination=table_id)

sql = """
    SELECT corpus
    FROM `bigquery-public-data.samples.shakespeare`
    GROUP BY corpus;
"""

# Start the query, passing in the extra configuration.
query_job = client.query(sql, job_config=job_config)  # Make an API request.
query_job.result()  # Wait for the job to complete.

print("Query results loaded to the table {}".format(table_id))

Como gravar resultados de consulta extensos

Normalmente, as consultas têm um tamanho máximo de resposta. Se você planeja executar uma consulta que possa retornar resultados maiores, é possível realizar uma das seguintes ações:

• especificar uma tabela de destino para os resultados da consulta no SQL padrão;
• especificar uma tabela de destino e definir a opção allowLargeResults no SQL legado.

Não há cobrança pelo armazenamento dos dados ao especificar uma tabela de destino para resultados de consulta extensos.

Limitações

No SQL legado, a gravação de resultados extensos está sujeita a estas limitações:

• É necessário especificar uma tabela de destino.
• Não é possível especificar uma cláusula de nível superior ORDER BY, TOP ou LIMIT. Se você fizer isso, o benefício de usar allowLargeResults será negado, porque a saída da consulta não poderá mais ser computada em paralelo.
• As funções de janela somente poderão retornar resultados de consulta extensos se usadas em conjunto com uma cláusula PARTITION BY.

Como gravar resultados extensos usando SQL legado

Para gravar conjuntos de resultados extensos usando SQL legado:

Console

1. No Console do Cloud, abra a página do BigQuery.

   Ir para o BigQuery

2. Clique em Escrever nova consulta.

3. Insira uma consulta SQL válida na área de texto do Editor de consultas. Use o prefixo #legacySQL ou verifique se você marcou Usar SQL legado nas configurações da consulta.

4. Clique em Mais e selecione Configurações de consulta.

   

5. Em Destino, marque Definir uma tabela de destino para os resultados da consulta.

   

6. Em Conjunto de dados, selecione o conjunto de dados que armazenará a tabela.

7. No campo ID da tabela, insira um nome de tabela.

8. Se você estiver gravando um conjunto de resultados extensos em uma tabela atual, use as opções de Preferência de gravação na tabela de destino para controlar a disposição de gravação da tabela de destino:

   • Write if empty: grava os resultados da consulta na tabela apenas se ela estiver vazia.
   • Anexar à tabela: anexa os resultados da consulta a uma tabela atual.
   • Overwrite table: usa os resultados da consulta para substituir uma tabela atual com o mesmo nome.

9. Em Tamanho dos resultados, marque Permitir resultados extensos (sem limite de tamanho).

10. Opcional: em Local dos dados, escolha o local dos dados.

11. Clique em Salvar para atualizar as configurações da consulta.

12. Clique em Executar. Isso cria um job de consulta que grava os resultados extensos definidos na tabela que você especificou.

bq

Use a sinalização --allow_large_results com a sinalização --destination_table para criar uma tabela de destino que armazene o conjunto de resultados extensos. Como a opção -- allow_large_results só se aplica ao SQL legado, é preciso especificar também a sinalização --use_legacy_sql=true. Para gravar os resultados da consulta em uma tabela que não esteja no projeto padrão, adicione o ID do projeto ao nome do conjunto de dados no seguinte formato: PROJECT_ID:DATASET. Forneça a sinalização --location e defina o valor como seu local.

Para controlar a disposição de gravação de uma tabela de destino atual, especifique uma das seguintes sinalizações opcionais:

• --append_table: se a tabela de destino existir, os resultados da consulta serão anexados a ela.
• --replace: se a tabela de destino existir, ela será substituída pelos resultados da consulta.

bq --location=location query \
--destination_table PROJECT_ID:DATASET.TABLE \
--use_legacy_sql=true \
--allow_large_results "QUERY"

Substitua:

• LOCATION é o nome do local usado para processar a consulta. A sinalização --location é opcional. Por exemplo, se estiver usando o BigQuery na região de Tóquio, é possível definir o valor da sinalização como asia-northeast1. É possível definir um valor padrão para o local usando o arquivo .bigqueryrc.
• PROJECT_ID é o ID do projeto.
• DATASET é o nome do conjunto de dados que contém a tabela na qual você está gravando os resultados da consulta.
• TABLE é o nome da tabela na qual você está gravando os resultados da consulta.
• QUERY é uma consulta na sintaxe do SQL legado.

Exemplos:

Observação: nestes exemplos, consultamos um conjunto de dados público. Como o conjunto de dados público é armazenado no local multirregional US, o conjunto de dados de destino também precisa estar nos EUA. Não é possível gravar resultados de uma consulta de dados públicos em uma tabela de outro local.

Digite o comando a seguir para gravar resultados de consulta extensos em uma tabela de destino chamada mytable em mydataset. O conjunto de dados está no projeto padrão. Como nenhuma sinalização de disposição de gravação está especificada no comando, a tabela precisa ser nova ou estar vazia. Caso contrário, é retornado um erro Already exists. A consulta recupera dados do conjunto de dados público USA Name Data. Essa consulta é usada apenas para fins de exemplo. O conjunto de resultados retornado não excede o tamanho máximo de resposta.

bq query \
--destination_table mydataset.mytable \
--use_legacy_sql=true \
--allow_large_results \
"SELECT
  name,
  number
FROM
  [bigquery-public-data:usa_names.usa_1910_current]
WHERE
  gender = 'M'
ORDER BY
  number DESC"

Digite o comando a seguir para usar resultados de consulta extensos e substituir uma tabela de destino chamada mytable em mydataset. O conjunto de dados está em myotherproject, e não no projeto padrão. O comando usa a sinalização --replace para substituir a tabela de destino.

bq query \
--destination_table mydataset.mytable \
--replace \
--use_legacy_sql=true \
--allow_large_results \
"SELECT
  name,
  number
FROM
  [bigquery-public-data:usa_names.usa_1910_current]
WHERE
  gender = 'M'
ORDER BY
  number DESC"

Digite o comando a seguir para anexar resultados de consulta extensos em uma tabela de destino chamada mytable em mydataset. O conjunto de dados está em myotherproject, e não no projeto padrão. O comando usa a sinalização --append_table para anexar os resultados da consulta na tabela de destino.

bq query \
--destination_table myotherproject:mydataset.mytable \
--append_table \
--use_legacy_sql=true \
--allow_large_results \
"SELECT
  name,
  number
FROM
  [bigquery-public-data:usa_names.usa_1910_current]
WHERE
  gender = 'M'
ORDER BY
  number DESC"

API

Para gravar resultados extensos em uma tabela de destino, chame o método jobs.insert, configure um job query e defina a property allowLargeResults como true. Especifique a tabela de destino usando a property destinationTable. Para controlar a disposição de gravação de uma tabela de destino atual, configure a property writeDisposition.

Especifique seu local na property location da seção jobReference do recurso do job.

Go

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

Ver no GitHub Feedback

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigquery"
	"google.golang.org/api/iterator"
)

// queryLegacyLargeResults demonstrates issuing a legacy SQL query and writing a large result set
// into a destination table.
func queryLegacyLargeResults(w io.Writer, projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "destinationdataset"
	// tableID := "destinationtable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	q := client.Query(
		"SELECT corpus FROM [bigquery-public-data:samples.shakespeare] GROUP BY corpus;")
	q.UseLegacySQL = true
	q.AllowLargeResults = true
	q.QueryConfig.Dst = client.Dataset(datasetID).Table(tableID)
	// Run the query and print results when the query job is completed.
	job, err := q.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
	}
	it, err := job.Read(ctx)
	for {
		var row []bigquery.Value
		err := it.Next(&row)
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintln(w, row)
	}
	return nil
}

Java

Para ativar resultados extensos, defina Permitir resultados extensos como true e configure a tabela de destino como o TableId desejado em uma QueryJobConfiguration.

samples/snippets/src/main/java/com/example/bigquery/QueryLargeResults.java

Ver no GitHub Feedback

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.QueryJobConfiguration;
import com.google.cloud.bigquery.TableId;
import com.google.cloud.bigquery.TableResult;

// Sample to run query with large results and save the results to a table.
public class QueryLargeResults {

  public static void runQueryLargeResults() {
    // TODO(developer): Replace these variables before running the sample.
    String destinationDataset = "MY_DESTINATION_DATASET_NAME";
    String destinationTable = "MY_DESTINATION_TABLE_NAME";
    String query = "SELECT corpus FROM [bigquery-public-data:samples.shakespeare] GROUP BY corpus;";
    queryLargeResults(destinationDataset, destinationTable, query);
  }

  public static void queryLargeResults(
      String destinationDataset, String destinationTable, String query) {
    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();

      QueryJobConfiguration queryConfig =
          // To use legacy SQL syntax, set useLegacySql to true.
          QueryJobConfiguration.newBuilder(query)
              .setUseLegacySql(true)
              // Save the results of the query to a permanent table.
              .setDestinationTable(TableId.of(destinationDataset, destinationTable))
              // Allow results larger than the maximum response size.
              // If true, a destination table must be set.
              .setAllowLargeResults(true)
              .build();

      TableResult results = bigquery.query(queryConfig);

      results
          .iterateAll()
          .forEach(row -> row.forEach(val -> System.out.printf("%s,", val.toString())));

      System.out.println("Query large results performed successfully.");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Query not performed \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 do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery Node.js.

Ver no GitHub Feedback

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

async function queryLegacyLargeResults() {
  // Query enables large result sets.

  /**
   * TODO(developer): Uncomment the following lines before running the sample
   */
  // const projectId = "my_project"
  // const datasetId = "my_dataset";
  // const tableId = "my_table";

  const query = `SELECT word FROM [bigquery-public-data:samples.shakespeare] LIMIT 10;`;

  // For all options, see https://cloud.google.com/bigquery/docs/reference/rest/v2/jobs/query
  const options = {
    query: query,
    // Location must match that of the dataset(s) referenced
    // in the query and of the destination table.
    useLegacySql: true,
    allowLargeResult: true,
    destinationTable: {
      projectId: projectId,
      datasetId: datasetId,
      tableId: tableId,
    },
  };

  const [job] = await bigquery.createQueryJob(options);
  console.log(`Job ${job.id} started.`);

  // Wait for the query to finish
  const [rows] = await job.getQueryResults();

  // Print the results
  console.log('Rows:');
  rows.forEach(row => console.log(row));
}

Python

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

Ver no GitHub Feedback

from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Set table_id to the ID of the destination table.
# table_id = "your-project.your_dataset.your_table_name"

# Set the destination table and use_legacy_sql to True to use
# legacy SQL syntax.
job_config = bigquery.QueryJobConfig(
    allow_large_results=True, destination=table_id, use_legacy_sql=True
)

sql = """
    SELECT corpus
    FROM [bigquery-public-data:samples.shakespeare]
    GROUP BY corpus;
"""

# Start the query, passing in the extra configuration.
query_job = client.query(sql, job_config=job_config)  # Make an API request.
query_job.result()  # Wait for the job to complete.

print("Query results loaded to the table {}".format(table_id))

Como fazer o download e salvar resultados de consulta no console do Google Cloud

Depois de executar uma consulta SQL usando o console do Google Cloud, salve os resultados em outro local. Use o console do Google Cloud para fazer o download dos resultados da consulta para um arquivo local, Planilhas ou Drive. Não é possível salvar os resultados em um arquivo local, no Planilhas Google ou no Google Drive usando a ferramenta de linha de comando bq ou a API.

Limitações

As seguintes limitações podem ser aplicadas ao fazer o download dos resultados da consulta e salvá-los:

• Só é possível fazer o download dos resultados da consulta localmente no formato CSV ou JSON delimitado por linhas novas.
• Não é possível salvar resultados de consulta que contenham dados aninhados e repetidos no Planilhas Google.
• Para salvar os resultados da consulta no Google Drive usando o console do Google Cloud, o conjunto de resultados precisa ter 1 GB ou menos. Se os resultados forem maiores, salve-os em uma tabela.
• Ao salvar os resultados da consulta em um arquivo CSV local, o tamanho máximo do download é de 10 MB. O tamanho máximo do download é baseado no tamanho de cada linha retornada na resposta do método tabledata.list e pode variar de acordo com o esquema dos resultados da consulta. Como resultado, o tamanho do arquivo CSV salvo pode variar e pode ser menor que o limite máximo de tamanho de download.
• Só é possível salvar os resultados da consulta no Google Drive no formato CSV ou JSON delimitado por linhas novas.

Como fazer o download de resultados de consulta para um arquivo local

Não é possível fazer o download dos resultados da consulta para um arquivo local usando a ferramenta de linha de comando bq ou a API.

Para fazer o download dos resultados da consulta como um arquivo CSV ou JSON delimitado por linhas novas, use o console do Google Cloud:

Console

1. No Console do Cloud, abra a página do BigQuery.

   Ir para o BigQuery

2. Clique em Escrever nova consulta.

3. Insira uma consulta SQL válida na área de texto do Editor de consultas.

4. Opcional: para alterar o local de processamento, clique em Mais e selecione Configurações de consulta. Em Local dos dados, escolha o local dos dados.

5. Clique em Executar.

6. Quando os resultados forem retornados, clique em Salvar resultados e selecione o formato/local em que quer salvá-los.

   O arquivo é salvo no local de download padrão do navegador.

Como salvar os resultados da consulta no Google Drive

Beta

Este recurso é coberto pelos Termos de ofertas pré-GA dos Termos de Serviço do Google Cloud. Os recursos anteriores à disponibilidade geral podem ter compatibilidade limitada, e as alterações neles podem não ser compatíveis com outras versões anteriores. Para mais informações, consulte as descrições das fases de lançamento.

Não é possível salvar os resultados da consulta no Drive usando a ferramenta de linha de comando bq ou a API.

Talvez você receba um erro ao tentar salvar os resultados do BigQuery no Drive. Esse erro ocorre porque a API SDK do Drive não pode acessar o Google Workspace. Para resolver o problema, ative sua conta de usuário para acessar o Drive com a API do SDK do Drive.

Para salvar os resultados da consulta no Drive, use o console do Google Cloud:

Console

1. No Console do Cloud, abra a página do BigQuery.

   Ir para o BigQuery

2. Insira uma consulta SQL válida na área de texto do Editor de consultas.

3. Clique em Executar.

4. Quando os resultados forem retornados, clique em Salvar resultados.

   

5. Selecione CSV (Google Drive) ou JSON (Google Drive). Quando você salva os resultados no Google Drive, não é possível escolher o local. Eles sempre são salvos na raiz "Meu Drive".

6. Pode levar alguns minutos para salvar os resultados no Google Drive. Depois que eles estiverem salvos, você receberá uma mensagem pop-up que inclui o nome do arquivo: bq-results-[TIMESTAMP]-[RANDOM_CHARACTERS].[CSV or JSON].

   

7. Na mensagem pop-up, clique em Abrir para abrir o arquivo. Você também pode navegar até o Google Drive e clicar em Meu Drive.

Como salvar os resultados da consulta no Planilhas Google

Não é possível salvar os resultados da consulta no Planilhas Google usando a ferramenta de linha de comando bq ou a API.

Você pode receber um erro ao tentar abrir os resultados do BigQuery no Planilhas. Esse erro ocorre porque a API SDK do Drive não pode acessar o Google Workspace. Para resolver o problema, você precisa ativar sua conta de usuário para acesso ao Planilhas com a API SDK do Drive.

Para salvar os resultados da consulta no Planilhas, use o console do Google Cloud:

Console

1. No Console do Cloud, abra a página do BigQuery.

   Ir para o BigQuery

2. Clique em Escrever nova consulta.

3. Insira uma consulta SQL válida na área de texto do Editor de consultas.

4. Opcional: para alterar o local de processamento, clique em Mais e selecione Configurações de consulta. Em Local dos dados, escolha o local dos dados.

5. Clique em Executar.

6. Quando os resultados forem retornados, clique em Salvar resultados e selecione Planilhas Google.

7. Se necessário, siga as instruções para fazer login na sua Conta do Google e clique em Permitir para permitir que o BigQuery grave os dados na pasta MY Drive do Google Drive.

   Depois de seguir as instruções, você receberá um e-mail com o assunto "Ferramentas do cliente do BigQuery conectadas à sua Conta do Google". O e-mail contém informações sobre as permissões que você concedeu, além das etapas para remover essas permissões.

8. Depois que os resultados forem salvos, será exibida uma mensagem semelhante a esta abaixo dos resultados da consulta no console do Google Cloud: Saved to Sheets as "results-20190225-103531. Open. Clique no link da mensagem para ver os resultados no Planilhas Google ou navegue até a pasta My Drive e abra o arquivo manualmente.

   Quando você salva os resultados da consulta no Planilhas Google, o nome do arquivo começa com results-[DATE], onde [DATE] é a data de hoje no formato YYYYMMDD.

Observação: não é possível salvar os resultados no Planilhas pela ferramenta de linha de comando bq ou pela API.