Esta página foi traduzida pela API Cloud Translation.

Escrever resultados de consultas

Este documento descreve como escrever resultados de consultas em tabelas temporárias ou permanentes.

Tabelas temporárias e permanentes

O BigQuery guarda todos os resultados da consulta numa tabela, que pode ser permanente ou temporária.

O BigQuery usa tabelas temporárias para colocar em cache os resultados das consultas que não são escritos numa tabela permanente. As tabelas são criadas num conjunto de dados especial e têm nomes aleatórios. Também pode criar tabelas temporárias para sua própria utilização em consultas com várias declarações e sessões. Não lhe são cobradas tabelas de resultados de consultas em cache temporárias. As tabelas temporárias que não são resultados de consultas em cache são-lhe cobradas.
Após a conclusão de uma consulta, a tabela temporária existe durante um máximo de 24 horas. Para ver a estrutura e os dados da tabela, aceda à consola do BigQuery, clique em Histórico pessoal e escolha a consulta que criou a tabela temporária. Em seguida, na linha Tabela de destino, clique em Tabela temporária.
O acesso aos dados da tabela temporária está restrito ao utilizador ou à conta de serviço que criou a tarefa de consulta.
Não pode partilhar tabelas temporárias, e estas não são visíveis através de nenhum dos métodos padrão de manipulação de listas ou outras tabelas. Se precisar de partilhar os resultados da consulta, escreva os resultados numa tabela permanente, transfira-os ou partilhe-os através do Google Sheets ou do Google Drive.
As tabelas temporárias são criadas na mesma região que a tabela ou as tabelas que estão a ser consultadas.
Uma tabela permanente pode ser uma tabela nova ou existente em qualquer conjunto de dados ao qual tenha acesso. Se escrever os resultados da consulta numa nova tabela, é-lhe cobrado o armazenamento dos dados. Quando escreve os resultados da consulta numa tabela permanente, as tabelas que está a consultar têm de estar na mesma localização que o conjunto de dados que contém a tabela de destino.
Não pode guardar os resultados da consulta numa tabela temporária quando a política organizacional restrita ao domínio está ativada. Como solução alternativa, desative temporariamente a política da organização restrita ao domínio, execute a consulta e, em seguida, volte a ativar a política. Em alternativa, pode guardar os resultados da consulta numa tabela de destino.

Autorizações necessárias

No mínimo, para escrever resultados de consultas numa tabela, tem de ter as seguintes autorizações:

bigquery.tables.create autorizações para criar uma nova tabela
bigquery.tables.updateData para escrever dados numa nova tabela, substituir uma tabela ou anexar dados a uma tabela
bigquery.jobs.create para executar uma tarefa de consulta

Podem ser necessárias autorizações adicionais, como bigquery.tables.getData, para aceder aos dados que está a consultar.

As seguintes funções de IAM predefinidas incluem autorizações bigquery.tables.create e bigquery.tables.updateData:

bigquery.dataEditor
bigquery.dataOwner
bigquery.admin

As seguintes funções de IAM predefinidas incluem bigquery.jobs.create autorizações:

bigquery.user
bigquery.jobUser
bigquery.admin

Além disso, se um utilizador tiver autorizações bigquery.datasets.create, quando esse utilizador cria um conjunto de dados, recebe acesso bigquery.dataOwner ao mesmo. bigquery.dataOwner dá ao utilizador a capacidade de criar e atualizar tabelas no conjunto de dados.

Para mais informações sobre as funções e as autorizações do IAM no BigQuery, consulte o artigo Funções e autorizações predefinidas.

Escreva os resultados da consulta numa tabela permanente

Quando escreve resultados de consultas numa tabela permanente, pode criar uma nova tabela, anexar os resultados a uma tabela existente ou substituir uma tabela existente.

Escrever resultados de consultas

Use o procedimento seguinte para escrever os resultados da consulta numa tabela permanente. Para ajudar a controlar os custos, pode pré-visualizar os dados antes de executar a consulta.

Consola

Abra a página do BigQuery na Google Cloud consola.

