Como atualizar as propriedades do conjunto de dados

Neste documento, descrevemos como atualizar as propriedades do conjunto de dados no BigQuery. Depois de criar um conjunto de dados, é possível atualizar as seguintes propriedades:

Permissões exigidas

Para atualizar as propriedades do conjunto de dados, você precisa ter pelo menos as permissões bigquery.datasets.update e bigquery.datasets.get. Os papéis predefinidos do Cloud IAM a seguir incluem permissões bigquery.datasets.update e bigquery.datasets.get:

  • bigquery.dataOwner
  • bigquery.admin

Além disso, quando um usuário com permissões bigquery.datasets.create cria um conjunto de dados, ele recebe o acesso de bigquery.dataOwner ao conjunto. Com o acesso bigquery.dataOwner, os usuários conseguem atualizar as propriedades dos conjuntos de dados criados por eles.

Para mais informações sobre papéis e permissões do Cloud IAM no BigQuery, consulte Controle de acesso.

Como atualizar descrições de conjunto de dados

É possível atualizar a descrição de um conjunto de dados. Para fazer isso, realize as etapas a seguir:

  • Use o Console do GCP ou a IU da Web clássica do BigQuery.
  • Use o comando bq update da CLI.
  • Chame o método de API datasets.patch.
  • Use bibliotecas de cliente.

Para atualizar a descrição de um conjunto de dados:

Console

  1. No painel Recursos, selecione o conjunto de dados.

  2. Na página Detalhes, clique no ícone de lápis ao lado de Descrição para editar o texto.

    Configurações de consulta

  3. Insira uma nova ou edite uma descrição atual na caixa de diálogo. Clique em Atualizar para salvar o novo texto da descrição.

IU clássica

  1. No painel de navegação, selecione o conjunto de dados.

  2. Na seção Descrição da página Detalhes do conjunto de dados, clique em Descrever este conjunto de dados para abrir a caixa de descrição caso ele não tenha uma. Caso contrário, clique no texto de descrição existente.

  3. Insira uma descrição na caixa ou edite a existente. Ao clicar fora da caixa, o texto é salvo.

    Descrição do conjunto de dados

CLI

Emita o comando bq update com a sinalização --description. Se você estiver atualizando um conjunto de dados em um projeto diferente do padrão, adicione o ID do projeto ao nome do conjunto no seguinte formato: project_id:dataset.

bq update \
--description "string" \
project_id:dataset

Em que:

  • string é o texto que descreve o conjunto de dados entre aspas;
  • project_id é o ID do projeto.
  • dataset é o nome do conjunto de dados que você está atualizando.

Por exemplo:

Insira o comando a seguir para alterar a descrição de mydataset para "Description of mydataset". O mydataset está no projeto padrão.

bq update --description "Description of mydataset" mydataset

Digite o comando a seguir para alterar a descrição de mydataset para "Description of mydataset". O conjunto de dados está em myotherproject, não no seu projeto padrão.

bq update \
--description "Description of mydataset" \
myotherproject:mydataset

API

Chame datasets.patch e atualize a propriedade description no recurso do conjunto de dados. Como o método datasets.update substitui todo o recurso do conjunto de dados, recomenda-se usar o datasets.patch.

Go

Antes de testar esta amostra, siga as instruções de configuração do Go 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 Go.

ds := client.Dataset(datasetID)
meta, err := ds.Metadata(ctx)
if err != nil {
	return err
}
update := bigquery.DatasetMetadataToUpdate{
	Description: "Updated Description.",
}
if _, err = ds.Update(ctx, update, meta.ETag); err != nil {
	return err
}

Java

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

Crie uma instância Dataset.Builder de uma instância Dataset atual com o método Dataset.toBuilder(). Configure o objeto de builder do conjunto de dados. Crie o conjunto de dados atualizado com o método Dataset.Builder.build() e chame o método Dataset.update() para enviar a atualização à API.
Dataset oldDataset = bigquery.getDataset(datasetName);
DatasetInfo datasetInfo = oldDataset.toBuilder().setDescription(newDescription).build();
Dataset newDataset = bigquery.update(datasetInfo);

