Eseguire la scansione per rilevare problemi di qualità dei dati

Questo documento spiega come utilizzare BigQuery e Dataplex Universal Catalog insieme per garantire che i dati soddisfino le tue aspettative di qualità. La qualità dei dati automatica di Dataplex Universal Catalog ti consente di definire e misurare la qualità dei dati nelle tabelle BigQuery. Puoi automatizzare la scansione dei dati, convalidarli in base a regole definite e registrare avvisi se i dati non soddisfano i requisiti di qualità.

Per saperne di più sulla qualità dei dati automatica, consulta la panoramica della qualità dei dati automatica.

Prima di iniziare

Enable the Dataplex API.
Roles required to enable APIs
To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.
Enable the API
(Facoltativo) Se vuoi che Dataplex Universal Catalog generi consigli per le regole di qualità dei dati in base ai risultati di una scansione del profilo dati, crea ed esegui la scansione del profilo dati.

Ruoli obbligatori

Per eseguire una scansione della qualità dei dati su una tabella BigQuery, devi disporre dell'autorizzazione per leggere la tabella BigQuery e per creare un job BigQuery nel progetto utilizzato per scansionare la tabella.

Nota :il Catalogo universale Dataplex non crea un job BigQuery nel tuo progetto. Tuttavia, hai bisogno di questa autorizzazione per creare un job DryRun per controllare le autorizzazioni per la tabella.
Se la tabella BigQuery e la scansione della qualità dei dati si trovano in progetti diversi, devi concedere all'account di servizio Dataplex Universal Catalog del progetto contenente la scansione della qualità dei dati l'autorizzazione di lettura per la tabella BigQuery corrispondente.

Nota :se non hai creato analisi della qualità dei dati o del profilo dei dati oppure non hai un lake Dataplex Universal Catalog in questo progetto, crea un identificatore di servizio eseguendo:gcloud beta services identity create --service=dataplex.googleapis.com. Questo comando restituisce un identificatore del servizio Dataplex Universal Catalog, se esistente.
Se le regole di qualità dei dati fanno riferimento a tabelle aggiuntive, il service account del progetto di scansione deve disporre delle autorizzazioni di lettura per le stesse tabelle.
Per ottenere le autorizzazioni necessarie per esportare i risultati della scansione in una tabella BigQuery, chiedi all'amministratore di concedere al service account Dataplex Universal Catalog il ruolo IAM Editor dati BigQuery (roles/bigquery.dataEditor) nel set di dati e nella tabella dei risultati. In questo modo vengono concesse le seguenti autorizzazioni:
- bigquery.datasets.get
- bigquery.tables.create
- bigquery.tables.get
- bigquery.tables.getData
- bigquery.tables.update
- bigquery.tables.updateData
Se i dati BigQuery sono organizzati in un lake Dataplex Universal Catalog, concedi all'account di servizio Dataplex Universal Catalog i ruoli IAM Lettore metadati Dataplex (roles/dataplex.metadataReader) e Visualizzatore Dataplex (roles/dataplex.viewer). In alternativa, devi disporre di tutte le seguenti autorizzazioni:
- dataplex.lakes.list
- dataplex.lakes.get
- dataplex.zones.list
- dataplex.zones.get
- dataplex.entities.list
- dataplex.entities.get
- dataplex.operations.get
Se esegui la scansione di una tabella esterna BigQuery da Cloud Storage, concedi all'account di servizio Dataplex Universal Catalog il ruolo Visualizzatore oggetti Storage (roles/storage.objectViewer) per il bucket. In alternativa, assegna all'account di servizio Dataplex Universal Catalog le seguenti autorizzazioni:
- storage.buckets.get
- storage.objects.get
Se vuoi pubblicare i risultati della scansione della qualità dei dati come metadati di Dataplex Universal Catalog, devi disporre del ruolo IAM Editor dati BigQuery (roles/bigquery.dataEditor) per la tabella e dell'autorizzazione dataplex.entryGroups.useDataQualityScorecardAspect per il gruppo di voci @bigquery nella stessa posizione della tabella. In alternativa, devi disporre del ruolo Editor Dataplex Catalog (roles/dataplex.catalogEditor) per il gruppo di voci @bigquery nella stessa posizione della tabella.

In alternativa, devi disporre di tutte le seguenti autorizzazioni:
- bigquery.tables.update - sul tavolo
- dataplex.entryGroups.useDataQualityScorecardAspect - sul gruppo di voci @bigquery
In alternativa, devi disporre di tutte le seguenti autorizzazioni:
- dataplex.entries.update - sul gruppo di voci @bigquery
- dataplex.entryGroups.useDataQualityScorecardAspect - sul gruppo di voci @bigquery
Se devi accedere a colonne protette da criteri di accesso a livello di colonna BigQuery, assegna all'account di servizio Dataplex Universal Catalog le autorizzazioni per queste colonne. L'utente che crea o aggiorna una scansione dei dati deve disporre anche delle autorizzazioni per le colonne.
Se una tabella ha criteri di accesso a livello di riga BigQuery abilitati, puoi scansionare solo le righe visibili all'account di servizio del Catalogo universale Dataplex. Tieni presente che i privilegi di accesso del singolo utente non vengono valutati per le norme a livello di riga.

Ruoli di scansione dei dati richiesti

Per utilizzare la qualità dei dati automatica, chiedi all'amministratore di concederti uno dei seguenti ruoli IAM:

Accesso completo alle risorse DataScan: Dataplex DataScan Administrator (roles/dataplex.dataScanAdmin)
Per creare risorse DataScan: Dataplex DataScan Creator (roles/dataplex.dataScanCreator) sul progetto
Accesso in scrittura alle risorse DataScan: Dataplex DataScan Editor (roles/dataplex.dataScanEditor)
Accesso in lettura alle risorse DataScan escluse regole e risultati: Dataplex DataScan Viewer (roles/dataplex.dataScanViewer)
Accesso in lettura alle risorse DataScan, incluse regole e risultati: Dataplex DataScan DataViewer (roles/dataplex.dataScanDataViewer)

La tabella seguente elenca le autorizzazioni DataScan:

Nome autorizzazione	Concede l'autorizzazione per svolgere le seguenti operazioni:
`dataplex.datascans.create`	Crea un `DataScan`
`dataplex.datascans.delete`	Eliminare un `DataScan`
`dataplex.datascans.get`	Visualizzare i metadati operativi come ID o pianificazione, ma non i risultati e le regole
`dataplex.datascans.getData`	Visualizzare i dettagli di `DataScan`, incluse regole e risultati
`dataplex.datascans.list`	Elenco `DataScan`
`dataplex.datascans.run`	Esegui un `DataScan`
`dataplex.datascans.update`	Aggiornare la descrizione di un `DataScan`
`dataplex.datascans.getIamPolicy`	Visualizza le autorizzazioni IAM correnti nella scansione
`dataplex.datascans.setIamPolicy`	Imposta le autorizzazioni IAM per la scansione

Crea una scansione della qualità dei dati

Console

Nella console Google Cloud , nella pagina BigQuery Cura dei metadati, vai alla scheda Profilazione e qualità dei dati.

