Escribe resultados de consultas

En este documento, se explica cómo escribir resultados de consultas en tablas temporales o permanentes.

Tablas temporales y permanentes

BigQuery guarda todos los resultados de las consultas en una tabla, que puede ser permanente o temporal.

  • BigQuery usa tablas temporales para almacenar en caché los resultados de las consultas que no se escriben en una tabla permanente. Las tablas se crean en un conjunto de datos especial y se les asigna un nombre al azar. También puedes crear tablas temporales para tu propio uso dentro de consultas de varias declaraciones y sesiones.

  • Una vez que finaliza una consulta, la tabla temporal existe por hasta 24 horas. Para ver los datos y la estructura de la tabla, ve a Consola de BigQuery, haz clic en Historial personal y elige la consulta que creó la tabla temporal. Luego, en la fila Tabla de destino, haz clic en Tabla temporal.

  • El acceso a los datos de la tabla temporal se restringe al usuario o a la cuenta de servicio que creó el trabajo de consulta.

  • No puedes compartir tablas temporales y no son visibles con ninguno de los métodos de lista estándar o de manipulación de tablas. Las tablas temporales se crean en la misma región que las tablas que se consultan.

  • Las tablas permanentes pueden ser tablas nuevas o existentes en cualquier conjunto de datos al que tengas acceso. Si escribes los resultados de las consultas en una tabla nueva, se te cobrará por almacenar los datos. Cuando escribes los resultados de las consultas en una tabla permanente, las tablas que consultas deben estar en la misma ubicación que el conjunto de datos que contiene la tabla de destino.

Permisos necesarios

Como mínimo, para escribir los resultados de las consultas en una tabla, debes tener los siguientes permisos:

  • bigquery.tables.create para crear una tabla nueva
  • bigquery.tables.updateData para escribir datos en una tabla nueva, reemplazar una tabla o agregar datos a una tabla
  • bigquery.jobs.create para ejecutar un trabajo de consulta

Es posible que se requieran permisos adicionales como bigquery.tables.getData para acceder a los datos que consultas.

En los siguientes roles predefinidos de IAM, se incluyen los permisos bigquery.tables.create y bigquery.tables.updateData:

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

Los siguientes roles predefinidos de IAM incluyen los permisos bigquery.jobs.create:

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

Además, si un usuario tiene permisos bigquery.datasets.create, se le otorga el acceso bigquery.dataOwner cuando crea un conjunto de datos. Con el acceso bigquery.dataOwner, el usuario puede crear y actualizar tablas en el conjunto de datos.

Para obtener más información sobre los roles y los permisos de IAM en BigQuery, consulta Funciones y permisos predefinidos.

Escribe los resultados de una consulta en una tabla permanente

Cuando escribes los resultados de las consultas en una tabla permanente, puedes crear una tabla nueva, agregar los resultados en una tabla existente o reemplazar una tabla existente.

Escribe resultados de consultas

Usa el siguiente procedimiento para escribir los resultados de las consultas en una tabla permanente. Para ayudar a controlar los costos, puedes obtener una vista previa de los datos antes de ejecutar la consulta.

Consola

  1. Abre la página BigQuery en la consola de Google Cloud.

    Ir a la página de BigQuery

  2. En el panel Explorador, expande tu proyecto y elige un conjunto de datos.

  3. Escribe una consulta de SQL válida.

  4. Haz clic en Más y, luego, elige Opciones de consulta.

    Configuración de consulta

  5. Elige la opción Set a destination table for query results (Establecer una tabla de destino para los resultados de la consulta).

    Establecer destino

  6. En la sección Destino, elige el Conjunto de datos en el que deseas crear la tabla y, luego, elige un ID de la tabla.

  7. En la sección Preferencia de escritura para la tabla de destino, elige una de las siguientes opciones:

    • Escribir si está vacía: escribe los resultados de las consultas en la tabla solo si está vacía.
    • Agregar a la tabla: Agrega los resultados de las consultas a una tabla existente.
    • Reemplazar la tabla: Se reemplaza una tabla existente que tiene el mismo nombre con los resultados de las consultas.
  8. Opcional: En Ubicación de los datos, elige tu ubicación.

  9. Para actualizar la configuración de la consulta, haz clic en Guardar.

  10. Haga clic en Ejecutar. Esta acción crea un trabajo de consulta que escribe los resultados de las consultas en la tabla que especificaste.

