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 sui dati BigQuery utilizzando uno dei seguenti tipi di job di query:

• Job di query interattive. Per impostazione predefinita, BigQuery esegue i job di query interattive (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.

• Esegui job di query batch. Con questi job, BigQuery mette in coda ogni query batch per tuo conto e poi avvia la query quando sono disponibili risorse inattive, 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 contemporanee in base alla disponibilità delle risorse e favorisce l'esecuzione di più query interattive contemporanee rispetto alle query batch. Una volta raggiunto il limite di query simultanee, le query aggiuntive rimangono in attesa in una coda. Per ulteriori informazioni, consulta le code 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.

Nota: se esegui query sui dati di un progetto per accedere ai dati archiviati in un altro progetto, al progetto che esegue la query viene addebitato il job di query, mentre al progetto che archivia i dati viene addebitato il volume di dati archiviati in BigQuery.

Ruoli obbligatori

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

• Utente job BigQuery (roles/bigquery.jobUser) nel progetto.
• Visualizzatore dati BigQuery (roles/bigquery.dataViewer) su 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 visualizzazioni autorizzate o set di dati autorizzati, non è necessario 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 contengono le autorizzazioni necessarie per eseguire un job di query. Per visualizzare le autorizzazioni esatte richieste, espandi la sezione Autorizzazioni richieste:

Autorizzazioni obbligatorie

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

• bigquery.jobs.create sul progetto da cui viene eseguita la query, indipendentemente da dove sono archiviati i dati.
• bigquery.tables.getData in 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 visualizzazioni autorizzate o set di dati autorizzati, non devi 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.

Eseguire una query interattiva

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

Console

1. Vai alla pagina BigQuery.

   Vai a BigQuery

2. Fai clic su Query SQL.

3. Nell'editor delle query, inserisci 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 gli 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;
   

4. (Facoltativo) Specifica la tabella di destinazione e la posizione per i risultati della query:

   1. Nell'editor di query, fai clic su Altro e poi 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 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 per questa query, anche il set di dati che contiene la tabella di destinazione deve essere nella regione multipla 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.

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

6. (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 sono maggiori di zero, il numero di byte viene visualizzato nella parte superiore del menu.

7. (Facoltativo) Per visualizzare la visualizzazione dei risultati della query, vai alla scheda Grafico. Puoi aumentare o diminuire lo zoom del grafico, scaricarlo come file PNG o attivare/disattivare 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.

8. (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

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. Utilizza il comando bq query. Nell'esempio seguente, il flag --use_legacy_sql=false ti consente di utilizzare la sintassi di 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 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 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 la regione multipla per la tabella di destinazione, 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 e 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 --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 compila 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. Esegui il sondaggio finché jobComplete non è 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 autenticarti in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare 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 di configurazione Go riportate nella guida rapida all'utilizzo di BigQuery con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API BigQuery Go.

Per autenticarti in BigQuery, configura le 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 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 in 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;

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 Configurare 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 autenticarti in 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 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 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 in 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 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 autenticarti in BigQuery, configura le 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 in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare 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 continua richiede una configurazione aggiuntiva. Per ulteriori informazioni, consulta Creare query continue.

Eseguire una query batch

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

Console

1. Vai alla pagina BigQuery.

   Vai a BigQuery

2. Fai clic su Query SQL.

3. Nell'editor delle query, inserisci 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 gli 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;
   

4. Fai clic su Altro, quindi su Impostazioni query.

5. Nella sezione Gestione risorse, seleziona Batch.

6. (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 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 per questa query, anche il set di dati che contiene la tabella di destinazione deve essere nella regione multipla 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.

8. Fai clic su Esegui.

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

9. (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 sono maggiori di zero, il numero di byte viene visualizzato nella parte superiore del menu.

10. (Facoltativo) Per visualizzare la visualizzazione dei risultati della query, vai alla scheda Grafico. Puoi aumentare o diminuire lo zoom del grafico, scaricarlo come file PNG o attivare/disattivare 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

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. Utilizza il comando bq query e specifica il flag --batch. Nell'esempio seguente, il flag --use_legacy_sql=false ti consente di utilizzare la sintassi di GoogleSQL.

   bq query \
       --batch \
       --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 \
       --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 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 per accodare (--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 la regione multipla per la tabella di destinazione, 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 e 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 --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 compila la proprietà di configurazione del job query. Se vuoi, specifica la tua posizione nella proprietà location nella sezione jobReference della risorsa job.

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. Esegui il sondaggio finché jobComplete non è uguale a true. Controlla la presenza di errori e avvisi nell'elenco errors.

Vai

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 la documentazione di riferimento dell'API BigQuery Go.

Per autenticarti in 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 priorità della query su QueryJobConfiguration.Priority.BATCH quando crei un 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 in 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 la documentazione di riferimento dell'API BigQuery Node.js.

Per autenticarti in 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 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 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 autenticarti in BigQuery, configura le 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(
    # 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

Anteprima

Questo prodotto o funzionalità è soggetto ai "Termini delle Offerte pre-GA" nella sezione Termini generali del servizio dei Termini specifici del servizio. I prodotti e le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per saperne di più, consulta le descrizioni della fase di lancio.

Nota: per fornire feedback o richiedere assistenza per questa funzionalità, invia un'email all'indirizzo [e-mail].

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 quando vengono eseguite, a meno che BigQuery non stabilisca che è necessaria la creazione di un job 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.

Quando il valore di questo campo è impostato su JOB_CREATION_OPTIONAL, BigQuery determina se la query può utilizzare la nuova modalità ottimizzata per le query brevi. 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 INFORMATION_SCHEMA.JOBS visualizzazione. 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 la query, viene restituito un valore jobReference. Puoi esaminare il campo job_creation_reason nella INFORMATION_SCHEMA.JOBS visualizzazione per determinare il motivo per cui è stato creato un job per la query. In questo caso, devi utilizzare jobs.getQueryResults per recuperare i risultati al termine della query.

Quando utilizzi il valore JOB_CREATION_OPTIONAL, non dovresti assumere che il campo jobReference sia sempre presente nella risposta. Prima di accedere, devi verificare se il campo esiste.

La modalità ottimizzata per le query brevi include anche una cache dei risultati delle query che migliora le prestazioni delle query ripetute quando i dati sottostanti non cambiano. Quando specifichi useQueryCache: true (il valore predefinito è useQueryCache: true se non specificato) e jobCreationMode: JOB_CREATION_OPTIONAL in QueryRequest, BigQuery tenta di pubblicare i risultati dalla cache.true Tieni presente che la memorizzazione nella cache viene eseguita secondo il criterio del "best effort".

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

Console

1. Vai alla pagina BigQuery.

   Vai a BigQuery

2. Fai clic su Query SQL.

3. Nell'editor delle query, inserisci 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 gli 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;
   

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

5. Fai clic su Esegui.

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. 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. 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 \
       --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 brevi utilizzando l'API, esegui una query in modo sincrono e compila 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 il queryId dalla risposta.

Se è presente jobRefernence, puoi controllare in jobCreationReason il motivo per cui un job è stato creato da BigQuery. Esegui il polling per i risultati chiamando getQueryResults. Esegui il sondaggio finché jobComplete non è uguale a true. Controlla la presenza di errori e avvisi nell'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
  

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

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 autenticarti in BigQuery, configura le 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
  

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 autenticarti in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare 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 la documentazione di riferimento dell'API BigQuery Go.

Per autenticarti in BigQuery, configura le 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;
  

Nota: puoi aggiungere LogLevel=6;LogPath=log.txt alla stringa di connessione per attivare il logging a livello TRACE ed estrarre informazioni sulla risoluzione dei problemi, incluso queryId, se necessario.

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
  

Nota: puoi aggiungere LogLevel=6 e LogPath=log.txt al file .ini per attivare il logging a livello dettagliato ed estrarre informazioni sulla risoluzione dei problemi, incluso queryId, se necessario.

Quote

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

Monitorare le query

Puoi ottenere informazioni sulle query durante l'esecuzione utilizzando lo esploratore dei job o eseguendo una query nella visualizzazione INFORMATION_SCHEMA.JOBS_BY_PROJECT.

Dry run

Una prova in BigQuery fornisce le seguenti informazioni:

• stima degli addebiti in modalità on demand
• convalida della query
• byte approssimativi elaborati dalla query in modalità di 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.

Nota: un'esecuzione di prova di una query federata che utilizza un'origine dati esterna potrebbe registrare un limite inferiore di 0 byte di dati, anche se vengono restituite righe. Questo accade perché la quantità di dati elaborati dalla tabella esterna non può essere determinata fino al completamento della query effettiva. L'esecuzione della query federata comporta comunque un costo per l'elaborazione di questi dati.

Esegui una prova

Per eseguire una simulazione:

Console

1. Vai alla pagina BigQuery.

   Vai a BigQuery

2. Inserisci la query nell'editor delle query.

   Se la query è valida, viene visualizzato automaticamente un segno di spunta insieme alla quantità di dati che verranno elaborati 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.

Nota: se la query elabora una piccola quantità di dati, potrebbe essere necessario convertire i byte elaborati da KB in MB. MB è la misura più piccola utilizzata dal Calcolatore prezzi.

API

Per eseguire una prova utilizzando l'API, invia un job di query con dryRun impostato su true nel tipo JobConfiguration.

Vai

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 la documentazione di riferimento dell'API BigQuery Go.

Per autenticarti in BigQuery, configura le 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"
)

// 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 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 in 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 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 autenticarti in 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 in 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 un QueryJob completato se viene fornita una configurazione di query di prova.

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 autenticarti in BigQuery, configura le 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.