Vai a Profilazione e qualità dei dati
Fai clic su Crea scansione qualità dati.
Nella finestra Definisci scansione, compila i seguenti campi:
1. (Facoltativo) Inserisci un nome visualizzato.
2. Inserisci un ID. Consulta le convenzioni di denominazione delle risorse.
3. Facoltativo: inserisci una descrizione.
4. Nel campo Table (Tabella), fai clic su Sfoglia. Scegli la tabella da analizzare e fai clic su Seleziona. Sono supportate solo le tabelle BigQuery standard.
  
  Per le tabelle nei set di dati multiregionali, scegli una regione in cui creare la scansione dei dati.
  
  Per sfogliare le tabelle organizzate all'interno dei lake Dataplex Universal Catalog, fai clic su Sfoglia all'interno dei data lake Dataplex.
5. Nel campo Ambito, scegli Incrementale o Tutti i dati.
  - Se scegli Incrementale: nel campo Colonna timestamp, seleziona una colonna di tipo DATE o TIMESTAMP dalla tabella BigQuery che aumenta man mano che vengono aggiunti nuovi record e che può essere utilizzata per identificare nuovi record. Può essere una colonna che partiziona la tabella.
6. Per filtrare i dati, seleziona la casella di controllo Filtra righe. Fornisci un filtro per le righe costituito da un'espressione SQL valida che può essere utilizzata come parte di una clausola WHERE nella sintassi GoogleSQL. Ad esempio: col1 >= 0. Il filtro può essere una combinazione di più condizioni di colonna. Ad esempio, col1 >= 0 AND col2 < 10.
7. Per campionare i dati, seleziona una percentuale di campionamento nell'elenco Dimensioni del campionamento. Scegli un valore percentuale compreso tra 0,0% e 100,0% con un massimo di tre cifre decimali. Per set di dati più grandi, scegli una percentuale di campionamento inferiore. Ad esempio, per una tabella da 1 PB, se inserisci un valore compreso tra 0,1% e 1,0%, la scansione della qualità dei dati campiona tra 1 e 10 TB di dati. Per le scansioni incrementali dei dati, la scansione della qualità dei dati applica il campionamento all' ultimo incremento.
8. Per pubblicare i risultati della scansione della qualità dei dati come metadati di Dataplex Universal Catalog, seleziona la casella di controllo Pubblica i risultati in Dataplex Catalog.
  
  Puoi visualizzare i risultati dell'ultima scansione nella scheda Qualità dei dati nelle pagine BigQuery e Dataplex Universal Catalog per la tabella di origine. Per consentire agli utenti di accedere ai risultati della scansione pubblicati, consulta la sezione Concedere l'accesso ai risultati della scansione della qualità dei dati di questo documento.
9. Nella sezione Pianificazione, scegli una delle seguenti opzioni:
  - Ripeti: esegui la scansione della qualità dei dati in base a una pianificazione: oraria, giornaliera, settimanale, mensile o personalizzata. Specifica la frequenza di esecuzione della scansione e l'ora. Se scegli l'opzione personalizzata, utilizza il formato cron per specificare la pianificazione.
  - On demand: esegui la scansione della qualità dei dati on demand.
  - Una tantum: esegui la scansione della qualità dei dati una volta ora e rimuovi la scansione dopo il periodo di tempo di validità.
  - Durata TTL (Time To Live): il valore TTL è l'intervallo di tempo tra l'esecuzione e l'eliminazione della scansione. Una scansione della qualità dei dati senza un TTL specificato viene eliminata automaticamente 24 ore dopo l'esecuzione. La durata può variare da 0 secondi (eliminazione immediata) a 365 giorni.
10. Fai clic su Continua.
Nella finestra Regole sulla qualità dei dati, definisci le regole da configurare per questa analisi della qualità dei dati.
1. Fai clic su Aggiungi regole e poi scegli una delle seguenti opzioni.
  - Suggerimenti basati sul profilo: crea regole a partire dai suggerimenti basati su una scansione di profilazione dei dati esistente.
    1. Scegli le colonne: seleziona le colonne per cui ottenere regole consigliate.
    2. Scegli progetto di analisi: se la scansione di profilazione dei dati si trova in un progetto diverso da quello in cui stai creando la scansione della qualità dei dati, seleziona il progetto da cui estrarre le scansioni del profilo.
    3. Scegli i risultati del profilo: seleziona uno o più risultati del profilo e fai clic su Ok. Viene compilato un elenco di regole suggerite che puoi utilizzare come punto di partenza.
    4. Seleziona la casella di controllo per le regole che vuoi aggiungere e poi fai clic su Seleziona. Una volta selezionate, le regole vengono aggiunte all'elenco delle regole corrente. Poi puoi modificare le regole.
  - Tipi di regole integrate: crea regole a partire da regole predefinite. Consulta l'elenco delle regole predefinite.
    1. Scegli colonne: seleziona le colonne per cui scegliere le regole.
    2. Scegli i tipi di regole: seleziona i tipi di regole da scegliere e poi fai clic su Ok. I tipi di regole visualizzati dipendono dalle colonne selezionate.
    3. Seleziona la casella di controllo per le regole che vuoi aggiungere e poi fai clic su Seleziona. Una volta selezionate, le regole vengono aggiunte all'elenco corrente. Poi puoi modificare le regole.
  - Regola per il controllo delle righe SQL: crea una regola SQL personalizzata da applicare a ogni riga.
    1. In Dimensione, scegli una dimensione.
    2. In Soglia di superamento, scegli una percentuale di record che devono superare il controllo.
    3. In Nome colonna, scegli una colonna.
    4. Nel campo Fornisci un'espressione SQL, inserisci un'espressione SQL che restituisce come valore booleano true (superato) o false (non superato). Per maggiori informazioni, vedi Tipi di regole SQL personalizzate supportati e gli esempi in Definisci regole di qualità dei dati.
    5. Fai clic su Aggiungi.
  - Regola per il controllo aggregato SQL: crea una regola di condizione della tabella SQL personalizzata.
    1. In Dimensione, scegli una dimensione.
    2. In Nome colonna, scegli una colonna.
    3. Nel campo Fornisci un'espressione SQL, inserisci un'espressione SQL che restituisce come valore booleano true (superato) o false (non superato). Per maggiori informazioni, vedi Tipi di regole SQL personalizzate supportati e gli esempi in Definisci regole di qualità dei dati.
    4. Fai clic su Aggiungi.
  - Regola di asserzione SQL: crea una regola di asserzione SQL personalizzata per verificare uno stato non valido dei dati.
    1. In Dimensione, scegli una dimensione.
    2. (Facoltativo) In Nome colonna, scegli una colonna.
    3. Nel campo Fornisci un'istruzione SQL, inserisci un'istruzione SQL che restituisce le righe che corrispondono allo stato non valido. Se vengono restituite delle righe, questa regola non riesce. Ometti il punto e virgola finale dall'istruzione SQL. Per ulteriori informazioni, consulta Tipi di regole SQL personalizzate supportati e gli esempi in Definisci regole di qualità dei dati.
    4. Fai clic su Aggiungi.
