Como migrar da biblioteca de cliente do Python v0.27

A biblioteca de cliente do Google 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 seguinte maneira:

  • 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 do Python e não quiser migrar seu código, especifique a versão da biblioteca de cliente do Python usada por seu aplicativo. Para definir uma versão de biblioteca específica, edite o arquivo requirements.txt como 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 do 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 à 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 anteriores da biblioteca google-cloud-bigquery, em vez de job.result(), o seguinte código 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 anteriores da biblioteca google-cloud-bigquery, em vez de job.query_results().fetch_data(), o seguinte código era usado para receber 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 Início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do BigQuery para Python.

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

query = (
    "SELECT name FROM `bigquery-public-data.usa_names.usa_1910_2013` "
    'WHERE state = "TX" '
    "LIMIT 100"
)
query_job = client.query(
    query,
    # Location must match that of the dataset(s) referenced in the query.
    location="US",
)  # API request - starts the query

for row in query_job:  # API request - fetches results
    # Row values can be accessed by field name or index
    assert row[0] == row.name == row["name"]
    print(row)

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

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, veja esta amostra.

Como consultar dados de maneira síncrona

Na v0.28 e posteriores, o método Client.query() é recomendado porque é 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 Início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do BigQuery para Python.

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

query = (
    "SELECT name FROM `bigquery-public-data.usa_names.usa_1910_2013` "
    'WHERE state = "TX" '
    "LIMIT 100"
)
query_job = client.query(
    query,
    # Location must match that of the dataset(s) referenced in the query.
    location="US",
)  # API request - starts the query

for row in query_job:  # API request - fetches results
    # Row values can be accessed by field name or index
    assert row[0] == row.name == row["name"]
    print(row)

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 anteriormente utilizavam a classe Table agora usam a classe TableReference na v0.28 e posteriores. Por exemplo:

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

Para 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 Início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do BigQuery para 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,
        location="US",  # Must match the destination dataset location.
        job_config=job_config,
    )  # API request

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 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 Início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do BigQuery para 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 Início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do BigQuery para 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 Início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do BigQuery para Python.

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

source_dataset = client.dataset("samples", project="bigquery-public-data")
source_table_ref = source_dataset.table("shakespeare")

# dataset_id = 'my_dataset'
dest_table_ref = client.dataset(dataset_id).table("destination_table")

job = client.copy_table(
    source_table_ref,
    dest_table_ref,
    # Location must match that of the source and destination tables.
    location="US",
)  # API request

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

assert job.state == "DONE"
dest_table = client.get_table(dest_table_ref)  # API request
assert dest_table.num_rows > 0

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 Início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do BigQuery para Python.

# TODO(developer): Uncomment the lines below and replace with your values.
# from google.cloud import bigquery
# client = bigquery.Client()
# dataset_id = 'my_dataset'  # replace with your dataset ID
# For this sample, the table must already exist and have a defined schema
# table_id = 'my_table'  # replace with your table ID
# table_ref = client.dataset(dataset_id).table(table_id)
# table = client.get_table(table_ref)  # API request

rows_to_insert = [(u"Phred Phlyntstone", 32), (u"Wylma Phlyntstone", 29)]

errors = client.insert_rows(table, rows_to_insert)  # API request

assert errors == []

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:

Python

Antes de testar esta amostra, siga as instruções de configuração do Python no Início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do BigQuery para 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 that contains
#                  the tables you are listing.
# dataset_id = 'your-project.your_dataset'

tables = client.list_tables(dataset_id)

print("Tables contained in '{}':".format(dataset_id))
for table in tables:
    print("{}.{}.{}".format(table.project, table.dataset_id, table.table_id))

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 Início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do BigQuery para 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 model to fetch.
# table_id = 'your-project.your_dataset.your_table'

table = client.get_table(table_id)

print(
    "Got table '{}.{}.{}'.".format(table.project, table.dataset_id, table.table_id)
)

# View table properties
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.

Como verificar se uma tabela existe

A API BigQuery não tem 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 Início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do BigQuery para Python.

def table_exists(client, table_reference):
    """Return if a table exists.

    Args:
        client (google.cloud.bigquery.client.Client):
            A client to connect to the BigQuery API.
        table_reference (google.cloud.bigquery.table.TableReference):
            A reference to the table to look for.

    Returns:
        bool: ``True`` if the table exists, ``False`` otherwise.
    """
    from google.cloud.exceptions import NotFound

    try:
        client.get_table(table_reference)
        return True
    except NotFound:
        return False

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 Início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do BigQuery para Python.

from google.cloud import bigquery

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

# 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"

table = bigquery.Table(table_id, schema=schema)
table = client.create_table(table)  # 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 Início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do BigQuery para 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 Início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do BigQuery para 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 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)
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. Por exemplo:

  • client.dataset('mydataset') agora retorna uma 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 Início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do BigQuery para Python.

from google.cloud import bigquery

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

datasets = list(client.list_datasets())
project = client.project

if datasets:
    print("Datasets in project {}:".format(project))
    for dataset in datasets:  # API request(s)
        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 Início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do BigQuery para 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 fetch.
# dataset_id = 'your-project.your_dataset'

dataset = client.get_dataset(dataset_id)

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

Como verificar se um conjunto de dados existe

A API BigQuery não tem 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 esta 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 Início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do BigQuery para Python.

def dataset_exists(client, dataset_reference):
    """Return if a dataset exists.

    Args:
        client (google.cloud.bigquery.client.Client):
            A client to connect to the BigQuery API.
        dataset_reference (google.cloud.bigquery.dataset.DatasetReference):
            A reference to the dataset to look for.

    Returns:
        bool: ``True`` if the dataset exists, ``False`` otherwise.
    """
    from google.cloud.exceptions import NotFound

    try:
        client.get_dataset(dataset_reference)
        return True
    except NotFound:
        return False

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 Início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do BigQuery para 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)  # 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 Início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do BigQuery para 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 fetch.
# dataset_id = 'your-project.your_dataset'

dataset = client.get_dataset(dataset_id)
dataset.description = "Updated description."
dataset = client.update_dataset(dataset, ["description"])

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 Início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do BigQuery para Python.

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)

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.