Como migrar da biblioteca de cliente do Python v0.27

A biblioteca de cliente do BigQuery para Python v0.28 inclui algumas alterações significativas em comparação com o design das bibliotecas de clientes anteriores (até a versão v0.27). Essas alterações podem ser resumidas da maneira a seguir:

  • As operações de consulta e visualização assumem como padrão o dialeto SQL padrão.
  • As funções do cliente relacionadas a jobs, como execução de consultas, iniciam o job imediatamente.
  • As funções para criar, receber, atualizar e excluir conjuntos de dados e tabelas foram movidas para a classe de cliente.

Neste tópico, você verá detalhes sobre as mudanças que devem ser feitas no seu código Python das bibliotecas de cliente do BigQuery para usar a versão mais recente da biblioteca de cliente do Python.

Como executar versões anteriores da biblioteca de cliente

Não é necessário atualizar a biblioteca de cliente do Python para a versão mais recente. No entanto, a nova funcionalidade na API BigQuery só é aceita nas versões v0.28 e posteriores.

Se você quiser continuar usando uma versão anterior da biblioteca de cliente Python e não quiser migrar seu código, especifique a versão da biblioteca de cliente Python usada por seu app. Para fazer isso, edite o arquivo requirements.txt conforme mostrado no exemplo a seguir:

google-cloud-bigquery==0.27

Como executar a versão mais recente da biblioteca de cliente

Para instalar a versão mais recente da biblioteca de cliente Python, use o comando pip.

pip install --upgrade google-cloud-bigquery

Para instruções mais detalhadas, consulte Bibliotecas de cliente do BigQuery.

Como importar a biblioteca e criar um cliente

Os métodos de importação da biblioteca de cliente do Python e de criação de um objeto cliente são os mesmos nas versões anteriores e mais recentes da biblioteca.

from google.cloud import bigquery

client = bigquery.Client()

Alterações no código da consulta

Como consultar dados com o dialeto SQL padrão

Estas são algumas das alterações na v0.28 e posteriores:

  • O SQL padrão é o dialeto SQL padrão.
  • Use a classe QueryJobConfig para configurar o job de consulta.
  • client.query() faz uma solicitação de API para iniciar imediatamente a consulta.
  • O código do job é opcional. Se esse código não foi fornecido, a biblioteca de cliente gera um para você.

Veja na amostra a seguir como executar uma consulta.

Versões anteriores das bibliotecas de cliente:

client = bigquery.Client()
query_job = client.run_async_query(str(uuid.uuid4()), query)

# Use standard SQL syntax.
query_job.use_legacy_sql = False

# Set a destination table.
dest_dataset = client.dataset(dest_dataset_id)
dest_table = dest_dataset.table(dest_table_id)
query_job.destination = dest_table

# Allow the results table to be overwritten.
query_job.write_disposition = 'WRITE_TRUNCATE'

query_job.begin()
query_job.result()  # Wait for query to finish.

rows = query_job.query_results().fetch_data()
for row in rows:
    print(row)

Na versão 0.25.0 ou anterior da biblioteca google-cloud-bigquery, em vez de job.result(), o código a seguir era necessário para aguardar a conclusão dos objetos do job:

while True:
    job.reload()  # Refreshes the state via a GET request.
    if job.state == 'DONE':
        if job.error_result:
            raise RuntimeError(job.errors)
        return
    time.sleep(1)

Na versão 0.25.0 ou anterior da biblioteca google-cloud-bigquery, em vez de job.query_results().fetch_data(), o seguinte código era usado para se conseguir as linhas resultantes:

rows = query_job.results().fetch_data()

Versão mais recente da biblioteca de cliente:

Por padrão, a biblioteca de cliente do Python usa o SQL padrão.

Python

Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery 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"]))

Para mais amostras de execução de consultas com a versão mais recente da biblioteca de cliente do Python, consulte:

Como fazer o download dos resultados da consulta como um DataFrame da pandas