2. (Facoltativo) Per qualsiasi regola di qualità dei dati, puoi assegnare un nome personalizzato da utilizzare per il monitoraggio e gli avvisi, nonché una descrizione. Per farlo, modifica una regola e specifica i seguenti dettagli:
  - Nome regola: inserisci un nome regola personalizzato con un massimo di 63 caratteri. Il nome della regola può includere lettere (a-z, A-Z), cifre (0-9) e trattini (-) e deve iniziare con una lettera e terminare con un numero o una lettera.
  - Descrizione: inserisci una descrizione della regola con una lunghezza massima di 1024 caratteri.
3. Ripeti i passaggi precedenti per aggiungere altre regole all'analisi della qualità dei dati. Al termine, fai clic su Continua.
(Facoltativo) Esporta i risultati della scansione in una tabella standard BigQuery. Nella sezione Esporta i risultati della scansione in una tabella BigQuery, esegui le seguenti operazioni:
1. Nel campo Seleziona set di dati BigQuery, fai clic su Sfoglia. Seleziona un set di dati BigQuery in cui archiviare i risultati della scansione della qualità dei dati.
2. Nel campo Tabella BigQuery, specifica la tabella in cui archiviare i risultati della scansione della qualità dei dati. Se utilizzi una tabella esistente, assicurati che sia compatibile con lo schema della tabella di esportazione. Se la tabella specificata non esiste, Dataplex Universal Catalog la crea per te.
  
  Nota: puoi utilizzare la stessa tabella dei risultati per più analisi della qualità dei dati.
(Facoltativo) Aggiungi etichette. Le etichette sono coppie chiave-valore che consentono di raggruppare oggetti correlati fra loro o con altre risorse Google Cloud .
(Facoltativo) Configura i report di notifica via email per avvisare le persone dello stato e dei risultati di un job di scansione della qualità dei dati. Nella sezione Report sulle notifiche, fai clic su Aggiungi ID email e inserisci fino a cinque indirizzi email. Poi seleziona gli scenari per i quali vuoi inviare i report:
- Punteggio di qualità (<=): invia un report quando un job viene completato correttamente con un punteggio di qualità dei dati inferiore al punteggio target specificato. Inserisci un punteggio di qualità target compreso tra 0 e 100.
- Errori del job: invia un report quando il job stesso non va a buon fine, indipendentemente dai risultati della qualità dei dati.
- Completamento job (con esito positivo o negativo): invia un report al termine del job, indipendentemente dai risultati della qualità dei dati.
Fai clic su Crea.

Dopo aver creato la scansione, puoi eseguirla in qualsiasi momento facendo clic su Esegui ora.

gcloud

Per creare una scansione della qualità dei dati, utilizza il comando gcloud dataplex datascans create data-quality.

Se i dati di origine sono organizzati in un lake Dataplex Universal Catalog, includi il flag --data-source-entity:

gcloud dataplex datascans create data-quality DATASCAN \
    --location=LOCATION \
    --data-quality-spec-file=DATA_QUALITY_SPEC_FILE \
    --data-source-entity=DATA_SOURCE_ENTITY

Se i dati di origine non sono organizzati in un lake Dataplex Universal Catalog, includi il flag --data-source-resource:

gcloud dataplex datascans create data-quality DATASCAN \
    --location=LOCATION \
    --data-quality-spec-file=DATA_QUALITY_SPEC_FILE \
    --data-source-resource=DATA_SOURCE_RESOURCE

Sostituisci le seguenti variabili:

DATASCAN: Il nome della scansione della qualità dei dati.
LOCATION: la regione Google Cloud in cui creare la scansione qualità dati.
DATA_QUALITY_SPEC_FILE: il percorso del file JSON o YAML contenente le specifiche per la scansione della qualità dei dati. Il file può essere un file locale o un percorso Cloud Storage con il prefisso gs://. Utilizza questo file per specificare le regole di qualità dei dati per la scansione. Puoi anche specificare ulteriori dettagli in questo file, come filtri, percentuale di campionamento e azioni post-scansione come l'esportazione in BigQuery o l'invio di report di notifica via email. Consulta la documentazione sulla rappresentazione JSON e l'esempio di rappresentazione YAML.
DATA_SOURCE_ENTITY: l'entità Dataplex Universal Catalog che contiene i dati per la scansione della qualità dei dati. Ad esempio, projects/test-project/locations/test-location/lakes/test-lake/zones/test-zone/entities/test-entity.
DATA_SOURCE_RESOURCE: il nome della risorsa che contiene i dati per la scansione della qualità dei dati. Ad esempio, //bigquery.googleapis.com/projects/test-project/datasets/test-dataset/tables/test-table.

C#

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

using Google.Api.Gax.ResourceNames;
using Google.Cloud.Dataplex.V1;
using Google.LongRunning;

public sealed partial class GeneratedDataScanServiceClientSnippets
{
    /// <summary>Snippet for CreateDataScan</summary>
    /// <remarks>
    /// This snippet has been automatically generated and should be regarded as a code template only.
    /// It will require modifications to work:
    /// - It may require correct/in-range values for request initialization.
    /// - It may require specifying regional endpoints when creating the service client as shown in
    ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
    /// </remarks>
    public void CreateDataScanRequestObject()
    {
        // Create client
        DataScanServiceClient dataScanServiceClient = DataScanServiceClient.Create();
        // Initialize request argument(s)
        CreateDataScanRequest request = new CreateDataScanRequest
        {
            ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
            DataScan = new DataScan(),
            DataScanId = "",
            ValidateOnly = false,
        };
        // Make the request
        Operation<DataScan, OperationMetadata> response = dataScanServiceClient.CreateDataScan(request);

        // Poll until the returned long-running operation is complete
        Operation<DataScan, OperationMetadata> completedResponse = response.PollUntilCompleted();
        // Retrieve the operation result
        DataScan result = completedResponse.Result;

        // Or get the name of the operation
        string operationName = response.Name;
        // This name can be stored, then the long-running operation retrieved later by name
        Operation<DataScan, OperationMetadata> retrievedResponse = dataScanServiceClient.PollOnceCreateDataScan(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            DataScan retrievedResult = retrievedResponse.Result;
        }
    }
}

Go

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.


package main

import (
	"context"

	dataplex "cloud.google.com/go/dataplex/apiv1"
	dataplexpb "cloud.google.com/go/dataplex/apiv1/dataplexpb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := dataplex.NewDataScanClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &dataplexpb.CreateDataScanRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#CreateDataScanRequest.
	}
	op, err := c.CreateDataScan(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Java

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

import com.google.cloud.dataplex.v1.CreateDataScanRequest;
import com.google.cloud.dataplex.v1.DataScan;
import com.google.cloud.dataplex.v1.DataScanServiceClient;
import com.google.cloud.dataplex.v1.LocationName;

public class SyncCreateDataScan {

  public static void main(String[] args) throws Exception {
    syncCreateDataScan();
  }

  public static void syncCreateDataScan() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (DataScanServiceClient dataScanServiceClient = DataScanServiceClient.create()) {
      CreateDataScanRequest request =
          CreateDataScanRequest.newBuilder()
              .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
              .setDataScan(DataScan.newBuilder().build())
              .setDataScanId("dataScanId1260787906")
              .setValidateOnly(true)
              .build();
      DataScan response = dataScanServiceClient.createDataScanAsync(request).get();
    }
  }
}

Node.js

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

// Copyright 2026 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// ** This file is automatically generated by gapic-generator-typescript. **
// ** https://github.com/googleapis/gapic-generator-typescript **
// ** All changes to this file may be overwritten. **



