Scrittura dei risultati delle query

Questo documento descrive come scrivere i risultati delle query in modalità temporanea o permanente tabelle.

Tabelle temporanee e permanenti

BigQuery salva tutti i risultati delle query in una tabella, che può essere permanenti o temporanee.

• BigQuery utilizza le tabelle temporanee per memorizza nella cache i risultati delle query che non vengono scritti in un una tabella permanente. Le tabelle vengono create in un set di dati speciale e denominate in modo casuale. Puoi anche creare tabelle temporanee per uso personale all'interno query multi-istruzione e sessioni.

• Al termine di una query, la tabella temporanea può avere al massimo 24 nell'orario lavorativo locale del TAM. Per visualizzare la struttura e i dati della tabella, vai a Console BigQuery fai clic su Cronologia personale e scegli la query che ha creato la query . Nella riga Tabella di destinazione, fai clic su Tabella temporanea.

• L'accesso ai dati della tabella temporanea è limitato all'utente o al servizio l'account che ha creato il job di query.

• Non puoi condividere tabelle temporanee e non visibile utilizzando uno degli elenchi standard o altri metodi di manipolazione delle tabelle. Le tabelle temporanee vengono create nella stessa regione della tabella o delle tabelle che stai con cui viene eseguita la query.

• Una tabella permanente può essere una tabella nuova o esistente in qualsiasi set di dati a cui dispongono dell'accesso. Se scrivi i risultati della query in una nuova tabella, ti vengono addebitati per l'archiviazione dei dati. Quando scrivi una query in una tabella permanente, le tabelle su cui esegui la query devono essere nelle stesse località come il set di dati che contiene la tabella di destinazione.

Nota: se esegui una query sui dati di un progetto con quelli archiviati in un altro progetto, al progetto di query viene addebitato il costo del job di query, mentre al progetto viene archiviato A questi dati viene addebitata la quantità di dati archiviati in BigQuery.

Autorizzazioni obbligatorie

Come minimo, per scrivere i risultati di una query in una tabella, ti deve essere concesso il le seguenti autorizzazioni:

• bigquery.tables.create autorizzazioni per creare una nuova tabella
• bigquery.tables.updateData per scrivere dati in una nuova tabella, sovrascrivere una tabella o aggiungere dati a una tabella
• bigquery.jobs.create per eseguire un job di query

Potrebbero essere necessarie autorizzazioni aggiuntive, come bigquery.tables.getData per accedere ai dati su cui esegui query.

I seguenti ruoli IAM predefiniti includono Autorizzazioni bigquery.tables.create e bigquery.tables.updateData:

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

I seguenti ruoli IAM predefiniti includono bigquery.jobs.create autorizzazioni:

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

Inoltre, se un utente dispone delle autorizzazioni bigquery.datasets.create, quando crea un set di dati e gli viene concesso l'accesso bigquery.dataOwner. L'accesso a bigquery.dataOwner offre all'utente la possibilità di creare e aggiornare le tabelle nel set di dati.

Per ulteriori informazioni su ruoli e autorizzazioni IAM in BigQuery, vedi Autorizzazioni e ruoli predefiniti.

Scrivi i risultati della query in una tabella permanente

Quando scrivi i risultati di una query in una tabella permanente, puoi creare una nuova tabella, aggiungere i risultati a una tabella esistente o sovrascrivere una tabella esistente.

Scrittura dei risultati delle query

Utilizza la seguente procedura per scrivere i risultati della query in una tabella permanente. Per controllare i costi, puoi: visualizza l'anteprima dei dati prima di eseguire la query.

Console

1. Apri la pagina BigQuery nella console Google Cloud.

   Vai alla pagina di BigQuery

2. Nel riquadro Spazio di esplorazione, espandi il progetto e seleziona un set di dati.

3. Inserisci una query SQL valida.

4. Fai clic su Altro e seleziona Impostazioni query.

   

5. Seleziona l'opzione Imposta una tabella di destinazione per i risultati della query.

   

6. Nella sezione Destinazione, seleziona il Set di dati in cui vuoi per creare la tabella, poi scegli un ID tabella.

7. Nella sezione Preferenza di scrittura per la tabella di destinazione, scegli una delle le seguenti:

   • Scrivi se vuoto: scrive i risultati della query solo nella tabella se la tabella è vuota.
   • Aggiungi alla tabella: aggiunge i risultati della query a una tabella esistente .
   • Sovrascrivi tabella: sovrascrive una tabella esistente con lo stesso utilizzando i risultati della query.

8. (Facoltativo) Per Località dei dati, scegli la tua posizione.

9. Per aggiornare le impostazioni della query, fai clic su Salva.

