Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Stima i costi di archiviazione e query

In BigQuery, il costo delle query on demand si basa sul numero di byte letti. Per i prezzi on demand delle query attuali, consulta la pagina Prezzi.

Per stimare i costi prima di eseguire una query, puoi utilizzare uno dei seguenti metodi:

  • Strumento di convalida delle query in Google Cloud Console
  • --dry_run flag nello strumento a riga di comando bq
  • Parametro dryRun quando si invia un job di query utilizzando l'API
  • Il Calcolatore prezzi di Google Cloud
  • Librerie client

I costi stimati forniti da questi metodi potrebbero variare da quelli effettivi a causa di diversi fattori. Ad esempio, considera i seguenti scenari:

  • Una clausola di query che filtra i dati, ad esempio una clausola WHERE, potrebbe ridurre in modo significativo il numero di byte letti.
  • I dati aggiunti o eliminati dopo l'invio della stima potrebbero aumentare o diminuire il numero di byte letti quando viene eseguita la query.

Stima i costi delle query

Per stimare i costi delle query:

Console

Quando inserisci una query nella console Google Cloud, lo strumento di convalida delle query verifica la sintassi della query e fornisce una stima del numero di byte letti. Puoi utilizzare questa stima per calcolare il costo della query nel Calcolatore prezzi.

Strumento di convalida delle query

bq

Quando esegui una query nello strumento a riga di comando bq, puoi utilizzare il flag --dry_run per stimare il numero di byte letti. Puoi utilizzare questa stima per calcolare il costo della query nel Calcolatore prezzi.

Una query dello strumento bq che utilizza il flag --dry_run ha il seguente aspetto:

bq query \
--use_legacy_sql=false \
--dry_run \
'SELECT
  column1,
  column2,
  column3
FROM
  `project_id.dataset.table`
LIMIT
  1000'

Quando esegui il comando, la risposta contiene i byte stimati letti: Query successfully validated. Assuming the tables are not modified, running this query will process 10918 bytes of data.

API

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

via

Prima di provare questo esempio, segui le istruzioni di configurazione di Go nella guida rapida di BigQuery che utilizza librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Go di BigQuery.

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 != 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 di Java nella guida rapida di BigQuery che utilizza librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Java di BigQuery.

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 di Node.js nella guida rapida di BigQuery che utilizza librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Node.js di BigQuery.

// 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 di PHP nella guida rapida di BigQuery che utilizza librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API PHP di BigQuery.

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di BigQuery che utilizza librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Python di BigQuery.

Per eseguire un'esecuzione di prova utilizzando la libreria client Python, imposta la proprietà QueryJobConfig.dry_run su True. Client.query() restituisce sempre un QueryJob completato quando viene fornita una configurazione di query di prova.
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))

Stima i costi delle query con il Calcolatore prezzi di Google Cloud

Per stimare i costi delle query on demand nel Calcolatore prezzi di Google Cloud, inserisci il numero di byte elaborati dalla query come B, KB, MB, GB, TB o PB. Se la tua query elabora meno di 1 TB, la stima è pari a 0 $perché BigQuery fornisce 1 TB di elaborazione on demand di query al mese senza costi aggiuntivi.

Calcolatore prezzi

Per stimare il costo di una query utilizzando il Calcolatore prezzi:

  1. Apri il Calcolatore prezzi di Google Cloud.
  2. Fai clic su BigQuery.
  3. Fai clic sulla scheda On demand.
  4. In Nome tabella, digita il nome della tabella. Ad esempio, airports.
  5. In Prezzi di archiviazione, inserisci 0 nel campo Spazio di archiviazione.
  6. In Prezzi delle query, inserisci i byte stimati letti dalla tua prova o lo strumento di convalida delle query. Calcolatrice
  7. Fai clic su Aggiungi alla stima.
  8. La stima viene visualizzata a destra. Puoi salvare o inviare la stima per email. Calcolatrice on demand

In questo caso, il numero di byte letti dalla query è inferiore a 1 TB di elaborazione on demand fornito tramite il livello gratuito. Di conseguenza, il costo stimato è pari a 0 $.

Includere il modello a costo fisso nel Calcolatore prezzi

Se hai applicato il costo fisso al tuo account di fatturazione, puoi fare clic sulla scheda Costo fisso, scegliere il piano a costo fisso e aggiungere i costi di archiviazione alla stima.

Calcolatore a costo fisso

Per ulteriori informazioni, consulta la sezione Modello di prezzo a costo fisso.

Stima i costi di archiviazione con il Calcolatore prezzi di Google Cloud

Per stimare i costi di archiviazione nel Calcolatore prezzi di Google Cloud, inserisci il numero di byte archiviati come B, KB, MB, GB, TB o PB. BigQuery fornisce 10 GB di spazio di archiviazione gratuito al mese.

