Agendamento de consultas

Consola

1. Abra a página do BigQuery na Trusted Cloud consola.

   Aceda ao BigQuery

2. Execute a consulta que lhe interessa. Quando estiver satisfeito com os resultados, clique em Agendar.

   

3. As opções de consulta agendada são abertas no painel Nova consulta agendada.

   

4. No painel Nova consulta agendada:

   • Em Nome da consulta agendada, introduza um nome como My scheduled query. O nome da consulta agendada pode ser qualquer valor que possa identificar mais tarde se precisar de modificar a consulta.

   • Opcional: por predefinição, a consulta está agendada para ser executada diariamente. Pode alterar a programação predefinida selecionando uma opção no menu pendente Repete-se:

     • Para especificar uma frequência personalizada, selecione Personalizado e, de seguida, introduza uma especificação de tempo semelhante a Cron no campo Agendamento personalizado, por exemplo, every mon 23:30 ou every 6 hours. Para ver detalhes sobre programações válidas, incluindo intervalos personalizados, consulte o campo schedule em Recurso: TransferConfig.

       

     • Para alterar a hora de início, selecione a opção Começar à hora definida, introduza a data e a hora de início selecionadas.

     • Para especificar uma hora de fim, selecione a opção Hora de fim do agendamento, introduza a data e a hora de fim selecionadas.

     • Para guardar a consulta sem um agendamento, para que a possa executar a pedido mais tarde, selecione A pedido no menu Repetições.

5. Para uma consulta SELECT do GoogleSQL, selecione a opção Definir uma tabela de destino para os resultados da consulta e faculte as seguintes informações acerca do conjunto de dados de destino.

   • Para Nome do conjunto de dados, escolha o conjunto de dados de destino adequado.
   • Em Nome da tabela, introduza o nome da tabela de destino.

   • Para Preferência de escrita da tabela de destino, escolha Anexar à tabela para anexar dados à tabela ou Substituir tabela para substituir a tabela de destino.

     

6. Escolha o Tipo de localização.

   • Se ativou a tabela de destino para os resultados da consulta, pode selecionar Seleção automática de localização para selecionar automaticamente a localização onde a tabela de destino reside.

   • Caso contrário, escolha a localização onde se encontram os dados sobre os quais está a fazer a consulta.

7. Opções avançadas:

   • Opcional: CMEK Se usar chaves de encriptação geridas pelo cliente, pode selecionar Chave gerida pelo cliente em Opções avançadas. É apresentada uma lista das suas CMEKs disponíveis para escolher. Para ver informações sobre como as chaves de encriptação geridas pelo cliente (CMEKs) funcionam com o Serviço de transferência de dados do BigQuery, consulte o artigo Especifique a chave de encriptação com consultas agendadas.

   • Autentique como uma conta de serviço Se tiver uma ou mais contas de serviço associadas ao seu Trusted Cloud projeto, pode associar uma conta de serviço à sua consulta agendada em vez de usar as suas credenciais de utilizador. Em Credencial de consulta agendada, clique no menu para ver uma lista das suas contas de serviço disponíveis. É necessária uma conta de serviço se tiver sessão iniciada como uma identidade federada.

     

8. Configurações adicionais:

   • Opcional: selecione Enviar notificações por email para permitir notificações por email de falhas de execução de transferências.

   • Opcional: para o tópico do Pub/Sub, introduza o nome do tópico do Pub/Sub, por exemplo: projects/myproject/topics/mytopic.

     

9. Clique em Guardar.

bq

Opção 1: use o comando bq query.

Para criar uma consulta agendada, adicione as opções destination_table (ou target_dataset), --schedule e --display_name ao seu comando bq query.

bq query \
--display_name=name \
--destination_table=table \
--schedule=interval

Substitua o seguinte:

• name. O nome a apresentar da consulta agendada. O nome a apresentar pode ser qualquer valor que possa identificar mais tarde se precisar de modificar a consulta.
• table. A tabela de destino para os resultados da consulta.
  • --target_dataset é uma forma alternativa de atribuir um nome ao conjunto de dados de destino para os resultados da consulta, quando usado com consultas DDL e DML.
  • Use --destination_table ou --target_dataset, mas não ambos.
• interval. Quando usado com bq query, transforma uma consulta numa consulta agendada recorrente. É necessário um agendamento que indique a frequência com que a consulta deve ser executada. Para ver detalhes sobre horários válidos, incluindo intervalos personalizados, consulte o campo schedule em Recurso: TransferConfig. Exemplos:
  • --schedule='every 24 hours'
  • --schedule='every 3 hours'
  • --schedule='every monday 09:00'
  • --schedule='1st sunday of sep,oct,nov 00:00'

Sinalizadores opcionais:

• --project_id é o ID do seu projeto. Se --project_id não for especificado, é usado o projeto predefinido.