10. Fai clic su Esegui. In questo modo viene creato un job di query che scrive dei risultati della query alla tabella specificata.

In alternativa, se dimentichi di specificare una tabella di destinazione prima di eseguire la query, puoi copiare la tabella dei risultati memorizzata nella cache in una tabella permanente facendo clic sul pulsante Salva risultati. sopra l'editor.

SQL

L'esempio seguente utilizza il metodo Dichiarazione CREATE TABLE per creare la tabella trips dai dati pubblici Tabella bikeshare_trips:

1. Nella console Google Cloud, vai alla pagina BigQuery.

   Vai a BigQuery

2. Nell'editor query, inserisci la seguente istruzione:

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

3. Fai clic su Esegui.

Per ulteriori informazioni su come eseguire le query, vedi Eseguire una query interattiva.

Per ulteriori informazioni, vedi Creazione di una nuova tabella da una tabella esistente.

bq

1. Nella console Google Cloud, attiva Cloud Shell.

   Attiva Cloud Shell

   Nella parte inferiore della console Google Cloud viene avviata una sessione di Cloud Shell che mostra un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installato e con valori già impostati per il progetto attuale. L'inizializzazione della sessione può richiedere alcuni secondi.

2. Inserisci il valore bq query e specifica il flag --destination_table creare una tabella permanente in base ai risultati della query. Specifica use_legacy_sql=false per usare la sintassi GoogleSQL. Per scrivere la query a una tabella che non è nel progetto predefinito, aggiungi l'ID progetto al nome del set di dati nel seguente formato: project_id:dataset.

   (Facoltativo) Fornisci il flag --location e imposta il valore su località.

   Per controllare l'istruzione di scrittura per una tabella di destinazione esistente, specifica uno dei seguenti flag facoltativi:

   • --append_table: se la tabella di destinazione esiste, i risultati della query sono aggiunti.

   • --replace: se la tabella di destinazione esiste, viene sovrascritta con i risultati della query.

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

     Sostituisci quanto segue:

   • location è il nome della località utilizzata per per elaborare la query. Il flag --location è facoltativo. Ad esempio, se utilizzi BigQuery nella regione di Tokyo, puoi impostare il flag su asia-northeast1. Puoi impostare un valore predefinito per la località: utilizzando File .bigqueryrc.

   • project_id è l'ID progetto.

   • dataset è il nome del set di dati che contiene la tabella in cui vengono scritti i risultati della query.

   • table è il nome della tabella a cui stai scrivere i risultati della query.

   • query è una query con la sintassi GoogleSQL.

     Se non viene specificato alcun flag di scrittura, il comportamento predefinito è scrivere i risultati alla tabella solo se è vuota. Se la tabella esiste ed è non è vuoto, viene restituito il seguente errore: "Errore BigQuery in Operazione di query: errore di elaborazione del job project_id:bqjob_123abc456789_00000e1234f_1': Already Exists: Table project_id:dataset.table.

     Esempi:

     Nota: questi esempi eseguono query su un set di dati pubblico basato negli Stati Uniti. Poiché il pubblico è archiviato nella località multiregionale degli Stati Uniti, il set di dati che contiene anche la tabella di destinazione deve trovarsi negli Stati Uniti. Non puoi eseguire query su un set di dati in una posizione e scrivere i risultati in una tabella di destinazione in un'altra posizione.

     Inserisci il comando seguente per scrivere i risultati della query in una tabella di destinazione denominato mytable in mydataset. Il set di dati si trova nel progetto predefinito. Poiché nel comando non viene specificato alcun flag di disposizione di scrittura, la tabella deve essere nuovo o vuoto. In caso contrario, viene restituito un errore Already exists. La query recupera i dati dal set di dati pubblico Name Data USA.

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

     Inserisci il comando seguente per utilizzare i risultati della query per sovrascrivere una destinazione tabella denominata mytable in mydataset. Il set di dati è quello predefinito progetto. Il comando utilizza il flag --replace per sovrascrivere la destinazione .

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

     Inserisci il comando seguente per aggiungere i risultati della query a una tabella di destinazione denominato mytable in mydataset. Il set di dati si trova in my-other-project, non il progetto predefinito. Il comando usa il flag --append_table per aggiungere i risultati della query nella tabella di destinazione.

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

     L'output per ciascuno di questi esempi è simile al seguente. Per la leggibilità elevata, alcuni output sono troncati.

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

API

Per salvare i risultati della query in una tabella permanente, richiama il metodo jobs.insert, configura un job query e includi un valore per destinationTable proprietà. per controllare l'istruzione di scrittura per una destinazione esistente. configura la proprietà writeDisposition.

Per controllare il percorso di elaborazione del job di query, specifica location nella sezione jobReference della risorsa job.

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 ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