O exemplo a seguir mostra como executar uma consulta e fazer o download dos resultados como um DataFrame da pandas (em inglês).

Versões anteriores das bibliotecas de cliente:

Não era possível fazer o download do resultados como um DataFrame da pandas nas versões anteriores das bibliotecas de cliente.

Versão mais recente da biblioteca de cliente:

Python

Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery Python.

# from google.cloud import bigquery
# client = bigquery.Client()

sql = """
    SELECT name, SUM(number) as count
    FROM `bigquery-public-data.usa_names.usa_1910_current`
    GROUP BY name
    ORDER BY count DESC
    LIMIT 10
"""

df = client.query(sql).to_dataframe()

Como consultar dados com o dialeto SQL legado

Veja na amostra a seguir como executar uma consulta usando o dialeto SQL legado.

Versões anteriores das bibliotecas de cliente:

As versões anteriores das bibliotecas de cliente usam a sintaxe SQL legada como padrão. Para informações sobre como configurar e executar uma consulta, consulte a amostra de consulta.

Versão mais recente da biblioteca de cliente:

A biblioteca de cliente usa a sintaxe SQL padrão quando não há outra especificada. Defina use_legacy_sql como verdadeiro para usar o SQL legado. Para mais informações sobre como configurar e executar uma consulta, consulte a amostra de consulta.

Como consultar dados de maneira síncrona

Na v0.28 e posteriores, o método Client.query() é recomendado porque com ele é possível acessar estatísticas e outras propriedades da consulta no QueryJob.

Versões anteriores das bibliotecas de cliente:

query_results = client.run_sync_query(query)
query_results.use_legacy_sql = False

query_results.run()

# The query might not complete in a single request. To account for a
# long-running query, force the query results to reload until the query
# is complete.
while not query_results.complete:
  query_iterator = query_results.fetch_data()
  try:
     six.next(iter(query_iterator))
  except StopIteration:
      pass

rows = query_results.fetch_data()
for row in rows:
    print(row)

Versão mais recente da biblioteca de cliente:

Python

Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery 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"]))

Alterações no código da tabela

Referências de tabelas

Use um objeto TableReference para se referir a uma tabela sem propriedades adicionais e um Table para se referir a um recurso de tabela completo. Várias propriedades, que antigamente usavam a classe Table, agora usam a classe TableReference na v0.28 e posteriores. Exemplo:

  • QueryJob.destination agora é um TableReference.
  • client.dataset('mydataset').table('mytable') agora retorna um TableReference.

Se você quiser ver um exemplo que usa as classes TableReference e Table, consulte Como criar uma tabela.

Como carregar dados de um arquivo local

Veja na amostra a seguir como carregar um arquivo local em uma tabela do BigQuery.

Versões anteriores das bibliotecas de cliente:

dataset = client.dataset(dataset_name)
table = dataset.table(table_name)

# Reload the table to get the schema.
table.reload()

with open(source_file_name, 'rb') as source_file:
    # This example uses CSV, but you can use other formats.
    # See https://cloud.google.com/bigquery/loading-data
    job = table.upload_from_file(
        source_file, source_format='text/csv')

# Wait for the load job to complete.
while True:
    job.reload()
    if job.state == 'DONE':
        if job.error_result:
            raise RuntimeError(job.errors)
        return
    time.sleep(1)

Versão mais recente da biblioteca de cliente:

Python

Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery Python.

# from google.cloud import bigquery
# client = bigquery.Client()
# filename = '/path/to/file.csv'
# dataset_id = 'my_dataset'
# table_id = 'my_table'

dataset_ref = client.dataset(dataset_id)
table_ref = dataset_ref.table(table_id)
job_config = bigquery.LoadJobConfig()
job_config.source_format = bigquery.SourceFormat.CSV
job_config.skip_leading_rows = 1
job_config.autodetect = True