• --replace substitui a tabela de destino pelos resultados da consulta após cada execução da consulta agendada. Todos os dados existentes são apagados. Para tabelas não particionadas, o esquema também é apagado.

• --append_table anexa os resultados à tabela de destino.

• Para consultas DDL e DML, também pode fornecer o sinalizador --location para especificar uma região específica para processamento. Se --location não for especificado, é usada a localização Trusted Cloud by S3NS mais próxima.

Por exemplo, o comando seguinte cria uma consulta agendada com o nome My Scheduled Query usando a consulta SELECT 1 from mydataset.test. A tabela de destino é mytable no conjunto de dados mydataset. A consulta agendada é criada no projeto predefinido:

    bq query \
    --use_legacy_sql=false \
    --destination_table=mydataset.mytable \
    --display_name='My Scheduled Query' \
    --schedule='every 24 hours' \
    --replace=true \
    'SELECT
      1
    FROM
      mydataset.test'

Opção 2: use o comando bq mk.

As consultas agendadas são um tipo de transferência. Para agendar uma consulta, pode usar a ferramenta de linhas de comando bq para criar uma configuração de transferência.

As consultas têm de estar no dialeto StandardSQL para serem agendadas.

Introduza o comando bq mk e forneça as seguintes flags obrigatórias:

• --transfer_config
• --data_source
• --target_dataset (opcional para consultas LDD e DML)
• --display_name
• --params

Sinalizadores opcionais:

• --project_id é o ID do seu projeto. Se --project_id não for especificado, é usado o projeto predefinido.

• --schedule é a frequência com que quer que a consulta seja executada. Se --schedule não for especificado, o valor predefinido é "a cada 24 horas" com base na hora de criação.

• Para consultas DDL e DML, também pode fornecer o sinalizador --location para especificar uma região específica para processamento. Se --location não for especificado, é usada a localização Trusted Cloud by S3NS mais próxima.

• --service_account_name destina-se a autenticar a sua consulta agendada com uma conta de serviço em vez da sua conta de utilizador individual.

• --destination_kms_key especifica o ID de recurso da chave para a chave se usar uma chave de encriptação gerida pelo cliente (CMEK) para esta transferência. Para obter informações sobre como as CMEKs funcionam com o Serviço de transferência de dados do BigQuery, consulte o artigo Especifique a chave de encriptação com consultas agendadas.

bq mk \
--transfer_config \
--target_dataset=dataset \
--display_name=name \
--params='parameters' \
--data_source=data_source

Substitua o seguinte:

• dataset. O conjunto de dados de destino para a configuração de transferência.
  • Este parâmetro é opcional para consultas DDL e DML. É obrigatório para todas as outras consultas.
• name. O nome a apresentar da configuração de transferência. O nome a apresentar pode ser qualquer valor que possa identificar posteriormente se precisar de modificar a consulta.
• parameters. Contém os parâmetros da configuração de transferência criada no formato JSON. Por exemplo: --params='{"param":"param_value"}'.
  • Para uma consulta agendada, tem de fornecer o parâmetro query.
  • O parâmetro destination_table_name_template é o nome da tabela de destino.
    • Este parâmetro é opcional para consultas DDL e DML. É obrigatório para todas as outras consultas.
  • Para o parâmetro write_disposition, pode optar por WRITE_TRUNCATE truncar (substituir) a tabela de destino ou WRITE_APPEND para anexar os resultados da consulta à tabela de destino.
    • Este parâmetro é opcional para consultas DDL e DML. É obrigatório para todas as outras consultas.
• data_source. A origem de dados: scheduled_query.
• Opcional: a flag --service_account_name destina-se à autenticação com uma conta de serviço em vez de uma conta de utilizador individual.
• Opcional: o elemento --destination_kms_key especifica o ID do recurso da chave para a chave do Cloud KMS, por exemplo, projects/project_name/locations/us/keyRings/key_ring_name/cryptoKeys/key_name.

Por exemplo, o comando seguinte cria uma configuração de transferência de consultas agendada denominada My Scheduled Query através da consulta SELECT 1 from mydataset.test. A tabela de destino mytable é truncada para cada gravação, e o conjunto de dados de destino é mydataset. A consulta agendada é criada no projeto predefinido e autentica-se como uma conta de serviço:

bq mk \
--transfer_config \
--target_dataset=mydataset \
--display_name='My Scheduled Query' \
--params='{"query":"SELECT 1 from mydataset.test","destination_table_name_template":"mytable","write_disposition":"WRITE_TRUNCATE"}' \
--data_source=scheduled_query \
--service_account_name=abcdef-test-sa@abcdef-test.s3ns.iam.gserviceaccount.com

Na primeira vez que executar o comando, recebe uma mensagem semelhante à seguinte:

[URL omitted] Please copy and paste the above URL into your web browser and follow the instructions to retrieve an authentication code.

Siga as instruções na mensagem e cole o código de autenticação na linha de comandos.

API