Python

Antes de testar esta amostra, siga as instruções de configuração do Python em 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 (em inglês).

Configure a propriedade Dataset.description e chame Client.update_dataset() para enviar a atualização à API.
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
    )
)

Como atualizar os prazos de validade padrão da tabela

É possível atualizar o prazo de validade padrão da tabela do conjunto de dados realizando as etapas a seguir:

  • Use o Console do GCP ou a IU da Web clássica do BigQuery.
  • Use o comando bq update da CLI.
  • Chame o método de API datasets.patch.
  • Use bibliotecas de cliente.

É possível configurar o prazo de validade padrão da tabela no nível do conjunto de dados ou defini-lo quando a tabela é criada. Ao fazer isso durante a criação da tabela, a expiração padrão da tabela do conjunto de dados será ignorada. Se você não a configurar no nível do conjunto de dados e não defini-la quando a tabela for criada, a tabela nunca expirará, e você precisará excluí-la manualmente.

Ao atualizar a configuração da expiração padrão da tabela de um conjunto de dados:

  • Se você alterar o valor de Never para um tempo de expiração definido, quaisquer tabelas do conjunto de dados não expirarão, a menos que o tempo de expiração tenha sido configurado na tabela quando ela foi criada.
  • Se você estiver alterando o valor da expiração padrão da tabela, quaisquer tabelas existentes expirarão de acordo com a configuração de expiração original. A nova configuração de expiração será aplicada a todas as novas tabelas criadas no conjunto de dados, a menos que você especifique uma expiração diferente na tabela quando ela for criada.

O valor da expiração padrão da tabela é expresso de diferentes formas, dependendo do local em que você o define. Use o método que garanta o nível apropriado de granularidade:

  • No Console do GCP e na IU da Web clássica do BigQuery, a expiração é expressa em dias.
  • Na ferramenta de linha de comando, a validade é expressa em segundos.
  • Na API, em milissegundos.

Para atualizar o prazo de validade padrão de um conjunto de dados:

Console

  1. No painel Recursos, selecione o conjunto de dados.

  2. Na página Detalhes, clique no ícone de lápis ao lado de Informações do conjunto de dados para editar a validade.

  3. Na caixa de diálogo Informações do conjunto de dados, na seção Expiração da tabela padrão, insira um valor para Número de dias após a criação da tabela.

  4. Clique em Salvar.

IU clássica

  1. No painel de navegação, selecione o conjunto de dados.

  2. Na página Dataset Details, na seção Details, à direita de Default Table Expiration, clique em Edit.

    Expiração da tabela

  3. Na caixa de diálogo Update Expiration, em Data expiration, selecione In e insira o tempo de expiração em dias. O valor padrão é Never.

CLI

Para atualizar o prazo de validade padrão de tabelas recém-criadas em um conjunto de dados, digite o comando bq update com a sinalização --default_table_expiration. Se você estiver atualizando um conjunto de dados em um projeto diferente do padrão, adicione o ID do projeto ao nome do conjunto no seguinte formato: project_id:dataset.

bq update \
--default_table_expiration integer \
project_id:dataset

Em que:

  • integer é o ciclo de vida padrão (em segundos) das tabelas recém-criadas. O valor mínimo é de 3.600 segundos (uma hora). O prazo de validade é a soma do horário UTC atual com o valor inteiro. Especifique 0 para remover o prazo de validade atual. Qualquer tabela criada no conjunto de dados será excluída após integer segundos, contados a partir do momento da criação. Esse valor será aplicado se você não definir uma validade durante a criação da tabela.
  • project_id é o ID do projeto.
  • dataset é o nome do conjunto de dados que você está atualizando.

Por exemplo:

Insira o comando a seguir para definir a expiração padrão de novas tabelas criadas em mydataset como duas horas (7.200 segundos) a partir do horário atual. O conjunto de dados está no projeto padrão.

bq update --default_table_expiration 7200 mydataset