'use strict';

function main(parent, dataScan, dataScanId) {
  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The resource name of the parent location:
   *  `projects/{project}/locations/{location_id}`
   *  where `project` refers to a *project_id* or *project_number* and
   *  `location_id` refers to a Google Cloud region.
   */
  // const parent = 'abc123'
  /**
   *  Required. DataScan resource.
   */
  // const dataScan = {}
  /**
   *  Required. DataScan identifier.
   *  * Must contain only lowercase letters, numbers and hyphens.
   *  * Must start with a letter.
   *  * Must end with a number or a letter.
   *  * Must be between 1-63 characters.
   *  * Must be unique within the customer project / location.
   */
  // const dataScanId = 'abc123'
  /**
   *  Optional. Only validate the request, but do not perform mutations.
   *  The default is `false`.
   */
  // const validateOnly = true

  // Imports the Dataplex library
  const {DataScanServiceClient} = require('@google-cloud/dataplex').v1;

  // Instantiates a client
  const dataplexClient = new DataScanServiceClient();

  async function callCreateDataScan() {
    // Construct request
    const request = {
      parent,
      dataScan,
      dataScanId,
    };

    // Run request
    const [operation] = await dataplexClient.createDataScan(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callCreateDataScan();
}

process.on('unhandledRejection', err => {
  console.error(err.message);
  process.exitCode = 1;
});
main(...process.argv.slice(2));

Python

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import dataplex_v1


def sample_create_data_scan():
    # Create a client
    client = dataplex_v1.DataScanServiceClient()

    # Initialize request argument(s)
    data_scan = dataplex_v1.DataScan()
    data_scan.data_quality_spec.rules.dimension = "dimension_value"
    data_scan.data.entity = "entity_value"

    request = dataplex_v1.CreateDataScanRequest(
        parent="parent_value",
        data_scan=data_scan,
        data_scan_id="data_scan_id_value",
    )

    # Make the request
    operation = client.create_data_scan(request=request)

    print("Waiting for operation to complete...")

    response = operation.result()

    # Handle the response
    print(response)

Ruby

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

require "google/cloud/dataplex/v1"

##
# Snippet for the create_data_scan call in the DataScanService service
#
# This snippet has been automatically generated and should be regarded as a code
# template only. It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
# client as shown in https://cloud.google.com/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::Dataplex::V1::DataScanService::Client#create_data_scan.
#
def create_data_scan
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::Dataplex::V1::DataScanService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::Dataplex::V1::CreateDataScanRequest.new

  # Call the create_data_scan method.
  result = client.create_data_scan request

  # The returned object is of type Gapic::Operation. You can use it to
  # check the status of an operation, cancel it, or wait for results.
  # Here is how to wait for a response.
  result.wait_until_done! timeout: 60
  if result.response?
    p result.response
  else
    puts "No response received."
  end
end

REST

Per creare un'analisi della qualità dei dati, utilizza il metodo dataScans.create.

La seguente richiesta crea una scansione della qualità dei dati una tantum:

POST https://dataplex.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/dataScans?data_scan_id=DATASCAN_ID

{
"data": {
  "resource": "//bigquery.googleapis.com/projects/PROJECT_ID/datasets/DATASET_ID/tables/TABLE_ID"
},
"type": "DATA_QUALITY",
"executionSpec": {
  "trigger": {
    "oneTime": {
      "ttl_after_scan_completion": "120s"
    }
  }
},
"dataQualitySpec": {
  "rules": [
    {
      "nonNullExpectation": {},
      "column": "COLUMN_NAME",
      "dimension": "DIMENSION",
      "threshold": 1
    }
  ]
}
}

Sostituisci quanto segue:

PROJECT_ID: il tuo ID progetto.
LOCATION: la regione in cui creare la scansione della qualità dei dati.
DATASCAN_ID: l'ID dell'analisi della qualità dei dati.
DATASET_ID: l'ID del set di dati BigQuery.
TABLE_ID: l'ID della tabella BigQuery.
COLUMN_NAME: il nome della colonna per la regola.
DIMENSION: la dimensione per la regola, ad esempio VALIDITY.

Se vuoi creare regole per la scansione della qualità dei dati utilizzando i suggerimenti basati sui risultati di una scansione di profilazione dei dati, ottieni i suggerimenti chiamando il metodo dataScans.jobs.generateDataQualityRules nella scansione di profilazione dei dati.

Nota:se la tabella BigQuery è configurata con l'opzione Richiedi filtro di partizione impostata su true, utilizza la colonna di partizione BigQuery come filtro delle righe di analisi della qualità dei dati o colonna timestamp.

Esegui una scansione della qualità dei dati

Console

Nella console Google Cloud , nella pagina BigQuery Cura dei metadati, vai alla scheda Profilazione e qualità dei dati.

Vai a Profilazione e qualità dei dati
Fai clic sulla scansione della qualità dei dati da eseguire.
Fai clic su Esegui ora.

gcloud

Per eseguire una scansione della qualità dei dati, utilizza il comando gcloud dataplex datascans run:

gcloud dataplex datascans run DATASCAN \
--location=LOCATION \

Sostituisci le seguenti variabili:

LOCATION: la regione Google Cloud in cui è stata creata l'analisi della qualità dei dati.
DATASCAN: Il nome della scansione della qualità dei dati.

C#

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

using Google.Cloud.Dataplex.V1;

public sealed partial class GeneratedDataScanServiceClientSnippets
{
    /// <summary>Snippet for RunDataScan</summary>
    /// <remarks>
    /// This snippet has been automatically generated and should be regarded as a code template only.
    /// It will require modifications to work:
    /// - It may require correct/in-range values for request initialization.
    /// - It may require specifying regional endpoints when creating the service client as shown in
    ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
    /// </remarks>
    public void RunDataScanRequestObject()
    {
        // Create client
        DataScanServiceClient dataScanServiceClient = DataScanServiceClient.Create();
        // Initialize request argument(s)
        RunDataScanRequest request = new RunDataScanRequest
        {
            DataScanName = DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]"),
        };
        // Make the request
        RunDataScanResponse response = dataScanServiceClient.RunDataScan(request);
    }
}

Go

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.


package main

import (
	"context"

	dataplex "cloud.google.com/go/dataplex/apiv1"
	dataplexpb "cloud.google.com/go/dataplex/apiv1/dataplexpb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := dataplex.NewDataScanClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &dataplexpb.RunDataScanRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#RunDataScanRequest.
	}
	resp, err := c.RunDataScan(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Java

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

import com.google.cloud.dataplex.v1.DataScanName;
import com.google.cloud.dataplex.v1.DataScanServiceClient;
import com.google.cloud.dataplex.v1.RunDataScanRequest;
import com.google.cloud.dataplex.v1.RunDataScanResponse;

public class SyncRunDataScan {

  public static void main(String[] args) throws Exception {
    syncRunDataScan();
  }

  public static void syncRunDataScan() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (DataScanServiceClient dataScanServiceClient = DataScanServiceClient.create()) {
      RunDataScanRequest request =
          RunDataScanRequest.newBuilder()
              .setName(DataScanName.of("[PROJECT]", "[LOCATION]", "[DATASCAN]").toString())
              .build();
      RunDataScanResponse response = dataScanServiceClient.runDataScan(request);
    }
  }
}

Python

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import dataplex_v1


def sample_run_data_scan():
    # Create a client
    client = dataplex_v1.DataScanServiceClient()

    # Initialize request argument(s)
    request = dataplex_v1.RunDataScanRequest(
        name="name_value",
    )

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

    # Handle the response
    print(response)

Ruby

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

require "google/cloud/dataplex/v1"

##
# Snippet for the run_data_scan call in the DataScanService service
#
# This snippet has been automatically generated and should be regarded as a code
# template only. It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
# client as shown in https://cloud.google.com/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::Dataplex::V1::DataScanService::Client#run_data_scan.
#
def run_data_scan
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::Dataplex::V1::DataScanService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::Dataplex::V1::RunDataScanRequest.new

  # Call the run_data_scan method.
  result = client.run_data_scan request

  # The returned object is of type Google::Cloud::Dataplex::V1::RunDataScanResponse.
  p result
end

REST

Per eseguire una scansione della qualità dei dati, utilizza il metodo dataScans.run.

Visualizzare i risultati dell'analisi della qualità dei dati

Console

Nella console Google Cloud , nella pagina BigQuery Cura dei metadati, vai alla scheda Profilazione e qualità dei dati.

Vai a Profilazione e qualità dei dati
Fai clic sul nome di un'analisi della qualità dei dati.
- La sezione Panoramica mostra informazioni sui job più recenti, tra cui la data di esecuzione della scansione, il numero di record scansionati in ogni job, se tutti i controlli della qualità dei dati sono stati superati e, in caso di errori, il numero di controlli della qualità dei dati non superati.
- La sezione Configurazione dell'analisi della qualità dei dati mostra i dettagli dell'analisi.
Per visualizzare informazioni dettagliate su un job, ad esempio i punteggi di qualità dei dati che indicano la percentuale di regole superate, le regole non superate e i log dei job, fai clic sulla scheda Cronologia job. Quindi, fai clic su un ID job.

gcloud

Per visualizzare i risultati di un job di scansione della qualità dei dati, utilizza il comando gcloud dataplex datascans jobs describe:

gcloud dataplex datascans jobs describe JOB \
--location=LOCATION \
--datascan=DATASCAN \
--view=FULL

Sostituisci le seguenti variabili:

JOB: l'ID job del job di analisi della qualità dei dati.
LOCATION: la regione Google Cloud in cui è stata creata la scansione della qualità dei dati.
DATASCAN: il nome dell'analisi della qualità dei dati a cui appartiene il job.
--view=FULL: per visualizzare il risultato del job di scansione, specifica FULL.

C#

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

using Google.Cloud.Dataplex.V1;

public sealed partial class GeneratedDataScanServiceClientSnippets
{
    /// <summary>Snippet for GetDataScan</summary>
    /// <remarks>
    /// This snippet has been automatically generated and should be regarded as a code template only.
    /// It will require modifications to work:
    /// - It may require correct/in-range values for request initialization.
    /// - It may require specifying regional endpoints when creating the service client as shown in
    ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
    /// </remarks>
    public void GetDataScanRequestObject()
    {
        // Create client
        DataScanServiceClient dataScanServiceClient = DataScanServiceClient.Create();
        // Initialize request argument(s)
        GetDataScanRequest request = new GetDataScanRequest
        {
            DataScanName = DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]"),
            View = GetDataScanRequest.Types.DataScanView.Unspecified,
        };
        // Make the request
        DataScan response = dataScanServiceClient.GetDataScan(request);
    }
}