Use o método projects.locations.transferConfigs.create e forneça uma instância do recurso TransferConfig.

Java

import com.google.api.gax.rpc.ApiException;
import com.google.cloud.bigquery.datatransfer.v1.CreateTransferConfigRequest;
import com.google.cloud.bigquery.datatransfer.v1.DataTransferServiceClient;
import com.google.cloud.bigquery.datatransfer.v1.ProjectName;
import com.google.cloud.bigquery.datatransfer.v1.TransferConfig;
import com.google.protobuf.Struct;
import com.google.protobuf.Value;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

// Sample to create a scheduled query
public class CreateScheduledQuery {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    final String projectId = "MY_PROJECT_ID";
    final String datasetId = "MY_DATASET_ID";
    final String query =
        "SELECT CURRENT_TIMESTAMP() as current_time, @run_time as intended_run_time, "
            + "@run_date as intended_run_date, 17 as some_integer";
    Map<String, Value> params = new HashMap<>();
    params.put("query", Value.newBuilder().setStringValue(query).build());
    params.put(
        "destination_table_name_template",
        Value.newBuilder().setStringValue("my_destination_table_{run_date}").build());
    params.put("write_disposition", Value.newBuilder().setStringValue("WRITE_TRUNCATE").build());
    params.put("partitioning_field", Value.newBuilder().build());
    TransferConfig transferConfig =
        TransferConfig.newBuilder()
            .setDestinationDatasetId(datasetId)
            .setDisplayName("Your Scheduled Query Name")
            .setDataSourceId("scheduled_query")
            .setParams(Struct.newBuilder().putAllFields(params).build())
            .setSchedule("every 24 hours")
            .build();
    createScheduledQuery(projectId, transferConfig);
  }

  public static void createScheduledQuery(String projectId, TransferConfig transferConfig)
      throws IOException {
    try (DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.create()) {
      ProjectName parent = ProjectName.of(projectId);
      CreateTransferConfigRequest request =
          CreateTransferConfigRequest.newBuilder()
              .setParent(parent.toString())
              .setTransferConfig(transferConfig)
              .build();
      TransferConfig config = dataTransferServiceClient.createTransferConfig(request);
      System.out.println("\nScheduled query created successfully :" + config.getName());
    } catch (ApiException ex) {
      System.out.print("\nScheduled query was not created." + ex.toString());
    }
  }
}

Python

from google.cloud import bigquery_datatransfer

transfer_client = bigquery_datatransfer.DataTransferServiceClient()

# The project where the query job runs is the same as the project
# containing the destination dataset.
project_id = "your-project-id"
dataset_id = "your_dataset_id"

# This service account will be used to execute the scheduled queries. Omit
# this request parameter to run the query as the user with the credentials
# associated with this client.
service_account_name = "abcdef-test-sa@abcdef-test.iam.gserviceaccount.com"

# Use standard SQL syntax for the query.
query_string = """
SELECT
  CURRENT_TIMESTAMP() as current_time,
  @run_time as intended_run_time,
  @run_date as intended_run_date,
  17 as some_integer
"""

parent = transfer_client.common_project_path(project_id)

transfer_config = bigquery_datatransfer.TransferConfig(
    destination_dataset_id=dataset_id,
    display_name="Your Scheduled Query Name",
    data_source_id="scheduled_query",
    params={
        "query": query_string,
        "destination_table_name_template": "your_table_{run_date}",
        "write_disposition": "WRITE_TRUNCATE",
        "partitioning_field": "",
    },
    schedule="every 24 hours",
)

transfer_config = transfer_client.create_transfer_config(
    bigquery_datatransfer.CreateTransferConfigRequest(
        parent=parent,
        transfer_config=transfer_config,
        service_account_name=service_account_name,
    )
)

print("Created scheduled query '{}'".format(transfer_config.name))

Java

import com.google.api.gax.rpc.ApiException;
import com.google.cloud.bigquery.datatransfer.v1.CreateTransferConfigRequest;
import com.google.cloud.bigquery.datatransfer.v1.DataTransferServiceClient;
import com.google.cloud.bigquery.datatransfer.v1.ProjectName;
import com.google.cloud.bigquery.datatransfer.v1.TransferConfig;
import com.google.protobuf.Struct;
import com.google.protobuf.Value;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

