Ejecuta trabajos de consulta interactivos y por lotes

En este documento, se describe cómo ejecutar trabajos de consulta interactivos (a pedido) y por lotes.

Permisos necesarios

Los trabajos son acciones que BigQuery ejecuta por ti para cargar datos, exportar datos, consultar datos o copiar datos.

Cuando usas Cloud Console, la IU web clásica de BigQuery o la CLI para cargar, exportar, consultar o copiar datos, un recurso de trabajo se crea, se programa y se ejecuta de forma automática. También puedes crear un trabajo de carga, exportación, consulta o copia de manera programática. Cuando creas un trabajo de manera programática, BigQuery programa y ejecuta el trabajo por ti.

Dado que los trabajos pueden tardar mucho tiempo en completarse, estos se ejecutan de forma asíncrona y se pueden consultar para determinar su estado. Las acciones más cortas, como obtener metadatos o realizar una lista de recursos, no se administran mediante un recurso de trabajo.

Como mínimo, para ejecutar un trabajo de consulta, debes tener los permisos bigquery.jobs.create. Para que el trabajo de consulta se complete con éxito, también debes tener acceso a los conjuntos de datos que contienen las tablas o vistas a las que hace referencia la consulta. Si deseas obtener más información sobre los controles de acceso a conjuntos de datos, consulta la página Controla el acceso a los conjuntos de datos.

Las siguientes funciones predefinidas de Cloud IAM incluyen los permisos bigquery.jobs.create:

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

Además, si un usuario tiene permisos bigquery.datasets.create, cuando crea un conjunto de datos, se le otorga el acceso bigquery.dataOwner. El acceso bigquery.dataOwner permite al usuario realizar consultas sobre las tablas y vistas en el conjunto de datos.

Para obtener más información sobre las funciones de Cloud IAM en BigQuery, consulta los permisos y funciones predefinidas.

Ejecuta consultas interactivas

De manera predeterminada, BigQuery ejecuta trabajos de consulta interactivos (a pedido), lo que significa que la consulta se ejecuta en cuanto sea posible. Las consultas interactivas se toman en cuenta para tu límite de frecuencia simultánea y límite diario.

Los resultados de las consultas se almacenan siempre en una tabla temporal o permanente. Puedes elegir si deseas adjuntar o sobrescribir datos en una tabla existente o si deseas crear una tabla nueva si no existe ninguna con el mismo nombre.

Para ejecutar una consulta interactiva que escribe en una tabla temporal, haz lo siguiente:

Console

  1. Abre la IU web de BigQuery en Cloud Console.
    Ir a Cloud Console

  2. Haz clic en Redactar consulta nueva.

    Redactar consulta nueva

  3. Ingresa una consulta válida de SQL en BigQuery en el área de texto Editor de consulta.

  4. Para cambiar la ubicación de procesamiento de datos (opcional), haz clic en Más y, luego, en Configuración de consulta. Debajo de Ubicación de procesamiento, haz clic en Selección automática y elige la ubicación de tus datos. Por último, haz clic en Guardar para actualizar la configuración de la consulta.

  5. Haz clic en Ejecutar.

Esto crea un trabajo de consulta que escribe el resultado en una tabla temporal.

IU clásica

  1. Ve a la IU web de BigQuery.
    Ir a la IU web de BigQuery

  2. Haz clic en Redactar consulta.

  3. Ingresa una consulta de SQL válida en el área de texto Consulta nueva.

  4. Haz clic en Mostrar opciones.

  5. Opcional: En Ubicación de procesamiento, haz clic en Sin especificar y elige la ubicación de tus datos.

  6. Haz clic en Ejecutar consulta.

Esto crea un trabajo de consulta que escribe el resultado en una tabla temporal.

CLI

Ingresa el comando bq query y agrega el texto de tu consulta.

Proporciona la marca --location y configura el valor como tu ubicación (opcional).

Puedes especificar las siguientes marcas opcionales. Esta lista incluye algunas de las marcas más comunes. Para obtener una lista completa de las marcas del comando query, consulta bq query en la referencia de la herramienta de línea de comandos de bq.

