Programar consultas

Consola

1. Abre la página de BigQuery en la Google Cloud consola.

   Ir a BigQuery

2. Ejecuta la consulta que te interese. Cuando estés conforme con los resultados, haz clic en Programar.

   

3. Las opciones de la consulta programada se abren en el panel Nueva consulta programada.

   

4. En el panel Nueva consulta programada:

   • En Nombre de la consulta programada, escriba un nombre como My scheduled query. El nombre de la consulta programada puede ser cualquier valor que puedas identificar más adelante si necesitas modificar la consulta.

   • Opcional: De forma predeterminada, la consulta se programa para ejecutarse diariamente. Para cambiar la programación predeterminada, selecciona una opción en el menú desplegable Se repite:

     • Para especificar una frecuencia personalizada, selecciona Personalizar y, a continuación, introduce una especificación de tiempo similar a Cron en el campo Programación personalizada. Por ejemplo, every mon 23:30 o every 6 hours. Para obtener información sobre las programaciones válidas, incluidos los intervalos personalizados, consulta el campo schedule en Recurso: TransferConfig.

       

     • Para cambiar la hora de inicio, selecciona la opción Empezar a una hora determinada y introduce la fecha y la hora de inicio seleccionadas.

     • Para especificar una hora de finalización, selecciona la opción Programar hora de finalización e introduce la fecha y la hora de finalización seleccionadas.

     • Para guardar la consulta sin una programación y poder ejecutarla cuando quieras, selecciona Bajo demanda en el menú Se repite.

5. En el caso de una consulta de GoogleSQL SELECT, selecciona la opción Definir una tabla de destino para los resultados de la consulta y proporciona la siguiente información sobre el conjunto de datos de destino.

   • En Nombre del conjunto de datos, elige el conjunto de datos de destino adecuado.
   • En Table name (Nombre de la tabla), introduce el nombre de la tabla de destino.

   • En Preferencia de escritura de la tabla de destino, elija una de las siguientes opciones: Añadir a la tabla para añadir datos a la tabla Sobrescribir tabla para sobrescribir la tabla de destino.

     

6. Elige el Tipo de ubicación.

   • Si ha habilitado la tabla de destino para los resultados de las consultas, puede seleccionar Selección automática de la ubicación para elegir automáticamente la ubicación en la que se encuentra la tabla de destino.

   • De lo contrario, elija la ubicación de los datos que se van a consultar.

7. Opciones avanzadas:

   • Opcional: CMEK Si usas claves de cifrado gestionadas por el cliente, puedes seleccionar Clave gestionada por el cliente en Opciones avanzadas. Aparecerá una lista de las CMEKs disponibles para que elijas la que quieras. Para obtener información sobre cómo funcionan las claves de cifrado gestionadas por el cliente (CMEKs) con BigQuery Data Transfer Service, consulta Especificar una clave de cifrado con consultas programadas.

   • Autenticarse como cuenta de servicio Si tienes una o varias cuentas de servicio asociadas a tu proyecto de Google Cloud , puedes asociar una cuenta de servicio a tu consulta programada en lugar de usar tus credenciales de usuario. En Credencial de consulta programada, haz clic en el menú para ver una lista de las cuentas de servicio disponibles. Se necesita una cuenta de servicio si has iniciado sesión como identidad federada.

     

8. Configuraciones adicionales:

   • Opcional: Marca Enviar notificaciones por correo para permitir que se envíen notificaciones por correo cuando se produzcan fallos en las transferencias.

   • Opcional: En Tema de Pub/Sub, introduce el nombre del tema de Pub/Sub. Por ejemplo: projects/myproject/topics/mytopic.

     

9. Haz clic en Guardar.

bq

Opción 1: Usa el comando bq query.

Para crear una consulta programada, añade las opciones destination_table (o target_dataset), --schedule y --display_name al comando bq query.

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

Haz los cambios siguientes:

• name. Nombre visible de la consulta programada. El nombre visible puede ser cualquier valor que puedas identificar más adelante si necesitas modificar la consulta.
• table. La tabla de destino de los resultados de la consulta.
  • --target_dataset es una forma alternativa de asignar un nombre al conjunto de datos de destino de los resultados de la consulta cuando se usa con consultas DDL y DML.
  • Usa --destination_table o --target_dataset, pero no ambos.
• interval. Cuando se usa con bq query, convierte una consulta en una consulta programada periódica. Es necesario programar la frecuencia con la que se debe ejecutar la consulta. Para obtener información sobre las programaciones válidas, incluidos los intervalos personalizados, consulta el campo schedule de Recurso: TransferConfig. Ejemplos:
  • --schedule='every 24 hours'
  • --schedule='every 3 hours'
  • --schedule='every monday 09:00'
  • --schedule='1st sunday of sep,oct,nov 00:00'