Go

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.


package main

import (
	"context"

	dataplex "cloud.google.com/go/dataplex/apiv1"
	dataplexpb "cloud.google.com/go/dataplex/apiv1/dataplexpb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := dataplex.NewDataScanClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &dataplexpb.GetDataScanRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#GetDataScanRequest.
	}
	resp, err := c.GetDataScan(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Java

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

import com.google.cloud.dataplex.v1.DataScan;
import com.google.cloud.dataplex.v1.DataScanName;
import com.google.cloud.dataplex.v1.DataScanServiceClient;
import com.google.cloud.dataplex.v1.GetDataScanRequest;

public class SyncGetDataScan {

  public static void main(String[] args) throws Exception {
    syncGetDataScan();
  }

  public static void syncGetDataScan() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (DataScanServiceClient dataScanServiceClient = DataScanServiceClient.create()) {
      GetDataScanRequest request =
          GetDataScanRequest.newBuilder()
              .setName(DataScanName.of("[PROJECT]", "[LOCATION]", "[DATASCAN]").toString())
              .build();
      DataScan response = dataScanServiceClient.getDataScan(request);
    }
  }
}

Python

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import dataplex_v1


def sample_get_data_scan():
    # Create a client
    client = dataplex_v1.DataScanServiceClient()

    # Initialize request argument(s)
    request = dataplex_v1.GetDataScanRequest(
        name="name_value",
    )

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

    # Handle the response
    print(response)

Ruby

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

require "google/cloud/dataplex/v1"

##
# Snippet for the get_data_scan call in the DataScanService service
#
# This snippet has been automatically generated and should be regarded as a code
# template only. It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
# client as shown in https://cloud.google.com/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::Dataplex::V1::DataScanService::Client#get_data_scan.
#
def get_data_scan
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::Dataplex::V1::DataScanService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::Dataplex::V1::GetDataScanRequest.new

  # Call the get_data_scan method.
  result = client.get_data_scan request

  # The returned object is of type Google::Cloud::Dataplex::V1::DataScan.
  p result
end

REST

Per visualizzare i risultati di una scansione della qualità dei dati, utilizza il metodo dataScans.get.

Visualizzare i risultati pubblicati

Se i risultati della scansione della qualità dei dati vengono pubblicati come metadati di Dataplex Universal Catalog, puoi visualizzare i risultati più recenti della scansione nelle pagine BigQuery e Dataplex Universal Catalog della consoleGoogle Cloud , nella scheda Qualità dei dati della tabella di origine.

Nella console Google Cloud , vai alla pagina BigQuery.

Vai a BigQuery
Nel riquadro a sinistra, fai clic su Spazio di esplorazione:

Se non vedi il riquadro a sinistra, fai clic su Espandi riquadro a sinistra per aprirlo.
Nel riquadro Explorer, fai clic su Set di dati e poi sul tuo set di dati.
Fai clic su Panoramica > Tabelle, quindi seleziona la tabella di cui vuoi visualizzare i risultati della scansione della qualità dei dati.
Fai clic sulla scheda Qualità dei dati.

Vengono visualizzati gli ultimi risultati pubblicati.

Nota: i risultati pubblicati potrebbero non essere disponibili se è in corso una scansione per la prima volta.

Visualizzare i risultati storici delle scansioni

Dataplex Universal Catalog salva la cronologia delle scansioni della qualità dei dati degli ultimi 300 job o dell'ultimo anno, a seconda di quale si verifica per primo.

Console

Nella console Google Cloud , nella pagina BigQuery Cura dei metadati, vai alla scheda Profilazione e qualità dei dati.

Vai a Profilazione e qualità dei dati
Fai clic sul nome di un'analisi della qualità dei dati.
Fai clic sulla scheda Cronologia dei job.

