Questa pagina è stata tradotta dall'API Cloud Translation.

esegui una query

Questo documento mostra come eseguire una query in BigQuery e comprendere quanti dati verranno elaborati dalla query prima dell'esecuzione mediante un simulacro.

Tipi di query

Puoi eseguire query su dati BigQuery utilizzando uno dei seguenti tipi di job di query:

Job di query interattive. Di predefinito, BigQuery esegue job di query interattivi (on demand) il prima possibile.
Job di query continua (anteprima). Con questi job, la query viene eseguita continuamente, consentendoti di analizzare i dati in entrata in BigQuery in tempo reale e di scrivere i risultati in una tabella BigQuery oppure di esportarli in Bigtable o Pub/Sub. Puoi utilizzare questa funzionalità per eseguire attività urgenti, come creare informazioni e intervenire immediatamente in base a queste, applicare l'inferenza di machine learning (ML) in tempo reale e creare pipeline di dati basate su eventi.
Job di query in batch. Con questi lavori, BigQuery mette in coda ogni query batch per tuo conto e poi avvia quando le risorse inattive sono disponibili, in genere entro pochi minuti.

Puoi eseguire job di query utilizzando i seguenti metodi:

Componi ed esegui una query nella console Google Cloud.
Esegui il comando bq query nello strumento a riga di comando bq.
Chiama in modo programmatico il metodo jobs.query o jobs.insert nell'API REST di BigQuery.
Utilizza le librerie client di BigQuery.

Per impostazione predefinita, BigQuery esegue le query come job di query interattive, che vengono eseguiti il prima possibile. BigQuery calcola dinamicamente il limite di query simultanee sulla disponibilità delle risorse, favorisce l'esecuzione di più query interattive rispetto alle query in batch. Una volta raggiunto il limite di query simultanee, le query aggiuntive rimangono in attesa in una coda. Per ulteriori informazioni, consulta la sezione Coda di query.

BigQuery salva i risultati delle query in una tabella temporanea (predefinita) o permanente. Quando specifichi una tabella permanente come tabella di destinazione per i risultati, puoi scegliere se aggiungere o sovrascrivere una tabella esistente o creare una nuova tabella con un nome univoco.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per eseguire un job di query, chiedi all'amministratore di concederti seguenti ruoli IAM:

Utente job BigQuery (roles/bigquery.jobUser) nel progetto.
Visualizzatore dati BigQuery (roles/bigquery.dataViewer) in tutte le tabelle e le visualizzazioni a cui fa riferimento la query. Per eseguire query sulle visualizzazioni, devi disporre di questo ruolo anche su tutte le tabelle e le visualizzazioni sottostanti. Se utilizzi viste autorizzate o set di dati autorizzati, non hai bisogno di accedere ai dati di origine sottostanti.

Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso a progetti, cartelle e organizzazioni.

Questi ruoli predefiniti le autorizzazioni necessarie per eseguire un job di query. Per vedere le autorizzazioni esatte obbligatorie, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

Per eseguire un job di query sono necessarie le seguenti autorizzazioni:

bigquery.jobs.create nel progetto da cui viene eseguita la query, indipendentemente da dove sono archiviati i dati.
bigquery.tables.getData su tutte le tabelle e le viste a cui fa riferimento la query. Per eseguire query sulle visualizzazioni, devi disporre di questa autorizzazione anche su tutte le tabelle e le visualizzazioni sottostanti. Se utilizzi viste autorizzate o set di dati autorizzati, non hai bisogno di accedere ai dati di origine sottostanti.

Potresti anche ottenere queste autorizzazioni con ruoli personalizzati o altri ruoli predefiniti.

Risoluzione dei problemi

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

Questo errore si verifica quando un principale non dispone dell'autorizzazione per creare job di query nel progetto.

Risoluzione: un amministratore deve concederti l'autorizzazione bigquery.jobs.create per il progetto su cui stai eseguendo una query. Questa autorizzazione è obbligatoria oltre a qualsiasi autorizzazione richiesta per accedere ai dati sottoposti a query.