Marcas posibles

• --project_id es el ID del proyecto. Si no se especifica --project_id, se usa el proyecto predeterminado.

• --replace sobrescribe la tabla de destino con los resultados de la consulta después de cada ejecución de la consulta programada. Se borrarán todos los datos. En el caso de las tablas sin particiones, el esquema también se borra.

• --append_table añade los resultados a la tabla de destino.

• En el caso de las consultas DDL y DML, también puedes proporcionar la marca --location para especificar una región concreta para el procesamiento. Si no se especifica --location, se usa la ubicación Google Cloud más cercana.

Por ejemplo, el siguiente comando crea una consulta programada llamada My Scheduled Query con la consulta SELECT 1 from mydataset.test. La tabla de destino es mytable en el conjunto de datos mydataset. La consulta programada se crea en el proyecto predeterminado:

    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'

Opción 2: Usa el comando bq mk.

Las consultas programadas son un tipo de transferencia. Para programar una consulta, puedes usar la herramienta de línea de comandos bq para crear una configuración de transferencia.

Las consultas deben estar en dialecto Standard SQL para poder programarse.

Introduce el comando bq mk y proporciona las siguientes marcas obligatorias:

• --transfer_config
• --data_source
• --target_dataset (opcional para las consultas DDL y DML)
• --display_name
• --params

Marcas posibles

• --project_id es el ID del proyecto. Si no se especifica --project_id, se usa el proyecto predeterminado.

• --schedule es la frecuencia con la que quieres que se ejecute la consulta. Si no se especifica --schedule, el valor predeterminado es "cada 24 horas" según la hora de creación.

• En el caso de las consultas DDL y DML, también puedes proporcionar la marca --location para especificar una región concreta para el procesamiento. Si no se especifica --location, se usa la ubicación Google Cloud más cercana.

• --service_account_name se usa para autenticar tu consulta programada con una cuenta de servicio en lugar de con tu cuenta de usuario.

• --destination_kms_key especifica el ID de recurso de la clave de la clave si usas una clave de cifrado gestionada por el cliente (CMEK) para esta transferencia. Para obtener información sobre cómo funcionan las CMEKs con BigQuery Data Transfer Service, consulta Especificar una clave de cifrado con consultas programadas.

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

Haz los cambios siguientes:

• dataset. El conjunto de datos de destino de la configuración de la transferencia.
  • Este parámetro es opcional para las consultas de DDL y DML. Es obligatorio para todas las demás consultas.
• name. Nombre visible de la configuración de transferencia. El nombre visible puede ser cualquier valor que pueda identificar más adelante si necesita modificar la consulta.
• parameters. Contiene los parámetros de la configuración de transferencia creada en formato JSON. Por ejemplo: --params='{"param":"param_value"}'.
  • En el caso de las consultas programadas, debe proporcionar el parámetro query.
  • El parámetro destination_table_name_template es el nombre de la tabla de destino.
    • Este parámetro es opcional para las consultas de DDL y DML. Es obligatorio para todas las demás consultas.
  • En el parámetro write_disposition, puede elegir WRITE_TRUNCATE para truncar (sobrescribir) la tabla de destino o WRITE_APPEND para añadir los resultados de la consulta a la tabla de destino.
    • Este parámetro es opcional para las consultas de DDL y DML. Es obligatorio para todas las demás consultas.
• data_source. La fuente de datos: scheduled_query.
• Opcional: La marca --service_account_name se usa para autenticar con una cuenta de servicio en lugar de con una cuenta de usuario individual.
• Opcional: --destination_kms_key especifica el ID de recurso de la clave de la clave de Cloud KMS. Por ejemplo, projects/project_name/locations/us/keyRings/key_ring_name/cryptoKeys/key_name.

Por ejemplo, el siguiente comando crea una configuración de transferencia de consulta programada llamada My Scheduled Query con la consulta SELECT 1 from mydataset.test. La tabla de destino mytable se trunca en cada escritura y el conjunto de datos de destino es mydataset. La consulta programada se crea en el proyecto predeterminado y se autentica como cuenta de servicio:

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.iam.gserviceaccount.com

La primera vez que ejecutes el comando, recibirás un mensaje como el siguiente:

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

Sigue las instrucciones del mensaje y pega el código de autenticación en la línea de comandos.

API

Usa el método projects.locations.transferConfigs.create y proporciona una instancia del 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 el estado de las consultas programadas, en el menú de navegación, haga clic en Programación y filtre por Consulta programada. Haz clic en una consulta programada para obtener más información sobre ella.