with open(filename, "rb") as source_file:
    job = client.load_table_from_file(source_file, table_ref, job_config=job_config)

job.result()  # Waits for table load to complete.

print("Loaded {} rows into {}:{}.".format(job.output_rows, dataset_id, table_id))

Para mais detalhes, consulte Como carregar dados de uma fonte de dados local.

Como carregar dados de um DataFrame da pandas

O exemplo a seguir mostra como fazer o upload de um DataFrame da pandas (em inglês) para uma tabela do BigQuery.

Versões anteriores das bibliotecas de cliente:

Não era possível fazer o upload de dados de um DataFrame de pandas nas versões anteriores das bibliotecas de cliente.

Versão mais recente da biblioteca de cliente:

Python

Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery Python.

from google.cloud import bigquery

import pandas

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

# TODO(developer): Set table_id to the ID of the table to create.
# table_id = "your-project.your_dataset.your_table_name"

records = [
    {"title": u"The Meaning of Life", "release_year": 1983},
    {"title": u"Monty Python and the Holy Grail", "release_year": 1975},
    {"title": u"Life of Brian", "release_year": 1979},
    {"title": u"And Now for Something Completely Different", "release_year": 1971},
]
dataframe = pandas.DataFrame(
    records,
    # In the loaded table, the column order reflects the order of the
    # columns in the DataFrame.
    columns=["title", "release_year"],
    # Optionally, set a named index, which can also be written to the
    # BigQuery table.
    index=pandas.Index(
        [u"Q24980", u"Q25043", u"Q24953", u"Q16403"], name="wikidata_id"
    ),
)
job_config = bigquery.LoadJobConfig(
    # Specify a (partial) schema. All columns are always written to the
    # table. The schema is used to assist in data type definitions.
    schema=[
        # Specify the type of columns whose type cannot be auto-detected. For
        # example the "title" column uses pandas dtype "object", so its
        # data type is ambiguous.
        bigquery.SchemaField("title", bigquery.enums.SqlTypeNames.STRING),
        # Indexes are written if included in the schema by name.
        bigquery.SchemaField("wikidata_id", bigquery.enums.SqlTypeNames.STRING),
    ],
    # Optionally, set the write disposition. BigQuery appends loaded rows
    # to an existing table by default, but with WRITE_TRUNCATE write
    # disposition it replaces the table with the loaded data.
    write_disposition="WRITE_TRUNCATE",
)

job = client.load_table_from_dataframe(
    dataframe, table_id, job_config=job_config
)  # Make an API request.
job.result()  # Wait for the job to complete.

table = client.get_table(table_id)  # Make an API request.
print(
    "Loaded {} rows and {} columns to {}".format(
        table.num_rows, len(table.schema), table_id
    )
)

Como carregar dados do Cloud Storage

Veja na amostra a seguir como carregar um arquivo do Cloud Storage em uma tabela do BigQuery.

Versões anteriores das bibliotecas de cliente:

dataset = client.dataset(dataset_name)
table = dataset.table(table_name)
job_id = str(uuid.uuid4())

job = client.load_table_from_storage(
    job_id, table, 'gs://bucket_name/object_name')
job.begin()

# Wait for the load job to complete.
while True:
    job.reload()
    if job.state == 'DONE':
        if job.error_result:
            raise RuntimeError(job.errors)
        return
    time.sleep(1)

Versão mais recente da biblioteca de cliente:

Python

Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery Python.

# from google.cloud import bigquery
# client = bigquery.Client()
# dataset_id = 'my_dataset'

dataset_ref = client.dataset(dataset_id)
job_config = bigquery.LoadJobConfig()
job_config.schema = [
    bigquery.SchemaField("name", "STRING"),
    bigquery.SchemaField("post_abbr", "STRING"),
]
job_config.skip_leading_rows = 1
# The source format defaults to CSV, so the line below is optional.
job_config.source_format = bigquery.SourceFormat.CSV
uri = "gs://cloud-samples-data/bigquery/us-states/us-states.csv"