Per ulteriori informazioni sulle autorizzazioni BigQuery, consulta Controllo dell'accesso con IAM.

Esegui una query interattiva

Per eseguire una query interattiva, seleziona una delle seguenti opzioni:

Console

Vai alla pagina BigQuery.

Vai a BigQuery
Fai clic su Crea una nuova query.
Nell'editor delle query, inserisci una query GoogleSQL valida.

Ad esempio, esegui una query Set di dati pubblico BigQuery usa_names per determinare i nomi più comuni negli Stati Uniti tra anni 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;
```
(Facoltativo) Specifica la tabella di destinazione e località per i risultati della query:
1. Nell'editor query, fai clic su Altro e poi fai clic su Impostazioni query.
2. Nella sezione Destinazione, seleziona Imposta una tabella di destinazione per i risultati della query.
3. In Set di dati, inserisci il nome di un set di dati esistente per la tabella di destinazione, ad esempio myProject.myDataset.
4. In ID tabella, inserisci un nome per la tabella di destinazione, ad ad esempio myTable.
5. Se la tabella di destinazione è una tabella esistente, per Preferenza di scrittura per tabella di destinazione, seleziona se aggiungere o sovrascrivere la tabella con i risultati della query.
  
  Se la tabella di destinazione è una nuova tabella, BigQuery la crea quando esegui la query.
6. Nella sezione Impostazioni aggiuntive, fai clic sul menu Posizione dei dati e seleziona un'opzione.
  
  In questo esempio, il set di dati usa_names è archiviato nella località con più regioni degli Stati Uniti. Se specifichi una tabella di destinazione query, anche il set di dati che contiene la tabella di destinazione deve essere nella località multiregionale degli Stati Uniti. Non puoi eseguire query su un set di dati in una posizione e scrivere i risultati in una tabella in un'altra posizione.
7. Fai clic su Salva.
Fai clic su Esegui.

Se non specifichi una tabella di destinazione, il job query scrive l'output in una tabella temporanea (cache).

Ora puoi esplorare i risultati della query nella scheda Risultati del riquadro Risultati delle query.
(Facoltativo) Per ordinare i risultati della query per colonna, fai clic su Apri menu di ordinamento accanto al nome della colonna e seleziona un ordinamento. Se i byte stimati elaborati per l'ordinamento è maggiore di zero, allora il numero di byte visualizzata nella parte superiore del menu.
(Facoltativo) Per visualizzare i risultati della query, vai a Scheda Grafico. Puoi aumentare o diminuire lo zoom del grafico, scaricare un grafico come file PNG o attiva/disattiva la visibilità della legenda.

Nel riquadro Configurazione grafico, puoi modificare il tipo di grafico (linea, barra o dispersione) e configurare le misure e le dimensioni del grafico. I campi in questo riquadro sono precompilati con la configurazione iniziale ricavata dallo schema della tabella di destinazione della query. La configurazione viene conservata tra le esecuzioni successive della query nello stesso editor di query. Le dimensioni supportano i tipi di dati INTEGER, INT64, FLOAT, FLOAT64, NUMERIC, BIGNUMERIC, TIMESTAMP, DATE, DATETIME, TIME e STRING, mentre le misure supportano i tipi di dati INTEGER, INT64, FLOAT, FLOAT64, NUMERIC e BIGNUMERIC.
(Facoltativo) Nella scheda JSON, puoi esplorare i risultati della query nel formato JSON, dove la chiave è il nome della colonna e il valore è il risultato per quella colonna.

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.
Utilizza il comando bq query. Nell'esempio seguente, il flag --use_legacy_sql=false ti consente di utilizzare Sintassi GoogleSQL.
```
bq query \
    --use_legacy_sql=false \
    'QUERY'