// Sample to create a scheduled query with service account
public class CreateScheduledQueryWithServiceAccount {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    final String projectId = "MY_PROJECT_ID";
    final String datasetId = "MY_DATASET_ID";
    final String serviceAccount = "MY_SERVICE_ACCOUNT";
    final String query =
        "SELECT CURRENT_TIMESTAMP() as current_time, @run_time as intended_run_time, "
            + "@run_date as intended_run_date, 17 as some_integer";
    Map<String, Value> params = new HashMap<>();
    params.put("query", Value.newBuilder().setStringValue(query).build());
    params.put(
        "destination_table_name_template",
        Value.newBuilder().setStringValue("my_destination_table_{run_date}").build());
    params.put("write_disposition", Value.newBuilder().setStringValue("WRITE_TRUNCATE").build());
    params.put("partitioning_field", Value.newBuilder().build());
    TransferConfig transferConfig =
        TransferConfig.newBuilder()
            .setDestinationDatasetId(datasetId)
            .setDisplayName("Your Scheduled Query Name")
            .setDataSourceId("scheduled_query")
            .setParams(Struct.newBuilder().putAllFields(params).build())
            .setSchedule("every 24 hours")
            .build();
    createScheduledQueryWithServiceAccount(projectId, transferConfig, serviceAccount);
  }

  public static void createScheduledQueryWithServiceAccount(
      String projectId, TransferConfig transferConfig, String serviceAccount) throws IOException {
    try (DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.create()) {
      ProjectName parent = ProjectName.of(projectId);
      CreateTransferConfigRequest request =
          CreateTransferConfigRequest.newBuilder()
              .setParent(parent.toString())
              .setTransferConfig(transferConfig)
              .setServiceAccountName(serviceAccount)
              .build();
      TransferConfig config = dataTransferServiceClient.createTransferConfig(request);
      System.out.println(
          "\nScheduled query with service account created successfully :" + config.getName());
    } catch (ApiException ex) {
      System.out.print("\nScheduled query with service account was not created." + ex.toString());
    }
  }
}

Python

from google.cloud import bigquery_datatransfer

transfer_client = bigquery_datatransfer.DataTransferServiceClient()

# The project where the query job runs is the same as the project
# containing the destination dataset.
project_id = "your-project-id"
dataset_id = "your_dataset_id"

# This service account will be used to execute the scheduled queries. Omit
# this request parameter to run the query as the user with the credentials
# associated with this client.
service_account_name = "abcdef-test-sa@abcdef-test.iam.gserviceaccount.com"

# Use standard SQL syntax for the query.
query_string = """
SELECT
  CURRENT_TIMESTAMP() as current_time,
  @run_time as intended_run_time,
  @run_date as intended_run_date,
  17 as some_integer
"""

parent = transfer_client.common_project_path(project_id)

transfer_config = bigquery_datatransfer.TransferConfig(
    destination_dataset_id=dataset_id,
    display_name="Your Scheduled Query Name",
    data_source_id="scheduled_query",
    params={
        "query": query_string,
        "destination_table_name_template": "your_table_{run_date}",
        "write_disposition": "WRITE_TRUNCATE",
        "partitioning_field": "",
    },
    schedule="every 24 hours",
)

transfer_config = transfer_client.create_transfer_config(
    bigquery_datatransfer.CreateTransferConfigRequest(
        parent=parent,
        transfer_config=transfer_config,
        service_account_name=service_account_name,
    )
)

print("Created scheduled query '{}'".format(transfer_config.name))

Consola

Para ver o estado das suas consultas agendadas, no menu de navegação, clique em Agendamento e filtre por Consulta agendada. Clique numa consulta agendada para ver mais detalhes sobre a mesma.

bq

As consultas agendadas são um tipo de transferência. Para mostrar os detalhes de uma consulta agendada, pode usar primeiro a ferramenta de linhas de comando bq para listar as suas configurações de transferência.

Introduza o comando bq ls e forneça a flag de transferência --transfer_config. Os seguintes indicadores também são obrigatórios:

• --transfer_location

Por exemplo:

bq ls \
--transfer_config \
--transfer_location=us

Para mostrar os detalhes de uma única consulta agendada, introduza o comando bq show e forneça o transfer_path para essa consulta agendada ou configuração de transferência.

Por exemplo:

bq show \
--transfer_config \
projects/862514376110/locations/us/transferConfigs/5dd12f26-0000-262f-bc38-089e0820fe38

API

Use o método projects.locations.transferConfigs.list e forneça uma instância do recurso TransferConfig.

Java

import com.google.api.gax.rpc.ApiException;
import com.google.cloud.bigquery.datatransfer.v1.DataTransferServiceClient;
import com.google.cloud.bigquery.datatransfer.v1.ListTransferConfigsRequest;
import com.google.cloud.bigquery.datatransfer.v1.ProjectName;
import java.io.IOException;

// Sample to get list of transfer config
public class ListTransferConfigs {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    final String projectId = "MY_PROJECT_ID";
    listTransferConfigs(projectId);
  }

  public static void listTransferConfigs(String projectId) throws IOException {
    try (DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.create()) {
      ProjectName parent = ProjectName.of(projectId);
      ListTransferConfigsRequest request =
          ListTransferConfigsRequest.newBuilder().setParent(parent.toString()).build();
      dataTransferServiceClient
          .listTransferConfigs(request)
          .iterateAll()
          .forEach(config -> System.out.print("Success! Config ID :" + config.getName() + "\n"));
    } catch (ApiException ex) {
      System.out.println("Config list not found due to error." + ex.toString());
    }
  }
}