load_job = client.load_table_from_uri(
    uri, dataset_ref.table("us_states"), job_config=job_config
)  # API request
print("Starting job {}".format(load_job.job_id))

load_job.result()  # Waits for table load to complete.
print("Job finished.")

destination_table = client.get_table(dataset_ref.table("us_states"))
print("Loaded {} rows.".format(destination_table.num_rows))

Para mais detalhes, consulte Como carregar dados do Cloud Storage.

Como extrair uma tabela para o Cloud Storage

Veja na amostra a seguir como extrair uma tabela para o Cloud Storage.

Versões anteriores das bibliotecas de cliente:

dataset = client.dataset(dataset_name)
table = dataset.table(table_name)
job_id = str(uuid.uuid4())

job = client.extract_table_to_storage(
    job_id, table, 'gs://bucket_name/object_name')
job.begin()

# Wait for the job to complete.
while True:
    job.reload()
    if job.state == 'DONE':
        if job.error_result:
            raise RuntimeError(job.errors)
        return
    time.sleep(1)

Versão mais recente da biblioteca de cliente:

Python

Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery Python.

# from google.cloud import bigquery
# client = bigquery.Client()
# bucket_name = 'my-bucket'
project = "bigquery-public-data"
dataset_id = "samples"
table_id = "shakespeare"

destination_uri = "gs://{}/{}".format(bucket_name, "shakespeare.csv")
dataset_ref = client.dataset(dataset_id, project=project)
table_ref = dataset_ref.table(table_id)

extract_job = client.extract_table(
    table_ref,
    destination_uri,
    # Location must match that of the source table.
    location="US",
)  # API request
extract_job.result()  # Waits for job to complete.

print(
    "Exported {}:{}.{} to {}".format(project, dataset_id, table_id, destination_uri)
)

Para mais informações, consulte Como exportar dados de tabelas.

Como copiar uma tabela

Veja na amostra a seguir como copiar uma tabela para outra.

Versões anteriores das bibliotecas de cliente:

dataset = client.dataset(dataset_name)
table = dataset.table(table_name)
destination_table = dataset.table(new_table_name)

job_id = str(uuid.uuid4())
job = client.copy_table(job_id, destination_table, table)

job.create_disposition = (
        google.cloud.bigquery.job.CreateDisposition.CREATE_IF_NEEDED)
job.begin()

# Wait for the job to complete.
while True:
    job.reload()
    if job.state == 'DONE':
        if job.error_result:
            raise RuntimeError(job.errors)
        return
    time.sleep(1)

Versão mais recente da biblioteca de cliente:

Python

Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery Python.

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

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

# TODO(developer): Set source_table_id to the ID of the original table.
# source_table_id = "your-project.source_dataset.source_table"

# TODO(developer): Set destination_table_id to the ID of the destination table.
# destination_table_id = "your-project.destination_dataset.destination_table"

job = client.copy_table(source_table_id, destination_table_id)
job.result()  # Wait for the job to complete.

print("A copy of the table created.")

Para mais detalhes, consulte Como copiar uma tabela.

Como fazer streaming de dados para uma tabela

Veja na amostra a seguir como gravar linhas no buffer de streaming de uma tabela.

Versões anteriores das bibliotecas de cliente:

dataset = client.dataset(dataset_name)
table = dataset.table(table_name)

# Reload the table to get the schema.
table.reload()

rows = [('values', 'in', 'same', 'order', 'as', 'schema')]
errors = table.insert_data(rows)

if not errors:
    print('Loaded 1 row into {}:{}'.format(dataset_name, table_name))
else:
    do_something_with(errors)

Versão mais recente da biblioteca de cliente:

Python

Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery Python.

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

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

# TODO(developer): Set table_id to the ID of the model to fetch.
# table_id = "your-project.your_dataset.your_table"