```
Sostituisci QUERY con una query GoogleSQL valida. Ad esempio, esegui una query sul set di dati pubblico BigQuery usa_names per determinare i nomi più comuni negli Stati Uniti tra il 1910 e il 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;'
```
Il job di query scrive l'output in una tabella temporanea (cache).

Se vuoi, puoi specificare la tabella di destinazione località per i risultati della query. Per scrivere i risultati in una tabella esistente, includi il flag appropriato per accodare (--append_table=true) o sovrascrivere (--replace=true) la tabella.
```
bq query \
    --location=LOCATION \
    --destination_table=TABLE \
    --use_legacy_sql=false \
    'QUERY'
```
Sostituisci quanto segue:
- LOCATION: la regione o più regioni per la destinazione tabella, ad esempio US
  
  In questo esempio, il set di dati usa_names è archiviato nella località con più regioni degli Stati Uniti. Se specifichi una tabella di destinazione per questa query, anche il set di dati che contiene la tabella di destinazione deve trovarsi nella regione multipla degli Stati Uniti. Non puoi eseguire query su un set di dati in una posizione scrivere i risultati in una tabella in un'altra posizione.
  
  Puoi impostare un valore predefinito per la posizione utilizzando il file .bigqueryrc.
- TABLE: un nome per la tabella di destinazione, ad esempio myDataset.myTable
  
  Se la tabella di destinazione è una nuova tabella, BigQuery la crea quando esegui la query. Tuttavia, devi specificare un set di dati esistente.
  
  Se la tabella non è nel progetto corrente, aggiungi l'ID progetto Google Cloud utilizzando il formatoPROJECT_ID:DATASET.TABLE, ad esempiomyProject:myDataset.myTable. Se il campo --destination_table non è specificato, viene generato un job di query che scrive l'output in una tabella temporanea.

API

Per eseguire una query utilizzando l'API, inserisci un nuovo job e compilare la proprietà di configurazione del job query. Se vuoi, specifica la tua posizione nella proprietà location nella sezione jobReference della risorsa job.

Esegui il polling per i risultati chiamando getQueryResults. Sondaggio fino a quando jobComplete non sarà uguale a true. Controlla la presenza di errori e avvisi nell'elenco errors.

C#

Prima di provare questo esempio, segui le istruzioni di configurazione C# riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery C#.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.


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"]}");
        }
    }
}

Vai

Prima di provare questo esempio, segui le istruzioni per la configurazione di Go nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Go BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

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

Prima di provare questo esempio, segui le istruzioni per la configurazione di Java nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Java BigQuery documentazione di riferimento.

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

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());
    }
  }
}

Per eseguire una query con un proxy, consulta Configurazione di un proxy.

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione Node.js riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Node.js.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

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

Prima di provare questo esempio, segui le istruzioni per la configurazione di PHP nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery PHP.

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

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

Prima di provare questo esempio, segui le istruzioni per la configurazione di Python nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Python.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

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

Prima di provare questo esempio, segui le istruzioni di configurazione Ruby riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Ruby.

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

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

Esegui una query continua

L'esecuzione di un job di query continuo richiede una configurazione aggiuntiva. Per maggiori informazioni le informazioni, vedi Crea query continue.

Eseguire una query batch

Per eseguire una query batch, seleziona una delle seguenti opzioni:

Console

Vai alla pagina BigQuery.

Vai a BigQuery
Fai clic su Crea una nuova query.
Nell'editor query, inserisci una query GoogleSQL valida.

