Execute uma consulta

Este documento mostra como executar uma consulta no BigQuery e compreender a quantidade de dados que a consulta vai processar antes da execução através de uma execução de teste.

Tipos de consultas

Pode consultar dados do BigQuery usando um dos seguintes tipos de tarefas de consulta:

• Tarefas de consulta interativas. Por predefinição, o BigQuery executa consultas como tarefas de consulta interativas, que se destinam a começar a ser executadas o mais rapidamente possível.

• Tarefas de consulta em lote. As consultas em lote têm uma prioridade inferior à das consultas interativas. Quando um projeto ou uma reserva usa todos os recursos de computação disponíveis, é mais provável que as consultas em lote sejam colocadas em fila e permaneçam na fila. Depois de uma consulta em lote começar a ser executada, esta é executada da mesma forma que uma consulta interativa. Para mais informações, consulte filas de consultas.

• Tarefas de consulta contínuas. Com estes trabalhos, a consulta é executada continuamente, o que lhe permite analisar os dados recebidos no BigQuery em tempo real e, em seguida, escrever os resultados numa tabela do BigQuery ou exportá-los para o Bigtable ou o Pub/Sub. Pode usar esta capacidade para realizar tarefas sensíveis ao tempo, como criar e agir imediatamente com base em estatísticas, aplicar inferência de aprendizagem automática (AA) em tempo real e criar pipelines de dados orientados por eventos.

Pode executar tarefas de consulta através dos seguintes métodos:

• Componha e execute uma consulta na Google Cloud consola.
• Execute o comando bq query na ferramenta de linhas de comando bq.
• Chame programaticamente o método jobs.query ou jobs.insert na API REST do BigQuery.
• Use as bibliotecas cliente do BigQuery.

O BigQuery guarda os resultados da consulta numa tabela temporária (predefinição) ou numa tabela permanente. Quando especifica uma tabela permanente como a tabela de destino dos resultados, pode escolher se quer acrescentar ou substituir uma tabela existente, ou criar uma nova tabela com um nome único.

Nota: se consultar dados de um projeto para dados armazenados num projeto diferente, o projeto de consulta é faturado pelo trabalho de consulta, enquanto o projeto que armazena os dados é faturado pela quantidade de dados armazenados no BigQuery.

Funções necessárias

Para receber as autorizações de que precisa para executar uma tarefa de consulta, peça ao seu administrador que lhe conceda as seguintes funções do IAM:

• Utilizador de tarefas do BigQuery (roles/bigquery.jobUser) no projeto.
• Visualizador de dados do BigQuery (roles/bigquery.dataViewer) em todas as tabelas e vistas a que a sua consulta faz referência. Para consultar visualizações, também precisa desta função em todas as tabelas e visualizações subjacentes. Se estiver a usar vistas autorizadas ou conjuntos de dados autorizados, não precisa de acesso aos dados de origem subjacentes.

Para mais informações sobre a atribuição de funções, consulte o artigo Faça a gestão do acesso a projetos, pastas e organizações.

Estas funções predefinidas contêm as autorizações necessárias para executar uma tarefa de consulta. Para ver as autorizações exatas que são necessárias, expanda a secção Autorizações necessárias:

Autorizações necessárias

São necessárias as seguintes autorizações para executar uma tarefa de consulta:

• bigquery.jobs.create no projeto a partir do qual a consulta está a ser executada, independentemente de onde os dados estão armazenados.
• bigquery.tables.getData em todas as tabelas e vistas a que a sua consulta faz referência. Para consultar visualizações, também precisa desta autorização em todas as tabelas e visualizações subjacentes. Se estiver a usar vistas autorizadas ou conjuntos de dados autorizados, não precisa de acesso aos dados de origem subjacentes.

Também pode conseguir estas autorizações com funções personalizadas ou outras funções predefinidas.

Resolução de problemas

Access Denied: Project [project_id]: User does not have bigquery.jobs.create
permission in project [project_id].

Este erro ocorre quando um principal não tem autorização para criar tarefas de consulta no projeto.

Resolução: um administrador tem de lhe conceder a autorização bigquery.jobs.create no projeto que está a consultar. Esta autorização é necessária além de qualquer autorização necessária para aceder aos dados consultados.

Para mais informações sobre as autorizações do BigQuery, consulte o artigo Controlo de acesso com a IAM.

Execute uma consulta interativa

Para executar uma consulta interativa, selecione uma das seguintes opções:

Consola

1. Aceda à página do BigQuery.

   Aceda ao BigQuery

2. Clique em Consulta SQL.

3. No editor de consultas, introduza uma consulta GoogleSQL válida.

   Por exemplo, consulte o conjunto de dados públicos do BigQueryusa_names para determinar os nomes mais comuns nos Estados Unidos entre os anos de 1910 e 2013:

   SELECT
     name, gender,
     SUM(number) AS total
   FROM
     `bigquery-public-data.usa_names.usa_1910_2013`
   GROUP BY
     name, gender
   ORDER BY
     total DESC
   LIMIT
     10;
   

   Em alternativa, pode usar o painel de referência para criar novas consultas.