Especifica lo siguiente:

  • La marca --destination_table para crear una tabla permanente basada en los resultados de la consulta. 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 siguiente formato: project_id:dataset. Si no se especifica --destination_table, se genera un trabajo de consulta que escribe el resultado en una tabla temporal (en caché).
  • La marca --append_table para agregar los resultados de la consulta a una tabla de destino.
  • La marca --destination_kms_key para usar una clave de Cloud Key Management Service a fin de encriptar los datos de la tabla de destino.
  • La marca --use_legacy_sql=false para usar la sintaxis de SQL estándar. Puedes establecer una sintaxis predeterminada para la herramienta de línea de comandos con el archivo .bigqueryrc.
  • La marca --label para aplicar una etiqueta al trabajo de consulta en la forma clave:valor. Repite esta marca para especificar varios archivos.
  • La marca --max_rows o -n para especificar la cantidad de filas que se mostrarán en los resultados de la consulta.
  • La marca --maximum_bytes_billed para limitar los bytes facturados por la consulta. Si la consulta supera el límite, falla (sin incurrir en cargos). Si no se especifica, los bytes facturados se configuran en el valor predeterminado del proyecto.
  • La marca --udf_resource para cargar y evaluar un archivo de código que se usará como recurso de función definido por el usuario. Puedes especificar un URI de Cloud Storage o la ruta de acceso a un archivo de código local. Repite esta marca para especificar varios archivos.

Ingresa el siguiente comando para ejecutar una consulta interactiva mediante la sintaxis de SQL estándar:

bq --location=location query \
--use_legacy_sql=false \
'query'

En el ejemplo anterior, se ilustra lo siguiente:

  • location es el nombre de la ubicación en la que se procesa la consulta. La marca --location es opcional. Por ejemplo, si usas BigQuery en la región de Tokio, puedes establecer el valor de la marca como asia-northeast1. Puedes configurar un valor predeterminado para la ubicación con el archivo .bigqueryrc.
  • query es una consulta en la sintaxis de SQL estándar.

Ejemplos:

Ingresa el siguiente comando para escribir los resultados de consultas interactivas en una tabla de destino llamada mytable en mydataset. El conjunto de datos se encuentra en tu proyecto predeterminado. La consulta recupera datos desde el 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'

Ingresa el siguiente comando para escribir los resultados de consultas interactivas en una tabla de destino llamada mytable en mydataset. El conjunto de datos está en myotherproject, no en tu proyecto predeterminado. La consulta obtiene datos de una tabla no particionada: el conjunto de datos públicos Datos de nombres de EE.UU..

bq query \
--destination_table myotherproject: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'

API

Para ejecutar una consulta con la API, inserta un trabajo nuevo y propaga la propiedad jobs#configuration.query. Especifica tu ubicación en la propiedad location de la sección jobReference del recurso de trabajo.

Busca resultado mediante una llamada a getQueryResults. Busca hasta que jobComplete sea igual a true. Verifica si hay errores y advertencias en la lista errors.

C#

Antes de probar este ejemplo, sigue las instrucciones de configuración para Go que se encuentran en la Guía de inicio rápido: usa bibliotecas cliente. Para obtener más información, consulta la Documentación de referencia de la API de C# de BigQuery.


using Google.Cloud.BigQuery.V2;
using System;

public class BigQueryQuery
{
    public void Query(
        string projectId = "your-project-id"
    )
    {
        BigQueryClient client = BigQueryClient.Create(projectId);
        string query = @"
            SELECT name FROM `bigquery-public-data.usa_names.usa_1910_2013`
            WHERE state = 'TX'
            LIMIT 100";
        BigQueryJob job = client.CreateQueryJob(
            sql: query,
            parameters: null,
            options: new QueryOptions { UseQueryCache = false });
        // Wait for the job to complete.
        job.PollUntilCompleted();
        // Display the results
        foreach (BigQueryRow row in client.GetQueryResults(job.Reference))
        {
            Console.WriteLine($"{row["name"]}");
        }
    }
}

Go

Antes de probar este ejemplo, sigue las instrucciones de configuración de Go incluidas en la Guía de inicio rápido: usa bibliotecas cliente. A fin de obtener más información, consulta la documentación de referencia de la API de BigQuery para Go.

import (
	"context"
	"fmt"
	"io"

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

// queryBasic demonstrates issuing a query and reading results.
func queryBasic(w io.Writer, projectID string) error {
	// projectID := "my-project-id"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}

	q := client.Query(
		"SELECT name FROM `bigquery-public-data.usa_names.usa_1910_2013` " +
			"WHERE state = \"TX\" " +
			"LIMIT 100")
	// Location must match that of the dataset(s) referenced in the query.
	q.Location = "US"
	// Run the query and print results when the query job is completed.
	job, err := q.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}
	if err := status.Err(); err != nil {
		return err
	}
	it, err := job.Read(ctx)
	for {
		var row []bigquery.Value
		err := it.Next(&row)
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintln(w, row)
	}
	return nil
}