Ad esempio, esegui una query Set di dati pubblico BigQuery usa_names per determinare i nomi più comuni negli Stati Uniti tra anni 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;
```
Fai clic su Altro e poi fai clic su Impostazioni query.
Nella sezione Gestione delle risorse, seleziona Batch.
(Facoltativo) Specifica la tabella di destinazione e la posizione per i risultati della query:
1. Nella sezione Destinazione, seleziona Imposta una tabella di destinazione per i risultati della query.
2. In Set di dati, inserisci il nome di un set di dati esistente per la tabella di destinazione, ad esempio myProject.myDataset.
3. In ID tabella, inserisci un nome per la tabella di destinazione, ad ad esempio myTable.
4. Se la tabella di destinazione è una tabella esistente, per Preferenza di scrittura per tabella di destinazione, seleziona se aggiungere o sovrascrivere la tabella con i risultati della query.
  
  Se la tabella di destinazione è una nuova tabella, BigQuery la crea quando esegui la query.
5. Nella sezione Impostazioni aggiuntive, fai clic sul menu Posizione dei dati e seleziona un'opzione.
  
  In questo esempio, il set di dati usa_names è archiviato nella località con più regioni degli Stati Uniti. Se specifichi una tabella di destinazione query, anche il set di dati che contiene la tabella di destinazione deve essere nella località multiregionale degli Stati Uniti. Non puoi eseguire query su un set di dati in una posizione e scrivere i risultati in una tabella in un'altra posizione.
Fai clic su Salva.
Fai clic su Esegui.

Se non specifichi una tabella di destinazione, il job di query scrive in una tabella temporanea (cache).
(Facoltativo) Per ordinare i risultati della query per colonna, fai clic su Apri il menu di ordinamento accanto al nome della colonna e seleziona un ordinamento. Se i byte stimati elaborati per l'ordinamento è maggiore di zero, allora il numero di byte visualizzata nella parte superiore del menu.
(Facoltativo) Per visualizzare i risultati della query, vai a Scheda Grafico. Puoi aumentare o diminuire lo zoom del grafico, scaricare un grafico come file PNG o attiva/disattiva la visibilità della legenda.

Nel riquadro Configurazione grafico, puoi modificare il tipo di grafico (linee, barre o dispersioni) e configurare le misure e le dimensioni del grafico. I campi in questo riquadro sono precompilati con la configurazione iniziale ricavata dallo schema della tabella di destinazione della query. La configurazione viene conservata tra le esecuzioni successive della query nello stesso editor di query. Le dimensioni supportano i tipi di dati INTEGER, INT64, FLOAT, FLOAT64, NUMERIC, BIGNUMERIC, TIMESTAMP, DATE, DATETIME, TIME e STRING, mentre le misure supportano i tipi di dati INTEGER, INT64, FLOAT, FLOAT64, NUMERIC e BIGNUMERIC.

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.
Utilizza il comando bq query e specifica il flag --batch. Nell'esempio seguente, il flag --use_legacy_sql=false consente di utilizzare la sintassi di GoogleSQL.
```
bq query \
    --batch \
    --use_legacy_sql=false \
    'QUERY'
```
Sostituisci QUERY con una query GoogleSQL valida. Per ad esempio, esegui una query Set di dati pubblico BigQuery usa_names per determinare i nomi più comuni negli Stati Uniti tra gli anni 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;'
```
Il job di query scrive l'output in una tabella temporanea (cache).

Se vuoi, puoi specificare la tabella di destinazione e la posizione per i risultati della query. Per scrivere i risultati in una tabella esistente, includi il flag appropriato da aggiungere (--append_table=true) o sovrascrivere (--replace=true) la tabella.
```
bq query \
    --batch \
    --location=LOCATION \
    --destination_table=TABLE \
    --use_legacy_sql=false \
    'QUERY'
```
Sostituisci quanto segue:
- LOCATION: la regione o più regioni per la destinazione tabella, ad esempio US
  
  In questo esempio, il set di dati usa_names è archiviato negli Stati Uniti una località multiregionale. Se specifichi una tabella di destinazione query, anche il set di dati che contiene la tabella di destinazione deve essere in nella località multiregionale degli Stati Uniti. Non puoi eseguire query su un set di dati in una posizione scrivere i risultati in una tabella in un'altra posizione.
  
  Puoi impostare un valore predefinito per la posizione utilizzando il file .bigqueryrc.