4. Opcional: para apresentar automaticamente sugestões de código quando escreve uma consulta, clique em Mais e, de seguida, selecione Preenchimento automático de SQL. Se não precisar de sugestões de preenchimento automático, desmarque a opção Preenchimento automático de SQL. Esta ação também desativa as sugestões de preenchimento automático do nome do projeto.

5. Opcional: para selecionar definições de consulta adicionais, clique em Mais e, de seguida, clique em Definições de consulta.

6. Clique em Executar.

   Se não especificar uma tabela de destino, a tarefa de consulta escreve o resultado numa tabela temporária (cache).

   Agora, pode explorar os resultados da consulta no separador Resultados do painel Resultados da consulta.

7. Opcional: para ordenar os resultados da consulta por coluna, clique em Abrir menu de ordenação junto ao nome da coluna e selecione uma ordem de ordenação. Se os bytes estimados processados para a ordenação forem superiores a zero, o número de bytes é apresentado na parte superior do menu.

8. Opcional: para ver a visualização dos resultados da consulta, aceda ao separador Visualização. Pode aumentar ou diminuir o zoom do gráfico, transferir o gráfico como um ficheiro PNG ou ativar/desativar a visibilidade da legenda.

   No painel Configuração da visualização, pode alterar o tipo de visualização e configurar as métricas e as dimensões da visualização. Os campos neste painel são pré-preenchidos com a configuração inicial inferida do esquema da tabela de destino da consulta. A configuração é preservada entre as execuções de consultas seguintes no mesmo editor de consultas.

   Para visualizações de linhas, barras ou dispersão, os tipos de dados de dimensões suportados são INT64, FLOAT64, NUMERIC, BIGNUMERIC, TIMESTAMP, DATE, DATETIME, TIME e STRING, enquanto os tipos de dados de medidas suportados são INT64, FLOAT64, NUMERIC e BIGNUMERIC.

   Se os resultados da sua consulta incluírem o tipo GEOGRAPHY, o Mapa é o tipo de visualização predefinido, que lhe permite visualizar os resultados num mapa interativo.

9. Opcional: no separador JSON, pode explorar os resultados da consulta no formato JSON, em que a chave é o nome da coluna e o valor é o resultado dessa coluna.

bq

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

2. Use o comando bq query. No exemplo seguinte, a flag --use_legacy_sql=false permite-lhe usar a sintaxe do GoogleSQL.

   bq query \
       --use_legacy_sql=false \
       'QUERY'

   Substitua QUERY por uma consulta GoogleSQL válida. Por exemplo, consulte o conjunto de dados público do BigQuery usa_names para determinar os nomes mais comuns nos Estados Unidos entre 1910 e 2013:

   bq query \
       --use_legacy_sql=false \
       'SELECT
         name, gender,
         SUM(number) AS total
       FROM
         `bigquery-public-data.usa_names.usa_1910_2013`
       GROUP BY
         name, gender
       ORDER BY
         total DESC
       LIMIT
         10;'
   

   A tarefa de consulta escreve o resultado numa tabela temporária (cache).

   Opcionalmente, pode especificar a tabela de destino e a localização para os resultados da consulta. Para escrever os resultados numa tabela existente, inclua a flag adequada para anexar (--append_table=true) ou substituir (--replace=true) a tabela.

   bq query \
       --location=LOCATION \
       --destination_table=TABLE \
       --use_legacy_sql=false \
       'QUERY'

   Substitua o seguinte:

   • LOCATION: a região ou a multirregião da tabela de destino, por exemplo, US

     Neste exemplo, o conjunto de dados usa_names é armazenado na localização multirregional dos EUA. Se especificar uma tabela de destino para esta consulta, o conjunto de dados que contém a tabela de destino também tem de estar na multirregião dos EUA. Não pode consultar um conjunto de dados numa localização e escrever os resultados numa tabela noutra localização.

     Pode definir um valor predefinido para a localização através do ficheiro.bigqueryrc.

   • TABLE: um nome para a tabela de destino, por exemplo, myDataset.myTable

     Se a tabela de destino for uma tabela nova, o BigQuery cria a tabela quando executa a consulta. No entanto, tem de especificar um conjunto de dados existente.

     Se a tabela não estiver no seu projeto atual, adicione o Google Cloud ID do projeto usando o formato PROJECT_ID:DATASET.TABLE, por exemplo, myProject:myDataset.myTable. Se --destination_table não for especificado, é gerada uma tarefa de consulta que escreve o resultado numa tabela temporária.

API

Para executar uma consulta através da API, insira uma nova tarefa e preencha a propriedade de configuração da tarefa query. Opcionalmente, especifique a sua localização na propriedade location na secção jobReference do recurso de tarefa .

Sonde os resultados chamando getQueryResults. A sondagem até jobComplete é igual a true. Verifique se existem erros e avisos na lista errors.

C#

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

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

public class BigQueryQuery
{
    public void Query(
        string projectId = "your-project-id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        string query = @"
            SELECT name FROM `bigquery-public-data.usa_names.usa_1910_2013`
            WHERE state = 'TX'
            LIMIT 100";
        BigQueryJob job = client.CreateQueryJob(
            sql: query,
            parameters: null,
            options: new QueryOptions { UseQueryCache = false });
        // Wait for the job to complete.
        job = job.PollUntilCompleted().ThrowOnAnyError();
        // Display the results
        foreach (BigQueryRow row in client.GetQueryResults(job.Reference))
        {
            Console.WriteLine($"{row["name"]}");
        }
    }
}

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