Per stimare i costi di archiviazione utilizzando il Calcolatore prezzi:

  1. Apri il Calcolatore prezzi di Google Cloud.
  2. Fai clic su BigQuery.
  3. Fai clic sulla scheda On demand.
  4. In Nome tabella, digita il nome della tabella. Ad esempio, airports.
  5. In Prezzi di archiviazione, inserisci 100 nel campo Spazio di archiviazione. Lascia la misura impostata su GB.
  6. Fai clic su Aggiungi alla stima.
  7. La stima viene visualizzata a destra. Puoi salvare o inviare la stima per email. Calcolatore prezzi

Calcolo delle dimensioni della query

Questa sezione descrive come calcolare il numero di byte elaborati da vari tipi di query utilizzando il modello di fatturazione on demand.

Istruzioni DML

Se utilizzi la fatturazione on demand, BigQuery addebita i costi per le istruzioni DML (Data Manipulation Language) in base al numero di byte elaborati dall'istruzione.

Tabelle non partizionate

Per le tabelle non partizionate, il numero di byte elaborati viene calcolato come segue:

  • q = la somma di byte elaborati per le colonne a cui viene fatto riferimento nelle tabelle scansionate dalla query.
  • t = la somma di byte per tutte le colonne della tabella aggiornata, nel momento in cui la query viene avviata, indipendentemente dal fatto che la colonna faccia riferimento a tali colonne o venga modificata.
Istruzione DML Byte elaborati
INSERT D
UPDATE Q + T
DELETE Q + T
MERGE Se sono presenti solo clausole INSERT: q.
Se esiste una clausola UPDATE o DELETE: q + t.

Tabelle partizionate

Per le tabelle partizionate, il numero di byte elaborati viene calcolato come segue:

  • q' = La somma di byte elaborati per le colonne a cui si fa riferimento in tutte le partizioni scansionate dalla query.
  • t' = la somma di byte per tutte le colonne nelle partizioni aggiornate o analizzate per le righe aggiornate, nel momento in cui la query viene avviata, indipendentemente dal fatto che tali colonne siano indicate o modificate nella query.
Istruzione DML Byte elaborati
INSERT Q'
UPDATE q' + t'
DELETE q' + t'
MERGE Se sono presenti solo clausole INSERT nell'istruzione MERGE: q'.
Se è presente una clausola UPDATE o DELETE nell'istruzione MERGE: q' + t'.

Istruzioni DDL

Se utilizzi la fatturazione on demand, BigQuery addebita i costi per le query in DDL (Data Definition Language) in base al numero di byte elaborati dalla query.

Istruzione DDL Byte elaborati
CREATE TABLE Nessuno.
CREATE TABLE ... AS SELECT ... La somma di byte elaborati per tutte le colonne cui viene fatto riferimento nelle tabelle analizzate dalla query.
CREATE VIEW Nessuno.
DROP TABLE Nessuno.
DROP VIEW Nessuno.

Query con più istruzioni

Se utilizzi la fatturazione on demand, BigQuery addebita il costo per le query con più istruzioni in base al numero di byte elaborati durante l'esecuzione delle query per più istruzioni.

I seguenti prezzi si applicano alle seguenti query con più dichiarazioni:

  • DECLARE: la somma dei byte analizzati per le tabelle cui viene fatto riferimento nell'espressione DEFAULT. Le istruzioni DECLARE senza riferimenti a tabelle non sono addebitate.
  • SET: la somma dei byte analizzati per le tabelle cui viene fatto riferimento nell'espressione. Le istruzioni SET senza riferimenti a tabelle non sono addebitate.
  • IF: la somma dei byte analizzati per le tabelle cui viene fatto riferimento nell'espressione della condizione. Le espressioni della condizione IF senza riferimenti a tabelle non sono addebitate. Eventuali istruzioni non eseguite all'interno del blocco IF non sono addebitate.
  • WHILE: la somma dei byte analizzati per le tabelle cui viene fatto riferimento nell'espressione della condizione. Le istruzioni WHILE senza riferimenti a tabelle nell'espressione della condizione non sono addebitate. Eventuali istruzioni non eseguite all'interno del blocco WHILE non sono addebitate.
  • CONTINUE o ITERATE: nessun costo associato.
  • BREAK o LEAVE: nessun costo associato.
  • BEGIN o END: nessun costo associato.

Le tabelle temporanee non comportano costi di archiviazione durante l'esecuzione di una query con più istruzioni. Tuttavia, vengono applicati i prezzi normali per qualsiasi istruzione che li crea, li modifica o li esegue query.

Se una query con più istruzioni ha esito negativo, il costo di qualsiasi istruzione fino all'errore continuerà a essere applicato. L'istruzione con esito negativo non sarà addebitata.