Java

Antes de probar este ejemplo, sigue las instrucciones de configuración de Java incluidas en Guía de inicio rápido: usa bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de BigQuery para Java.

// BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();
String query = "SELECT corpus FROM `bigquery-public-data.samples.shakespeare` GROUP BY corpus;";
QueryJobConfiguration queryConfig = QueryJobConfiguration.newBuilder(query).build();

// Print the results.
for (FieldValueList row : bigquery.query(queryConfig).iterateAll()) {
  for (FieldValue val : row) {
    System.out.printf("%s,", val.toString());
  }
  System.out.printf("\n");
}

Node.js

Antes de probar esta muestra, sigue las instrucciones de configuración para Node.js que se encuentran en la Guía de inicio rápido de BigQuery con bibliotecas cliente. A fin de obtener más información, consulta la documentación de referencia de la API de BigQuery para Node.js.

// Import the Google Cloud client library using default credentials
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();
async function query() {
  // Queries the U.S. given names dataset for the state of Texas.

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

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

  // Run the query as a job
  const [job] = await bigquery.createQueryJob(options);
  console.log(`Job ${job.id} started.`);

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

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

PHP

Antes de probar este ejemplo, sigue las instrucciones de configuración de PHP incluidas en Guía de inicio rápido: usa bibliotecas cliente. A fin de obtener más información, consulta la documentación de referencia de la API de BigQuery para PHP.

use Google\Cloud\BigQuery\BigQueryClient;
use Google\Cloud\Core\ExponentialBackoff;

/** Uncomment and populate these variables in your code */
// $projectId = 'The Google project ID';
// $query = 'SELECT id, view_count FROM `bigquery-public-data.stackoverflow.posts_questions`';

$bigQuery = new BigQueryClient([
    'projectId' => $projectId,
]);
$jobConfig = $bigQuery->query($query);
$job = $bigQuery->startQuery($jobConfig);

$backoff = new ExponentialBackoff(10);
$backoff->execute(function () use ($job) {
    print('Waiting for job to complete' . PHP_EOL);
    $job->reload();
    if (!$job->isComplete()) {
        throw new Exception('Job has not yet completed', 500);
    }
});
$queryResults = $job->queryResults();

$i = 0;
foreach ($queryResults as $row) {
    printf('--- Row %s ---' . PHP_EOL, ++$i);
    foreach ($row as $column => $value) {
        printf('%s: %s' . PHP_EOL, $column, json_encode($value));
    }
}
printf('Found %s row(s)' . PHP_EOL, $i);

Python

Antes de probar esta muestra, sigue las instrucciones de configuración de Python que se incluyen en la Guía de inicio rápido de BigQuery: usa bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de BigQuery para Python.

# TODO(developer): Import the client library.
# from google.cloud import bigquery

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

query = """
    SELECT name, SUM(number) as total_people
    FROM `bigquery-public-data.usa_names.usa_1910_2013`
    WHERE state = 'TX'
    GROUP BY name, state
    ORDER BY total_people DESC
    LIMIT 20
"""
query_job = client.query(query)  # Make an API request.

print("The query data:")
for row in query_job:
    # Row values can be accessed by field name or index.
    print("name={}, count={}".format(row[0], row["total_people"]))

Ruby

Antes de probar este ejemplo, sigue las instrucciones de configuración de Ruby incluidas en Guía de inicio rápido: usa bibliotecas cliente. A fin de obtener más información, consulta la documentación de referencia de la API de BigQuery para Ruby.

require "google/cloud/bigquery"

def query
  bigquery = Google::Cloud::Bigquery.new
  sql = "SELECT name FROM `bigquery-public-data.usa_names.usa_1910_2013` " +
        "WHERE state = 'TX' " +
        "LIMIT 100"

  # Location must match that of the dataset(s) referenced in the query.
  results = bigquery.query sql do |config|
    config.location = "US"
  end

  results.each do |row|
    puts row.inspect
  end
end

Cómo ejecutar consultas por lotes

BigQuery también ofrece consultas por lotes. BigQuery pone en cola cada consulta por lotes en tu nombre y comienza la consulta en cuanto los recursos inactivos estén disponibles en el grupo de recursos compartidos de BigQuery. Esto suele ocurrir en unos minutos. Si BigQuery no inicia la consulta en 24 horas, BigQuery cambia la prioridad del trabajo a interactivo.

Las consultas por lotes no cuentan para tu límite de frecuencia simultánea, lo que puede facilitar el inicio de muchas consultas a la vez. Las consultas por lotes utilizan los mismos recursos que las consultas interactivas (bajo demanda). Si usas consultas por lotes y consultas interactivas con tarifa plana, comparte tus espacios asignados.

Para ejecutar una consulta por lotes:

Console

  1. Abre la IU web de BigQuery en Cloud Console.
    Ir a Cloud Console

  2. Haz clic en el botón Redactar nueva consulta.

    Redactar consulta nueva

  3. Ingresa una consulta de SQL válida en el área de texto del Editor de consultas.

  4. Haz clic en el botón Más y, luego, en Configuración de consulta.

    Configuración de consulta

  5. Selecciona la opción Por lotes en la sección Prioridad del trabajo.

    Ejecución por lotes

  6. En Ubicación de procesamiento, haz clic en Sin especificar y elige la ubicación de tus datos (opcional).

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

  8. Haz clic en Ejecutar.

IU clásica

  1. Ve a la IU web de BigQuery.
    Ir a la IU web de BigQuery

  2. Haz clic en el botón Redactar consulta.

  3. Ingresa una consulta válida de SQL en BigQuery en el área de texto Consulta nueva.

  4. Haz clic en el botón Mostrar opciones.

  5. Selecciona la opción Por lotes en la sección Prioridad de la consulta.

  6. En Ubicación de procesamiento, haz clic en Sin especificar y elige la ubicación de tus datos (opcional).

  7. Haz clic en el botón Ejecutar consulta.

CLI

Ingresa el comando bq query y agrega el texto de tu consulta. Especifica la marca -- batch para ejecutar una consulta por lotes.

Proporciona la marca --location y configura el valor como tu ubicación (opcional).

Puedes especificar las siguientes marcas opcionales. Esta lista incluye algunas de las marcas más comunes. Para obtener una lista completa de las marcas del comando query, consulta bq query en la referencia de la herramienta de línea de comandos de bq.

Especifica lo siguiente:

  • La marca --destination_table para crear una tabla permanente basada en los resultados de la consulta. 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 siguiente formato: project_id:dataset. Si no se especifica --destination_table, se genera un trabajo de consulta que escribe el resultado en una tabla temporal (en caché).
  • La marca --append_table para agregar los resultados de la consulta a una tabla de destino.
  • La marca --destination_kms_key para usar una clave de Cloud Key Management Service a fin de encriptar los datos de la tabla de destino.
  • La marca --use_legacy_sql=false para usar la sintaxis de SQL estándar. Puedes establecer una sintaxis predeterminada para la herramienta de línea de comandos con el archivo .bigqueryrc.
  • La marca --label para aplicar una etiqueta al trabajo de consulta en la forma clave:valor. Repite esta marca para especificar varios archivos.
  • La marca --max_rows o -n para especificar la cantidad de filas que se mostrarán en los resultados de la consulta.
  • La marca --maximum_bytes_billed para limitar los bytes facturados por la consulta. Si la consulta supera el límite, falla (sin incurrir en cargos). Si no se especifica, los bytes facturados se configuran en el valor predeterminado del proyecto.
  • La marca --udf_resource para cargar y evaluar un archivo de código que se usará como recurso de función definido por el usuario. Puedes especificar un URI de Cloud Storage o la ruta de acceso a un archivo de código local. Repite esta marca para especificar varios archivos.

Ingresa el siguiente comando para ejecutar una consulta por lotes con la sintaxis de SQL estándar:

bq --location=location query \
--batch \
--use_legacy_sql=false \
'query'

En el ejemplo anterior, se ilustra lo siguiente:

  • location es el nombre de la ubicación en la que se procesa la consulta. La marca --location es opcional. Por ejemplo, si usas BigQuery en la región de Tokio, puedes establecer el valor de la marca como asia-northeast1. Puedes configurar un valor predeterminado para la ubicación con el archivo .bigqueryrc.
  • query es una consulta en la sintaxis de SQL estándar.

Ejemplos:

Ingresa el siguiente comando para escribir los resultados de consultas por lotes en una tabla de destino llamada mytable en mydataset. El conjunto de datos se encuentra en tu proyecto predeterminado. La consulta recupera datos desde el conjunto de datos públicos Datos de nombres de EE.UU..

bq query \
--batch \
--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'

Ingresa el siguiente comando para escribir los resultados de consultas por lotes en una tabla de destino llamada mytable en mydataset. El conjunto de datos está en myotherproject, no en tu proyecto predeterminado. La consulta obtiene datos de una tabla no particionada: el conjunto de datos públicos Datos de nombres de EE.UU..

bq query \
--batch \
--destination_table myotherproject: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'

API

Para ejecutar una consulta con la API, inserta un nuevo trabajo y propaga la propiedad de configuración del trabajo query. Especifica tu ubicación en la propiedad location de la sección jobReference del recurso de trabajo (opcional).

Cuando propagues las propiedades del trabajo de consulta, incluye la propiedad configuration.query.priority con el valor establecido en BATCH.

Go

Antes de probar este ejemplo, sigue las instrucciones de configuración de Go incluidas en la Guía de inicio rápido: usa bibliotecas cliente. A fin de obtener más información, consulta la documentación de referencia de la API de BigQuery para Go.

import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/bigquery"
)