// queryBasic demonstrates issuing a query and reading results.
func queryBasic(w io.Writer, projectID string) error {
	// projectID := "my-project-id"
	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 name FROM `bigquery-public-data.usa_names.usa_1910_2013` " +
			"WHERE state = \"TX\" " +
			"LIMIT 100")
	// Location must match that of the dataset(s) referenced in the query.
	q.Location = "US"
	// 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.

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.TableResult;

public class SimpleQuery {

  public static void runSimpleQuery() {
    // TODO(developer): Replace this query before running the sample.
    String query = "SELECT corpus FROM `bigquery-public-data.samples.shakespeare` GROUP BY corpus;";
    simpleQuery(query);
  }

  public static void simpleQuery(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();

      // Create the query job.
      QueryJobConfiguration queryConfig = QueryJobConfiguration.newBuilder(query).build();

      // Execute the query.
      TableResult result = bigquery.query(queryConfig);

      // Print the results.
      result.iterateAll().forEach(rows -> rows.forEach(row -> System.out.println(row.getValue())));

      System.out.println("Query ran successfully");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Query did not run \n" + e.toString());
    }
  }
}

Para executar uma consulta com um proxy, consulte o artigo Configurar um proxy.

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 using default credentials
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();
async function query() {
  // Queries the U.S. given names dataset for the state of Texas.

  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/rest/v2/jobs/query
  const options = {
    query: query,
    // Location must match that of the dataset(s) referenced in the query.
    location: 'US',
  };

  // Run the query as a job
  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));
}

PHP

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

use Google\Cloud\BigQuery\BigQueryClient;
use Google\Cloud\Core\ExponentialBackoff;

/** Uncomment and populate these variables in your code */
// $projectId = 'The Google project ID';
// $query = 'SELECT id, view_count FROM `bigquery-public-data.stackoverflow.posts_questions`';

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$jobConfig = $bigQuery->query($query);
$job = $bigQuery->startQuery($jobConfig);

$backoff = new ExponentialBackoff(10);
$backoff->execute(function () use ($job) {
    print('Waiting for job to complete' . PHP_EOL);
    $job->reload();
    if (!$job->isComplete()) {
        throw new Exception('Job has not yet completed', 500);
    }
});
$queryResults = $job->queryResults();

$i = 0;
foreach ($queryResults as $row) {
    printf('--- Row %s ---' . PHP_EOL, ++$i);
    foreach ($row as $column => $value) {
        printf('%s: %s' . PHP_EOL, $column, json_encode($value));
    }
}
printf('Found %s row(s)' . PHP_EOL, $i);

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.

from google.cloud import bigquery

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

query = """
    SELECT name, SUM(number) as total_people
    FROM `bigquery-public-data.usa_names.usa_1910_2013`
    WHERE state = 'TX'
    GROUP BY name, state
    ORDER BY total_people DESC
    LIMIT 20
"""
rows = client.query_and_wait(query)  # Make an API request.

print("The query data:")
for row in rows:
    # Row values can be accessed by field name or index.
    print("name={}, count={}".format(row[0], row["total_people"]))

Ruby

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

require "google/cloud/bigquery"

def query
  bigquery = Google::Cloud::Bigquery.new
  sql = "SELECT name FROM `bigquery-public-data.usa_names.usa_1910_2013` " \
        "WHERE state = 'TX' " \
        "LIMIT 100"

  # Location must match that of the dataset(s) referenced in the query.
  results = bigquery.query sql do |config|
    config.location = "US"
  end

  results.each do |row|
    puts row.inspect
  end
end

Execute uma consulta em lote

Para executar uma consulta em lote, selecione uma das seguintes opções:

Consola

1. Aceda à página do BigQuery.

   Aceda ao BigQuery

2. Clique em Consulta SQL.

3. No editor de consultas, introduza uma consulta GoogleSQL válida.

   Por exemplo, consulte o conjunto de dados públicos do BigQueryusa_names para determinar os nomes mais comuns nos Estados Unidos entre os anos de 1910 e 2013:

   SELECT
     name, gender,
     SUM(number) AS total
   FROM
     `bigquery-public-data.usa_names.usa_1910_2013`
   GROUP BY
     name, gender
   ORDER BY
     total DESC
   LIMIT
     10;
   

4. Clique em Mais e, de seguida, clique em Definições de consulta.

5. Na secção Gestão de recursos, selecione Lote.

6. Opcional: ajuste as definições de consulta.

7. Clique em Guardar.

8. Clique em Executar.

   Se não especificar uma tabela de destino, a tarefa de consulta escreve o resultado numa tabela temporária (cache).

bq

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