Como alternativa, si te olvidas de especificar una tabla de destino antes de ejecutar la consulta, puedes hacer clic en el botón Guardar los resultados encima del editor para copiar la tabla de resultados almacenados en caché en una tabla permanente.

SQL

En el siguiente ejemplo, se usa la declaración CREATE TABLE para crear la tabla trips a partir de los datos de la tabla bikeshare_trips pública:

  1. En la consola de Google Cloud, ve a la página de BigQuery.

    Ir a BigQuery

  2. En el editor de consultas, escribe la siguiente sentencia:

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

  3. Haz clic en Ejecutar.

Si deseas obtener información sobre cómo ejecutar consultas, visita Ejecuta una consulta interactiva.

Para obtener más información, consulta Crea una tabla nueva a partir de una tabla existente.

bq

  1. En la consola de Google Cloud, activa Cloud Shell.

    Activar Cloud Shell

    En la parte inferior de la consola de Google Cloud, se inicia una sesión de Cloud Shell en la que se muestra una ventana de línea de comandos. Cloud Shell es un entorno de shell con Google Cloud CLI ya instalada y con valores ya establecidos para el proyecto actual. La sesión puede tardar unos segundos en inicializarse.

  2. Escribe el comando bq query y especifica la marca --destination_table para crear una tabla permanente basada en los resultados de las consultas. Especifica la marca use_legacy_sql=false para usar la sintaxis GoogleSQL. Para escribir los resultados de las consultas en una tabla que no se encuentra en tu proyecto predeterminado, agrega el ID del proyecto al nombre del conjunto de datos con el formato siguiente: project_id:dataset.

    Opcional: Proporciona la marca --location y configura el valor en tu ubicación.

    Para controlar la disposición de escritura de una tabla de destino existente, especifica una de las marcas opcionales siguientes:

    • --append_table: Si existe la tabla de destino, los resultados de las consultas se agregan a esta tabla.
    • --replace: Si existe la tabla de destino, se reemplaza por los resultados de las consultas.

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

      Reemplaza lo siguiente:

    • location es el nombre de la ubicación que se usa para procesar la consulta. La marca --location es opcional. Por ejemplo, si usas BigQuery en la región de Tokio, puedes configurar el valor de la marca como asia-northeast1. Puedes configurar un valor predeterminado para la ubicación mediante el archivo .bigqueryrc.

    • project_id es el ID del proyecto.

    • dataset es el nombre del conjunto de datos que contiene la tabla en la que escribes los resultados de la consulta.

    • table es el nombre de la tabla en la que escribes los resultados de las consultas.

    • query es una consulta en la sintaxis de GoogleSQL.

      Si no se especifica una marca de disposición de escritura, el comportamiento predeterminado es escribir los resultados en la tabla solo si está vacía. Si la tabla existe y no está vacía, se muestra el error siguiente: Error de BigQuery en la operación de consulta: error durante el procesamiento del trabajo project_id:bqjob_123abc456789_00000e1234f_1': Already Exists: Table project_id:dataset.table.

      Por ejemplo:

      Escribe el comando siguiente para escribir los resultados de las consultas en una tabla de destino llamada mytable en mydataset. El conjunto de datos se encuentra en tu proyecto predeterminado. Debido a que no se especifica ninguna marca de disposición de escritura en el comando, la tabla debe ser nueva o estar vacía. De lo contrario, se muestra un error Already exists. Con la consulta, se recuperan datos del conjunto de datos públicos Datos de nombres de EE.UU.

      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'
      

      Escribe el comando siguiente para usar los resultados de las consultas para reemplazar una tabla de destino llamada mytable en mydataset. El conjunto de datos se encuentra en tu proyecto predeterminado. En el comando, se usa la marca --replace para reemplazar la tabla de destino.

      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'
      

      Escribe el comando siguiente para agregar los resultados de las consultas a una tabla de destino llamada mytable en mydataset. El conjunto de datos está en my-other-project, no en tu proyecto predeterminado. En el comando, se usa la marca --append_table para agregar los resultados de las consultas a la tabla de destino.

      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'
      

      El resultado de cada uno de estos ejemplos se verá de la manera siguiente. Para facilitar la lectura, algunos resultados se truncaron.

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

API

Si deseas guardar los resultados de las consultas en una tabla permanente, haz una llamada al método jobs.insert, configura un trabajo query y, por último, incluye un valor para la propiedad destinationTable. Para controlar la disposición de escritura de una tabla de destino existente, configura la propiedad writeDisposition.