// queryBatch demonstrates issuing a query job using batch priority.
func queryBatch(w io.Writer, projectID, dstDatasetID, dstTableID string) error {
	// projectID := "my-project-id"
	// dstDatasetID := "mydataset"
	// dstTableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	} // Build an aggregate table.
	q := client.Query(`
		SELECT
  			corpus,
  			SUM(word_count) as total_words,
  			COUNT(1) as unique_words
		FROM ` + "`bigquery-public-data.samples.shakespeare`" + `
		GROUP BY corpus;`)
	q.Priority = bigquery.BatchPriority
	q.QueryConfig.Dst = client.Dataset(dstDatasetID).Table(dstTableID)

	// Start the job.
	job, err := q.Run(ctx)
	if err != nil {
		return err
	}
	// Job is started and will progress without interaction.
	// To simulate other work being done, sleep a few seconds.
	time.Sleep(5 * time.Second)
	status, err := job.Status(ctx)
	if err != nil {
		return err
	}

	state := "Unknown"
	switch status.State {
	case bigquery.Pending:
		state = "Pending"
	case bigquery.Running:
		state = "Running"
	case bigquery.Done:
		state = "Done"
	}
	// You can continue to monitor job progress until it reaches
	// the Done state by polling periodically.  In this example,
	// we print the latest status.
	fmt.Fprintf(w, "Job %s in Location %s currently in state: %s\n", job.ID(), job.Location(), state)

	return nil

}