2. Use o bq query comando e especifique a flag --batch. No exemplo seguinte, a flag --use_legacy_sql=false permite-lhe usar a sintaxe do GoogleSQL.

   bq query \
       --batch \
       --use_legacy_sql=false \
       'QUERY'

   Substitua QUERY por uma consulta GoogleSQL válida. Por exemplo, consulte o conjunto de dados público do BigQuery usa_names para determinar os nomes mais comuns nos Estados Unidos entre 1910 e 2013:

   bq query \
       --batch \
       --use_legacy_sql=false \
       'SELECT
         name, gender,
         SUM(number) AS total
       FROM
         `bigquery-public-data.usa_names.usa_1910_2013`
       GROUP BY
         name, gender
       ORDER BY
         total DESC
       LIMIT
         10;'
   

   A tarefa de consulta escreve o resultado numa tabela temporária (cache).

   Opcionalmente, pode especificar a tabela de destino e a localização para os resultados da consulta. Para escrever os resultados numa tabela existente, inclua a flag adequada para anexar (--append_table=true) ou substituir (--replace=true) a tabela.

   bq query \
       --batch \
       --location=LOCATION \
       --destination_table=TABLE \
       --use_legacy_sql=false \
       'QUERY'

   Substitua o seguinte:

   • LOCATION: a região ou a multirregião da tabela de destino, por exemplo, US

     Neste exemplo, o conjunto de dados usa_names é armazenado na localização multirregional dos EUA. Se especificar uma tabela de destino para esta consulta, o conjunto de dados que contém a tabela de destino também tem de estar na multirregião dos EUA. Não pode consultar um conjunto de dados numa localização e escrever os resultados numa tabela noutra localização.

     Pode definir um valor predefinido para a localização através do ficheiro.bigqueryrc.

   • TABLE: um nome para a tabela de destino, por exemplo, myDataset.myTable

     Se a tabela de destino for uma tabela nova, o BigQuery cria a tabela quando executa a consulta. No entanto, tem de especificar um conjunto de dados existente.

     Se a tabela não estiver no seu projeto atual, adicione o Google Cloud ID do projeto usando o formato PROJECT_ID:DATASET.TABLE, por exemplo, myProject:myDataset.myTable. Se --destination_table não for especificado, é gerada uma tarefa de consulta que escreve o resultado numa tabela temporária.

API

Para executar uma consulta através da API, insira uma nova tarefa e preencha a propriedade de configuração da tarefa query. Opcionalmente, especifique a sua localização na propriedade location na secção jobReference do recurso de tarefa .

Quando preencher as propriedades da tarefa de consulta, inclua a propriedade configuration.query.priority e defina o valor como BATCH.

Sonde os resultados chamando getQueryResults. A sondagem até jobComplete é igual a true. Verifique se existem erros e avisos na lista errors.

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"
	"time"

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

// queryBatch demonstrates issuing a query job using batch priority.
func queryBatch(w io.Writer, projectID, dstDatasetID, dstTableID string) error {
	// projectID := "my-project-id"
	// dstDatasetID := "mydataset"
	// dstTableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	// Build an aggregate table.
	q := client.Query(`
		SELECT
  			corpus,
  			SUM(word_count) as total_words,
  			COUNT(1) as unique_words
		FROM ` + "`bigquery-public-data.samples.shakespeare`" + `
		GROUP BY corpus;`)
	q.Priority = bigquery.BatchPriority
	q.QueryConfig.Dst = client.Dataset(dstDatasetID).Table(dstTableID)

	// Start the job.
	job, err := q.Run(ctx)
	if err != nil {
		return err
	}
	// Job is started and will progress without interaction.
	// To simulate other work being done, sleep a few seconds.
	time.Sleep(5 * time.Second)
	status, err := job.Status(ctx)
	if err != nil {
		return err
	}

	state := "Unknown"
	switch status.State {
	case bigquery.Pending:
		state = "Pending"
	case bigquery.Running:
		state = "Running"
	case bigquery.Done:
		state = "Done"
	}
	// You can continue to monitor job progress until it reaches
	// the Done state by polling periodically.  In this example,
	// we print the latest status.
	fmt.Fprintf(w, "Job %s in Location %s currently in state: %s\n", job.ID(), job.Location(), state)

	return nil

}

Java

Para executar uma consulta em lote, defina a prioridade da consulta como QueryJobConfiguration.Priority.BATCH quando criar uma QueryJobConfiguration.

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.

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.TableResult;

// Sample to query batch in a table
public class QueryBatch {