- TABLE: un nome per la tabella di destinazione, ad esempio myDataset.myTable
  
  Se la tabella di destinazione è una nuova tabella, BigQuery la crea quando esegui la query. Tuttavia, devi specificare un set di dati esistente.
  
  Se la tabella non è nel progetto corrente, aggiungi l'ID progetto Google Cloud utilizzando il formatoPROJECT_ID:DATASET.TABLE, ad esempiomyProject:myDataset.myTable. Se il campo --destination_table non è specificato, viene generato un job di query che scrive l'output in una tabella temporanea.

API

Per eseguire una query utilizzando l'API, inserisci un nuovo job e compilare la proprietà di configurazione del job query. Se vuoi, puoi specificare località nella proprietà location nella sezione jobReference del risorse di lavoro.

Quando compili le proprietà del job di query, includi la proprietà configuration.query.priority e imposta il valore su BATCH.

Esegui il polling per i risultati chiamando getQueryResults. Sondaggio fino a quando jobComplete non sarà uguale a true. Verifica la presenza di errori e avvisi nel Elenco errors.

Vai

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

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

Per eseguire una query batch, imposta la query priorità a QueryJobConfiguration.Priority.BATCH quando crei QueryJobConfiguration.

Prima di provare questo esempio, segui le istruzioni di configurazione Java riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Java.

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

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

Prima di provare questo esempio, segui le istruzioni di configurazione Node.js riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta API Node.js BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

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

Prima di provare questo esempio, segui le istruzioni per la configurazione di Python nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Python BigQuery documentazione di riferimento.

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

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

Modalità ottimizzata per le query a breve termine

La modalità ottimizzata per le query brevi è progettata per migliorare la latenza complessiva delle query brevi comuni in carichi di lavoro come dashboard o esplorazione dei dati. Esegue la query e restituisce i risultati in linea per le istruzioni SELECT. Le query che utilizzano la modalità ottimizzata per le query a breve termine non creano un job se eseguite, a meno che BigQuery determina che la creazione di un job è necessaria per completare la query.

Per attivare la modalità ottimizzata per le query a breve termine, imposta il campo jobCreationMode dell'istanza QueryRequest su JOB_CREATION_OPTIONAL nel corpo della richiesta jobs.query.

Se il valore di questo campo è impostato su JOB_CREATION_OPTIONAL, BigQuery determina se per la query è possibile utilizzare la nuova query breve in modalità ottimizzata. In questo caso, BigQuery esegue la query e restituisce tutti i risultati nel campo rows della risposta. Poiché non viene creato un job per questa query, BigQuery non restituisce un jobReference nel corpo della risposta. Restituisce invece un campo queryId che puoi utilizzare per ottenere informazioni sulla query utilizzando la visualizzazioneINFORMATION_SCHEMA.JOBS. Poiché non viene creato alcun job, non è possibile passare jobReference alle API jobs.get e jobs.getQueryResults per cercare query brevi.

Se BigQuery determina che è necessario un job per completare viene restituito un valore jobReference. Puoi controllare job_creation_reason campo in INFORMATION_SCHEMA.JOBS per determinare il motivo per cui è stato creato un job per la query. In questo caso, devi usare jobs.getQueryResults per recuperare i risultati al termine della query.

Quando utilizzi il valore JOB_CREATION_OPTIONAL, non devi dare per scontato che Il campo jobReference è sempre presente nella risposta. Devi controllare se esistente prima di accedervi.

La modalità ottimizzata per le query a breve termine include anche una cache dei risultati delle query che migliora il rendimento delle query ripetute se i dati sottostanti non cambiano. Quando specificare useQueryCache: true (il valore predefinito è true se non specificato) e jobCreationMode: JOB_CREATION_OPTIONAL pollice QueryRequest, BigQuery tenta di fornire i risultati dalla cache. Tieni presente che la memorizzazione nella cache fa del suo meglio.

Per eseguire una query utilizzando la modalità ottimizzata per le query a breve termine, seleziona una delle seguenti opzioni:

Console

Vai alla pagina BigQuery.