Esempio di prezzo per query multi-affermazione

L'esempio che segue contiene commenti che precedono ogni affermazione che spiega l'eventuale costo sostenuto dalla seguente affermazione.

-- No cost, since no tables are referenced.
DECLARE x DATE DEFAULT CURRENT_DATE();
-- Incurs the cost of scanning string_col from dataset.table.
DECLARE y STRING DEFAULT (SELECT MAX(string_col) FROM dataset.table);
-- Incurs the cost of copying the data from dataset.big_table.  Once the
-- table is created, you are not charged for storage while the rest of the
-- multi-statement query runs.
CREATE TEMP TABLE t AS SELECT * FROM dataset.big_table;
-- Incurs the cost of scanning column1 from temporary table t.
SELECT column1 FROM t;
-- No cost, since y = 'foo' doesn't reference a table.
IF y = 'foo' THEN
  -- Incurs the cost of scanning all columns from dataset.other_table, if
  -- y was equal to 'foo', or otherwise no cost since it is not executed.
  SELECT * FROM dataset.other_table;
ELSE
  -- Incurs the cost of scanning all columns from dataset.different_table, if
  -- y was not equal to 'foo', or otherwise no cost since it is not executed.
  UPDATE dataset.different_table
  SET col = 10
  WHERE true;
END IF;
-- Incurs the cost of scanning date_col from dataset.table for each
-- iteration of the loop.
WHILE x < (SELECT MIN(date_col) FROM dataset.table) DO
  -- No cost, since the expression does not reference any tables.
  SET x = DATE_ADD(x, INTERVAL 1 DAY);
  -- No cost, since the expression does not reference any tables.
  IF true THEN
    -- LEAVE has no associated cost.
    LEAVE;
  END IF;
  -- Never executed, since the IF branch is always taken, so does not incur
  -- a cost.
  SELECT * FROM dataset.big_table;
END WHILE;

Tabelle in cluster

Le tabelle in cluster possono aiutarti a ridurre i costi delle query eliminando i dati in modo che non vengano elaborati dalla query. Questo processo è chiamato eliminazione dei blocchi.

Eliminazione dei blocchi

BigQuery ordina i dati in una tabella in cluster in base ai valori nelle colonne di clustering e li organizza in blocchi.

Quando esegui una query su una tabella in cluster e la query include un filtro sulle colonne in cluster, BigQuery utilizza l'espressione di filtro e i metadati del blocco per rimuovere i blocchi analizzati dalla query. Questo consente a BigQuery di analizzare solo i blocchi pertinenti.

Quando un blocco viene eliminato, non viene scansionato. Solo i blocchi analizzati vengono utilizzati per calcolare i byte dei dati elaborati dalla query. Il numero di byte elaborati da una query su una tabella in cluster corrisponde alla somma dei byte letti in ogni colonna a cui fa riferimento la query nei blocchi analizzati.

Se una tabella in cluster viene menzionata più volte in una query che utilizza diversi filtri, BigQuery addebita la scansione delle colonne nei blocchi appropriati in ciascuno dei rispettivi filtri.

Esempio di prezzi di tabelle in cluster

Hai una tabella in cluster denominata ClusteredSalesData. La tabella è partizionata in base alla colonna timestamp ed è raggruppata in cluster in base alla colonna customer_id. I dati sono organizzati nel seguente insieme di blocchi:

Identificatore di partizione ID blocco Valore minimo per customer_id nel blocco Valore massimo per customer_id nel blocco
20160501 B1 10000 19999
20160501 B2 20000 24999
20160502 B3 15000 17999
20160501 B4 22000 27999

Esegui la seguente query sulla tabella. La query contiene un filtro nella colonna customer_id.

SELECT
  SUM(totalSale)
FROM
  `mydataset.ClusteredSalesData`
WHERE
  customer_id BETWEEN 20000
  AND 23000
  AND DATE(timestamp) = "2016-05-01"

Questa query:

  • Analizza le colonne timestamp, customer_id e totalSale nei blocchi B2 e B4.
  • Elimina il blocco B3 a causa del predicato del filtro DATE(timestamp) = "2016-05-01" nella colonna di partizionamento timestamp.
  • Elimina il blocco B1 a causa del predicato del filtro customer_id BETWEEN 20000 AND 23000 nella colonna di clustering customer_id.

Esegui query su formati a colonne su Cloud Storage

Se i tuoi dati esterni sono archiviati in formato ORC o Parquet, il numero di byte addebitati è limitato alle colonne lette da BigQuery. Poiché i tipi di dati di un'origine dati esterna sono convertiti dalla query in tipi di dati BigQuery, il numero di byte letti è calcolato in base alle dimensioni dei tipi di dati BigQuery. Per informazioni sulle conversioni dei tipi di dati, consulta le seguenti pagine: