Estima los costos de almacenamiento y consultas

Las consultas a pedido se cobran en función de la cantidad de bytes leídos. Para ver los precios de las consultas a pedido, consulta la página Precios.

Para estimar los costos antes de ejecutar una consulta, usa lo siguiente:

  • El validador de consultas en Cloud Console
  • La marca --dry_run en la herramienta de línea de comandos de bq
  • El parámetro dryRun cuando se envía un trabajo de consulta mediante la API
  • Calculadora de precios de Google Cloud
  • Bibliotecas cliente

Estima los costos de las consultas

Para estimar los costos de las consultas, haz lo siguiente:

Console

Cuando ingresas una consulta en Cloud Console, el validador de consultas verifica la sintaxis de la consulta y proporciona una estimación del número de bytes leídos. Puedes usar esta estimación para calcular el costo de la consulta en la calculadora de precios.

Validador de consultas

bq

Cuando ejecutas una consulta en la herramienta de línea de comandos de bq, puedes usar la marca --dry_run para estimar la cantidad de bytes leídos. Puedes usar esta estimación para calcular el costo de la consulta en la calculadora de precios.

Una consulta de la herramienta de bq que usa la marca --dry_run se ve de la siguiente manera:

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

Cuando ejecutas el comando, la respuesta contiene la estimación de bytes leídos: Query successfully validated. Assuming the tables are not modified, running this query will process 10918 bytes of data.

API

Para realizar una ejecución de prueba mediante la API, envía un trabajo de consulta con dryRun establecido en true.

go

Antes de probar este ejemplo, sigue las instrucciones de configuración para Go incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de Go de 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

Antes de probar este ejemplo, sigue las instrucciones de configuración para Java incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Java.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.JobStatistics;
import com.google.cloud.bigquery.QueryJobConfiguration;

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

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

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

      QueryJobConfiguration queryConfig =
          QueryJobConfiguration.newBuilder(query).setDryRun(true).setUseQueryCache(false).build();

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

      System.out.println(
          "Query dry run performed successfully." + statistics.getTotalBytesProcessed());
    } catch (BigQueryException e) {
      System.out.println("Query not performed \n" + e.toString());
    }
  }
}

Node.js

Antes de probar este ejemplo, sigue las instrucciones de configuración para Node.js incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la Documentación de referencia de la API de Node.js de 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);
}

Python

Antes de probar esta muestra, sigue las instrucciones de configuración para Python incluidas en la guía de inicio rápido de BigQuery sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de Python de BigQuery.

Para realizar una ejecución de prueba con la biblioteca cliente de Python, configura la propiedad QueryJobConfig.dry_run como True. Client.query() siempre muestra un QueryJob completo cuando se proporciona una configuración de consulta de ejecución de prueba.
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))

Estima los costos de las consultas con la calculadora de precios de Google Cloud

Para estimar los costos de las consultas a pedido en la calculadora de precios de Google Cloud, ingresa la cantidad de bytes que procesa la consulta en B, KB, MB, GB, TB o PB. Si tu consulta procesa menos de 1 TB, la estimación es de $0 porque BigQuery proporciona 1 TB de procesamiento de consultas a pedido gratis por mes.

Calculadora de precios

Para estimar el costo de una consulta con la calculadora de precios, sigue estos pasos:

  1. Abre la calculadora de precios de Google Cloud.
  2. Haz clic en BigQuery.
  3. Haz clic en la pestaña On-Demand (A pedido).
  4. En Nombre de la tabla, escribe el nombre de la tabla. Por ejemplo, airports.
  5. En Precios de almacenamiento (Storage Pricing), ingresa 0 en el campo Almacenamiento (Storage).
  6. En Query Pricing (Precios de las consultas), ingresa los bytes leídos estimados de tu ejecución de prueba o el validador de consultas.Calculadora
  7. Haz clic en Add To Estimate (Agregar a la estimación).
  8. La estimación aparece a la derecha. Ten en cuenta que puedes guardar o enviar la estimación por correo electrónico. Calculadora a pedido

En este caso, la cantidad de bytes que leyó la consulta es menor que 1 TB de procesamiento a pedido proporcionado a través del nivel gratuito. Como resultado, el costo estimado es de $0.