  public static void runQueryBatch() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "MY_PROJECT_ID";
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String query =
        "SELECT corpus"
            + " FROM `"
            + projectId
            + "."
            + datasetName
            + "."
            + tableName
            + " GROUP BY corpus;";
    queryBatch(query);
  }

  public static void queryBatch(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 =
          QueryJobConfiguration.newBuilder(query)
              // Run at batch priority, which won't count toward concurrent rate limit.
              .setPriority(QueryJobConfiguration.Priority.BATCH)
              .build();

      TableResult results = bigquery.query(queryConfig);

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

      System.out.println("Query batch performed successfully.");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Query batch not performed \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 and create a client
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function queryBatch() {
  // Runs a query at batch priority.

  // Create query job configuration. For all options, see
  // https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#jobconfigurationquery
  const queryJobConfig = {
    query: `SELECT corpus
            FROM \`bigquery-public-data.samples.shakespeare\` 
            LIMIT 10`,
    useLegacySql: false,
    priority: 'BATCH',
  };

  // Create job configuration. For all options, see
  // https://cloud.google.com/bigquery/docs/reference/rest/v2/Job#jobconfiguration
  const jobConfig = {
    // Specify a job configuration to set optional job resource properties.
    configuration: {
      query: queryJobConfig,
    },
  };

  // Make API request.
  const [job] = await bigquery.createJob(jobConfig);

  const jobId = job.metadata.id;
  const state = job.metadata.status.state;
  console.log(`Job ${jobId} is currently in state ${state}`);
}

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.

from google.cloud import bigquery

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

job_config = bigquery.QueryJobConfig(
    # Run at batch priority, which won't count toward concurrent rate limit.
    priority=bigquery.QueryPriority.BATCH
)

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.

# Check on the progress by getting the job's updated state. Once the state
# is `DONE`, the results are ready.
query_job = client.get_job(
    query_job.job_id, location=query_job.location
)  # Make an API request.

print("Job {} is currently in state {}".format(query_job.job_id, query_job.state))

Execute uma consulta contínua

A execução de uma tarefa de consulta contínua requer uma configuração adicional. Para mais informações, consulte Crie consultas contínuas.

Use o painel Referência

No editor de consultas, o painel Referência apresenta dinamicamente informações sensíveis ao contexto sobre tabelas, instantâneos, vistas e vistas materializadas. O painel permite-lhe pré-visualizar os detalhes do esquema destes recursos ou abri-los num novo separador. Também pode usar o painel Referência para criar novas consultas ou editar consultas existentes inserindo fragmentos de consultas ou nomes de campos.

Para criar uma nova consulta através do painel Referência, siga estes passos:

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

   Aceda ao BigQuery

2. Clique em Consulta SQL.

3. Clique em quick_reference_all Referência.

4. Clique numa tabela ou vista recente ou marcada com estrela. Também pode usar a barra de pesquisa para encontrar tabelas e vistas.

5. Clique em Ver ações e, de seguida, clique em Inserir fragmento de consulta.

   

6. Opcional: pode pré-visualizar os detalhes do esquema da tabela ou da vista, ou abri-los num novo separador.

7. Agora, pode editar a consulta manualmente ou inserir nomes de campos diretamente na consulta. Para inserir um nome de campo, aponte e clique num local no editor de consultas onde quer inserir o nome de campo e, de seguida, clique no nome de campo no painel Referência.

Definições da consulta

Quando executa uma consulta, pode especificar as seguintes definições:

• Uma tabela de destino para os resultados da consulta.

• A prioridade da tarefa.

• Se deve usar resultados de consultas em cache.

• O limite de tempo da tarefa em milissegundos.

• Se deve usar o modo de sessão.

• O tipo de encriptação a usar.

• O número máximo de bytes faturados para a consulta.

• O dialeto de SQL a usar.

• A localização na qual executar a consulta. A consulta tem de ser executada na mesma localização que as tabelas referenciadas na consulta.

• A reserva para executar a consulta em (pré-visualização).

Modo de criação de tarefas opcional

O modo de criação de tarefas opcional pode melhorar a latência geral das consultas executadas durante um curto período, como as provenientes de painéis de controlo ou cargas de trabalho de exploração de dados. Este modo executa a consulta e devolve os resultados inline para declarações SELECT sem exigir a utilização de jobs.getQueryResults para obter os resultados. As consultas que usam o modo de criação de tarefas opcional não criam uma tarefa quando são executadas, a menos que o BigQuery determine que é necessária uma criação de tarefas para concluir a consulta.

Para ativar o modo de criação de tarefas opcional, defina o campo jobCreationMode da instância QueryRequest como JOB_CREATION_OPTIONAL no corpo do pedido jobs.query.

Quando o valor deste campo está definido como JOB_CREATION_OPTIONAL, o BigQuery determina se a consulta pode usar o modo de criação de tarefas opcional. Se for o caso, o BigQuery executa a consulta e devolve todos os resultados no campo rows da resposta. Uma vez que não é criada uma tarefa para esta consulta, o BigQuery não devolve um jobReference no corpo da resposta. Em alternativa, devolve um campo queryId, que pode usar para obter estatísticas sobre a consulta através da INFORMATION_SCHEMA.JOBS vista. Uma vez que não é criado nenhum trabalho, não existe nenhum jobReference que possa ser transmitido às APIs jobs.get e jobs.getQueryResults para procurar estas consultas.

Se o BigQuery determinar que é necessária uma tarefa para concluir a consulta, é devolvido um jobReference. Pode inspecionar o campo job_creation_reason na INFORMATION_SCHEMA.JOBS vista para determinar o motivo pelo qual foi criado um trabalho para a consulta. Neste caso, deve usar jobs.getQueryResults para obter os resultados quando a consulta estiver concluída.

Quando usa o valor JOB_CREATION_OPTIONAL, o campo jobReference pode não estar presente na resposta. Verifique se o campo existe antes de aceder ao mesmo.

Quando JOB_CREATION_OPTIONAL é especificado para consultas com várias declarações (scripts), o BigQuery pode otimizar o processo de execução. Como parte desta otimização, o BigQuery pode determinar que consegue concluir o script criando menos recursos de tarefas do que o número de declarações individuais, podendo até executar todo o script sem criar nenhuma tarefa. Esta otimização depende da avaliação do script por parte do BigQuery e a otimização pode não ser aplicada em todos os casos. A otimização é totalmente automatizada pelo sistema. Não são necessários controlos nem ações do utilizador.

Para executar uma consulta usando o modo de criação de tarefas opcional, selecione uma das seguintes opções:

Consola

1. Aceda à página do BigQuery.

   Aceda ao BigQuery

2. Clique em Consulta SQL.

3. No editor de consultas, introduza uma consulta GoogleSQL válida.

   Por exemplo, consulte o conjunto de dados públicos do BigQueryusa_names para determinar os nomes mais comuns nos Estados Unidos entre os anos de 1910 e 2013:

   SELECT
     name, gender,
     SUM(number) AS total
   FROM
     `bigquery-public-data.usa_names.usa_1910_2013`
   GROUP BY
     name, gender
   ORDER BY
     total DESC
   LIMIT
     10;
   

4. Clique em Mais e, de seguida, escolha o modo de consulta Criação de tarefas opcional. Para confirmar esta escolha, clique em Confirmar.

5. Clique em Executar.

bq

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

2. Use o bq query comando e especifique a flag --job_creation_mode=JOB_CREATION_OPTIONAL. No exemplo seguinte, a flag --use_legacy_sql=false permite-lhe usar a sintaxe do GoogleSQL.

   bq query \
       --rpc=true \
       --use_legacy_sql=false \
       --job_creation_mode=JOB_CREATION_OPTIONAL \
       --location=LOCATION \
       'QUERY'

   Substitua QUERY por uma consulta GoogleSQL válida e substitua LOCATION por uma região válida onde o conjunto de dados está localizado. Por exemplo, consulte o conjunto de dados público do BigQuery usa_names para determinar os nomes mais comuns nos Estados Unidos entre 1910 e 2013:

   bq query \
       --rpc=true \
       --use_legacy_sql=false \
       --job_creation_mode=JOB_CREATION_OPTIONAL \
       --location=us \
       'SELECT
         name, gender,
         SUM(number) AS total
       FROM
         `bigquery-public-data.usa_names.usa_1910_2013`
       GROUP BY
         name, gender
       ORDER BY
         total DESC
       LIMIT
         10;'
   

   A tarefa de consulta devolve o resultado inline na resposta.

   Nota: pode usar --apilog=stdout para registar pedidos e respostas da API para extrair o queryId, se necessário.

API

Para executar uma consulta no modo de criação de tarefas opcional através da API, execute uma consulta de forma síncrona e preencha a propriedade QueryRequest. Inclua a propriedade jobCreationMode e defina o respetivo valor como JOB_CREATION_OPTIONAL.

Verifique a resposta. Se jobComplete for igual a true e jobReference estiver vazio, leia os resultados do campo rows. Também pode obter o queryId a partir da resposta.

Se jobReference estiver presente, pode verificar jobCreationReason para saber por que motivo o BigQuery criou uma tarefa. Sonde os resultados chamando getQueryResults. A sondagem até jobComplete é igual a true. Verifique se existem erros e avisos na lista errors.

Java

Versão disponível: 2.51.0 e superior

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.

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

// Sample demonstrating short mode query execution.
//
// This feature is controlled by setting the defaultJobCreationMode
// field in the BigQueryOptions used for the client. JOB_CREATION_OPTIONAL
// allows for the execution of queries without creating a job.
public class QueryJobOptional {

  public static void main(String[] args) {
    String query =
        "SELECT name, gender, SUM(number) AS total FROM "
            + "bigquery-public-data.usa_names.usa_1910_2013 GROUP BY "
            + "name, gender ORDER BY total DESC LIMIT 10";
    queryJobOptional(query);
  }

  public static void queryJobOptional(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.
      BigQueryOptions options = BigQueryOptions.getDefaultInstance();
      options.setDefaultJobCreationMode(JobCreationMode.JOB_CREATION_OPTIONAL);
      BigQuery bigquery = options.getService();

      // Execute the query. The returned TableResult provides access information
      // about the query execution as well as query results.
      TableResult results = bigquery.query(QueryJobConfiguration.of(query));

      JobId jobId = results.getJobId();
      if (jobId != null) {
        System.out.println("Query was run with job state.  Job ID: " + jobId.toString());
      } else {
        System.out.println("Query was run in short mode.  Query ID: " + results.getQueryId());
      }

      // Print the results.
      results
          .iterateAll()
          .forEach(
              row -> {
                System.out.print("name:" + row.get("name").getStringValue());
                System.out.print(", gender: " + row.get("gender").getStringValue());
                System.out.print(", total: " + row.get("total").getLongValue());
                System.out.println();
              });

    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Query not performed \n" + e.toString());
    }
  }
}