Insira o comando a seguir para definir a expiração padrão de novas tabelas criadas em mydataset como duas horas (7.200 segundos) a partir do horário atual. O conjunto de dados está em myotherproject, e não no projeto padrão.

bq update --default_table_expiration 7200 myotherproject:mydataset

API

Chame datasets.patch e atualize a propriedade defaultTableExpirationMs no recurso do conjunto de dados. A expiração é expressa em milissegundos na API. Como o método datasets.update substitui todo o recurso do banco de dados, o método datasets.patch é o preferido.

Go

Antes de testar esta amostra, siga as instruções de configuração do Go 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 Go.

ds := client.Dataset(datasetID)
meta, err := ds.Metadata(ctx)
if err != nil {
	return err
}
update := bigquery.DatasetMetadataToUpdate{
	DefaultTableExpiration: 24 * time.Hour,
}
if _, err := client.Dataset(datasetID).Update(ctx, update, meta.ETag); err != nil {
	return err
}

Java

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

Crie uma instância Dataset.Builder de uma instância Dataset atual com o método Dataset.toBuilder(). Configure o objeto de builder do conjunto de dados. Crie o conjunto de dados atualizado com o método Dataset.Builder.build() e chame o método Dataset.update() para enviar a atualização à API.

Configure o prazo de validade padrão com o método Dataset.Builder.setDefaultTableLifetime().

Long beforeExpiration = dataset.getDefaultTableLifetime();

Long oneDayMilliseconds = 24 * 60 * 60 * 1000L;
DatasetInfo.Builder builder = dataset.toBuilder();
builder.setDefaultTableLifetime(oneDayMilliseconds);
bigquery.update(builder.build());  // API request.

Python

Antes de testar esta amostra, siga as instruções de configuração do Python em 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 (em inglês).

Configure a propriedade Dataset.default_table_expiration_ms e chame Client.update_dataset() para enviar a atualização à API.
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.default_table_expiration_ms = 24 * 60 * 60 * 1000  # in milliseconds

dataset = client.update_dataset(
    dataset, ["default_table_expiration_ms"]
)  # API request

full_dataset_id = "{}.{}".format(dataset.project, dataset.dataset_id)
print(
    "Updated dataset {} with new expiration {}".format(
        full_dataset_id, dataset.default_table_expiration_ms
    )
)

Como atualizar os prazos de validade padrão de partições

É possível atualizar a validade padrão da partição de um conjunto de dados realizando as etapas a seguir:

  • Use o comando bq update da CLI.
  • Chame o método de API datasets.patch.
  • Use bibliotecas de cliente.

A configuração ou atualização da validade da partição padrão de um conjunto de dados não é compatível com o Console do GCP ou com a IU da Web clássica do BigQuery.

É possível definir um prazo de validade padrão da partição no nível do conjunto de dados que afetará todas as tabelas particionadas recém-criadas. Se preferir, defina um prazo de validade da partição individualmente durante a criação de cada tabela particionada. Se você definir os prazos de validade padrão de partição e de tabela no nível do conjunto de dados, as novas tabelas particionadas terão apenas prazo de validade de partição. Quando ambas as opções são definidas, a validade padrão de partição modifica a validade padrão de tabela.

Se você definir o prazo de validade da partição no momento da criação da tabela, esse valor modificará a validade padrão definida no nível do conjunto de dados.

Se você não definir uma validade padrão de partição no nível do conjunto de dados nem a validade de partição durante a criação da tabela, as partições nunca expirarão e será necessário excluí-las manualmente.

Quando definimos uma validade padrão de partição em um conjunto de dados, esse prazo será aplicado a todas as partições nas tabelas particionadas criadas em tal conjunto de dados. Quando definimos a validade de partição em uma tabela, esse prazo será aplicado a todas as partições criadas na tabela específica. Atualmente, não é possível aplicar prazos de validade distintos a partições diferentes na mesma tabela.