Aceda à página do BigQuery
No painel Explorador, expanda o projeto e selecione um conjunto de dados.
Introduza uma consulta SQL válida.
Clique em Mais e, de seguida, selecione Definições de consulta.
Selecione a opção Definir uma tabela de destino para os resultados da consulta.
Na secção Destino, selecione o Conjunto de dados no qual quer criar a tabela e, de seguida, escolha um ID da tabela.
Na secção Preferência de gravação da tabela de destino, escolha uma das seguintes opções:
- Escrever se estiver vazia: escreve os resultados da consulta na tabela apenas se esta estiver vazia.
- Anexar à tabela: anexa os resultados da consulta a uma tabela existente.
- Substituir tabela: substitui uma tabela existente com o mesmo nome usando os resultados da consulta.
Opcional: para Localização de dados, escolha a sua localização.
Para atualizar as definições de consulta, clique em Guardar.
Clique em Executar. Esta ação cria uma tarefa de consulta que escreve os resultados da consulta na tabela especificada.

Em alternativa, se se esquecer de especificar uma tabela de destino antes de executar a consulta, pode copiar a tabela de resultados em cache para uma tabela permanente clicando no botão Guardar resultados acima do editor.

SQL

O exemplo seguinte usa a declaração CREATE TABLE para criar a tabela trips a partir dos dados na tabela pública bikeshare_trips:

Na Google Cloud consola, aceda à página BigQuery.

Aceda ao BigQuery

No editor de consultas, introduza a seguinte declaração:

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

Clique em Executar.

Para mais informações sobre como executar consultas, consulte o artigo Execute uma consulta interativa.

Para mais informações, consulte o artigo Criar uma nova tabela a partir de uma tabela existente.

bq

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Introduza o comando bq query e especifique a flag --destination_table para criar uma tabela permanente com base nos resultados da consulta. Especifique a flag use_legacy_sql=false para usar a sintaxe GoogleSQL. Para escrever os resultados da consulta numa tabela que não esteja no seu projeto predefinido, adicione o ID do projeto ao nome do conjunto de dados no seguinte formato:project_id:dataset.

Opcional: forneça o sinalizador --location e defina o valor para a sua localização.

Para controlar a disposição de escrita de uma tabela de destino existente, especifique um dos seguintes flags opcionais:
- --append_table: se a tabela de destino existir, os resultados da consulta são anexados à mesma.
- --replace: se a tabela de destino existir, é substituída pelos resultados da consulta.
```
bq --location=location query \
--destination_table project_id:dataset.table \
--use_legacy_sql=false 'query'
```
  Substitua o seguinte:
- location é o nome da localização usada para processar a consulta. A flag --location é opcional. Por exemplo, se estiver a usar o BigQuery na região de Tóquio, pode definir o valor da flag como asia-northeast1. Pode predefinir um valor para a localização através do ficheiro .bigqueryrc.
- project_id é o ID do seu projeto.
- dataset é o nome do conjunto de dados que contém a tabela na qual está a escrever os resultados da consulta.
- table é o nome da tabela na qual está a escrever os resultados da consulta.
- query é uma consulta na sintaxe do GoogleSQL.
  
  Se não for especificada nenhuma flag de disposição de escrita, o comportamento predefinido é escrever os resultados na tabela apenas se estiver vazia. Se a tabela existir e não estiver vazia, é devolvido o seguinte erro: BigQuery error in query operation: Error processing job project_id:bqjob_123abc456789_00000e1234f_1: Already Exists: Table project_id:dataset.table.
  
  Exemplos:
  
  Nota: estes exemplos consultam um conjunto de dados público sediado nos EUA. Uma vez que o conjunto de dados público está armazenado na localização multirregião dos EUA, o conjunto de dados que contém a tabela de destino também tem de estar nos EUA. Não pode consultar um conjunto de dados numa localização e escrever os resultados numa tabela de destino noutra localização.
  
  Introduza o seguinte comando para escrever os resultados da consulta numa tabela de destino denominada mytable em mydataset. O conjunto de dados está no seu projeto predefinido. Uma vez que não é especificada nenhuma flag de disposição de escrita no comando, a tabela tem de ser nova ou estar vazia. Caso contrário, é devolvido um erro Already exists. A consulta extrai dados do conjunto de dados público de nomes dos EUA.
```
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'
```
  Introduza o seguinte comando para usar os resultados da consulta para substituir uma tabela de destino denominada mytable em mydataset. O conjunto de dados está no seu projeto predefinido. O comando usa a flag --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'