Si deseas controlar la ubicación de procesamiento para el trabajo de consulta, especifica la propiedad location en la sección jobReference del recurso de trabajo.

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. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Go.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

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.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

Para guardar los resultados de las consultas en una tabla permanente, configura la tabla de destino con el valor TableId que desees en una 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

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 BigQuery para Node.js.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

Antes de probar este ejemplo, 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. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Python.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

Para guardar los resultados de las consultas en una tabla permanente, crea una QueryJobConfig y configura el destino con el valor TableReference que desees. Pasa la configuración del trabajo al método de consulta.
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))

Escribe resultados de consultas grandes

Por lo general, las consultas tienen un tamaño de respuesta máximo. Si planeas ejecutar una consulta que podría mostrar resultados más grandes, puedes hacer una de las siguientes acciones:

  • En GoogleSQL, especifica una tabla de destino para los resultados de las consultas.
  • En SQL heredado, especifica una tabla de destino y configura la opción allowLargeResults.

Cuando especificas una tabla de destino para los resultados de las consultas grandes, se te cobra por almacenar los datos.

Limitaciones

En SQL heredado, la escritura de resultados grandes está sujeta a las siguientes limitaciones:

  • Debes especificar una tabla de destino.
  • No puedes especificar una cláusula de nivel superior ORDER BY, TOP o LIMIT. Si lo haces, se anula el beneficio de usar allowLargeResults porque el resultado de la consulta ya no se puede procesar en paralelo.
  • Con las funciones analíticas, se pueden mostrar los resultados de las consultas grandes solo si se usan junto con una cláusula PARTITION BY.

Escribe resultados grandes con SQL heredado

Para escribir conjuntos de resultados grandes mediante SQL heredado, sigue estos pasos:

Consola

  1. En la consola de Google Cloud, abre la página de BigQuery.

    Ir a BigQuery

  2. Haz clic en Redactar consulta nueva.

  3. Escribe una consulta de SQL válida en el área de texto del Editor de consultas. Usa el prefijo #legacySQL o asegúrate de que la opción Usa SQL heredado esté marcada en la configuración de la consulta.

  4. Haz clic en More (Más) y elige Query settings (Configuración de consulta).

    Configuración de consulta

  5. En Destination (Destino), marca Set a destination table for query results (Establecer una tabla de destino para los resultados de la consulta).

    Establecer destino

  6. En Conjunto de datos, elige el conjunto de datos que almacenará la tabla.

  7. En el campo ID de tabla, escribe un nombre de tabla.

  8. Si escribes un conjunto de resultados grandes en una tabla existente, puedes usar las opciones Destination table write preference (Preferencia de escritura para la tabla de destino) para controlar la disposición de escritura de la tabla de destino con los resultados siguientes:

    • Escribir si está vacía: Se escriben los resultados de las consultas en la tabla solo si está vacía.
    • Agregar a la tabla: Agrega los resultados de las consultas a una tabla existente.
    • Reemplazar la tabla: Se reemplaza una tabla existente con el mismo nombre mediante los resultados de las consultas.
  9. En Results size (Tamaño de los resultados), marca Allow Large Results (no size limit) (Permitir resultados grandes [sin límite de tamaño]).

  10. Opcional: En Ubicación de los datos, elige la ubicación de tus datos.

  11. Haz clic en Guardar para actualizar la configuración de la consulta.

  12. Haz clic en Ejecutar. Esta acción crea un trabajo de consulta que escribe el conjunto de resultados grandes en la tabla que especificaste.

bq

Usa la marca --allow_large_results con la marca --destination_table para crear una tabla de destino que contenga el conjunto de resultados grandes. Debido a que la opción --allow_large_results solo se aplica al SQL heredado, también debes especificar la marca --use_legacy_sql=true. Para escribir los resultados de las consultas en una tabla que no se encuentra en tu proyecto predeterminado, agrega el ID del proyecto al nombre del conjunto de datos con el formato siguiente: PROJECT_ID:DATASET. Proporciona la marca --location y configura el valor en tu ubicación.

Para controlar la disposición de escritura de una tabla de destino existente, especifica una de las marcas opcionales siguientes:

  • --append_table: Si existe la tabla de destino, los resultados de las consultas se agregan a esta tabla.
  • --replace: Si existe la tabla de destino, se reemplaza por los resultados de las consultas.