Para executar uma consulta com um proxy, consulte o artigo Configurar um proxy.

Python

Versão disponível: 3.34.0 e superior

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.

# This example demonstrates executing a query without requiring an associated
# job.
from google.cloud import bigquery
from google.cloud.bigquery.enums import JobCreationMode

# Construct a BigQuery client object, specifying that the library should
# avoid creating jobs when possible.
client = bigquery.Client(
    default_job_creation_mode=JobCreationMode.JOB_CREATION_OPTIONAL
)

query = """
    SELECT
        name,
        gender,
        SUM(number) AS total
    FROM
        bigquery-public-data.usa_names.usa_1910_2013
    GROUP BY
        name, gender
    ORDER BY
        total DESC
    LIMIT 10
"""
# Run the query.  The returned `rows` iterator can return information about
# how the query was executed as well as the result data.
rows = client.query_and_wait(query)

if rows.job_id is not None:
    print("Query was run with job state.  Job ID: {}".format(rows.job_id))
else:
    print(
        "Query was run without creating a job.  Query ID: {}".format(rows.query_id)
    )

print("The query data:")
for row in rows:
    # Row values can be accessed by field name or index.
    print("name={}, gender={}, total={}".format(row[0], row[1], row["total"]))

Nó

Versão disponível: 8.1.0 e superior

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.