Ao atualizar a validade padrão de partição de um conjunto de dados:

  • altere o valor de “nunca” para um prazo de validade definido. Assim, todas as partições atuais das tabelas particionadas no conjunto de dados não expirarão, a menos que tal prazo tenha sido definido nas tabelas quando elas foram criadas;
  • altere o valor de validade padrão de partição, assim, todas as partições nas tabelas particionadas atuais expirarão de acordo com o prazo original. A nova validade padrão de partição será aplicada a todas as novas tabelas particionadas criadas no conjunto de dados, a menos que você especifique um prazo diferente durante a criação das tabelas.

O valor da validade padrão da tabela é expresso de formas diferentes, dependendo do local em que é definido. Use o método que garanta o nível apropriado de granularidade:

  • Na ferramenta de linha de comando, a validade é expressa em segundos.
  • Na API, o prazo de validade é expresso em milissegundos.

Para atualizar o prazo de validade da partição padrão de um conjunto de dados:

Console

A atualização da validade da partição padrão de um conjunto de dados não é aceita no Console do GCP.

IU clássica

A atualização da validade da partição padrão de um conjunto de dados não é aceita na IU da Web clássica do BigQuery.

CLI

Para atualizar o prazo de validade padrão de um conjunto de dados, digite o comando bq update com a sinalização --default_partition_expiration. Se você estiver atualizando um conjunto de dados em um projeto diferente do padrão, adicione o ID do projeto ao nome do conjunto no seguinte formato: project_id:dataset.

bq update \
--default_partition_expiration integer \
project_id:dataset

Em que:

  • integer é o ciclo de vida padrão (em segundos) das tabelas particionadas recém-criadas. Esta sinalização não tem valor mínimo. Especifique 0 para remover o prazo de validade atual. Todas as partições nas tabelas particionadas recém-criadas serão excluídas após [INTEGER] segundos contados a partir da data UTC da partição. Esse valor será aplicado se você não definir uma validade de partição na tabela quando ela for criada.
  • project_id é o ID do projeto.
  • dataset é o nome do conjunto de dados que você está atualizando.

Por exemplo:

Digite o comando a seguir para definir a validade padrão de partição das novas tabelas particionadas criadas em mydataset como 26 horas (93.600 segundos). O conjunto de dados está no projeto padrão.

bq update --default_partition_expiration 93600 mydataset

Digite o comando a seguir para definir a validade padrão de partição das novas tabelas particionadas criadas em mydataset como 26 horas (93.600 segundos). O conjunto de dados está em myotherproject, e não no projeto padrão.

bq update --default_partition_expiration 93600 myotherproject:mydataset

API

Chame datasets.patch e atualize a propriedade defaultPartitionExpirationMs no recurso do conjunto de dados. A validade é expressa em milissegundos. Como o método datasets.update substitui todo o recurso do conjunto de dados, recomenda-se usar o datasets.patch.

Como atualizar os controles de acesso ao conjunto de dados

O processo de atualização dos controles de acesso do conjunto de dados é muito semelhante ao de atribuição. Os controles de acesso não podem ser aplicados durante a criação do conjunto de dados usando o Console do GCP, a IU da Web clássica do BigQuery ou a ferramenta de linha de comando. É preciso primeiro criar o conjunto de dados e atualizar os controles de acesso dele. Com a API, é possível atualizar os controles de acesso ao conjunto de dados chamando o método datasets.patch.

Ao atualizar os controles de acesso em um conjunto de dados, é possível modificar o acesso das seguintes entidades:

  • E-mail da conta do Google: concede acesso ao conjunto de dados a uma conta individual do Google.
  • Grupo do Google: concede acesso ao conjunto de dados a todos os membros de um grupo do Google.
  • Domínio do Google Apps: concede acesso ao conjunto de dados a todos os usuários e grupos em um domínio do Google.
  • Conta de serviço: concede acesso ao conjunto de dados a uma conta de serviço.
  • Qualquer pessoa: insira "allUsers" para conceder acesso ao público em geral.
  • Todas as Contas do Google: insira "allAuthenticatedUsers" para conceder acesso a qualquer usuário conectado a uma Conta do Google.
  • Visualização autorizada: fornece acesso de visualização ao conjunto de dados.