Incluye precios de tasa fija en la calculadora de precios

Si tienes precios de tasa fija aplicados a tu cuenta de facturación, puedes hacer clic en la pestaña Flat-Rate (Tasa fija), elegir tu plan de tasa fija y agregar tus costos de almacenamiento a la estimación.

Calculadora de tasa fija

Para obtener más información, consulta Precios con tarifa plana.

Estima los costos de almacenamiento con la calculadora de precios de Google Cloud

Para calcular los costos de almacenamiento en la calculadora de precios de Google Cloud , ingresa la cantidad de bytes que se almacenan como B, KB, MB, GB, TB o PB. BigQuery proporciona 10 GB de almacenamiento gratuito por mes.

Para estimar los costos de almacenamiento con la calculadora de precios, sigue estos pasos:

  1. Abre la calculadora de precios de Google Cloud.
  2. Haz clic en BigQuery.
  3. Haz clic en la pestaña On-Demand (A pedido).
  4. En Nombre de la tabla, escribe el nombre de la tabla. Por ejemplo, airports.
  5. En Precios de almacenamiento (Storage Pricing), ingresa 100 en el campo Almacenamiento (Storage). Deja la medida establecida en GB.
  6. Haz clic en Add To Estimate (Agregar a la estimación).
  7. La estimación aparece a la derecha. Ten en cuenta que puedes guardar o enviar la estimación por correo electrónico. Calculadora de precios

Cálculo del tamaño de la consulta

En esta sección, se describe cómo calcular la cantidad de bytes que procesan varios tipos de consultas mediante el modelo de facturación a pedido.

Declaraciones DML

Si usas la facturación a pedido, BigQuery cobra por las declaraciones del lenguaje de manipulación de datos (DML) según la cantidad de bytes que procesa la declaración.

Tablas no particionadas

En las tablas no particionadas, la cantidad de bytes procesados se calcula de la siguiente manera:

  • q = la suma de bytes procesados de las columnas a las que se hace referencia en las tablas que se analizaron en la consulta.
  • t = la suma de bytes de todas las columnas en la tabla actualizada en el momento en que comienza la consulta, sin importar si se hace referencia a esas columnas o se modifican en la consulta.
Declaración DML Bytes procesados
INSERT q
UPDATE q + t
DELETE q + t
MERGE Si solo hay cláusulas INSERT, q.
Si existe una cláusula UPDATE o DELETE: q + t.

Tablas particionadas

En el caso de las tablas particionadas, la cantidad de bytes procesados se calcula de la siguiente manera:

  • q' = la suma de bytes procesados de las columnas a las que se hace referencia en todas las particiones que se analizaron en la consulta.
  • t = la suma de bytes de todas las columnas en las particiones actualizadas o analizadas de las filas actualizadas, en el momento en que comienza la consulta, sin importar si se hace referencia a esas columnas o se modifican en la consulta.
Declaración DML Bytes procesados
INSERT q'
UPDATE q' + t'
DELETE q' + t'
MERGE Si solo hay cláusulas INSERT en la declaración MERGE: q'.
Si hay una cláusula UPDATE o DELETE en la declaración MERGE: q' + t'.

Declaraciones DDL

Si usas la facturación a pedido, BigQuery cobra por las consultas en el lenguaje de definición de datos (DDL) según la cantidad de bytes que procesa cada consulta.

Declaración DDL Bytes procesados
CREATE TABLE Ninguno.
CREATE TABLE ... AS SELECT ... La suma de bytes procesados de todas las columnas a las que se hace referencia en las tablas que se analizaron en la consulta.
CREATE VIEW Ninguno.
DROP TABLE Ninguno.
DROP VIEW Ninguno

Secuencia de comandos

Si usas la facturación a pedido, BigQuery cobra por las secuencias de comandos según la cantidad de bytes procesados durante su ejecución.