table = client.get_table(table_id)  # Make an API request.
rows_to_insert = [(u"Phred Phlyntstone", 32), (u"Wylma Phlyntstone", 29)]

errors = client.insert_rows(table, rows_to_insert)  # Make an API request.
if errors == []:
    print("New rows have been added.")

Para mais detalhes, consulte Como fazer streaming de dados para o BigQuery.

Como listar tabelas

Veja na amostra a seguir como listar as tabelas em um conjunto de dados.

Versões anteriores das bibliotecas de cliente:

dataset = client.dataset(dataset_name)
for table in dataset.list_tables():
    print(table.name)

Versão mais recente da biblioteca de cliente:

Para mais detalhes, consulte Como listar tabelas.

Como receber uma tabela

Veja na amostra a seguir como receber uma tabela.

Versões anteriores das bibliotecas de cliente:

dataset = client.dataset(dataset_name)
table = dataset.table(table_name)
table.reload()

Versão mais recente da biblioteca de cliente:

Python

Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery Python.

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

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

# TODO(developer): Set table_id to the ID of the model to fetch.
# table_id = 'your-project.your_dataset.your_table'

table = client.get_table(table_id)  # Make an API request.

# View table properties
print(
    "Got table '{}.{}.{}'.".format(table.project, table.dataset_id, table.table_id)
)
print("Table schema: {}".format(table.schema))
print("Table description: {}".format(table.description))
print("Table has {} rows".format(table.num_rows))

Para mais detalhes, consulte Como conseguir informações sobre tabelas.

Verificar se uma tabela existe

A API do BigQuery não fornece um método exists nativo. Em vez disso, recebe o recurso da tabela e verifica se essa solicitação gera um erro 404. Anteriormente, a biblioteca de cliente fornecia o auxiliar exists() para executar essa verificação. O auxiliar exists() permitia alguns casos de uso ineficientes, como a chamada de exists() antes de tentar receber o recurso completo. Como resultado, o auxiliar exists() foi removido da biblioteca de cliente.

Veja na amostra a seguir como verificar se uma tabela existe.

Versões anteriores das bibliotecas de cliente:

dataset = client.dataset(dataset_name)
table = dataset.table(table_name)
if table.exists():
    # do something
else:
    # do something else

Versão mais recente da biblioteca de cliente:

Python

Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery Python.

from google.cloud.exceptions import NotFound

# TODO(developer): Set table_id to the ID of the table to determine existence.
# table_id = "your-project.your_dataset.your_table"

try:
    client.get_table(table_id)  # Make an API request.
    print("Table {} already exists.".format(table_id))
except NotFound:
    print("Table {} is not found.".format(table_id))

Como criar uma tabela

Veja na amostra a seguir como criar uma tabela.

Versões anteriores das bibliotecas de cliente:

dataset = client.dataset(dataset_name)
table = dataset.table(table_name)
table.create()

Versão mais recente da biblioteca de cliente:

Python

Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery Python.

from google.cloud import bigquery

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

# TODO(developer): Set table_id to the ID of the table to create.
# table_id = "your-project.your_dataset.your_table_name"

schema = [
    bigquery.SchemaField("full_name", "STRING", mode="REQUIRED"),
    bigquery.SchemaField("age", "INTEGER", mode="REQUIRED"),
]

table = bigquery.Table(table_id, schema=schema)
table = client.create_table(table)  # Make an API request.
print(
    "Created table {}.{}.{}".format(table.project, table.dataset_id, table.table_id)
)

Para mais detalhes, consulte Como criar uma tabela.

Como atualizar uma tabela

Veja na amostra a seguir como atualizar uma tabela.

Versões anteriores das bibliotecas de cliente:

dataset = client.dataset(dataset_name)
table = dataset.table(table_name)
table.patch(description='new description')

Observe que as versões anteriores da biblioteca não verificam as versões do recurso da tabela por meio da propriedade etag. Portanto, um procedimento de leitura-modificação-gravação não é seguro.