Vai a BigQuery
Fai clic su QUERY SQL.
Nell'editor query, inserisci una query GoogleSQL valida.

Ad esempio, esegui una query Set di dati pubblico BigQuery usa_names per determinare i nomi più comuni negli Stati Uniti tra anni 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;
```
Fai clic su Altro e poi su Query ottimizzata per gli Short in Scegli la modalità di query. Fai clic su CONFERMA per confermare la scelta.
Fai clic su Esegui.

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.
Utilizza il comando bq query e specifica il flag --job_creation_mode=JOB_CREATION_OPTIONAL. Nell'esempio seguente, il flag --use_legacy_sql=false ti consente di utilizzare la sintassi di GoogleSQL.
```
bq query \
    --rpc=true \
    --use_legacy_sql=false \
    --job_creation_mode=JOB_CREATION_OPTIONAL \
    --location=LOCATION \
    'QUERY'
```
Sostituisci QUERY con una query GoogleSQL valida e LOCATION con una regione valida in cui si trova il set di dati. Per ad esempio, esegui una query Set di dati pubblico BigQuery usa_names per determinare i nomi più comuni negli Stati Uniti tra gli anni 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;'
```
Il job di query restituisce l'output in linea nella risposta.

Nota: se necessario, puoi utilizzare --apilog=stdout per registrare le richieste e le risposte dell'API al fine di estrarre queryId.

API

Per eseguire una query in modalità di query a breve termine utilizzando l'API, esegui una query in modo sincrono e compilano la proprietà QueryRequest. Includi la proprietà jobCreationMode e impostane il valore su JOB_CREATION_OPTIONAL.

Controlla la risposta. Se jobComplete è uguale a true e jobReference è vuoto, leggi i risultati dal campo rows. Puoi anche ottenere queryId dalla risposta.

Se è presente jobRefernence, puoi controllare in jobCreationReason il motivo per cui un job è stato creato da BigQuery. Sondaggio per ottenere i risultati chiamando getQueryResults Sondaggio fino a quando jobComplete non sarà uguale a true. Verifica la presenza di errori e avvisi nel Elenco errors.

Java

Versione disponibile: 2.37.1 e successive

È necessario impostare la variabile di ambiente QUERY_PREVIEW_ENABLED=true.

Esempio: Linux o macOS

    export QUERY_PREVIEW_ENABLED=TRUE

Esempio: Windows

    $env:QUERY_PREVIEW_ENABLED=TRUE

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

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

// Sample demonstrating short mode query execution.
//
// While this feature is still in preview, it is controlled by
// setting the environment variable QUERY_PREVIEW_ENABLED=TRUE
// to request short mode execution.
public class QueryShortMode {

  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";
    queryShortMode(query);
  }

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

      // 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());
    }
  }
}

Per eseguire una query con un proxy, consulta Configurare un proxy.

Python

Versione disponibile: 3.21.0 e successive

È necessario impostare la variabile di ambiente QUERY_PREVIEW_ENABLED=true.

Esempio: Linux o macOS

    export QUERY_PREVIEW_ENABLED=TRUE

Esempio: Windows

    $env:QUERY_PREVIEW_ENABLED=TRUE

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

# This example demonstrates issuing a query that may be run in short query mode.
#
# To enable the short query mode preview feature, the QUERY_PREVIEW_ENABLED
# environmental variable should be set to `TRUE`.
from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.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.  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 in short mode.  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"]))

Nodo

Versione disponibile: 7.6.1 e successive

È necessario impostare la variabile di ambiente QUERY_PREVIEW_ENABLED=true.

Esempio: Linux o macOS

    export QUERY_PREVIEW_ENABLED=TRUE

Esempio: Windows

    $env:QUERY_PREVIEW_ENABLED=TRUE

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

// Demonstrates issuing a query that may be run in short query mode.
// To enable the short query mode preview feature, the QUERY_PREVIEW_ENABLED
// environmental variable should be set to `TRUE`.

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