import (
	"context"
	"fmt"
	"io"

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

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

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

Java

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 eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

Per salvare i risultati della query in una tabella permanente, imposta la destinazione tavola al TableId in un QueryJobConfiguration.

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

public class SaveQueryToTable {

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

    saveQueryToTable(destinationDataset, destinationTable, query);
  }

  public static void saveQueryToTable(
      String destinationDataset, String destinationTableId, String query) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

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

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

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

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

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

Node.js

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 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
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

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

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

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

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

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

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

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

Python

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 eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

Per salvare i risultati della query in una tabella permanente, crea un'istanza QueryJobConfig e imposta destinazione al TableReference. passa la configurazione del job alla query .

from google.cloud import bigquery

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

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

job_config = bigquery.QueryJobConfig(destination=table_id)

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

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

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

Scrivere risultati di query di grandi dimensioni

Normalmente, le query hanno una dimensione massima della risposta. Se prevedi di eseguire una query che potrebbe restituire risultati più grandi, puoi eseguire una delle seguenti le seguenti:

• In GoogleSQL, specifica una tabella di destinazione per i risultati della query.
• In SQL precedente, specifica una tabella di destinazione e imposta allowLargeResults .

Quando specifichi una tabella di destinazione per risultati di query di grandi dimensioni, ti vengono addebitati per l'archiviazione dei dati.

Limitazioni

In SQL precedente, la scrittura di risultati di grandi dimensioni è soggetta a queste limitazioni:

• Devi specificare una tabella di destinazione.
• Non puoi specificare una clausola ORDER BY, TOP o LIMIT di primo livello. In questo modo nega il vantaggio di utilizzare allowLargeResults, perché l'output della query non possono più essere calcolati in parallelo.
• Le funzioni finestra possono restituire risultati di query di grandi dimensioni solo se utilizzati insieme a un PARTITION BY una clausola.

Scrittura di risultati di grandi dimensioni utilizzando il linguaggio SQL precedente

Per scrivere set di risultati di grandi dimensioni utilizzando il linguaggio SQL precedente:

Console

1. Nella console Google Cloud, apri la pagina BigQuery.

   Vai a BigQuery

2. Fai clic su Crea nuova query.

3. Inserisci una query SQL valida nell'area di testo Editor query. Utilizza le funzionalità di il prefisso #legacySQL o assicurati di aver selezionato Utilizza SQL precedente le impostazioni della query.

4. Fai clic su Altro e poi seleziona Impostazioni query.

   

5. Per Destinazione, seleziona Imposta una tabella di destinazione per i risultati della query.

   

6. In Set di dati, scegli il set di dati in cui verrà archiviata la tabella.

7. Nel campo ID tabella, inserisci un nome per la tabella.

8. Se stai scrivendo un set di risultati di grandi dimensioni in una tabella esistente, puoi usare le opzioni Preferenza di scrittura della tabella di destinazione per controllare la scrittura della tabella di destinazione:

   • Scrivi se vuoto: scrive i risultati della query solo nella tabella se la tabella è vuota.
   • Aggiungi alla tabella: aggiunge i risultati della query a una tabella esistente .
   • Sovrascrivi tabella: sovrascrive una tabella esistente con lo stesso utilizzando i risultati della query.

9. Per Dimensioni dei risultati, seleziona Consenti risultati di grandi dimensioni (nessun limite di dimensione).

10. (Facoltativo) Per Località dei dati, scegli la posizione dei tuoi dati.

11. Fai clic su Salva per aggiornare le impostazioni della query.

12. Fai clic su Esegui. Questo crea un job di query che scrive risultati di grandi dimensioni impostata in base alla tabella specificata.

bq

Usa il flag --allow_large_results con il flag --destination_table per e creare una tabella di destinazione che contenga un set di risultati di grandi dimensioni. Poiché L'opzione --allow_large_results si applica solo a SQL precedente, devi inoltre specifica il flag --use_legacy_sql=true. Per scrivere i risultati della query in un che non si trova nel progetto predefinito, aggiungi l'ID progetto al set di dati nome nel seguente formato: PROJECT_ID:DATASET. Fornisci il flag --location e imposta il valore su località.

Per controllare l'istruzione di scrittura per una tabella di destinazione esistente, specifica uno dei seguenti flag facoltativi:

• --append_table: se la tabella di destinazione esiste, i risultati della query sono aggiunti.
• --replace: se la tabella di destinazione esiste, viene sovrascritta con i risultati della query.

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

Sostituisci quanto segue:

• LOCATION è il nome della località utilizzata per per elaborare la query. Il flag --location è facoltativo. Ad esempio, se utilizzi BigQuery nella regione di Tokyo, puoi impostare il flag su asia-northeast1. Puoi impostare un valore predefinito per la località utilizzando File .bigqueryrc.
• PROJECT_ID è l'ID progetto.
• DATASET è il nome del set di dati che contiene la tabella in cui vengono scritti i risultati della query.
• TABLE è il nome della tabella a cui stai scrivere i risultati della query.
• QUERY è una query nella sintassi SQL precedente.

Esempi:

Nota: questi esempi eseguono query su un set di dati pubblico. Poiché il set di dati è archiviato nella località multiregionale US, anche il set di dati di destinazione deve trovarsi negli Stati Uniti. Non puoi scrivere risultati di query su dati pubblici in una tabella di un'altra regione.

Inserisci il comando seguente per scrivere risultati di query di grandi dimensioni in una destinazione tabella denominata mytable in mydataset. Il set di dati è quello predefinito progetto. Poiché nel comando non viene specificato nessun flag dell'istruzione di scrittura, la tabella deve essere nuova o vuota. In caso contrario, viene restituito un errore Already exists restituito. La query recupera i dati dal set di dati pubblico Name Data USA. Questa query viene utilizzata solo a scopo di esempio. Il set di risultati restituito non superare la dimensione massima della risposta.

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

Inserisci il seguente comando per utilizzare risultati di query di grandi dimensioni per sovrascrivere un tabella di destinazione denominata mytable in mydataset. Il set di dati è in myotherproject, non il progetto predefinito. Il comando utilizza --replace per sovrascrivere la tabella di destinazione.

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

Inserisci il comando seguente per aggiungere risultati di query di grandi dimensioni a una destinazione tabella denominata mytable in mydataset. Il set di dati si trova in myotherproject, non è il progetto predefinito. Il comando usa il flag --append_table per aggiungere i risultati della query alla tabella di destinazione.

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

API

Per scrivere risultati di grandi dimensioni in una tabella di destinazione, chiama il metodo jobs.insert, configurare un job query e impostare la proprietà allowLargeResults su true. Specifica la tabella di destinazione utilizzando la proprietà destinationTable. A controllare l'istruzione di scrittura per una tabella di destinazione esistente, configurare la proprietà writeDisposition.

Specifica la tua località nella proprietà location del Sezione jobReference della risorsa job.

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 ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

import (
	"context"
	"fmt"
	"io"

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

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

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

Java

Per attivare risultati di grandi dimensioni, imposta consenti grandi su true e imposta la destinazione tabella al TableId in un QueryJobConfiguration.

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 eseguire l'autenticazione su BigQuery, configura 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.TableId;
import com.google.cloud.bigquery.TableResult;

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

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

  public static void queryLargeResults(
      String destinationDataset, String destinationTable, String query) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

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

      TableResult results = bigquery.query(queryConfig);

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

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

Node.js

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 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
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

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

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

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

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

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

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

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

Python

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 eseguire l'autenticazione su BigQuery, configura 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()

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

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

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

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

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

Download e salvataggio dei risultati delle query dalla console Google Cloud

Dopo aver eseguito una query SQL utilizzando la console Google Cloud, puoi salvare di ricerca in un'altra posizione. Puoi utilizzare la console Google Cloud per scaricare i risultati della query in un file locale, Fogli Google o Google Drive. Se prima i risultati della query per colonna, l'ordine viene mantenuto nella e i dati di Google Cloud. Il salvataggio dei risultati in un file locale, in Fogli Google o su Google Drive non supportate dallo strumento a riga di comando bq o dall'API.

Limitazioni

Il download e il salvataggio dei risultati delle query sono soggetti alle seguenti limitazioni:

• Puoi scaricare i risultati delle query solo localmente in formato CSV o JSON delimitato da nuova riga formato.
• Non puoi salvare i risultati delle query contenenti dati nidificati e ripetuti in in Fogli Google.
• Per salvare i risultati della query su Google Drive utilizzando la console Google Cloud, deve essere di massimo 1 GB. Se i risultati sono più grandi, puoi salvare in una tabella.
• Quando salvi i risultati di una query in un file CSV locale, la dimensione massima di download è 10 MB La dimensione massima di download si basa sulle dimensioni di ogni riga restituita nel Metodo tabledata.list e può variare in base allo schema dei risultati della query. Di conseguenza, la dimensione del file CSV scaricato può variare e potrebbe essere inferiore alla dimensioni massime di download.
• Puoi salvare i risultati delle query su Google Drive solo in formato CSV o delimitato da nuova riga JSON.

Passaggi successivi

• Scopri come esportare una tabella in un file JSON in modo programmatico.
• Scopri di più sulle quote per i job di query.
• Scopri di più sui prezzi di archiviazione di BigQuery.