La scheda Cronologia job fornisce informazioni sui job precedenti, ad esempio il numero di record scansionati in ogni job, lo stato del job, l'ora in cui è stato eseguito il job e se ogni regola è stata superata o meno.
Per visualizzare informazioni dettagliate su un job, fai clic su uno qualsiasi dei job nella colonna ID job.

gcloud

Per visualizzare i job di scansione della qualità dei dati storici, utilizza il comando gcloud dataplex datascans jobs list:

gcloud dataplex datascans jobs list \
--location=LOCATION \
--datascan=DATASCAN \

Sostituisci le seguenti variabili:

LOCATION: la regione Google Cloud in cui è stata creata la scansione della qualità dei dati.
DATASCAN: il nome della scansione della qualità dei dati per cui visualizzare i job storici.

C#

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

using Google.Api.Gax;
using Google.Cloud.Dataplex.V1;
using System;

public sealed partial class GeneratedDataScanServiceClientSnippets
{
    /// <summary>Snippet for ListDataScanJobs</summary>
    /// <remarks>
    /// This snippet has been automatically generated and should be regarded as a code template only.
    /// It will require modifications to work:
    /// - It may require correct/in-range values for request initialization.
    /// - It may require specifying regional endpoints when creating the service client as shown in
    ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
    /// </remarks>
    public void ListDataScanJobsRequestObject()
    {
        // Create client
        DataScanServiceClient dataScanServiceClient = DataScanServiceClient.Create();
        // Initialize request argument(s)
        ListDataScanJobsRequest request = new ListDataScanJobsRequest
        {
            ParentAsDataScanName = DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]"),
            Filter = "",
        };
        // Make the request
        PagedEnumerable<ListDataScanJobsResponse, DataScanJob> response = dataScanServiceClient.ListDataScanJobs(request);

        // Iterate over all response items, lazily performing RPCs as required
        foreach (DataScanJob item in response)
        {
            // Do something with each item
            Console.WriteLine(item);
        }

        // Or iterate over pages (of server-defined size), performing one RPC per page
        foreach (ListDataScanJobsResponse page in response.AsRawResponses())
        {
            // Do something with each page of items
            Console.WriteLine("A page of results:");
            foreach (DataScanJob item in page)
            {
                // Do something with each item
                Console.WriteLine(item);
            }
        }

        // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
        int pageSize = 10;
        Page<DataScanJob> singlePage = response.ReadPage(pageSize);
        // Do something with the page of items
        Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
        foreach (DataScanJob item in singlePage)
        {
            // Do something with each item
            Console.WriteLine(item);
        }
        // Store the pageToken, for when the next page is required.
        string nextPageToken = singlePage.NextPageToken;
    }
}

Go

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.


package main

import (
	"context"

	dataplex "cloud.google.com/go/dataplex/apiv1"
	dataplexpb "cloud.google.com/go/dataplex/apiv1/dataplexpb"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := dataplex.NewDataScanClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &dataplexpb.ListDataScanJobsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#ListDataScanJobsRequest.
	}
	it := c.ListDataScanJobs(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*dataplexpb.ListDataScanJobsResponse)
	}
}

Java

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

import com.google.cloud.dataplex.v1.DataScanJob;
import com.google.cloud.dataplex.v1.DataScanName;
import com.google.cloud.dataplex.v1.DataScanServiceClient;
import com.google.cloud.dataplex.v1.ListDataScanJobsRequest;

public class SyncListDataScanJobs {

  public static void main(String[] args) throws Exception {
    syncListDataScanJobs();
  }

  public static void syncListDataScanJobs() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (DataScanServiceClient dataScanServiceClient = DataScanServiceClient.create()) {
      ListDataScanJobsRequest request =
          ListDataScanJobsRequest.newBuilder()
              .setParent(DataScanName.of("[PROJECT]", "[LOCATION]", "[DATASCAN]").toString())
              .setPageSize(883849137)
              .setPageToken("pageToken873572522")
              .setFilter("filter-1274492040")
              .build();
      for (DataScanJob element : dataScanServiceClient.listDataScanJobs(request).iterateAll()) {
        // doThingsWith(element);
      }
    }
  }
}

Python

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import dataplex_v1


def sample_list_data_scan_jobs():
    # Create a client
    client = dataplex_v1.DataScanServiceClient()

    # Initialize request argument(s)
    request = dataplex_v1.ListDataScanJobsRequest(
        parent="parent_value",
    )

    # Make the request
    page_result = client.list_data_scan_jobs(request=request)

    # Handle the response
    for response in page_result:
        print(response)

Ruby

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

require "google/cloud/dataplex/v1"

##
# Snippet for the list_data_scan_jobs call in the DataScanService service
#
# This snippet has been automatically generated and should be regarded as a code
# template only. It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
# client as shown in https://cloud.google.com/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::Dataplex::V1::DataScanService::Client#list_data_scan_jobs.
#
def list_data_scan_jobs
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::Dataplex::V1::DataScanService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::Dataplex::V1::ListDataScanJobsRequest.new

  # Call the list_data_scan_jobs method.
  result = client.list_data_scan_jobs request

  # The returned object is of type Gapic::PagedEnumerable. You can iterate
  # over elements, and API calls will be issued to fetch pages as needed.
  result.each do |item|
    # Each element is of type ::Google::Cloud::Dataplex::V1::DataScanJob.
    p item
  end
end

REST

Per visualizzare i job di scansione della qualità dei dati storici, utilizza il metodo dataScans.jobs.list.

Concedere l'accesso ai risultati dell'analisi della qualità dei dati

Per consentire agli utenti della tua organizzazione di visualizzare i risultati della scansione:

Nella console Google Cloud , nella pagina BigQuery Cura dei metadati, vai alla scheda Profilazione e qualità dei dati.

Vai a Profilazione e qualità dei dati
Fai clic sulla scansione della qualità dei dati di cui vuoi condividere i risultati.
Fai clic sulla scheda Autorizzazioni.
Segui questi passaggi:
- Per concedere l'accesso a un'entità, fai clic su Concedi l'accesso. Concedi il ruolo Dataplex DataScan DataViewer all'entità associata.
- Per rimuovere l'accesso da un'entità, seleziona l'entità da cui vuoi rimuovere il ruolo Dataplex DataScan DataViewer. Fai clic su Rimuovi accesso e poi conferma quando richiesto.

Risolvere i problemi relativi a un errore di qualità dei dati

Puoi impostare avvisi per gli errori di qualità dei dati utilizzando i log in Cloud Logging. Per saperne di più, incluse le query di esempio, consulta Impostare avvisi in Cloud Logging.

Per ogni job con regole a livello di riga non riuscite, Dataplex Universal Catalog fornisce una query per ottenere i record non riusciti. Esegui questa query per visualizzare i record che non corrispondono alla tua regola.

Console

Nella console Google Cloud , nella pagina BigQuery Cura dei metadati, vai alla scheda Profilazione e qualità dei dati.

Vai a Profilazione e qualità dei dati
Fai clic sul nome della scansione della qualità dei dati di cui vuoi risolvere i problemi relativi ai record.
Fai clic sulla scheda Cronologia dei job.
Fai clic sull'ID del job che ha identificato errori di qualità dei dati.
Nella finestra dei risultati del job che si apre, nella sezione Regole, individua la colonna Query per ottenere i record non riusciti. Fai clic su Copia query negli appunti per la regola non riuscita.
Esegui la query in BigQuery per visualizzare i record che hanno causato l'errore del job.