Java

Para ejecutar una consulta por lotes, establece la prioridad de consulta en QueryJobConfiguration.Priority.BATCH cuando crees una QueryJobConfiguration.

// BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();
String query = "SELECT corpus FROM `bigquery-public-data.samples.shakespeare` GROUP BY corpus;";
QueryJobConfiguration queryConfig =
    QueryJobConfiguration.newBuilder(query)
        // Run at batch priority, which won't count toward concurrent rate
        // limit.
        .setPriority(QueryJobConfiguration.Priority.BATCH)
        .build();

// Location must match that of the dataset(s) referenced in the query.
JobId jobId = JobId.newBuilder().setRandomJob().setLocation("US").build();
String jobIdString = jobId.getJob();

// API request - starts the query.
bigquery.create(JobInfo.newBuilder(queryConfig).setJobId(jobId).build());

// Check on the progress by getting the job's updated state. Once the state
// is `DONE`, the results are ready.
Job queryJob = bigquery.getJob(
    JobId.newBuilder().setJob(jobIdString).setLocation("US").build());
System.out.printf(
    "Job %s in location %s currently in state: %s%n",
    queryJob.getJobId().getJob(),
    queryJob.getJobId().getLocation(),
    queryJob.getStatus().getState().toString());

Python

Antes de probar esta muestra, sigue las instrucciones de configuración de Python que se incluyen en la Guía de inicio rápido de BigQuery: usa bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de BigQuery para Python.

from google.cloud import bigquery

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

job_config = bigquery.QueryJobConfig(
    # Run at batch priority, which won't count toward concurrent rate limit.
    priority=bigquery.QueryPriority.BATCH
)

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

# Start the query, passing in the extra configuration.
query_job = client.query(sql, job_config=job_config)  # Make an API request.

# Check on the progress by getting the job's updated state. Once the state
# is `DONE`, the results are ready.
query_job = client.get_job(
    query_job.job_id, location=query_job.location
)  # Make an API request.

print("Job {} is currently in state {}".format(query_job.job_id, query_job.state))