```
  Introduza o seguinte comando para anexar os resultados da consulta a uma tabela de destino denominada mytable em mydataset. O conjunto de dados está em my-other-project e não no seu projeto predefinido. O comando usa a flag --append_table para anexar os resultados da consulta à 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'
```
  O resultado de cada um destes exemplos tem o seguinte aspeto. Para facilitar a leitura, alguns resultados são truncados.
```
Waiting on bqjob_r123abc456_000001234567_1 ... (2s) Current status: DONE
+---------+--------+
|  name   | number |
+---------+--------+
| Robert  |  10021 |
| John    |   9636 |
| Robert  |   9297 |
| ...              |
+---------+--------+
```

API

Para guardar os resultados da consulta numa tabela permanente, chame o método jobs.insert, configure uma tarefa query e inclua um valor para a propriedade destinationTable. Para controlar a disposição de gravação de uma tabela de destino existente, configure a propriedade writeDisposition.

Para controlar a localização do processamento da tarefa de consulta, especifique a propriedade location na secção jobReference do recurso de tarefa.

Go

Antes de experimentar este exemplo, siga as Goinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Go BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

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 experimentar este exemplo, siga as Javainstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Java BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

Para guardar os resultados da consulta numa tabela permanente, defina a tabela de destino para o TableId desejado num QueryJobConfiguration.

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 experimentar este exemplo, siga as Node.jsinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Node.js BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

// 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 experimentar este exemplo, siga as Pythoninstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Python BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

Para guardar os resultados da consulta numa tabela permanente, crie um QueryJobConfig e defina o destino para o TableReference desejado. Transmita a configuração da tarefa ao método query.

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

Escreva resultados de consultas grandes

Normalmente, as consultas têm um tamanho máximo de resposta. Se planear executar uma consulta que possa devolver resultados maiores, pode fazer uma das seguintes ações:

No GoogleSQL, especifique uma tabela de destino para os resultados da consulta.
No SQL antigo, especifique uma tabela de destino e defina a opção allowLargeResults.

Quando especifica uma tabela de destino para resultados de consultas grandes, é-lhe cobrado o armazenamento dos dados.

Limitações

No SQL antigo, a escrita de resultados grandes está sujeita às seguintes limitações:

Tem de especificar uma tabela de destino.
Não pode especificar uma cláusula ORDER BY, TOP ou LIMIT de nível superior. Ao fazê-lo, anula a vantagem de usar allowLargeResults, porque o resultado da consulta já não pode ser calculado em paralelo.
As funções de janela só podem devolver resultados de consultas grandes se forem usadas em conjunto com uma cláusula PARTITION BY.

Escrever resultados grandes com SQL antigo

Para escrever grandes conjuntos de resultados com SQL antigo:

Consola

Na Google Cloud consola, abra a página do BigQuery.

Aceda ao BigQuery
Clique em Redigir nova consulta.
Introduza uma consulta SQL válida na área de texto do editor de consultas. Use o prefixo #legacySQL ou certifique-se de que a opção Usar SQL antigo está selecionada nas definições da consulta.
Clique em Mais e, de seguida, selecione Definições de consulta.
Para Destino, consulte o artigo Defina uma tabela de destino para os resultados da consulta.
Para Conjunto de dados, escolha o conjunto de dados que vai armazenar a tabela.
No campo ID da tabela, introduza um nome da tabela.
Se estiver a escrever um grande conjunto de resultados numa tabela existente, pode usar as opções de preferência de escrita da tabela de destino para controlar a disposição de escrita da tabela de destino:
- Escrever se estiver vazia: escreve os resultados da consulta na tabela apenas se esta estiver vazia.
- Anexar à tabela: anexa os resultados da consulta a uma tabela existente.
- Substituir tabela: substitui uma tabela existente com o mesmo nome usando os resultados da consulta.
Para o Tamanho dos resultados, selecione Permitir resultados grandes (sem limite de tamanho).
Opcional: para Localização de dados, escolha a localização dos seus dados.
Clique em Guardar para atualizar as definições de consulta.
Clique em Executar. Isto cria uma tarefa de consulta que escreve o conjunto de resultados grande na tabela especificada.

bq

Use a flag --allow_large_results com a flag --destination_table para criar uma tabela de destino para conter o grande conjunto de resultados. Uma vez que a opção --allow_large_results se aplica apenas ao SQL antigo, também tem de especificar a flag --use_legacy_sql=true. Para escrever os resultados da consulta numa tabela que não esteja no seu projeto predefinido, adicione o ID do projeto ao nome do conjunto de dados no seguinte formato: PROJECT_ID:DATASET. Forneça a flag --location e defina o valor para a sua localização.