bq

Las consultas programadas son un tipo de transferencia. Para ver los detalles de una consulta programada, primero puedes usar la herramienta de línea de comandos bq para enumerar tus configuraciones de transferencia.

Introduce el comando bq ls y proporciona la marca de transferencia --transfer_config. También se necesitan las siguientes marcas:

• --transfer_location

Por ejemplo:

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

Para mostrar los detalles de una sola consulta programada, introduce el comando bq show y proporciona el transfer_path de esa consulta programada o configuración de transferencia.

Por ejemplo:

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

API

Usa el método projects.locations.transferConfigs.list y proporciona una instancia del 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 actualizar una consulta programada, sigue estos pasos:

1. En el menú de navegación, haga clic en Consultas programadas o en Programación.
2. En la lista de consultas programadas, haga clic en el nombre de la consulta que quiera cambiar.
3. En la página Detalles de la consulta programada que se abre, haga clic en Editar.
4. Opcional: Cambia el texto de la consulta en el panel de edición de consultas.
5. Haz clic en Programar consulta y, a continuación, selecciona Actualizar consulta programada.
6. Opcional: Cambia cualquier otra opción de programación de la consulta.
7. Haz clic en Actualizar.

bq

Las consultas programadas son un tipo de transferencia. Para actualizar una consulta programada, puedes usar la herramienta de línea de comandos bq para crear una configuración de transferencia.

Introduce el comando bq update con la marca --transfer_config obligatoria.

Marcas posibles

• --project_id es el ID del proyecto. Si no se especifica --project_id, se usa el proyecto predeterminado.

• --schedule es la frecuencia con la que quieres que se ejecute la consulta. Si no se especifica --schedule, el valor predeterminado es "cada 24 horas" según la hora de creación.

• --service_account_name solo tiene efecto si también se define --update_credentials. Para obtener más información, consulta Actualizar las credenciales de una consulta programada.

• --target_dataset (opcional para las consultas DDL y DML) es una forma alternativa de asignar un nombre al conjunto de datos de destino de los resultados de la consulta cuando se usa con consultas DDL y DML.

• --display_name es el nombre de la consulta programada.

• --params los parámetros de la configuración de transferencia creada en formato JSON. Por ejemplo: --params='{"param":"param_value"}'.

• --destination_kms_key especifica el ID de recurso de la clave de Cloud KMS si usas una clave de cifrado gestionada por el cliente (CMEK) para esta transferencia. Para obtener información sobre cómo funcionan las claves de cifrado gestionadas por el cliente (CMEK) con BigQuery Data Transfer Service, consulta Especificar una clave de cifrado con consultas programadas.

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

Haz los cambios siguientes:

• dataset. El conjunto de datos de destino de la configuración de la transferencia. Este parámetro es opcional para las consultas de DDL y DML. Es obligatorio para el resto de las consultas.
• name. Nombre visible de la configuración de transferencia. El nombre visible puede ser cualquier valor que pueda identificar más adelante si necesita modificar la consulta.
• parameters. Contiene los parámetros de la configuración de transferencia creada en formato JSON. Por ejemplo: --params='{"param":"param_value"}'.
  • En el caso de las consultas programadas, debe proporcionar el parámetro query.
  • El parámetro destination_table_name_template es el nombre de la tabla de destino. Este parámetro es opcional para las consultas de DDL y DML. Es obligatorio para el resto de las consultas.
  • En el parámetro write_disposition, puede elegir WRITE_TRUNCATE para truncar (sobrescribir) la tabla de destino o WRITE_APPEND para añadir los resultados de la consulta a la tabla de destino. Este parámetro es opcional para las consultas DDL y DML. Es obligatorio para el resto de las consultas.
• Opcional: --destination_kms_key especifica el ID de recurso de la clave de la clave de Cloud KMS. Por ejemplo, projects/project_name/locations/us/keyRings/key_ring_name/cryptoKeys/key_name.
• RESOURCE_NAME: El nombre de recurso de la transferencia (también denominado "configuración de transferencia"). Si no sabes el nombre del recurso de la transferencia, puedes encontrarlo con: bq ls --transfer_config --transfer_location=location.

Por ejemplo, el siguiente comando actualiza una configuración de transferencia de consulta programada llamada My Scheduled Query con la consulta SELECT 1 from mydataset.test. La tabla de destino mytable se trunca en cada escritura y el conjunto de datos de destino es 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