Se aplican los siguientes precios a los tipos de instrucciones específicos de secuencias de comandos:

  • DECLARE: La suma de bytes que se analizaron en cualquier tabla a la que se hizo referencia en la expresión DEFAULT. Las declaraciones DECLARE sin referencias de tablas no generan ningún costo.
  • SET: Suma de bytes que se analizaron en cualquier tabla a la que se hizo referencia en la expresión. Las declaraciones SET sin referencias de tablas no generan ningún costo.
  • IF: Suma de bytes que se analizaron en cualquier tabla a la que se hizo referencia en la expresión de condición. Las expresiones de condición IF sin referencia de tabla no generan ningún costo. Cualquier declaración en el bloque IF que no se ejecute no generará ningún costo.
  • WHILE: Suma de bytes que se analizaron en cualquier tabla a la que se hizo referencia en la expresión de condición. Las declaraciones WHILE sin referencias de tablas en la expresión de condición no generan ningún costo. Cualquier declaración en el bloque WHILE que no se ejecute no generará ningún costo.
  • CONTINUE o ITERATE: Sin costos asociados
  • BREAK o LEAVE: Sin costos asociados
  • BEGIN o END: Sin costos asociados

Las tablas temporales no generan cargos por almacenamiento mientras se ejecuta la secuencia de comandos. Sin embargo, se aplican precios regulares a cualquier declaración que las cree, modifique o consulte.

Si una secuencia de comandos falla, se aplican los costos de cualquier declaración hasta el momento en que ocurre la falla. La declaración que falló no genera ningún costo.

Ejemplo de precios de las secuencias de comandos

La siguiente secuencia de comandos de ejemplo contiene comentarios arriba de cada declaración con los que se explica el costo (si lo hay) que genera la siguiente declaración.

-- 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
-- script 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;

Tablas agrupadas

Las tablas agrupadas en clústeres reducen los datos para que las consultas no los procesen, lo que te permite disminuir este tipo de gastos. Este proceso se conoce como reducción de bloques.

Reducción de bloques

BigQuery ordena los datos en una tabla agrupada en clústeres según los valores de las columnas de agrupamiento en clústeres y, luego, los organiza en bloques.

Cuando ejecutas una consulta en una tabla agrupada en clústeres, y la consulta tiene un filtro en las columnas agrupadas en clústeres, BigQuery usa la expresión de filtro y los metadatos del bloque a fin de reducir la cantidad de bloques que analiza la consulta. Esto permite que BigQuery analice solo los bloques relevantes.

Cuando se reduce un bloque, no se lo analiza. Para calcular los bytes de datos que procesó la consulta, solo se usan los bloques analizados. La cantidad de bytes que procesó una consulta en una tabla agrupada en clústeres equivale a la suma de los bytes leídos en cada columna a la que hizo referencia la consulta en los bloques analizados.

Si se hace referencia varias veces a una tabla agrupada en una consulta que usa muchos filtros, BigQuery cobra por el análisis de las columnas en los bloques apropiados de cada filtro respectivo.

Ejemplo de precio de una tabla agrupada en clústeres

Supón que tienes una tabla agrupada en clústeres con el nombre ClusteredSalesData. La tabla está particionada en la columna timestamp y se agrupa en clústeres según la columna customer_id. Los datos se organizan en el conjunto de bloques que se indica a continuación:

Identificador de la partición ID del bloque Valor mínimo de customer_id en el bloque Valor máximo de customer_id en el bloque
20160501 B1 10000 19999
20160501 B2 20000 24999
20160502 B3 15000 17999
20160501 B4 22000 27999

Ejecutas la siguiente consulta en la tabla. La consulta contiene un filtro en la columna customer_id.

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

La consulta realiza las siguientes acciones:

  • Analiza las columnas timestamp, customer_id y totalSale en los bloques B2 y B4.
  • Reduce el bloque B3 debido al predicado de filtro DATE(timestamp) = "2016-05-01" en la columna de partición timestamp.
  • Reduce el bloque B1 debido al predicado de filtro customer_id BETWEEN 20000 AND 23000 en la columna de agrupamiento en clústeres customer_id.

Consulta formatos de columna en Cloud Storage

Si tus datos externos se almacenan en ORC o Parquet, la cantidad de bytes que se cobran está limitada por las columnas que BigQuery lee. Debido a que la consulta convierte los tipos de datos de una fuente externa en tipos de datos de BigQuery, la cantidad de bytes leídos se calcula según el tamaño de los tipos de datos de BigQuery. Para obtener más información sobre las conversiones de tipos de datos, consulta las siguientes páginas: