Abfragen planen

Console

1. Öffnen Sie in der Google Cloud Console die Seite "BigQuery".

   BigQuery aufrufen

2. Führen Sie die gewünschte Abfrage aus. Wenn die Ergebnisse Ihren Erwartungen entsprechen, klicken Sie auf Planen und auf Neue geplante Abfrage erstellen.

   

3. Die Optionen für die geplante Abfrage werden im Bereich Neue geplante Abfrage angezeigt.

4. Im Bereich New scheduled query (Neue geplante Abfrage):

   • Geben Sie unter Name der geplanten Abfrage einen Namen ein, z. B. My scheduled query. Der Name der geplanten Abfrage kann ein beliebiger Wert sein, den Sie später identifizieren können, wenn Sie die Abfrage ändern müssen.

   • Optional: Die Abfrage wird standardmäßig täglich ausgeführt. Sie können den Standardzeitplan ändern, indem Sie im Drop-down-Menü Wiederholungen eine Option auswählen:

     • Wenn Sie eine benutzerdefinierte Häufigkeit angeben möchten, wählen Sie Benutzerdefiniert aus und geben Sie eine Cron-ähnliche Zeitangabe in das Feld Benutzerdefinierter Zeitplan ein. Beispiel: every mon 23:30 oder every 6 hours. Weitere Informationen zu gültigen Zeitplänen einschließlich benutzerdefinierter Intervalle finden Sie im Feld schedule unter Ressource: TransferConfig.

       

     • Wählen Sie die Option Zum festgelegten Zeitpunkt starten aus, um das Startdatum zu ändern. Geben Sie das gewünschte Startdatum und die gewünschte Uhrzeit ein.

     • Wählen Sie zum Festlegen des Endes die Option Ende planen aus und geben Sie das gewünschte Enddatum und die gewünschte Uhrzeit ein.

     • Wenn Sie die Abfrage ohne Zeitplan speichern möchten, um sie später nach Bedarf auszuführen, wählen Sie Bei Bedarf im Menü Wiederholung aus.

5. Für eine GoogleSQL-SELECT-Abfrage wählen Sie die Option Zieltabelle für Abfrageergebnisse festlegen aus und geben die folgenden Informationen zum Ziel-Dataset an.

   • Wählen Sie für Dataset name (Dataset-Name) das passende Ziel-Dataset aus.
   • Geben Sie unter Table name (Tabellenname) den Namen Ihrer Zieltabelle ein.
   • Wählen Sie für Schreibeinstellung für Zieltabelle entweder An Tabelle anfügen, um Daten an die Tabelle anzuhängen, oder Tabelle überschreiben aus, um die Zieltabelle zu überschreiben.

   • Wählen Sie für DDL- und DML-Abfragen den Verarbeitungsstandort oder die Region aus.

     

6. Erweiterte Optionen:

   • Optional: CMEK: Wenn Sie vom Kunden verwaltete Verschlüsselungsschlüssel verwenden, können Sie unter Erweiterte Optionen die Option Vom Kunden verwalteter Schlüssel auswählen. Es wird eine Liste Ihrer verfügbaren CMEKs angezeigt, aus denen Sie wählen können. Informationen zur Funktionsweise von vom Kunden verwalteten Verschlüsselungsschlüsseln (CMEKs) mit BigQuery Data Transfer Service finden Sie unter Verschlüsselungsschlüssel mit geplanten Abfragen angeben.

   • Optional: Authentifizierung über ein Dienstkonto: Wenn ein oder mehrere Dienstkonten zu Ihrem Google Cloud-Projekt gehören, können Sie statt der Nutzeranmeldedaten ein Dienstkonto mit Ihrer geplanten Abfrage verknüpfen. Klicken Sie unter Anmeldedaten für geplante Abfragen auf das Menü, um eine Liste der verfügbaren Dienstkonten aufzurufen. Wenn Sie als föderierte Identität angemeldet sind, ist ein Dienstkonto erforderlich.

     

7. Zusätzliche Konfigurationen:

   • Optional: Aktivieren Sie E-Mail-Benachrichtigungen senden, um im Falle von Fehlern bei der Übertragungsausführung Benachrichtigungen zu senden.

   • Optional: Geben Sie unter Cloud Pub/Sub-Thema den Namen Ihres Cloud Pub/Sub-Themas ein, beispielsweise projects/myproject/topics/mytopic.

     

8. Klicken Sie auf Planen.

bq

Option 1: Verwenden Sie den Befehl bq query.

Fügen Sie zum Erstellen einer geplanten Abfrage dem bq query-Befehl die Optionen destination_table (oder target_dataset), --schedule und --display_name hinzu.

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

Ersetzen Sie Folgendes:

• name. Der angezeigte Name für die geplante Abfrage. Der angezeigte Name kann ein beliebiger Wert sein, den Sie später identifizieren können, wenn Sie die Abfrage ändern müssen.
• table. Die Zieltabelle für die Abfrageergebnisse.
  • --target_dataset ist in DLL- oder DMS-Abfragen eine alternative Möglichkeit, das Ziel-Dataset für die Abfrageergebnisse zu benennen.
  • Verwenden Sie entweder --destination_table oder --target_dataset, aber nicht beides.
• interval. Bei Verwendung mit bq query wird eine Abfrage zu einer wiederkehrenden geplanten Abfrage. Hierfür ist ein Zeitplan erforderlich, der angibt, wie häufig die Abfrage ausgeführt werden soll. Weitere Informationen zu gültigen Zeitplänen einschließlich benutzerdefinierter Intervalle finden Sie im Feld schedule unter Ressource: TransferConfig. Beispiele:
  • --schedule='every 24 hours'
  • --schedule='every 3 hours'
  • --schedule='every monday 09:00'
  • --schedule='1st sunday of sep,oct,nov 00:00'

Optionale Flags:

• --project_id ist die Projekt-ID. Wenn --project_id nicht angegeben ist, wird das Standardprojekt verwendet.

• --replace kürzt die Zieltabelle und schreibt neue Ergebnisse bei jeder Ausführung der geplanten Abfrage.

• --append_table hängt Ergebnisse an die Zieltabelle an.

• Bei DDL- und DML-Abfragen können Sie auch das Flag --location übergeben, um eine bestimmte Region für die Verarbeitung anzugeben. Wenn --location nicht angegeben ist, wird der nächste Google Cloud-Standort verwendet.

Mit dem folgenden Befehl wird beispielsweise eine geplante Abfrage namens My Scheduled Query erstellt, die auf der einfachen Abfrage SELECT 1 from mydataset.test aufbaut. Die Zieltabelle ist mytable im Dataset mydataset. Die geplante Abfrage wird im Standardprojekt erstellt:

    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'

Option 2: Verwenden Sie den Befehl bq mk.

Geplante Abfragen sind eine Art der Übertragung. Zum Planen einer Abfrage können Sie mit dem bq-Befehlszeilentool eine Übertragungskonfiguration vornehmen.

Abfragen müssen in Standard-SQL geschrieben werden, um geplant zu werden.

Geben Sie den Befehl bq mk ein und legen Sie die folgenden erforderlichen Flags fest:

• --transfer_config
• --data_source
• --target_dataset (optional für DDL- und DML-Abfragen)
• --display_name
• --params

Optionale Flags:

• --project_id ist die Projekt-ID. Wenn --project_id nicht angegeben ist, wird das Standardprojekt verwendet.

• --schedule gibt an, wie oft die Abfrage ausgeführt werden soll. Wenn --schedule nicht angegeben ist, wird als Standardeinstellung "alle 24 Stunden" basierend auf der Erstellungszeit verwendet.

• Bei DDL- und DML-Abfragen können Sie auch das Flag --location übergeben, um eine bestimmte Region für die Verarbeitung anzugeben. Wenn --location nicht angegeben ist, wird der nächste Google Cloud-Standort verwendet.

• --service_account_name dient der Authentifizierung der geplanten Abfrage über ein Dienstkonto statt über Ihr eigenes Nutzerkonto.

• --destination_kms_key gibt die Schlüsselressourcen-ID für den Schlüssel an, wenn Sie für diese Übertragung einen vom Kunden verwalteten Verschlüsselungsschlüssel (CMEK) verwenden. Informationen zur Funktionsweise von CMEKs mit BigQuery Data Transfer Service finden Sie unter Verschlüsselungsschlüssel mit geplanten Abfragen angeben.

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

Ersetzen Sie Folgendes:

• dataset. Das Ziel-Dataset für die Übertragungskonfiguration.
  • Dieser Parameter ist für DDL- und DML-Abfragen optional. Er wird für alle anderen Abfragen benötigt.