Versão mais recente da biblioteca de cliente:

Python

Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery Python.

# from google.cloud import bigquery
# client = bigquery.Client()
# table_ref = client.dataset('my_dataset').table('my_table')
# table = client.get_table(table_ref)  # API request

assert table.description == "Original description."
table.description = "Updated description."

table = client.update_table(table, ["description"])  # API request

assert table.description == "Updated description."

Para mais detalhes, consulte Como atualizar as propriedades da tabela.

Como excluir uma tabela

Veja na amostra a seguir como excluir uma tabela.

Versões anteriores das bibliotecas de cliente:

dataset = client.dataset(dataset_name)
table = dataset.table(table_name)
table.delete()

Versão mais recente da biblioteca de cliente:

Python

Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery Python.

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

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

# TODO(developer): Set table_id to the ID of the table to fetch.
# table_id = 'your-project.your_dataset.your_table'

# If the table does not exist, delete_table raises
# google.api_core.exceptions.NotFound unless not_found_ok is True.
client.delete_table(table_id, not_found_ok=True)  # Make an API request.
print("Deleted table '{}'.".format(table_id))

Para mais detalhes, consulte Como excluir uma tabela.

Alterações no código do conjunto de dados

Referências do conjunto de dados

Use um objeto DatasetReference para se referir a um conjunto de dados sem propriedades adicionais e um Dataset para se referir a um recurso completo do conjunto de dados. Alguns métodos, que antigamente usavam a classe Dataset, agora usam a classe DatasetReference na v0.28 e posteriores. Exemplo:

  • client.dataset('mydataset') agora retorna um DatasetReference.

Para ver um exemplo que usa as classes DatasetReference e Dataset, consulte Como criar um conjunto de dados.

Como listar conjuntos de dados

Veja na amostra a seguir como listar conjuntos de dados em um projeto.

Versões anteriores das bibliotecas de cliente:

for dataset in client.list_datasets():
    print(dataset.name)

Versão mais recente da biblioteca de cliente:

Python

Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery Python.

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

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

datasets = list(client.list_datasets())  # Make an API request.
project = client.project

if datasets:
    print("Datasets in project {}:".format(project))
    for dataset in datasets:
        print("\t{}".format(dataset.dataset_id))
else:
    print("{} project does not contain any datasets.".format(project))

Para mais detalhes, consulte Como listar conjuntos de dados.

Como receber um conjunto de dados

Veja na amostra a seguir como receber um conjunto de dados.

Versões anteriores das bibliotecas de cliente:

dataset = client.dataset(dataset_name)
dataset.reload()

Versão mais recente da biblioteca de cliente:

Python

Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery Python.

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

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

# TODO(developer): Set dataset_id to the ID of the dataset to fetch.
# dataset_id = 'your-project.your_dataset'

dataset = client.get_dataset(dataset_id)  # Make an API request.

full_dataset_id = "{}.{}".format(dataset.project, dataset.dataset_id)
friendly_name = dataset.friendly_name
print(
    "Got dataset '{}' with friendly_name '{}'.".format(
        full_dataset_id, friendly_name
    )
)

# View dataset properties.
print("Description: {}".format(dataset.description))
print("Labels:")
labels = dataset.labels
if labels:
    for label, value in labels.items():
        print("\t{}: {}".format(label, value))
else:
    print("\tDataset has no labels defined.")

# View tables in dataset.
print("Tables:")
tables = list(client.list_tables(dataset))  # Make an API request(s).
if tables:
    for table in tables:
        print("\t{}".format(table.table_id))
else:
    print("\tThis dataset does not contain any tables.")

Para mais detalhes, consulte Como receber informações sobre conjuntos de dados.

Verificar se um conjunto de dados existe