gcloud

Non supportati.

REST

Per ottenere il job che ha identificato errori di qualità dei dati, utilizza il metodo dataScans.get.

Nell'oggetto della risposta, il campo failingRowsQuery mostra la query.
Esegui la query in BigQuery per visualizzare i record che hanno causato l'errore del job.

Gestire le scansioni della qualità dei dati per una tabella specifica

I passaggi descritti in questo documento mostrano come gestire le scansioni della qualità dei dati nel tuo progetto utilizzando la pagina Organizzazione dei metadati > Profilazione e qualità dei dati di BigQuery nella consoleGoogle Cloud .

Puoi anche creare e gestire le analisi della qualità dei dati quando lavori con una tabella specifica. Nella console Google Cloud , nella pagina BigQuery della tabella, utilizza la scheda Qualità dei dati. Segui questi passaggi:

Nella console Google Cloud , vai alla pagina BigQuery.

Vai a BigQuery

Nel riquadro Explorer (nel riquadro a sinistra), fai clic su Set di dati e poi sul tuo set di dati. Fai clic su Panoramica > Tabelle, quindi seleziona la tabella di cui vuoi visualizzare i risultati della scansione della qualità dei dati.
Fai clic sulla scheda Qualità dei dati.
A seconda che la tabella abbia un'analisi della qualità dei dati i cui risultati sono pubblicati come metadati di Dataplex Universal Catalog, puoi utilizzare le analisi della qualità dei dati della tabella nei seguenti modi:
- I risultati della scansione della qualità dei dati sono pubblicati: i risultati dell'ultima scansione vengono visualizzati nella pagina.
  
  Per gestire le scansioni della qualità dei dati per questa tabella, fai clic su Analisi della qualità dei dati e poi seleziona una delle seguenti opzioni:
  - Crea nuova scansione: crea una nuova scansione della qualità dei dati. Per saperne di più, consulta la sezione Crea un'analisi della qualità dei dati di questo documento. Quando crei una scansione dalla pagina dei dettagli di una tabella, la tabella è preselezionata.
  - Esegui ora: esegui la scansione.
  - Modifica configurazione di scansione: modifica le impostazioni, tra cui il nome visualizzato, i filtri e la pianificazione.
    
    Per modificare le regole di qualità dei dati, fai clic sulla scheda Qualità dei dati e poi sulla scheda Regole. Fai clic su Modifica regole. Aggiorna le regole e poi fai clic su Salva.
  - Gestisci autorizzazioni della scansione: controlla chi può accedere ai risultati della scansione. Per saperne di più, consulta la sezione Concedere l'accesso ai risultati dell'analisi della qualità dei dati di questo documento.
  - Visualizza risultati storici: visualizza informazioni dettagliate sui job di scansione della qualità dei dati precedenti. Per saperne di più, consulta le sezioni Visualizzare i risultati della scansione della qualità dei dati e Visualizzare i risultati della scansione cronologica di questo documento.
  - Visualizza tutte le scansioni: visualizza un elenco delle scansioni della qualità dei dati che si applicano a questa tabella.
- I risultati della scansione della qualità dei dati non vengono pubblicati: seleziona una delle seguenti opzioni:
  - Crea scansione qualità dati: crea una nuova scansione qualità dati. Per saperne di più, consulta la sezione Crea un'analisi della qualità dei dati di questo documento. Quando crei una scansione dalla pagina dei dettagli di una tabella, la tabella è preselezionata.
  - Visualizza le scansioni esistenti: visualizza un elenco delle scansioni della qualità dei dati che si applicano a questa tabella.

Visualizzare le scansioni della qualità dei dati per una tabella

Per visualizzare le analisi della qualità dei dati che si applicano a una tabella specifica:

Nella console Google Cloud , nella pagina Organizzazione dei metadati di BigQuery, vai alla scheda Profilazione e qualità dei dati.

Vai a Profilazione e qualità dei dati
Filtra l'elenco in base al nome della tabella e al tipo di scansione.

Aggiorna un'analisi della qualità dei dati

Puoi modificare varie impostazioni per una scansione della qualità dei dati esistente, ad esempio nome visualizzato, filtri, pianificazione e regole di qualità dei dati.

Console

Nella console Google Cloud , nella pagina BigQuery Cura dei metadati, vai alla scheda Profilazione e qualità dei dati.

Vai a Profilazione e qualità dei dati
Fai clic sul nome di un'analisi della qualità dei dati.
Per modificare le impostazioni, inclusi il nome visualizzato, i filtri e la programmazione, fai clic su Modifica. Modifica i valori e poi fai clic su Salva.
Per modificare le regole di qualità dei dati, nella pagina dei dettagli dell'analisi, fai clic sulla scheda Regole attuali. Fai clic su Modifica regole. Aggiorna le regole e poi fai clic su Salva.

gcloud

Per aggiornare la descrizione di una scansione della qualità dei dati, utilizza il comando gcloud dataplex datascans update data-quality:

gcloud dataplex datascans update data-quality DATASCAN \
--location=LOCATION \
--description=DESCRIPTION

Sostituisci quanto segue:

DATASCAN: il nome della scansione della qualità dei dati da aggiornare.
LOCATION: la regione Google Cloud in cui è stata creata la scansione della qualità dei dati.
DESCRIPTION: la nuova descrizione della scansione della qualità dei dati.

C#

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

using Google.Cloud.Dataplex.V1;
using Google.LongRunning;
using Google.Protobuf.WellKnownTypes;

public sealed partial class GeneratedDataScanServiceClientSnippets
{
    /// <summary>Snippet for UpdateDataScan</summary>
    /// <remarks>
    /// This snippet has been automatically generated and should be regarded as a code template only.
    /// It will require modifications to work:
    /// - It may require correct/in-range values for request initialization.
    /// - It may require specifying regional endpoints when creating the service client as shown in
    ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
    /// </remarks>
    public void UpdateDataScanRequestObject()
    {
        // Create client
        DataScanServiceClient dataScanServiceClient = DataScanServiceClient.Create();
        // Initialize request argument(s)
        UpdateDataScanRequest request = new UpdateDataScanRequest
        {
            DataScan = new DataScan(),
            UpdateMask = new FieldMask(),
            ValidateOnly = false,
        };
        // Make the request
        Operation<DataScan, OperationMetadata> response = dataScanServiceClient.UpdateDataScan(request);

        // Poll until the returned long-running operation is complete
        Operation<DataScan, OperationMetadata> completedResponse = response.PollUntilCompleted();
        // Retrieve the operation result
        DataScan result = completedResponse.Result;

        // Or get the name of the operation
        string operationName = response.Name;
        // This name can be stored, then the long-running operation retrieved later by name
        Operation<DataScan, OperationMetadata> retrievedResponse = dataScanServiceClient.PollOnceUpdateDataScan(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            DataScan retrievedResult = retrievedResponse.Result;
        }
    }
}

Go

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.


package main