// Demonstrates issuing a query that may be run in short query mode.

// Import the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery({
  // default behavior is to create jobs when using the jobs.query API
  defaultJobCreationMode: 'JOB_CREATION_REQUIRED',
});

async function queryJobOptional() {
  // SQL query to run.

  const sqlQuery = `
    SELECT name, gender, SUM(number) AS total
    FROM bigquery-public-data.usa_names.usa_1910_2013
    GROUP BY name, gender
    ORDER BY total DESC
    LIMIT 10`;

  // Run the query
  const [rows, , res] = await bigquery.query({
    query: sqlQuery,
    // Skip job creation to enable short mode.
    jobCreationMode: 'JOB_CREATION_OPTIONAL',
  });

  if (!res.jobReference) {
    console.log(`Query was run in short mode. Query ID: ${res.queryId}`);
  } else {
    const jobRef = res.jobReference;
    const qualifiedId = `${jobRef.projectId}.${jobRef.location}.${jobRef.jobId}`;
    console.log(
      `Query was run with job state. Job ID: ${qualifiedId}, Query ID: ${res.queryId}`,
    );
  }
  // Print the results
  console.log('Rows:');
  rows.forEach(row => console.log(row));
}

Go

Versão disponível: 1.69.0 e superior

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

// queryJobOptional demonstrates issuing a query that doesn't require a
// corresponding job.
func queryJobOptional(w io.Writer, projectID string) error {
	// projectID := "my-project-id"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID,
		bigquery.WithDefaultJobCreationMode(bigquery.JobCreationModeOptional),
	)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %w", err)
	}
	defer client.Close()

	q := client.Query(`
		SELECT
  			name, gender,
  			SUM(number) AS total
		FROM
			bigquery-public-data.usa_names.usa_1910_2013
		GROUP BY 
			name, gender
		ORDER BY
			total DESC
		LIMIT 10
		`)
	// Run the query and process the returned row iterator.
	it, err := q.Read(ctx)
	if err != nil {
		return fmt.Errorf("query.Read(): %w", err)
	}

	// The iterator provides information about the query execution.
	// Queries that were run in short query mode will not have the source job
	// populated.
	if it.SourceJob() == nil {
		fmt.Fprintf(w, "Query was run in optional job mode.  Query ID: %q\n", it.QueryID())
	} else {
		j := it.SourceJob()
		qualifiedJobID := fmt.Sprintf("%s:%s.%s", j.ProjectID(), j.Location(), j.ID())
		fmt.Fprintf(w, "Query was run with job state.  Job ID: %q, Query ID: %q\n",
			qualifiedJobID, it.QueryID())
	}

	// Print row data.
	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
}

Controlador JDBC

Versão disponível: JDBC v1.6.1 e superior

Requer a definição de JobCreationMode=2 na string de ligação.

    jdbc:bigquery://https://www.googleapis.com/bigquery/v2:443;JobCreationMode=2;Location=US;
  

Nota: pode anexar LogLevel=6;LogPath=log.txt à string de ligação para ativar o registo ao nível TRACE e extrair informações de resolução de problemas, incluindo queryId, se necessário.

Controlador ODBC

Versão disponível: ODBC v3.0.7.1016 e superior

Requer a definição de JobCreationMode=2 no ficheiro .ini.

    [ODBC Data Sources]
    Sample DSN=Simba Google BigQuery ODBC Connector 64-bit
    [Sample DSN]
    JobCreationMode=2
  

Nota: pode anexar LogLevel=6 e LogPath=log.txt ao ficheiro .ini para ativar o registo ao nível detalhado e extrair informações de resolução de problemas, incluindo queryId, se necessário.

Quotas

Para informações sobre quotas relativas a consultas interativas e em lote, consulte o artigo Tarefas de consulta.

Monitorize consultas

Pode obter informações sobre as consultas à medida que são executadas através do explorador de tarefas ou consultando a vista INFORMATION_SCHEMA.JOBS_BY_PROJECT.

Execução de ensaio

Uma execução de teste no BigQuery fornece as seguintes informações:

• estimativa de encargos no modo a pedido
• validação da sua consulta
• bytes aproximados processados pela sua consulta no modo de capacidade

Os ensaios não usam espaços de consultas e não lhe é cobrado nenhum valor pela execução de um ensaio. Pode usar a estimativa devolvida por um teste de execução para calcular os custos das consultas na calculadora de preços.

Nota: uma execução de teste de uma consulta federada que usa uma origem de dados externa pode comunicar um limite inferior de 0 bytes de dados, mesmo que sejam devolvidas linhas. Isto deve-se ao facto de não ser possível determinar a quantidade de dados processados a partir da tabela externa até a consulta real ser concluída. A execução da consulta federada continua a incorrer num custo para o processamento destes dados.