Python

from google.cloud import bigquery_datatransfer

transfer_client = bigquery_datatransfer.DataTransferServiceClient()

project_id = "my-project"
parent = transfer_client.common_project_path(project_id)

configs = transfer_client.list_transfer_configs(parent=parent)
print("Got the following configs:")
for config in configs:
    print(f"\tID: {config.name}, Schedule: {config.schedule}")

Consola

Para atualizar uma consulta agendada, siga estes passos:

1. No menu de navegação, clique em Consultas agendadas ou Agendamento.
2. Na lista de consultas agendadas, clique no nome da consulta que quer alterar.
3. Na página Detalhes da consulta agendada apresentada, clique em Editar.
4. Opcional: altere o texto da consulta no painel de edição de consultas.
5. Clique em Programar consulta e, de seguida, selecione Atualizar consulta programada.
6. Opcional: altere quaisquer outras opções de programação para a consulta.
7. Clique em Atualizar.

bq

As consultas agendadas são um tipo de transferência. Para atualizar uma consulta agendada, pode usar a ferramenta de linhas de comando bq para fazer uma configuração de transferência.

Introduza o comando bq update com a flag --transfer_config necessária.

Sinalizadores opcionais:

• --project_id é o ID do seu projeto. Se --project_id não for especificado, é usado o projeto predefinido.

• --schedule é a frequência com que quer que a consulta seja executada. Se --schedule não for especificado, o valor predefinido é "a cada 24 horas" com base na hora de criação.

• --service_account_name só tem efeito se --update_credentials também estiver definido. Para mais informações, consulte o artigo Atualize as credenciais de consultas agendadas.

• --target_dataset (opcional para consultas LDD e LMD) é uma forma alternativa de atribuir um nome ao conjunto de dados de destino para os resultados da consulta, quando usado com consultas LDD e LMD.

• --display_name é o nome da consulta agendada.

• --params os parâmetros da configuração de transferência criada no formato JSON. Por exemplo: --params='{"param":"param_value"}'.

• --destination_kms_key especifica o ID de recurso da chave para a chave do Cloud KMS se usar uma chave de encriptação gerida pelo cliente (CMEK) para esta transferência. Para obter informações sobre como as chaves de encriptação geridas pelo cliente (CMEK) funcionam com o Serviço de transferência de dados do BigQuery, consulte o artigo Especifique a chave de encriptação com consultas agendadas.

bq update \
--target_dataset=dataset \
--display_name=name \
--params='parameters'
--transfer_config \
RESOURCE_NAME

Substitua o seguinte:

• dataset. O conjunto de dados de destino para a configuração de transferência. Este parâmetro é opcional para consultas DDL e DML. É necessário para todas as outras consultas.
• name. O nome a apresentar da configuração de transferência. O nome a apresentar pode ser qualquer valor que possa identificar posteriormente se precisar de modificar a consulta.
• parameters. Contém os parâmetros da configuração de transferência criada no formato JSON. Por exemplo: --params='{"param":"param_value"}'.
  • Para uma consulta agendada, tem de fornecer o parâmetro query.
  • O parâmetro destination_table_name_template é o nome da tabela de destino. Este parâmetro é opcional para consultas DDL e DML. É obrigatório para todas as outras consultas.
  • Para o parâmetro write_disposition, pode optar por WRITE_TRUNCATE truncar (substituir) a tabela de destino ou WRITE_APPEND para anexar os resultados da consulta à tabela de destino. Este parâmetro é opcional para consultas de LDD e LMD. É obrigatório para todas as outras consultas.
• Opcional: o elemento --destination_kms_key especifica o ID do recurso da chave para a chave do Cloud KMS, por exemplo, projects/project_name/locations/us/keyRings/key_ring_name/cryptoKeys/key_name.
• RESOURCE_NAME: o nome do recurso da transferência (também conhecido como configuração de transferência). Se não souber o nome do recurso da transferência, encontre-o com: bq ls --transfer_config --transfer_location=location.

Por exemplo, o comando seguinte atualiza uma configuração de transferência de consultas agendada denominada My Scheduled Query através da consulta SELECT 1 from mydataset.test. A tabela de destino mytable é truncada para cada gravação e o conjunto de dados de destino é mydataset:

bq update \
--target_dataset=mydataset \
--display_name='My Scheduled Query' \
--params='{"query":"SELECT 1 from mydataset.test","destination_table_name_template":"mytable","write_disposition":"WRITE_TRUNCATE"}'
--transfer_config \
projects/myproject/locations/us/transferConfigs/1234a123-1234-1a23-1be9-12ab3c456de7

API

Use o método projects.transferConfigs.patch e forneça o nome do recurso da transferência através do parâmetro transferConfig.name. Se não souber o nome do recurso da transferência, use o comando bq ls --transfer_config --transfer_location=location para listar todas as transferências ou chame o método projects.locations.transferConfigs.list e forneça o ID do projeto através do parâmetro parent.

