python - create new table bigquery

Crear una tabla a partir de los resultados de la consulta en Google BigQuery.

Question

Estamos utilizando Google BigQuery a través de la API de Python. ¿Cómo puedo crear una tabla (una nueva o sobrescribir la anterior) a partir de los resultados de la consulta? Revisé la documentación de la consulta , pero no la encontré útil.

Queremos simular:

"SELEC ... INTO ..." de ANSI SQL.

Answer 1

Crear una tabla de resultados de la consulta en Google BigQuery. Suponiendo que está utilizando Jupyter Notebook con Python 3, se explicarán los siguientes pasos:

1. Cómo crear un nuevo conjunto de datos en BQ (para guardar los resultados)
2. Cómo ejecutar una consulta y guardar los resultados en un nuevo conjunto de datos en formato de tabla en BQ

Crear un nuevo conjunto de datos en BQ: my_dataset

bigquery_client  = bigquery.Client() #Create a BigQuery service object
dataset_id = ''my_dataset'' 
dataset_ref = bigquery_client.dataset(dataset_id) # Create a DatasetReference using a chosen dataset ID.
dataset = bigquery.Dataset(dataset_ref)  # Construct a full Dataset object to send to the API.
dataset.location = ''US'' # Specify the geographic location where the new dataset will reside. Remember this should be same location as that of source data set from where we are getting data to run a query

# Send the dataset to the API for creation. Raises google.api_core.exceptions.AlreadyExists if the Dataset already exists within the project.
dataset = bigquery_client.create_dataset(dataset)  # API request
print(''Dataset {} created.''.format(dataset.dataset_id))

Ejecuta una consulta en BQ usando Python:

Hay 2 tipos aquí:

1. Permitiendo grandes resultados
2. Consulta sin mencionar grandes resultados etc.

Estoy tomando el conjunto de datos públicos aquí: bigquery-public-data: hacker_news & Table id: comentarios para ejecutar una consulta.

Permitiendo grandes resultados

DestinationTableName=''table_id1''  #Enter new table name you want to give
!bq query --allow_large_results --destination_table=project_id:my_dataset.$DestinationTableName ''SELECT * FROM [bigquery-public-data:hacker_news.comments]''

Esta consulta permitirá resultados de consulta grandes si es necesario.

Sin mencionar --allow_large_results:

DestinationTableName=''table_id2''  #Enter new table name you want to give
!bq query destination_table=project_id:my_dataset.$DestinationTableName ''SELECT * FROM [bigquery-public-data:hacker_news.comments] LIMIT 100''

Esto funcionará para la consulta donde el resultado no va a cruzar el límite mencionado en la documentación de Google BQ.

Salida:

1. Un nuevo conjunto de datos en BQ con el nombre my_dataset
2. Resultados de las consultas guardadas como tablas en my_dataset

Nota:

1. Estas consultas son Comandos que puede ejecutar en el terminal (sin! Al principio). ¡Pero como estamos usando Python para ejecutar estos comandos / consultas estamos usando! Esto nos permitirá usar / ejecutar comandos en el programa Python también.
2. También por favor upvote la respuesta :). Gracias.

Answer 2

La respuesta aceptada es correcta, pero no proporciona el código de Python para realizar la tarea. Aquí hay un ejemplo, refactorizado de una pequeña clase de cliente personalizado que acabo de escribir. No maneja las excepciones, y la consulta codificada debe personalizarse para hacer algo más interesante que SELECT * ...

import time

from google.cloud import bigquery
from google.cloud.bigquery.table import Table
from google.cloud.bigquery.dataset import Dataset


class Client(object):

    def __init__(self, origin_project, origin_dataset, origin_table,
                 destination_dataset, destination_table):
        """
        A Client that performs a hardcoded SELECT and INSERTS the results in a
        user-specified location.

        All init args are strings. Note that the destination project is the
        default project from your Google Cloud configuration.
        """
        self.project = origin_project
        self.dataset = origin_dataset
        self.table = origin_table
        self.dest_dataset = destination_dataset
        self.dest_table_name = destination_table
        self.client = bigquery.Client()

    def run(self):
        query = ("SELECT * FROM `{project}.{dataset}.{table}`;".format(
            project=self.project, dataset=self.dataset, table=self.table))

        job_config = bigquery.QueryJobConfig()

        # Set configuration.query.destinationTable
        destination_dataset = self.client.dataset(self.dest_dataset)
        destination_table = destination_dataset.table(self.dest_table_name)
        job_config.destination = destination_table

        # Set configuration.query.createDisposition
        job_config.create_disposition = ''CREATE_IF_NEEDED''

        # Set configuration.query.writeDisposition
        job_config.write_disposition = ''WRITE_APPEND''

        # Start the query
        job = self.client.query(query, job_config=job_config)

        # Wait for the query to finish
        job.result()

Answer 3

Puede hacerlo especificando una tabla de destino en la consulta. Necesitaría usar la API Jobs.insert lugar de la llamada Jobs.query , y debería writeDisposition=WRITE_APPEND y completar la tabla de destino.

Aquí es cómo se vería la configuración, si estuviera usando la API en bruto. Si está utilizando Python, el cliente de Python debería dar acceso a estos mismos campos:

"configuration": {
  "query": {
    "query": "select count(*) from foo.bar",
    "destinationTable": {
      "projectId": "my_project",
      "datasetId": "my_dataset",
      "tableId": "my_table"
    },
    "createDisposition": "CREATE_IF_NEEDED",
    "writeDisposition": "WRITE_APPEND",
  }
}