Faça uma execução de ensaio

Para fazer um teste de execução, faça o seguinte:

Consola

1. Aceda à página do BigQuery.

   Aceda ao BigQuery

2. Introduza a consulta no editor de consultas.

   Se a consulta for válida, é apresentado automaticamente uma marca de verificação juntamente com a quantidade de dados que a consulta vai processar. Se a consulta for inválida, é apresentado um ponto de exclamação juntamente com uma mensagem de erro.

bq

Introduza uma consulta como a seguinte usando a flag --dry_run.

bq query \
--use_legacy_sql=false \
--dry_run \
'SELECT
   COUNTRY,
   AIRPORT,
   IATA
 FROM
   `project_id`.dataset.airports
 LIMIT
   1000'
 

Para uma consulta válida, o comando produz a seguinte resposta:

Query successfully validated. Assuming the tables are not modified,
running this query will process 10918 bytes of data.

Nota: se a sua consulta processar uma pequena quantidade de dados, pode ter de converter os bytes processados de KB para MB. MB é a medida mais pequena usada pela calculadora de preços.

API

Para executar um teste simulado através da API, envie uma tarefa de consulta com o valor dryRun definido como true no tipo JobConfiguration.

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

// queryDryRun demonstrates issuing a dry run query to validate query structure and
// provide an estimate of the bytes scanned.
func queryDryRun(w io.Writer, projectID string) error {
	// projectID := "my-project-id"
	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
		name,
		COUNT(*) as name_count
	FROM ` + "`bigquery-public-data.usa_names.usa_1910_2013`" + `
	WHERE state = 'WA'
	GROUP BY name`)
	q.DryRun = true
	// Location must match that of the dataset(s) referenced in the query.
	q.Location = "US"

	job, err := q.Run(ctx)
	if err != nil {
		return err
	}
	// Dry run is not asynchronous, so get the latest status and statistics.
	status := job.LastStatus()
	if err := status.Err(); err != nil {
		return err
	}
	fmt.Fprintf(w, "This query will process %d bytes\n", status.Statistics.TotalBytesProcessed)
	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.

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.JobInfo;
import com.google.cloud.bigquery.JobStatistics;
import com.google.cloud.bigquery.QueryJobConfiguration;

// Sample to run dry query on the table
public class QueryDryRun {

  public static void runQueryDryRun() {
    String query =
        "SELECT name, COUNT(*) as name_count "
            + "FROM `bigquery-public-data.usa_names.usa_1910_2013` "
            + "WHERE state = 'WA' "
            + "GROUP BY name";
    queryDryRun(query);
  }

  public static void queryDryRun(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 =
          QueryJobConfiguration.newBuilder(query).setDryRun(true).setUseQueryCache(false).build();

      Job job = bigquery.create(JobInfo.of(queryConfig));
      JobStatistics.QueryStatistics statistics = job.getStatistics();

      System.out.println(
          "Query dry run performed successfully." + statistics.getTotalBytesProcessed());
    } catch (BigQueryException e) {
      System.out.println("Query not performed \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 queryDryRun() {
  // Runs a dry query of the U.S. given names dataset for the state of Texas.

  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/rest/v2/jobs/query
  const options = {
    query: query,
    // Location must match that of the dataset(s) referenced in the query.
    location: 'US',
    dryRun: true,
  };

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

  // Print the status and statistics
  console.log('Status:');
  console.log(job.metadata.status);
  console.log('\nJob Statistics:');
  console.log(job.metadata.statistics);
}

PHP

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

use Google\Cloud\BigQuery\BigQueryClient;

/** Uncomment and populate these variables in your code */
// $projectId = 'The Google project ID';
// $query = 'SELECT id, view_count FROM `bigquery-public-data.stackoverflow.posts_questions`';

// Construct a BigQuery client object.
$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);

// Set job configs
$jobConfig = $bigQuery->query($query);
$jobConfig->useQueryCache(false);
$jobConfig->dryRun(true);

// Extract query results
$queryJob = $bigQuery->startJob($jobConfig);
$info = $queryJob->info();

printf('This query will process %s bytes' . PHP_EOL, $info['statistics']['totalBytesProcessed']);

Python

Defina a propriedade QueryJobConfig.dry_run como True. Client.query() devolve sempre um QueryJob concluído quando é fornecida uma configuração de consulta de teste.

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.

from google.cloud import bigquery

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

job_config = bigquery.QueryJobConfig(dry_run=True, use_query_cache=False)

# Start the query, passing in the extra configuration.
query_job = client.query(
    (
        "SELECT name, COUNT(*) as name_count "
        "FROM `bigquery-public-data.usa_names.usa_1910_2013` "
        "WHERE state = 'WA' "
        "GROUP BY name"
    ),
    job_config=job_config,
)  # Make an API request.

# A dry run query completes immediately.
print("This query will process {} bytes.".format(query_job.total_bytes_processed))

O que se segue?

• Saiba como gerir tarefas de consulta.
• Saiba como ver o histórico de consultas.
• Saiba como guardar e partilhar consultas.
• Saiba mais acerca das filas de consultas.
• Saiba como escrever resultados de consultas.