Java

import com.google.api.gax.rpc.ApiException;
import com.google.cloud.bigquery.datatransfer.v1.DataTransferServiceClient;
import com.google.cloud.bigquery.datatransfer.v1.TransferConfig;
import com.google.cloud.bigquery.datatransfer.v1.UpdateTransferConfigRequest;
import com.google.protobuf.FieldMask;
import com.google.protobuf.util.FieldMaskUtil;
import java.io.IOException;

// Sample to update transfer config.
public class UpdateTransferConfig {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String configId = "MY_CONFIG_ID";
    TransferConfig transferConfig =
        TransferConfig.newBuilder()
            .setName(configId)
            .setDisplayName("UPDATED_DISPLAY_NAME")
            .build();
    FieldMask updateMask = FieldMaskUtil.fromString("display_name");
    updateTransferConfig(transferConfig, updateMask);
  }

  public static void updateTransferConfig(TransferConfig transferConfig, FieldMask updateMask)
      throws IOException {
    try (DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.create()) {
      UpdateTransferConfigRequest request =
          UpdateTransferConfigRequest.newBuilder()
              .setTransferConfig(transferConfig)
              .setUpdateMask(updateMask)
              .build();
      TransferConfig updateConfig = dataTransferServiceClient.updateTransferConfig(request);
      System.out.println("Transfer config updated successfully :" + updateConfig.getDisplayName());
    } catch (ApiException ex) {
      System.out.print("Transfer config was not updated." + ex.toString());
    }
  }
}

Python

from google.cloud import bigquery_datatransfer
from google.protobuf import field_mask_pb2

transfer_client = bigquery_datatransfer.DataTransferServiceClient()

transfer_config_name = "projects/1234/locations/us/transferConfigs/abcd"
new_display_name = "My Transfer Config"

transfer_config = bigquery_datatransfer.TransferConfig(name=transfer_config_name)
transfer_config.display_name = new_display_name

transfer_config = transfer_client.update_transfer_config(
    {
        "transfer_config": transfer_config,
        "update_mask": field_mask_pb2.FieldMask(paths=["display_name"]),
    }
)

print(f"Updated config: '{transfer_config.name}'")
print(f"New display name: '{transfer_config.display_name}'")

Consola

Para atualizar as credenciais existentes numa consulta agendada:

1. Encontre e veja o estado de uma consulta agendada.

2. Clique no botão MAIS e selecione Atualizar credenciais.

   

3. Aguarde 10 a 20 minutos para que a alteração entre em vigor. Pode ter de limpar a cache do navegador.

bq

As consultas agendadas são um tipo de transferência. Para atualizar as credenciais de uma consulta agendada, pode usar a ferramenta de linha de comandos bq para atualizar a configuração de transferência.

Introduza o comando bq update e forneça a flag de transferência --transfer_config. Os seguintes indicadores também são obrigatórios:

• --update_credentials

Sinalizador opcional:

• --service_account_name destina-se a autenticar a sua consulta agendada com uma conta de serviço em vez da sua conta de utilizador individual.

Por exemplo, o comando seguinte atualiza uma configuração de transferência de consultas agendada para autenticar como uma conta de serviço:

bq update \
--update_credentials \
--service_account_name=abcdef-test-sa@abcdef-test.s3ns.iam.gserviceaccount.com \
--transfer_config \
projects/myproject/locations/us/transferConfigs/1234a123-1234-1a23-1be9-12ab3c456de7

Java

import com.google.api.gax.rpc.ApiException;
import com.google.cloud.bigquery.datatransfer.v1.DataTransferServiceClient;
import com.google.cloud.bigquery.datatransfer.v1.TransferConfig;
import com.google.cloud.bigquery.datatransfer.v1.UpdateTransferConfigRequest;
import com.google.protobuf.FieldMask;
import com.google.protobuf.util.FieldMaskUtil;
import java.io.IOException;

// Sample to update credentials in transfer config.
public class UpdateCredentials {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String configId = "MY_CONFIG_ID";
    String serviceAccount = "MY_SERVICE_ACCOUNT";
    TransferConfig transferConfig = TransferConfig.newBuilder().setName(configId).build();
    FieldMask updateMask = FieldMaskUtil.fromString("service_account_name");
    updateCredentials(transferConfig, serviceAccount, updateMask);
  }

  public static void updateCredentials(
      TransferConfig transferConfig, String serviceAccount, FieldMask updateMask)
      throws IOException {
    try (DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.create()) {
      UpdateTransferConfigRequest request =
          UpdateTransferConfigRequest.newBuilder()
              .setTransferConfig(transferConfig)
              .setUpdateMask(updateMask)
              .setServiceAccountName(serviceAccount)
              .build();
      dataTransferServiceClient.updateTransferConfig(request);
      System.out.println("Credentials updated successfully");
    } catch (ApiException ex) {
      System.out.print("Credentials was not updated." + ex.toString());
    }
  }
}

Python

from google.cloud import bigquery_datatransfer
from google.protobuf import field_mask_pb2

transfer_client = bigquery_datatransfer.DataTransferServiceClient()

service_account_name = "abcdef-test-sa@abcdef-test.iam.gserviceaccount.com"
transfer_config_name = "projects/1234/locations/us/transferConfigs/abcd"

transfer_config = bigquery_datatransfer.TransferConfig(name=transfer_config_name)

transfer_config = transfer_client.update_transfer_config(
    {
        "transfer_config": transfer_config,
        "update_mask": field_mask_pb2.FieldMask(paths=["service_account_name"]),
        "service_account_name": service_account_name,
    }
)

print("Updated config: '{}'".format(transfer_config.name))

Consola

Depois de clicar em Agendar para guardar a consulta agendada, pode clicar no botão Consultas agendadas para ver a lista de consultas agendadas. Clique em qualquer nome a apresentar para ver os detalhes da programação da consulta. Na parte superior direita da página, clique em Agendar preenchimento para especificar um intervalo de datas do histórico.

Os tempos de execução escolhidos estão todos dentro do intervalo selecionado, incluindo a primeira data e excluindo a última data.

Exemplo 1

A sua consulta agendada está definida para ser executada às every day 09:00, hora do Pacífico. Faltam-lhe dados de 1, 2 e 3 de janeiro. Escolha o seguinte intervalo de datas histórico:

Start Time = 1/1/19
End Time = 1/4/19

A sua consulta é executada com os parâmetros run_date e run_time que correspondem aos seguintes horários:

• 1/1/19 09:00 Hora do Pacífico
• 02/01/19 às 09:00 Hora do Pacífico
• 03/01/19 às 09:00, Hora do Pacífico

Exemplo 2

A sua consulta agendada está definida para ser executada às every day 23:00, hora do Pacífico. Faltam-lhe dados de 1, 2 e 3 de janeiro. Escolha os seguintes intervalos de datas históricos (são escolhidas datas posteriores porque o UTC tem uma data diferente às 23:00, hora do Pacífico):

Start Time = 1/2/19
End Time = 1/5/19

A sua consulta é executada com os parâmetros run_date e run_time que correspondem aos seguintes horários:

• 02/01/19 às 06:00 UTC ou 01/01/2019 às 23:00, hora do Pacífico
• 03/01/19 às 06:00 UTC ou 02/01/2019 às 23:00 Hora do Pacífico
• 04/01/19 às 06:00 UTC ou 03/01/2019 às 23:00 Hora do Pacífico

Depois de configurar as execuções manuais, atualize a página para as ver na lista de execuções.

bq

Para executar manualmente a consulta num intervalo de datas do histórico:

Introduza o comando bq mk e forneça a flag de execução da transferência --transfer_run. Os seguintes indicadores também são obrigatórios:

• --start_time
• --end_time

bq mk \
--transfer_run \
--start_time='start_time' \
--end_time='end_time' \
resource_name

Substitua o seguinte:

• start_time e end_time selecionados. Datas/horas que terminam em Z ou contêm um desvio de fuso horário válido. Exemplos:
  • 2017-08-19T12:11:35.00Z
  • 2017-05-25T00:00:00+00:00
• resource_name. O nome do recurso da consulta agendada (ou da transferência). O nome do recurso também é conhecido como a configuração de transferência.

Por exemplo, o comando seguinte agenda um preenchimento para o recurso de consulta agendada (ou configuração de transferência): projects/myproject/locations/us/transferConfigs/1234a123-1234-1a23-1be9-12ab3c456de7.

  bq mk \
  --transfer_run \
  --start_time 2017-05-25T00:00:00Z \
  --end_time 2017-05-25T00:00:00Z \
  projects/myproject/locations/us/transferConfigs/1234a123-1234-1a23-1be9-12ab3c456de7

Para mais informações, consulte bq mk --transfer_run.

API

Use o método projects.locations.transferConfigs.scheduleRun e forneça um caminho do recurso TransferConfig.

Java

import com.google.api.gax.rpc.ApiException;
import com.google.cloud.bigquery.datatransfer.v1.DataTransferServiceClient;
import com.google.cloud.bigquery.datatransfer.v1.ScheduleTransferRunsRequest;
import com.google.cloud.bigquery.datatransfer.v1.ScheduleTransferRunsResponse;
import com.google.protobuf.Timestamp;
import java.io.IOException;
import org.threeten.bp.Clock;
import org.threeten.bp.Instant;
import org.threeten.bp.temporal.ChronoUnit;

// Sample to run schedule back fill for transfer config
public class ScheduleBackFill {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String configId = "MY_CONFIG_ID";
    Clock clock = Clock.systemDefaultZone();
    Instant instant = clock.instant();
    Timestamp startTime =
        Timestamp.newBuilder()
            .setSeconds(instant.minus(5, ChronoUnit.DAYS).getEpochSecond())
            .setNanos(instant.minus(5, ChronoUnit.DAYS).getNano())
            .build();
    Timestamp endTime =
        Timestamp.newBuilder()
            .setSeconds(instant.minus(2, ChronoUnit.DAYS).getEpochSecond())
            .setNanos(instant.minus(2, ChronoUnit.DAYS).getNano())
            .build();
    scheduleBackFill(configId, startTime, endTime);
  }

  public static void scheduleBackFill(String configId, Timestamp startTime, Timestamp endTime)
      throws IOException {
    try (DataTransferServiceClient client = DataTransferServiceClient.create()) {
      ScheduleTransferRunsRequest request =
          ScheduleTransferRunsRequest.newBuilder()
              .setParent(configId)
              .setStartTime(startTime)
              .setEndTime(endTime)
              .build();
      ScheduleTransferRunsResponse response = client.scheduleTransferRuns(request);
      System.out.println("Schedule backfill run successfully :" + response.getRunsCount());
    } catch (ApiException ex) {
      System.out.print("Schedule backfill was not run." + ex.toString());
    }
  }
}

Python

import datetime

from google.cloud.bigquery_datatransfer_v1 import (
    DataTransferServiceClient,
    StartManualTransferRunsRequest,
)

# Create a client object
client = DataTransferServiceClient()

# Replace with your transfer configuration name
transfer_config_name = "projects/1234/locations/us/transferConfigs/abcd"
now = datetime.datetime.now(datetime.timezone.utc)
start_time = now - datetime.timedelta(days=5)
end_time = now - datetime.timedelta(days=2)

# Some data sources, such as scheduled_query only support daily run.
# Truncate start_time and end_time to midnight time (00:00AM UTC).
start_time = datetime.datetime(
    start_time.year, start_time.month, start_time.day, tzinfo=datetime.timezone.utc
)
end_time = datetime.datetime(
    end_time.year, end_time.month, end_time.day, tzinfo=datetime.timezone.utc
)

requested_time_range = StartManualTransferRunsRequest.TimeRange(
    start_time=start_time,
    end_time=end_time,
)

# Initialize request argument(s)
request = StartManualTransferRunsRequest(
    parent=transfer_config_name,
    requested_time_range=requested_time_range,
)

# Make the request
response = client.start_manual_transfer_runs(request=request)

# Handle the response
print("Started manual transfer runs:")
for run in response.runs:
    print(f"backfill: {run.run_time} run: {run.name}")

Consola

Para eliminar uma consulta agendada na página Consultas agendadas da Trusted Cloud consola, faça o seguinte:

1. No menu de navegação, clique em Consultas agendadas.
2. Na lista de consultas agendadas, clique no nome da consulta agendada que quer eliminar.

3. Na página Detalhes da consulta agendada, clique em Eliminar.

   

Em alternativa, pode eliminar uma consulta agendada na página Agendamento da consola: Trusted Cloud

1. No menu de navegação, clique em Agendamento.
2. Na lista de consultas agendadas, clique no menu more_vert Ações da consulta agendada que quer eliminar.

3. Selecione Eliminar.

   

Java

import com.google.api.gax.rpc.ApiException;
import com.google.cloud.bigquery.datatransfer.v1.DataTransferServiceClient;
import com.google.cloud.bigquery.datatransfer.v1.DeleteTransferConfigRequest;
import java.io.IOException;

// Sample to delete a transfer config
public class DeleteTransferConfig {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // i.e projects/{project_id}/transferConfigs/{config_id}` or
    // `projects/{project_id}/locations/{location_id}/transferConfigs/{config_id}`
    String configId = "MY_CONFIG_ID";
    deleteTransferConfig(configId);
  }

  public static void deleteTransferConfig(String configId) throws IOException {
    try (DataTransferServiceClient dataTransferServiceClient = DataTransferServiceClient.create()) {
      DeleteTransferConfigRequest request =
          DeleteTransferConfigRequest.newBuilder().setName(configId).build();
      dataTransferServiceClient.deleteTransferConfig(request);
      System.out.println("Transfer config deleted successfully");
    } catch (ApiException ex) {
      System.out.println("Transfer config was not deleted." + ex.toString());
    }
  }
}

Python

import google.api_core.exceptions
from google.cloud import bigquery_datatransfer

transfer_client = bigquery_datatransfer.DataTransferServiceClient()

transfer_config_name = "projects/1234/locations/us/transferConfigs/abcd"
try:
    transfer_client.delete_transfer_config(name=transfer_config_name)
except google.api_core.exceptions.NotFound:
    print("Transfer config not found.")
else:
    print(f"Deleted transfer config: {transfer_config_name}")