• name. Der angezeigte Name für die Übertragungskonfiguration. Der angezeigte Name kann ein beliebiger Wert sein, den Sie später identifizieren können, wenn Sie die Abfrage ändern müssen.
• parameters. Enthält die Parameter für die erstellte Übertragungskonfiguration im JSON-Format. Beispiel: --params='{"param":"param_value"}'.
  • Für eine geplante Abfrage müssen Sie den Parameter query angeben.
  • Der Parameter destination_table_name_template ist der Name der Zieltabelle.
    • Dieser Parameter ist für DDL- und DML-Abfragen optional. Er wird für alle anderen Abfragen benötigt.
  • Für den Parameter write_disposition wählen Sie entweder WRITE_TRUNCATE, um die Zieltabelle zu kürzen (überschreiben), oder WRITE_APPEND, um die Abfrageergebnisse an die Zieltabelle anzuhängen.
    • Dieser Parameter ist für DDL- und DML-Abfragen optional. Er wird für alle anderen Abfragen benötigt.
• data_source. Die Datenquelle: scheduled_query.
• Optional: Das Flag --service_account_name dient zur Authentifizierung über ein Dienstkonto statt über ein persönliches Nutzerkonto.
• Optional: --destination_kms_key gibt die Schlüsselressourcen-ID für den Cloud KMS-Schlüssel an, z. B. projects/project_name/locations/us/keyRings/key_ring_name/cryptoKeys/key_name.

Mit dem folgenden Befehl wird beispielsweise eine Konfiguration für eine geplante Abfrageübertragung mit der Bezeichnung My Scheduled Query unter Verwendung der einfachen Abfrage SELECT 1 from mydataset.test erstellt. Die Zieltabelle mytable wird bei jedem Schreibvorgang gekürzt und das Ziel-Dataset ist mydataset. Die geplante Abfrage wird im Standardprojekt erstellt und mit einem Dienstkonto authentifiziert:

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

Wenn Sie den Befehl zum ersten Mal ausführen, erhalten Sie eine Nachricht wie die folgende:

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

Richten Sie sich nach der Anleitung in der Nachricht und fügen Sie den Authentifizierungscode in die Befehlszeile ein.

API

Verwenden Sie die Methode projects.locations.transferConfigs.create und geben Sie eine Instanz der Ressource TransferConfig an.

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 = "[email protected]"

# 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 = "[email protected]"

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

Console

Klicken Sie im Navigationsbereich auf Geplante Abfragen, um den Status Ihrer geplanten Abfragen anzeigen zu lassen. Laden Sie die Seite neu, um den Status der geplanten Abfragen zu aktualisieren. Klicken Sie auf eine geplante Abfrage, um weitere Informationen zu erhalten.

bq

Geplante Abfragen sind eine Art der Übertragung. Zum Anzeigen der Details einer geplanten Abfrage können Sie zuerst das bq-Befehlszeilentool verwenden, um die Übertragungskonfigurationen aufzulisten.

Geben Sie den Befehl bq ls mit dem Flag --transfer_config für die Ausführung der Übertragung an. Die folgenden Flags sind ebenfalls erforderlich:

• --transfer_location

Beispiel:

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

Wenn Sie die Details einer einzelnen geplanten Abfrage aufrufen möchten, geben Sie den Befehl bq show mit dem transfer_path für diese Konfiguration der geplanten Abfrage/Übertragung ein.

Beispiel:

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

API

Verwenden Sie die Methode projects.locations.transferConfigs.list und geben Sie eine Instanz der Ressource TransferConfig an.

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}")

Console

So aktualisieren Sie eine geplante Abfrage:

1. Klicken Sie im Navigationsbereich auf Geplante Abfragen.
2. Klicken Sie in der Liste der geplanten Abfragen auf den Namen der Abfrage, die Sie ändern möchten.
3. Die Seite Details der geplanten Abfrage wird geöffnet. Klicken Sie auf Bearbeiten.
4. Optional: Ändern Sie den Abfragetext im Bearbeitungsbereich der Abfrage.
5. Klicken Sie auf Abfrage planen () und wählen Sie dann Geplante Abfrage aktualisieren () aus.
6. Optional: Ändern Sie anderen Planungsoptionen für die Abfrage.
7. Klicken Sie auf Aktualisieren.

bq

Geplante Abfragen sind eine Art der Übertragung. Zum Aktualisieren einer geplanten Abfrage können Sie mit dem bq-Befehlszeilentool eine Übertragungskonfiguration vornehmen.

Geben Sie den Befehl bq update mit dem erforderlichen Flag --transfer_config ein.

Optionale Flags:

• --project_id ist die Projekt-ID. Wenn --project_id nicht angegeben ist, wird das Standardprojekt verwendet.

• --schedule gibt an, wie oft die Abfrage ausgeführt werden soll. Wenn --schedule nicht angegeben ist, wird als Standardeinstellung "alle 24 Stunden" basierend auf der Erstellungszeit verwendet.

• --service_account_name wird nur wirksam, wenn auch --update_credentials festgelegt ist. Weitere Informationen finden Sie unter Anmeldedaten für geplante Abfragen aktualisieren.

• --target_dataset (optional für DDL- und DML-Abfragen) ist eine alternative Möglichkeit, das Ziel-Dataset für die Abfrageergebnisse zu benennen, wenn es mit DDL- und DML-Abfragen verwendet wird.

• --display_name ist der Name der geplanten Abfrage.

• --params die Parameter für die erstellte Übertragungskonfiguration im JSON-Format. Beispiel: --params='{"param":"param_value"}'.

• --destination_kms_key gibt die Schlüsselressourcen-ID für den Cloud KMS-Schlüssel an, wenn Sie für diese Übertragung einen vom Kunden verwalteten Verschlüsselungsschlüssel (CMEK) verwenden. Informationen zur Funktionsweise von vom Kunden verwalteten Verschlüsselungsschlüsseln (CMEKs) mit BigQuery Data Transfer Service finden Sie unter Verschlüsselungsschlüssel mit geplanten Abfragen angeben.

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

Ersetzen Sie Folgendes:

• dataset. Das Ziel-Dataset für die Übertragungskonfiguration. Dieser Parameter ist für DDL- und DML-Abfragen optional. Er wird für alle anderen Abfragen benötigt.
• name. Der angezeigte Name für die Übertragungskonfiguration. Der angezeigte Name kann ein beliebiger Wert sein, den Sie später identifizieren können, wenn Sie die Abfrage ändern müssen.
• parameters. Enthält die Parameter für die erstellte Übertragungskonfiguration im JSON-Format. Beispiel: --params='{"param":"param_value"}'.
  • Für eine geplante Abfrage müssen Sie den Parameter query angeben.
  • Der Parameter destination_table_name_template ist der Name der Zieltabelle. Dieser Parameter ist für DDL- und DML-Abfragen optional. Er wird für alle anderen Abfragen benötigt.
  • Für den Parameter write_disposition wählen Sie entweder WRITE_TRUNCATE, um die Zieltabelle zu kürzen (überschreiben), oder WRITE_APPEND, um die Abfrageergebnisse an die Zieltabelle anzuhängen. Dieser Parameter ist für DDL- und DML-Abfragen optional. Er wird für alle anderen Abfragen benötigt.
• Optional: --destination_kms_key gibt die Schlüsselressourcen-ID für den Cloud KMS-Schlüssel an, z. B. projects/project_name/locations/us/keyRings/key_ring_name/cryptoKeys/key_name.
• RESOURCE_NAME: Der Ressourcenname der Übertragung (auch als Übertragungskonfiguration bezeichnet). Wenn Sie den Ressourcennamen der Übertragung nicht kennen, suchen Sie den Ressourcennamen mit bq ls --transfer_config --transfer_location=location.

Mit dem folgenden Befehl wird beispielsweise eine Konfiguration für eine geplante Abfrageübertragung mit der Bezeichnung My Scheduled Query unter Verwendung der einfachen Abfrage SELECT 1 from mydataset.test aktualisiert. Die Zieltabelle mytable wird bei jedem Schreibvorgang gekürzt und das Ziel-Dataset ist 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

Verwenden Sie die Methode projects.transferConfigs.patch und geben Sie den Ressourcennamen der Übertragung mithilfe des Parameters transferConfig.name an. Wenn Sie den Ressourcennamen der Übertragung nicht kennen, verwenden Sie den Befehl bq ls --transfer_config --transfer_location=location, um alle Übertragungen aufzulisten, oder rufen Sie die Methode projects.locations.transferConfigs.list auf und geben Sie die Projekt-ID mithilfe des Parameters parent an.

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}'")

Console

So aktualisieren Sie die vorhandenen Anmeldedaten für eine geplante Abfrage:

1. Rufen Sie den Status einer geplanten Abfrage auf.

2. Klicken Sie auf die Schaltfläche MORE (Mehr) und wählen Sie Update credentials (Anmeldedaten aktualisieren) aus.

   

3. Warten Sie 10 bis 20 Minuten, bis die Änderung wirksam wird. Unter Umständen müssen Sie auch den Cache Ihres Browsers löschen.

bq

Geplante Abfragen sind eine Art der Übertragung. Wenn Sie die Anmeldedaten einer geplanten Abfrage aktualisieren, können Sie das bq-Befehlszeilentool verwenden, um die Übertragungskonfiguration zu aktualisieren.