Para atualizar os controles de acesso em um conjunto de dados:

Console

  1. Clique no conjunto de dados na seção Recursos do painel de navegação.

  2. Clique em Compartilhar conjunto de dados.

  3. Para excluir as entradas existentes, na caixa de diálogo Compartilhar conjunto de dados, expanda a entrada e clique no ícone de excluir (lixeira).

  4. Na caixa de diálogo Compartilhar conjunto de dados, para adicionar novas entradas:

    1. Insira a entidade na caixa Adicionar membros.

    2. Em Selecionar um papel, escolha um papel adequado do Cloud IAM na lista. Para mais informações sobre as permissões atribuídas a cada papel predefinido do BigQuery, consulte a página Controle de acesso.

    3. Clique em Adicionar.

  5. Para adicionar uma visualização autorizada, clique na guia Visualização autorizada e insira o projeto, o conjunto de dados e a visualização. Depois clique em Adicionar.

  6. Quando terminar de adicionar ou excluir os controles de acesso, clique em Concluído.

IU clássica

  1. Clique na seta suspensa à direita do conjunto de dados e escolha Compartilhar conjunto de dados.

  2. Na caixa de diálogo Compartilhar conjunto de dados, para modificar as entradas existentes:

    • Remova as entradas existentes clicando no ícone de X à direita da entidade.
    • Altere as permissões de uma entidade clicando no botão das permissões e selecionando um nível de acesso adequado: Is owner (OWNER), Can edit (WRITER) ou Can view (READER). Para mais informações sobre papéis no nível do conjunto de dados, consulte Papéis e permissões primárias.
  3. Na caixa de diálogo Compartilhar conjunto de dados, para adicionar novas entradas:

    1. Clique na lista suspensa à esquerda do campo Adicionar pessoas e escolha a opção adequada.

    2. Digite um valor na caixa de texto. Por exemplo, se você escolher Usuário por e-mail, digite o endereço de e-mail do usuário.

    3. À direita do campo Adicionar pessoas, clique em Pode visualizar e escolha o papel apropriado na lista.

      Adicionar pessoas ao conjunto de dados

    4. Clique em Adicionar.

  4. Quando terminar de adicionar, excluir ou modificar os controles de acesso, clique em Salvar alterações.

  5. Clique na seta suspensa à direita do conjunto de dados e escolha Compartilhar conjunto de dados para verificar os controles de acesso. Confirme as configurações na caixa de diálogo Compartilhar conjunto de dados.