Para controlar a disposição de escrita de uma tabela de destino existente, especifique um dos seguintes flags opcionais:

--append_table: se a tabela de destino existir, os resultados da consulta são anexados à mesma.
--replace: se a tabela de destino existir, é 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 o seguinte:

LOCATION é o nome da localização usada para processar a consulta. A flag --location é opcional. Por exemplo, se estiver a usar o BigQuery na região de Tóquio, pode definir o valor da flag como asia-northeast1. Pode predefinir um valor para a localização através do ficheiro .bigqueryrc.
PROJECT_ID é o ID do seu projeto.
DATASET é o nome do conjunto de dados que contém a tabela na qual está a escrever os resultados da consulta.
TABLE é o nome da tabela na qual está a escrever os resultados da consulta.
QUERY é uma consulta na sintaxe SQL antiga.

Exemplos:

Introduza o seguinte comando para escrever resultados de consultas grandes numa tabela de destino denominada mytable em mydataset. O conjunto de dados está no seu projeto predefinido. Uma vez que não é especificado nenhum sinalizador de disposição de escrita no comando, a tabela tem de ser nova ou estar vazia. Caso contrário, é devolvido um erro Already exists. A consulta obtém dados do conjunto de dados público de nomes dos EUA. Esta consulta é usada apenas para fins de exemplo. O conjunto de resultados devolvido não excede o tamanho máximo da 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"

Introduza o seguinte comando para usar resultados de consultas grandes para substituir uma tabela de destino com o nome mytable em mydataset. O conjunto de dados está em myotherproject e não no seu projeto predefinido. O comando usa a flag --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"

Introduza o seguinte comando para anexar resultados de consultas grandes a uma tabela de destino denominada mytable em mydataset. O conjunto de dados está em myotherproject, e não no seu projeto predefinido. O comando usa a flag --append_table para anexar os resultados da consulta à 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 escrever resultados grandes numa tabela de destino, chame o método jobs.insert, configure uma tarefa query e defina a propriedade allowLargeResults como true. Especifique a tabela de destino através da propriedade destinationTable. Para controlar a disposição de escrita de uma tabela de destino existente, configure a propriedade writeDisposition.

Especifique a sua localização na propriedade location na secção jobReference do recurso de emprego.

Go

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

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 grandes, defina allow large results como true e defina a destination table para o TableId desejado numa QueryJobConfiguration.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

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

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

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

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

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

Transferir e guardar resultados de consultas a partir da Google Cloud consola

Depois de executar uma consulta SQL através da consola Google Cloud , pode guardar os resultados noutro local. Pode usar a Google Cloud consola para transferir resultados da consulta para um ficheiro local, o Google Sheets ou o Google Drive. Se primeiro ordenar os resultados da consulta por coluna, a ordem é preservada nos dados transferidos. A ferramenta de linha de comandos bq ou a API não suportam a gravação de resultados num ficheiro local, no Google Sheets nem no Google Drive.

Limitações

A transferência e a gravação de resultados de consultas estão sujeitas às seguintes limitações:

Só pode transferir os resultados da consulta localmente no formato CSV ou JSON delimitado por nova linha.
Não pode guardar resultados de consultas que contenham dados aninhados e repetidos no Google Sheets.
Para guardar os resultados da consulta no Google Drive através da Google Cloud consola, o conjunto de resultados tem de ter um tamanho igual ou inferior a 1 GB. Se os resultados forem maiores, pode guardá-los numa tabela.
Quando guarda os resultados da consulta num ficheiro CSV local, o tamanho máximo de transferência é de 10 MB. O tamanho máximo de transferência baseia-se no tamanho de cada linha devolvida na resposta do método tabledata.list e pode variar consoante o esquema dos resultados da consulta. Como resultado, o tamanho do ficheiro CSV transferido pode variar e pode ser inferior ao limite máximo de tamanho de transferência.
Pode guardar os resultados da consulta no Google Drive apenas em formato CSV ou JSON delimitado por nova linha.

O que se segue?

Saiba como exportar uma tabela para um ficheiro JSON de forma programática.
Saiba mais sobre as quotas para tarefas de consulta.
Saiba mais acerca dos preços de armazenamento do BigQuery.