async function queryShortMode() {
  // 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(sqlQuery);

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

Vai

Versione disponibile: 1.58.0 e successive

Richiede l'impostazione della variabile di ambiente QUERY_PREVIEW_ENABLED=true

Esempio: Linux o macOS

    export QUERY_PREVIEW_ENABLED=TRUE

Esempio: Windows

    $env:QUERY_PREVIEW_ENABLED=TRUE

Prima di provare questo esempio, segui le istruzioni di configurazione Go riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta API Go BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

import (
	"context"
	"fmt"
	"io"

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

// queryShortMode demonstrates issuing a query that may be run in short query mode.
//
// To enable the short query mode preview feature, the QUERY_PREVIEW_ENABLED
// environmental variable should be set to `TRUE`.
func queryShortMode(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: %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 short 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
}

Driver JDBC

Versione disponibile: JDBC v1.6.1

Richiede l'impostazione JobCreationMode=2 nella stringa di connessione.

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

Driver ODBC

Versione disponibile: ODBC v3.0.7.1016

Richiede l'impostazione JobCreationMode=2 nel file .ini.

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

Quote

Per informazioni sulle quote relative alle query interattive e batch, consulta Job di query.

Visualizza il numero di query interattive e batch

Puoi visualizzare il numero di query interattive e batch utilizzando la visualizzazione INFORMATION_SCHEMA.JOBS_BY_PROJECT. L'esempio seguente utilizza la vista INFORMATION_SCHEMA.JOBS_BY_PROJECT per ottenere il numero di query interattive e batch eseguite nelle ultime 7 ore:

SELECT
  priority,
  COUNT(*) active_jobs,
FROM
  `region-us`.INFORMATION_SCHEMA.JOBS_BY_PROJECT
WHERE
  creation_time > TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 7 hour)
  AND end_time IS NULL
  AND job_type = 'QUERY'
GROUP BY priority

La vista INFORMATION_SCHEMA.JOBS_BY_PROJECT utilizza il campo priority per indicano se una query è INTERACTIVE o BATCH. Per ulteriori informazioni, vedi Schema.

Prova

Una prova in BigQuery fornisce le seguenti informazioni:

stima degli addebiti in modalità on demand
convalida della tua query
byte approssimativi elaborati dalla query in modalità capacità

Le prove non utilizzano slot di query e non ti viene addebitato alcun costo per l'esecuzione di una prova. Puoi utilizzare la stima restituita da una prova secca per calcolare i costi delle query nel Calcolatore prezzi.

Esegui una prova

Per eseguire una simulazione:

Console

Vai alla pagina BigQuery.

Vai a BigQuery
Inserisci la query nell'editor di query.

Se la query è valida, viene visualizzato automaticamente un segno di spunta insieme alla quantità di dati che verrà elaborata dalla query. Se la query non è valida, viene visualizzato un punto esclamativo con un messaggio di errore.

bq

Inserisci una query come la seguente utilizzando il flag --dry_run.

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

Per una query valida, il comando produce la seguente risposta:

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

API

Per eseguire una prova utilizzando l'API, invia un job di query con dryRun impostata su true in JobConfiguration di testo.

Vai

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

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

Prima di provare questo esempio, segui le istruzioni per la configurazione di Java nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Java.

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

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

Prima di provare questo esempio, segui le istruzioni per la configurazione di Node.js nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Node.js BigQuery documentazione di riferimento.

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

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

Prima di provare questo esempio, segui le istruzioni di configurazione PHP riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery PHP.

Per autenticarti a BigQuery, configura le credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

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

Imposta la proprietà QueryJobConfig.dry_run su True. Client.query() restituisce sempre QueryJob quando viene fornita una configurazione delle query dry run.

Prima di provare questo esempio, segui le istruzioni di configurazione Python riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Python.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

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

Passaggi successivi

Scopri come gestire i job di query.
Scopri come visualizzare la cronologia delle query.
Scopri come salvare e condividere le query.
Scopri di più sulle code di query.