CLI

  1. Grave as informações atuais do conjunto de dados, incluindo controles de acesso, em um arquivo JSON usando o comando show. Se o conjunto de dados estiver em um projeto diferente do padrão, adicione o ID do projeto ao nome do conjunto de dados no formato: project_id:dataset.

    bq show \
    --format=prettyjson \
    project_id:dataset > path_to_file
    

    Em que:

    • project_id é o ID do projeto.
    • dataset é o nome do seu conjunto de dados.
    • path_to_file é o caminho para o arquivo JSON em sua máquina local.

    Por exemplo:

    Digite o comando a seguir para gravar os controles de acesso de mydataset em um arquivo JSON. O mydataset está no projeto padrão.

    bq show --format=prettyjson mydataset > /tmp/mydataset.json
    

    Digite o comando a seguir para gravar os controles de acesso de mydataset em um arquivo JSON. O mydataset está em myotherproject.

    bq show --format=prettyjson \
    myotherproject:mydataset > /tmp/mydataset.json
    
  2. Faça suas alterações na seção "access" do arquivo JSON. É possível adicionar ou remover qualquer uma das entradas specialGroup: projectOwners, projectWriters, projectReaders e allAuthenticatedUsers. É possível também adicionar, remover ou modificar qualquer uma das opções a seguir: userByEmail, groupByEmail e domain.

    Por exemplo, a seção “access” do arquivo JSON de um conjunto de dados tem esta aparência:

    {
     "access": [
      {
       "role": "READER",
       "specialGroup": "projectReaders"
      },
      {
       "role": "WRITER",
       "specialGroup": "projectWriters"
      },
      {
       "role": "OWNER",
       "specialGroup": "projectOwners"
      }
      {
       "role": "READER",
       "specialGroup": "allAuthenticatedUsers"
      }
      {
       "role": "READER",
       "domain": "[DOMAIN_NAME]"
      }
      {
       "role": "WRITER",
       "userByEmail": "[USER_EMAIL]"
      }
      {
       "role": "READER",
       "groupByEmail": "[GROUP_EMAIL]"
      }
     ],
    }
    

  3. Quando suas edições estiverem concluídas, use o comando update e inclua o arquivo JSON usando a sinalização --source. Se o conjunto de dados estiver em um projeto diferente do padrão, adicione o ID do projeto ao nome do conjunto de dados no formato: project_id:dataset.

    bq update --source path_to_file project_id:dataset
    

    Em que:

    • path_to_file é o caminho para o arquivo JSON em sua máquina local.
    • project_id é o ID do projeto.
    • dataset é o nome do seu conjunto de dados.

    Por exemplo:

    Digite o comando a seguir para atualizar os controles de acesso de mydataset. O mydataset está no projeto padrão.

    bq update --source /tmp/mydataset.json mydataset
    

    Insira o comando a seguir para atualizar os controles de acesso de mydataset. O mydataset está em myotherproject.

    bq update --source /tmp/mydataset.json myotherproject:mydataset
    
  4. Para verificar as alterações no controle de acesso, insira o comando show novamente sem gravar as informações em um arquivo.

    bq show --format=prettyjson dataset
    

    ou

    bq show --format=prettyjson project_id:dataset
    

API

Chame datasets.patch e atualize a propriedade access no recurso do conjunto de dados.

Como datasets.update substitui todo o recurso do conjunto de dados, o método datasets.patch é recomendado para atualizar os controles de acesso.

Go

Antes de testar esta amostra, siga as instruções de configuração do Go 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 Go.

ds := client.Dataset(datasetID)
meta, err := ds.Metadata(ctx)
if err != nil {
	return err
}
// Append a new access control entry to the existing access list.
update := bigquery.DatasetMetadataToUpdate{
	Access: append(meta.Access, &bigquery.AccessEntry{
		Role:       bigquery.ReaderRole,
		EntityType: bigquery.UserEmailEntity,
		Entity:     "sample.bigquery.dev@gmail.com"},
	),
}

// Leverage the ETag for the update to assert there's been no modifications to the
// dataset since the metadata was originally read.
if _, err := ds.Update(ctx, update, meta.ETag); err != nil {
	return err
}

Java

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

Crie uma instância Dataset.Builder de uma instância Dataset atual com o método Dataset.toBuilder(). Configure o objeto de builder do conjunto de dados. Crie o conjunto de dados atualizado com o método Dataset.Builder.build() e chame o método Dataset.update() para enviar a atualização à API.

Configure os controles de acesso com o método Dataset.Builder.setAcl().

List<Acl> beforeAcls = dataset.getAcl();

// Make a copy of the ACLs so that they can be modified.
ArrayList<Acl> acls = new ArrayList<>(beforeAcls);
acls.add(Acl.of(new Acl.User("sample.bigquery.dev@gmail.com"), Acl.Role.READER));
DatasetInfo.Builder builder = dataset.toBuilder();
builder.setAcl(acls);

bigquery.update(builder.build());  // API request.

Python

Antes de testar esta amostra, siga as instruções de configuração do Python em 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 (em inglês).

Defina a propriedade dataset.access_entries com os controles de acesso de um conjunto de dados. Em seguida, chame a função client.update_dataset() para atualizar a propriedade.
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)

entry = bigquery.AccessEntry(
    role="READER",
    entity_type="userByEmail",
    entity_id="sample.bigquery.dev@gmail.com",
)

entries = list(dataset.access_entries)
entries.append(entry)
dataset.access_entries = entries

dataset = client.update_dataset(dataset, ["access_entries"])  # API request

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

Próximas etapas

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

Enviar comentários sobre…

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