import (
	"context"

	dataplex "cloud.google.com/go/dataplex/apiv1"
	dataplexpb "cloud.google.com/go/dataplex/apiv1/dataplexpb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := dataplex.NewDataScanClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &dataplexpb.UpdateDataScanRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#UpdateDataScanRequest.
	}
	op, err := c.UpdateDataScan(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Java

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

import com.google.cloud.dataplex.v1.DataScan;
import com.google.cloud.dataplex.v1.DataScanServiceClient;
import com.google.cloud.dataplex.v1.UpdateDataScanRequest;
import com.google.protobuf.FieldMask;

public class SyncUpdateDataScan {

  public static void main(String[] args) throws Exception {
    syncUpdateDataScan();
  }

  public static void syncUpdateDataScan() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (DataScanServiceClient dataScanServiceClient = DataScanServiceClient.create()) {
      UpdateDataScanRequest request =
          UpdateDataScanRequest.newBuilder()
              .setDataScan(DataScan.newBuilder().build())
              .setUpdateMask(FieldMask.newBuilder().build())
              .setValidateOnly(true)
              .build();
      DataScan response = dataScanServiceClient.updateDataScanAsync(request).get();
    }
  }
}

Python

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import dataplex_v1


def sample_update_data_scan():
    # Create a client
    client = dataplex_v1.DataScanServiceClient()

    # Initialize request argument(s)
    data_scan = dataplex_v1.DataScan()
    data_scan.data_quality_spec.rules.dimension = "dimension_value"
    data_scan.data.entity = "entity_value"

    request = dataplex_v1.UpdateDataScanRequest(
        data_scan=data_scan,
    )

    # Make the request
    operation = client.update_data_scan(request=request)

    print("Waiting for operation to complete...")

    response = operation.result()

    # Handle the response
    print(response)

Ruby

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

require "google/cloud/dataplex/v1"

##
# Snippet for the update_data_scan call in the DataScanService service
#
# This snippet has been automatically generated and should be regarded as a code
# template only. It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
# client as shown in https://cloud.google.com/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::Dataplex::V1::DataScanService::Client#update_data_scan.
#
def update_data_scan
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::Dataplex::V1::DataScanService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::Dataplex::V1::UpdateDataScanRequest.new

  # Call the update_data_scan method.
  result = client.update_data_scan request

  # The returned object is of type Gapic::Operation. You can use it to
  # check the status of an operation, cancel it, or wait for results.
  # Here is how to wait for a response.
  result.wait_until_done! timeout: 60
  if result.response?
    p result.response
  else
    puts "No response received."
  end
end

REST

Per modificare un'analisi della qualità dei dati, utilizza il metodo dataScans.patch.

Eliminare un'analisi della qualità dei dati

Console

Nella console Google Cloud , nella pagina BigQuery Cura dei metadati, vai alla scheda Profilazione e qualità dei dati.

Vai a Profilazione e qualità dei dati
Fai clic sulla scansione che vuoi eliminare.
Fai clic su Elimina e poi conferma quando richiesto.

gcloud

Per eliminare una scansione della qualità dei dati, utilizza il comando gcloud dataplex datascans delete:

gcloud dataplex datascans delete DATASCAN \
--location=LOCATION \
--async

Sostituisci le seguenti variabili:

DATASCAN: il nome della scansione della qualità dei dati da eliminare.
LOCATION: la regione Google Cloud in cui è stata creata la scansione della qualità dei dati.

C#

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

using Google.Cloud.Dataplex.V1;
using Google.LongRunning;
using Google.Protobuf.WellKnownTypes;

public sealed partial class GeneratedDataScanServiceClientSnippets
{
    /// <summary>Snippet for DeleteDataScan</summary>
    /// <remarks>
    /// This snippet has been automatically generated and should be regarded as a code template only.
    /// It will require modifications to work:
    /// - It may require correct/in-range values for request initialization.
    /// - It may require specifying regional endpoints when creating the service client as shown in
    ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
    /// </remarks>
    public void DeleteDataScanRequestObject()
    {
        // Create client
        DataScanServiceClient dataScanServiceClient = DataScanServiceClient.Create();
        // Initialize request argument(s)
        DeleteDataScanRequest request = new DeleteDataScanRequest
        {
            DataScanName = DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]"),
            Force = false,
        };
        // Make the request
        Operation<Empty, OperationMetadata> response = dataScanServiceClient.DeleteDataScan(request);

        // Poll until the returned long-running operation is complete
        Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
        // Retrieve the operation result
        Empty result = completedResponse.Result;

        // Or get the name of the operation
        string operationName = response.Name;
        // This name can be stored, then the long-running operation retrieved later by name
        Operation<Empty, OperationMetadata> retrievedResponse = dataScanServiceClient.PollOnceDeleteDataScan(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            Empty retrievedResult = retrievedResponse.Result;
        }
    }
}

Go

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.


package main

import (
	"context"

	dataplex "cloud.google.com/go/dataplex/apiv1"
	dataplexpb "cloud.google.com/go/dataplex/apiv1/dataplexpb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := dataplex.NewDataScanClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &dataplexpb.DeleteDataScanRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#DeleteDataScanRequest.
	}
	op, err := c.DeleteDataScan(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	err = op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
}

Java

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

import com.google.cloud.dataplex.v1.DataScanName;
import com.google.cloud.dataplex.v1.DataScanServiceClient;
import com.google.cloud.dataplex.v1.DeleteDataScanRequest;
import com.google.protobuf.Empty;

public class SyncDeleteDataScan {

  public static void main(String[] args) throws Exception {
    syncDeleteDataScan();
  }

  public static void syncDeleteDataScan() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (DataScanServiceClient dataScanServiceClient = DataScanServiceClient.create()) {
      DeleteDataScanRequest request =
          DeleteDataScanRequest.newBuilder()
              .setName(DataScanName.of("[PROJECT]", "[LOCATION]", "[DATASCAN]").toString())
              .setForce(true)
              .build();
      dataScanServiceClient.deleteDataScanAsync(request).get();
    }
  }
}

Python

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import dataplex_v1


def sample_delete_data_scan():
    # Create a client
    client = dataplex_v1.DataScanServiceClient()

    # Initialize request argument(s)
    request = dataplex_v1.DeleteDataScanRequest(
        name="name_value",
    )

    # Make the request
    operation = client.delete_data_scan(request=request)

    print("Waiting for operation to complete...")

    response = operation.result()

    # Handle the response
    print(response)

Ruby

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

require "google/cloud/dataplex/v1"

##
# Snippet for the delete_data_scan call in the DataScanService service
#
# This snippet has been automatically generated and should be regarded as a code
# template only. It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
# client as shown in https://cloud.google.com/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::Dataplex::V1::DataScanService::Client#delete_data_scan.
#
def delete_data_scan
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::Dataplex::V1::DataScanService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::Dataplex::V1::DeleteDataScanRequest.new

  # Call the delete_data_scan method.
  result = client.delete_data_scan request

  # The returned object is of type Gapic::Operation. You can use it to
  # check the status of an operation, cancel it, or wait for results.
  # Here is how to wait for a response.
  result.wait_until_done! timeout: 60
  if result.response?
    p result.response
  else
    puts "No response received."
  end
end

REST

Per eliminare una scansione della qualità dei dati, utilizza il metodo dataScans.delete.

Passaggi successivi

Scopri di più sulla governance dei dati in BigQuery.