A API do BigQuery não fornece um método exists nativo. Em vez disso, recebe o recurso do conjunto de dados e verifica se essa solicitação gera um erro 404. Anteriormente, a biblioteca de cliente fornecia o auxiliar exists() para executar essa verificação. O auxiliar exists() permitia alguns casos de uso ineficientes, como a chamada de exists() antes de tentar receber o recurso completo. Como resultado, o auxiliar exists() foi removido da biblioteca de cliente.

Veja na amostra a seguir como verificar se um conjunto de dados existe.

Versões anteriores das bibliotecas de cliente:

dataset = client.dataset(dataset_name)
if dataset.exists():
    # do something
else:
    # do something else

Versão mais recente da biblioteca de cliente:

Python

Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery Python.

from google.cloud.exceptions import NotFound

# TODO(developer): Set dataset_id to the ID of the dataset to determine existence.
# dataset_id = "your-project.your_dataset"

try:
    client.get_dataset(dataset_id)  # Make an API request.
    print("Dataset {} already exists".format(dataset_id))
except NotFound:
    print("Dataset {} is not found".format(dataset_id))

Como criar um conjunto de dados

Veja na amostra a seguir como criar um conjunto de dados.

Versões anteriores das bibliotecas de cliente:

dataset = client.dataset(dataset_name)
dataset.create()

Versão mais recente da biblioteca de cliente:

Python

Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery Python.

from google.cloud import bigquery

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

# TODO(developer): Set dataset_id to the ID of the dataset to create.
# dataset_id = "{}.your_dataset".format(client.project)

# Construct a full Dataset object to send to the API.
dataset = bigquery.Dataset(dataset_id)

# TODO(developer): Specify the geographic location where the dataset should reside.
dataset.location = "US"

# Send the dataset to the API for creation.
# Raises google.api_core.exceptions.Conflict if the Dataset already
# exists within the project.
dataset = client.create_dataset(dataset)  # Make an API request.
print("Created dataset {}.{}".format(client.project, dataset.dataset_id))

Para mais detalhes, consulte Como criar conjuntos de dados.

Como atualizar um conjunto de dados

Veja na amostra a seguir como atualizar um conjunto de dados.

Versões anteriores das bibliotecas de cliente:

dataset = client.dataset(dataset_name)
dataset.patch(description='new description')

Observe que as versões anteriores da biblioteca não verificam as versões do recurso do conjunto de dados por meio da propriedade etag. Portanto, um procedimento de leitura-modificação-gravação não é seguro.

Versão mais recente da biblioteca de cliente:

Python

Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery Python.

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

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

# TODO(developer): Set dataset_id to the ID of the dataset to fetch.
# dataset_id = 'your-project.your_dataset'

dataset = client.get_dataset(dataset_id)  # Make an API request.
dataset.description = "Updated description."
dataset = client.update_dataset(dataset, ["description"])  # Make an API request.

full_dataset_id = "{}.{}".format(dataset.project, dataset.dataset_id)
print(
    "Updated dataset '{}' with description '{}'.".format(
        full_dataset_id, dataset.description
    )
)

Para mais detalhes, consulte Como atualizar as propriedades do conjunto de dados.

Como excluir um conjunto de dados

Veja na amostra a seguir como excluir um conjunto de dados.

Versões anteriores das bibliotecas de cliente:

dataset = client.dataset(dataset_name)
dataset.delete()

Versão mais recente da biblioteca de cliente:

Python

Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery Python.

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

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

# TODO(developer): Set model_id to the ID of the model to fetch.
# dataset_id = 'your-project.your_dataset'

# Use the delete_contents parameter to delete a dataset and its contents.
# Use the not_found_ok parameter to not receive an error if the dataset has already been deleted.
client.delete_dataset(
    dataset_id, delete_contents=True, not_found_ok=True
)  # Make an API request.

print("Deleted dataset '{}'.".format(dataset_id))

Para mais detalhes, consulte Como excluir conjuntos de dados.

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Precisa de ajuda? Acesse nossa página de suporte.