Usa el método projects.transferConfigs.patch y proporciona el nombre de recurso de la transferencia mediante el parámetro transferConfig.name. Si no sabes el nombre de recurso de la transferencia, usa el comando bq ls --transfer_config --transfer_location=location para enumerar todas las transferencias o llama al método projects.locations.transferConfigs.list y proporciona el ID de proyecto mediante el 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 actualizar las credenciales de una consulta programada, sigue estos pasos:

1. Consulta el estado de una consulta programada.

2. Haz clic en el botón MÁS y selecciona Actualizar credenciales.

   

3. Espera entre 10 y 20 minutos para que el cambio se aplique. Es posible que tengas que borrar la caché del navegador.

bq

Las consultas programadas son un tipo de transferencia. Para actualizar las credenciales de una consulta programada, puedes usar la herramienta de línea de comandos bq para actualizar la configuración de la transferencia.

Introduce el comando bq update y proporciona la marca de transferencia --transfer_config. También se necesitan las siguientes marcas:

• --update_credentials

Marca opcional:

• --service_account_name se usa para autenticar tu consulta programada con una cuenta de servicio en lugar de con tu cuenta de usuario.

Por ejemplo, el siguiente comando actualiza una configuración de transferencia de consulta programada para autenticarla como cuenta de servicio:

bq update \
--update_credentials \
--service_account_name=abcdef-test-sa@abcdef-test.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

Después de hacer clic en Programar para guardar la consulta programada, puedes hacer clic en el botón Consultas programadas para ver la lista de consultas programadas. Haz clic en cualquier nombre visible para ver los detalles de la programación de la consulta. En la parte superior derecha de la página, haz clic en Programar carga retroactiva para especificar un periodo anterior.

Todos los tiempos de ejecución elegidos están dentro del intervalo seleccionado, incluida la primera fecha y excluida la última.

Ejemplo 1

La consulta programada se ejecutará a las every day 09:00 (hora del Pacífico). Te faltan datos del 1, el 2 y el 3 de enero. Elige el siguiente intervalo de fechas:

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

La consulta se ejecuta con los parámetros run_date y run_time, que corresponden a las siguientes horas:

• 1/1/19 09:00 (hora del Pacífico)
• 2/1/19 09:00 (hora del Pacífico)
• 1/3/19 09:00 (hora del Pacífico)

Ejemplo 2

La consulta programada se ejecutará a las every day 23:00 (hora del Pacífico). Te faltan datos del 1, el 2 y el 3 de enero. Elige los siguientes periodos históricos (se eligen fechas posteriores porque la hora UTC tiene una fecha diferente a las 23:00 de la hora del Pacífico):

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

La consulta se ejecuta con los parámetros run_date y run_time, que corresponden a las siguientes horas:

• 2/1/19 06:00 UTC o 1/1/2019 23:00 (hora del Pacífico)
• 3/1/19 a las 06:00 (UTC) o 2/1/2019 a las 23:00 (hora del Pacífico)
• 4/1/19 a las 06:00 (UTC) o 3/1/2019 a las 23:00 (hora del Pacífico)

Después de configurar las ejecuciones manuales, actualiza la página para verlas en la lista de ejecuciones.

bq

Para ejecutar manualmente la consulta en un periodo del historial, siga estos pasos:

Introduce el comando bq mk y proporciona la marca de ejecución de la transferencia --transfer_run. También se necesitan las siguientes marcas:

• --start_time
• --end_time

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

Haz los cambios siguientes:

• start_time y end_time. Marcas de tiempo que terminan en Z o que contienen una diferencia horaria válida. Ejemplos:
  • 2017-08-19T12:11:35.00Z
  • 2017-05-25T00:00:00+00:00
• resource_name. Nombre de recurso de la consulta programada (o de la transferencia). El nombre de recurso también se conoce como configuración de transferencia.

Por ejemplo, el siguiente comando programa un relleno para el recurso de consulta programada (o configuración de transferencia): 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 obtener más información, consulta bq mk --transfer_run.

API

Usa el método projects.locations.transferConfigs.scheduleRun y proporciona una ruta del 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 una consulta programada en la página Consultas programadas de la Google Cloud consola, siga estos pasos:

1. En el menú de navegación, haga clic en Consultas programadas.
2. En la lista de consultas programadas, haga clic en el nombre de la consulta programada que quiera eliminar.

3. En la página Detalles de la consulta programada, haga clic en Eliminar.

   

También puedes eliminar una consulta programada en la página Programación de la consola de Google Cloud :

1. En el menú de navegación, haga clic en Programación.
2. En la lista de consultas programadas, haga clic en el menú more_vert Acciones de la consulta programada que quiera eliminar.

3. Selecciona 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}")