bq --location=location query \
--destination_table PROJECT_ID:DATASET.TABLE \
--use_legacy_sql=true \
--allow_large_results "QUERY"

Reemplaza lo siguiente:

  • LOCATION es el nombre de la ubicación que se usa para procesar la consulta. La marca --location es opcional. Por ejemplo, si usas BigQuery en la región de Tokio, puedes configurar el valor de la marca como asia-northeast1. Puedes establecer un valor predeterminado para la ubicación con el archivo .bigqueryrc.
  • PROJECT_ID es el ID del proyecto.
  • DATASET es el nombre del conjunto de datos que contiene la tabla en la que escribes los resultados de la consulta.
  • TABLE es el nombre de la tabla en la que escribes los resultados de las consultas.
  • QUERY es una consulta en la sintaxis de SQL heredado.

Ejemplos:

Escribe el comando siguiente para escribir los resultados de las consultas grandes en una tabla de destino llamada mytable en mydataset. El conjunto de datos se encuentra en tu proyecto predeterminado. Debido a que no se especifica ninguna marca de disposición de escritura en el comando, la tabla debe ser nueva o estar vacía. De lo contrario, se muestra un error Already exists. Con la consulta, se recuperan datos del conjunto de datos públicos Datos de nombres de EE.UU. Esta consulta se usa solo como ejemplo. El conjunto de resultados que se muestra no excede el tamaño de respuesta máximo.

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"

Escribe el comando siguiente para usar los resultados de las consultas grandes para reemplazar una tabla de destino llamada mytable en mydataset. El conjunto de datos está en myotherproject, no en tu proyecto predeterminado. En el comando, se usa la marca --replace para reemplazar la tabla de destino.

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"

Escribe el comando siguiente para agregar los resultados de las consultas grandes a una tabla de destino llamada mytable en mydataset. El conjunto de datos está en myotherproject, no en tu proyecto predeterminado. En el comando, se usa la marca --append_table para agregar los resultados de las consultas a la tabla de destino.

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

Para escribir resultados grandes en una tabla de destino, haz una llamada al método jobs.insert y, luego, configura un trabajo query y la propiedad allowLargeResults como true. Especifica la tabla de destino con la propiedad destinationTable. Para controlar la disposición de escritura de una tabla de destino existente, configura la propiedad writeDisposition.

Especifica tu ubicación en la propiedad location en la sección jobReference del recurso de trabajo.

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. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Go.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

Para habilitar resultados grandes, configura Permitir resultados grandes como true y la Tabla de destino con el valor TableId que desees en una 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;
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

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 BigQuery para Node.js.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

Antes de probar este ejemplo, 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. Para obtener más información, consulta la documentación de referencia de la API de BigQuery para Python.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

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

Descarga y guarda los resultados de las consultas desde la consola de Google Cloud

Después de ejecutar una consulta de SQL con la consola de Google Cloud, puedes guardar los resultados en otra ubicación. Puedes usar la consola de Google Cloud para descargar los resultados de las consultas en un archivo local, Hojas de cálculo de Google o Google Drive. Si ordenas por primera vez los resultados de la consulta por columna, el orden se conserva en los datos descargados. La herramienta de línea de comandos de bq y la API no admiten el almacenamiento de resultados en un archivo local, en Hojas de cálculo de Google ni en Google Drive.

Limitaciones

Si quieres descargar y guardar los resultados de las consultas, debes tener en cuenta las siguientes limitaciones:

  • Solo puedes descargar los resultados de las consultas de forma local en formato CSV o JSON delimitado por saltos de línea.
  • No puedes guardar resultados de consultas que contengan datos anidados y repetidos en Hojas de cálculo de Google.
  • Para guardar los resultados de las consultas en Google Drive con la consola de Google Cloud, el conjunto de resultados debe ocupar 1 GB o menos. Si los resultados tienen un tamaño mayor a ese, puedes guardarlos en una tabla.
  • Cuando guardas los resultados de las consultas en un archivo CSV local, el tamaño máximo de descarga es de 10 MB. El tamaño máximo de descarga se basa en el tamaño de cada fila que se muestra en la respuesta del método tabledata.list y puede variar según el esquema de los resultados de la consulta. Como resultado, el tamaño del archivo CSV descargado puede variar y podría ser menor que el límite de tamaño de descarga máximo.
  • Solo puedes guardar los resultados de las consultas en Google Drive en formato CSV o JSON delimitado por saltos de línea.

¿Qué sigue?