Geben Sie den Befehl bq update mit dem Flag --transfer_config für die Ausführung der Übertragung an. Die folgenden Flags sind ebenfalls erforderlich:

• --update_credentials

Optionales Flag:

• --service_account_name dient der Authentifizierung der geplanten Abfrage über ein Dienstkonto statt über Ihr eigenes Nutzerkonto.

Mit dem folgenden Befehl wird beispielsweise die Übertragungskonfiguration einer geplanten Abfrage zur Authentifizierung über ein Dienstkonto aktualisiert.

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 = "[email protected]"
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))

Console

Speichern Sie die geplante Abfrage zuerst, indem Sie auf Schedule (Planen) klicken. Klicken Sie dann auf Scheduled queries (Geplante Abfragen), um die Liste der aktuell geplanten Abfragen aufzurufen. Sie können die Details zu einer geplanten Abfrage aufrufen, indem Sie auf den zugehörigen Anzeigenamen klicken. Klicken Sie oben rechts auf Schedule backfill (Backfill planen), um einen festen Zeitraum anzugeben.

Die ausgewählten Laufzeiten liegen alle innerhalb des ausgewählten Bereichs, wobei das erste Datum enthalten ist, das letzte aber nicht.

Beispiel 1

Die geplante Abfrage wird so eingestellt, dass sie every day 09:00 in der Zeitzone U.S. Pacific ausgeführt wird. Daten vom 1., 2. und 3. Januar fehlen. Wählen Sie den folgenden festen Zeitraum:

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

Die Abfrage wird mit den Parametern run_date und run_time ausgeführt, die den folgenden Zeiten entsprechen:

• 01.01.19, 09:00 Uhr, Zeitzone U.S. Pacific
• 02.01.19, 09:00 Uhr, Zeitzone U.S. Pacific
• 03.01.19, 09:00 Uhr, Zeitzone U.S. Pacific

Beispiel 2

Die geplante Abfrage wird so eingestellt, dass sie every day 23:00 in der Zeitzone U.S. Pacific ausgeführt wird. Daten vom 1., 2. und 3. Januar fehlen. Wählen Sie die folgenden festen Zeiträume aus (spätere Datumsangaben werden ausgewählt, da die Zeitzone UTC um 23:00 Uhr in der Zeitzone U.S. Pacific ein anderes Datum als diese hat):

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

Die Abfrage wird mit den Parametern run_date und run_time ausgeführt, die den folgenden Zeiten entsprechen:

• 02.01.19, 06:00 Uhr, Zeitzone UTC oder 01.01.2019, 23:00 Uhr, Zeitzone U.S. Pacific
• 02.01.19, 06:00 Uhr, Zeitzone UTC oder 01.01.2019, 23:00 Uhr, Zeitzone U.S. Pacific
• 02.01.19, 06:00 Uhr, Zeitzone UTC oder 01.01.2019, 23:00 Uhr, Zeitzone U.S. Pacific

Aktualisieren Sie nach dem Einrichten der manuellen Ausführung die Seite, um sie in der Liste der Ausführungen anzeigen zu lassen.

bq

So führen Sie die Abfrage manuell in einem festen Zeitraum aus:

Geben Sie den Befehl bq mk mit dem Flag --transfer_run für die Ausführung der Übertragung an. Die folgenden Flags sind ebenfalls erforderlich:

• --start_time
• --end_time

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

Ersetzen Sie Folgendes:

• start_time und end_time. Zeitstempel, die mit Z enden oder einen gültigen Zeitzonenversatz haben. Beispiele:
  • 2017-08-19T12:11:35.00Z
  • 2017-05-25T00:00:00+00:00
• resource_name. Der Ressourcenname der geplanten Abfrage (oder der Übertragung). Der Ressourcenname ist auch als Übertragungskonfiguration bekannt.

Mit dem folgenden Befehl können Sie beispielsweise ein Backfill für die geplante Abfrageressource (oder Übertragungskonfiguration) planen: 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

Weitere Informationen finden Sie unter bq mk --transfer_run.

API

Verwenden Sie die Methode projects.locations.transferConfigs.scheduleRun und geben Sie einen Pfad für die TransferConfig-Ressource an.

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}")

Console

So löschen Sie eine geplante Abfrage über den Konsole:

1. Klicken Sie im Navigationsbereich auf Geplante Abfragen.

2. Klicken Sie in der Liste der geplanten Abfragen auf den Namen der geplanten Abfrage, die Sie löschen möchten.

3. Die Seite Details der geplanten Abfrage wird geöffnet. Klicken Sie auf Löschen.

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}")