O Google usa tecnologia de IA na tradução de conteúdos para seu idioma de preferência. As traduções com IA podem ter erros.

Verificar problemas de qualidade de dados

A qualidade de dados automática do Knowledge Catalog permite definir e medir a qualidade dos dados nas tabelas do BigQuery. É possível automatizar as verificações de dados, validar os dados de acordo com as regras definidas e registrar alertas se os dados não atenderem aos requisitos de qualidade.

É possível gerenciar as verificações de qualidade de dados em todo o projeto ou em uma tabela específica. Para mais informações sobre a qualidade de dados automática, consulte Visão geral da qualidade de dados automática.

Antes de começar

Ative a API Dataplex, se ainda não tiver feito isso.
Funções necessárias para ativar APIs
Para ativar APIs, você precisa da permissão serviceusage.services.enable. Se você criou o projeto, provavelmente já tem essa permissão pelo papel de proprietário (roles/owner). Caso contrário, é possível conseguir essa permissão pelo papel de administrador do Service Usage (roles/serviceusage.serviceUsageAdmin). Saiba como conceder papéis.
Ativar a API
Opcional: se você quiser que o Knowledge Catalog gere recomendações para regras de qualidade de dados com base nos resultados de uma verificação do perfil de dados, crie e execute a verificação do perfil de dados.

Funções exigidas

Nesta seção, descrevemos os papéis e as permissões do IAM necessários para usar as verificações de qualidade de dados do Knowledge Catalog.

Funções e permissões do usuário

Para receber as permissões necessárias para executar e gerenciar verificações de qualidade de dados, peça ao administrador para conceder a você os seguintes papéis do IAM:

Execute uma verificação de qualidade de dados em uma tabela do BigQuery:
- Usuário de jobs do BigQuery (roles/bigquery.jobUser) no projeto para executar jobs de verificação
- Visualizador de dados do BigQuery (roles/bigquery.dataViewer) na tabela do BigQuery que será verificada
Publique os resultados da verificação de qualidade de dados no Knowledge Catalog:
- Editor de dados do BigQuery (roles/bigquery.dataEditor) na tabela verificada
- Editor do catálogo do Dataplex (roles/dataplex.catalogEditor) no grupo de entrada @bigquery no mesmo local da tabela
Realizar tarefas específicas em recursos do DataScan:
- Administrador do DataScan Dataplex (roles/dataplex.dataScanAdmin) no projeto para acesso total
- Criador de DataScan Dataplex (roles/dataplex.dataScanCreator) no projeto para criar verificações
- Editor do DataScan Dataplex (roles/dataplex.dataScanEditor) no projeto para acesso de gravação
- Leitor do DataScan Dataplex (roles/dataplex.dataScanViewer) no projeto para ler os metadados da verificação
- Leitor de dados do DataScan Dataplex (roles/dataplex.dataScanDataViewer) no projeto para ler dados de verificação, incluindo regras e resultados.

Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Esses papéis predefinidos contêm as permissões necessárias para executar e gerenciar verificações de qualidade de dados. Para acessar as permissões exatas necessárias, expanda a seção Permissões necessárias:

Permissões necessárias

As seguintes permissões são necessárias para executar e gerenciar verificações de qualidade de dados:

Execute uma verificação de qualidade de dados em uma tabela do BigQuery:
- bigquery.jobs.create no projeto para executar jobs de verificação
- bigquery.tables.get na tabela do BigQuery a ser verificada
- bigquery.tables.getData na tabela do BigQuery a ser verificada
Publicar resultados da verificação de qualidade de dados no Knowledge Catalog:
- bigquery.tables.update na tabela verificada
- dataplex.entryGroups.useDataQualityScorecardAspect no grupo de entrada @bigquery no mesmo local da tabela
Criar um DataScan: dataplex.datascans.create no projeto
Exclua um DataScan: dataplex.datascans.delete no projeto
Ver metadados de DataScan: dataplex.datascans.get no projeto
Ver detalhes de DataScan, incluindo regras e resultados: dataplex.datascans.getData no projeto
Liste DataScans: dataplex.datascans.list no projeto
Execute um DataScan: dataplex.datascans.run no projeto
Atualizar um DataScan: dataplex.datascans.update no projeto
Receber ou definir a política do IAM em um DataScan:
- dataplex.datascans.getIamPolicy no projeto
- dataplex.datascans.setIamPolicy no projeto

Essas permissões também podem ser concedidas com funções personalizadas ou outros papéis predefinidos.

Se precisar acessar colunas protegidas por políticas de acesso no nível da coluna do BigQuery, você também precisará de permissões para essas colunas.

Papéis e permissões da conta de serviço do Knowledge Catalog

Se você ainda não criou nenhuma verificação de qualidade de dados ou verificação do perfil de dados ou não tem um lake do Knowledge Catalog neste projeto, crie um identificador de serviço executando: gcloud beta services identity create --service=dataplex.googleapis.com. Esse comando retorna um identificador de serviço do Knowledge Catalog, caso ele exista.

Para garantir que a conta de serviço do Knowledge Catalog do projeto que contém a verificação de qualidade de dados tenha as permissões necessárias para ler dados de várias fontes e exportar resultados, peça ao administrador para conceder os seguintes papéis do IAM à conta de serviço do Knowledge Catalog do projeto que contém a verificação de qualidade de dados:

Ler dados da tabela do BigQuery: Visualizador de dados do BigQuery (roles/bigquery.dataViewer) nas tabelas a serem verificadas e em todas as outras tabelas referenciadas nas regras
Ler o catálogo REST do Iceberg, o SAP Business Data Cloud Delta Lake e o Apache Hive nos dados da tabela do Lakehouse do Google Cloud : Leitor do BigLake (roles/biglake.viewer) nas respectivas tabelas a serem verificadas e em todas as outras tabelas referenciadas nas regras
Exportar os resultados da verificação para uma tabela do BigQuery: Editor de dados do BigQuery (roles/bigquery.dataEditor) no conjunto de dados e na tabela de resultados
Verifique os dados do BigQuery organizados em um lake do Knowledge Catalog:
- Leitor de metadados do Dataplex (roles/dataplex.metadataReader) nos recursos do Dataplex
- Leitor do Dataplex (roles/dataplex.viewer) nos recursos do Dataplex
Verificar uma tabela externa do BigQuery no Cloud Storage: Leitor de objetos do Storage (roles/storage.objectViewer) no bucket do Cloud Storage

Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Esses papéis predefinidos contêm as permissões necessárias para ler dados de várias fontes e exportar resultados. Para acessar as permissões exatas necessárias, expanda a seção Permissões necessárias:

Permissões necessárias

As permissões a seguir são necessárias para ler dados de várias fontes e exportar resultados:

Ler dados da tabela do BigQuery:
- bigquery.tables.get em tabelas do BigQuery
- bigquery.tables.getData em tabelas do BigQuery
Exportar os resultados da verificação para uma tabela do BigQuery:
- bigquery.datasets.get no conjunto de dados e na tabela de resultados
- bigquery.tables.create no conjunto de dados e na tabela de resultados
- bigquery.tables.get no conjunto de dados e na tabela de resultados
- bigquery.tables.getData no conjunto de dados e na tabela de resultados
- bigquery.tables.update no conjunto de dados e na tabela de resultados
- bigquery.tables.updateData no conjunto de dados e na tabela de resultados
Verifique os dados do BigQuery organizados em um lake do Knowledge Catalog:
- dataplex.lakes.list nos recursos do Dataplex
- dataplex.lakes.get nos recursos do Dataplex
- dataplex.zones.list nos recursos do Dataplex
- dataplex.zones.get nos recursos do Dataplex
- dataplex.entities.list nos recursos do Dataplex
- dataplex.entities.get nos recursos do Dataplex
- dataplex.operations.get nos recursos do Dataplex
Verificar uma tabela externa do BigQuery no Cloud Storage:
- storage.buckets.get no bucket do Cloud Storage
- storage.objects.get no bucket do Cloud Storage

O administrador também pode conceder essas permissões à conta de serviço do Knowledge Catalog do projeto que contém a verificação de qualidade de dados com papéis personalizados ou outros papéis predefinidos.

Se precisar acessar colunas protegidas por políticas de acesso no nível da coluna do BigQuery, atribua à conta de serviço do Knowledge Catalog permissões para essas colunas.

Se uma tabela tiver políticas de acesso no nível da linha do BigQuery habilitadas, só será possível verificar as linhas visíveis para a conta de serviço do Knowledge Catalog. Os privilégios de acesso do usuário individual não são avaliados para fins de políticas no nível da linha.

Criar uma verificação de qualidade de dados

Console

No console do Google Cloud , na página Curadoria de metadados do BigQuery, acesse a guia Qualidade e criação do perfil de dados.

Acessar "Qualidade e perfilamento de dados"
Clique em Criar verificação de qualidade de dados.
Na janela Definir verificação, preencha os seguintes campos:
1. Opcional: insira um Nome de exibição.
2. Insira um ID. Consulte as convenções de nomenclatura de recursos.
3. Opcional: digite uma Descrição.
4. No campo Tabela, clique em Procurar. Escolha a tabela a ser verificada e clique em Selecionar. Somente as tabelas padrão do BigQuery, do catálogo REST do Iceberg, do SAP BDC Delta e do Hive no Google Cloud Lakehouse são compatíveis.
  
  Para tabelas em conjuntos de dados multirregionais, escolha uma região para criar a verificação de dados.
  
  Para navegar pelas tabelas organizadas nos lakes do Knowledge Catalog, clique em Procurar nos lakes do Knowledge Catalog.
5. No campo Escopo, escolha Incremental ou Dados completos.
  - Se você escolher Incremental: no campo Coluna de carimbo de data/hora, selecione uma coluna do tipo DATE ou TIMESTAMP na tabela do BigQuery que cresça à medida que novos registros são adicionados e que possa ser usada para identificar novos registros. Pode ser uma coluna que particiona a tabela.
6. Opcional: para filtrar os dados, marque a caixa de seleção Filtrar linhas. Forneça um filtro de linha que consiste em uma expressão SQL válida que pode ser usada como parte de uma cláusula WHERE na sintaxe do GoogleSQL. Por exemplo, col1 >= 0. O filtro pode ser uma combinação de várias condições de coluna. Por exemplo, col1 >= 0 AND col2 < 10.
7. Para fazer uma amostragem dos dados, na lista Tamanho da amostragem, selecione uma porcentagem de amostragem. Escolha uma porcentagem entre 0,0% e 100,0% com até três casas decimais. Para conjuntos de dados maiores, escolha uma porcentagem de amostragem menor. Por exemplo, para uma tabela de 1 PB, se você inserir um valor entre 0,1% e 1,0%, a verificação de qualidade de dados vai amostrar entre 1 e 10 TB de dados. Nas verificações de dados incrementais, a verificação de qualidade de dados aplica amostragem ao incremento mais recente.
8. Opcional: para publicar os resultados da verificação de qualidade de dados como metadados do Knowledge Catalog, marque a caixa de seleção Publicar resultados no Knowledge Catalog.
  
  É possível conferir os resultados mais recentes da verificação na guia Qualidade de dados nas páginas do BigQuery e do Knowledge Catalog para a tabela de origem. Para permitir que os usuários acessem os resultados publicados da verificação, consulte a seção Conceder acesso aos resultados da verificação de qualidade de dados neste documento.
9. Para Tipo de credencial, consulte Configurar identidade de execução.
10. Para criar uma verificação de qualidade de dados usando regras, selecione Tipo de regra > Criar com regra baseada em entrada.
11. Na seção Programação, escolha uma das seguintes opções:
  - Repetir: execute a verificação de qualidade de dados em uma programação: por hora, diária, semanal, mensal ou personalizada. Especifique a frequência e o horário da verificação. Se você escolher "Personalizado", use o formato cron para especificar a programação.
  - Sob demanda: execute a verificação de qualidade de dados sob demanda.
  - Execução única: execute a verificação de qualidade de dados uma vez agora e remova-a após o tempo de exclusão automática. Esse recurso está na visualização.
    - Definir a exclusão automática dos resultados após a verificação: o tempo de exclusão automática é o período entre a execução e a exclusão da verificação. Uma verificação de qualidade de dados sem um tempo de exclusão automática especificado é excluída automaticamente 24 horas após a execução. O tempo de exclusão automática pode variar de 0 segundos (exclusão imediata) a 365 dias.
12. Clique em Continuar.
Na janela Regras de qualidade de dados, defina as regras a serem configuradas para essa verificação de qualidade de dados.
1. Clique em Adicionar regras e escolha uma das opções a seguir.
  - Recomendações com base no perfil: crie regras com base nas recomendações de uma verificação de perfil de dados atual.
    1. Escolher colunas: selecione as colunas para receber regras recomendadas.
    2. Escolher projeto de verificação: se a verificação do perfil de dados estiver em um projeto diferente daquele em que você está criando a verificação de qualidade de dados, selecione o projeto de onde as verificações de perfil serão extraídas.
    3. Escolher resultados de perfil: selecione um ou mais resultados de perfil e clique em OK. Isso preenche uma lista de regras sugeridas que você pode usar como ponto de partida.
    4. Marque a caixa de seleção das regras que você quer adicionar e clique em Selecionar. Depois de selecionadas, as regras são adicionadas à sua lista de regras atual. Em seguida, você pode editar as regras.
  - Tipos de regras integradas: crie regras com base em regras predefinidas. Consulte a lista de regras predefinidas.
    1. Escolher colunas: selecione as colunas para as quais você quer escolher regras.
    2. Escolher tipos de regra: selecione os tipos de regra que você quer escolher e clique em OK. Os tipos de regra que aparecem dependem das colunas selecionadas.
    3. Marque a caixa de seleção das regras que você quer adicionar e clique em Selecionar. Depois de selecionadas, as regras são adicionadas à sua lista de regras atual. Em seguida, você pode editar as regras.
  - Regra de verificação de linhas SQL: crie uma regra SQL personalizada para aplicar a cada linha.
    1. Em Dimensão, escolha uma dimensão.
    2. Em Limite de aprovação, escolha uma porcentagem de registros que precisam passar na verificação.
    3. Em Nome da coluna, escolha uma coluna.
    4. No campo Fornecer uma expressão SQL, insira uma expressão SQL que seja avaliada como um booleano true (aprovado) ou false (reprovado). Para mais informações, consulte Tipos de regras SQL personalizadas compatíveis e os exemplos em Definir regras de qualidade de dados.
    5. Clique em Adicionar.
  - Regra de verificação agregada do SQL: crie uma regra de condição de tabela SQL personalizada.
    1. Em Dimensão, escolha uma dimensão.
    2. Em Nome da coluna, escolha uma coluna.
    3. No campo Fornecer uma expressão SQL, insira uma expressão SQL que seja avaliada como um booleano true (aprovado) ou false (reprovado). Para mais informações, consulte Tipos de regras SQL personalizadas compatíveis e os exemplos em Definir regras de qualidade de dados.
    4. Clique em Adicionar.
  - Regra de declaração SQL: crie uma regra de declaração SQL personalizada para verificar se há um estado inválido dos dados.
    1. Em Dimensão, escolha uma dimensão.
    2. Opcional: em Nome da coluna, escolha uma coluna.
    3. No campo Fornecer uma instrução SQL, insira uma instrução SQL que retorne linhas que correspondam ao estado inválido. Se alguma linha for retornada, essa regra falhará. Omita o ponto e vírgula final da instrução SQL. Para mais informações, consulte Tipos de regras SQL personalizadas compatíveis e os exemplos em Definir regras de qualidade de dados.
    4. Clique em Adicionar.
2. Opcional: para qualquer regra de qualidade de dados, é possível atribuir um nome personalizado para usar no monitoramento e nos alertas, além de uma descrição. Para fazer isso, edite uma regra e especifique os seguintes detalhes:
  - Nome da regra: insira um nome personalizado com até 63 caracteres. O nome da regra pode incluir letras (a-z, A-Z), dígitos (0-9) e hifens (-) e precisa começar com uma letra e terminar com um número ou uma letra.
  - Descrição: insira uma descrição de regra com no máximo 1.024 caracteres.
3. Repita as etapas anteriores para adicionar outras regras à verificação de qualidade de dados. Quando terminar, clique em Continuar.
Opcional: exporte os resultados da verificação para uma tabela padrão do BigQuery. Na seção Exportar os resultados da verificação para a tabela do BigQuery, faça o seguinte:
1. No campo Selecionar conjunto de dados do BigQuery, clique em Procurar. Selecione um conjunto de dados do BigQuery para armazenar os resultados da verificação de qualidade de dados.
2. No campo Tabela do BigQuery, especifique a tabela para armazenar os resultados da verificação de qualidade de dados. Se você estiver usando uma tabela, verifique se ela é compatível com o esquema de tabela de exportação. Se a tabela especificada não existir, o Knowledge Catalog vai criá-la.
  
  Observação :é possível usar a mesma tabela de resultados para várias verificações de qualidade de dados.
Opcional: adicione rótulos. Rótulos são pares de chave-valor que permitem agrupar objetos relacionados entre si ou com outros recursos do Google Cloud .
Opcional: configure relatórios de notificação por e-mail para alertar as pessoas sobre o status e os resultados de um job de verificação de qualidade de dados. Na seção Relatório de notificações, clique em Adicionar ID de e-mail e insira até cinco endereços de e-mail. Em seguida, selecione os cenários para os quais você quer enviar relatórios:
- Índice de qualidade (<=): envia um relatório quando um job é concluído com um índice de qualidade de dados menor que o índice de destino especificado. Insira um índice de qualidade desejado entre 0 e 100.
- Falhas no job: envia um relatório quando o job falha, independentemente dos resultados da qualidade de dados.
- Conclusão do job (sucesso ou falha): envia um relatório quando o job termina, independentemente dos resultados da qualidade de dados.
Clique em Criar.

Depois que a verificação for criada, você poderá executá-la a qualquer momento clicando em Executar agora.

gcloud

Para criar uma verificação de qualidade de dados, use o comando gcloud dataplex datascans create data-quality.

Se os dados de origem estiverem organizados em um lake do Knowledge Catalog, inclua a 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 os dados de origem não estiverem organizados em um lake do Knowledge Catalog, inclua a 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

Substitua as seguintes variáveis:

DATASCAN: o nome da verificação de qualidade de dados.
LOCATION: a região Google Cloud em que a verificação da qualidade de dados será criada.
DATA_QUALITY_SPEC_FILE: o caminho para o arquivo JSON ou YAML que contém as especificações da verificação de qualidade de dados. O arquivo pode ser local ou um caminho do Cloud Storage com o prefixo gs://. Use esse arquivo para especificar as regras de qualidade de dados da verificação. Também é possível especificar outros detalhes nesse arquivo, como filtros, porcentagem de amostragem e ações pós-verificação, como exportar para o BigQuery ou enviar relatórios de notificação por e-mail. Consulte a documentação para representação JSON e o exemplo de representação YAML.
DATA_SOURCE_ENTITY: a entidade do Knowledge Catalog que contém os dados da verificação de qualidade de dados. Por exemplo, projects/test-project/locations/test-location/lakes/test-lake/zones/test-zone/entities/test-entity.
DATA_SOURCE_RESOURCE: o nome do recurso que contém os dados da verificação de qualidade de dados. Por exemplo, //bigquery.googleapis.com/projects/test-project/datasets/test-dataset/tables/test-table.

C#

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.


//go:build examples

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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

// 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) {
  /**
   * 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 = {}
  /**
   *  Optional. DataScan identifier. If not provided, a unique ID will be
   *  generated with the prefix "data-scan-".
   *  * 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,
    };

    // 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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

# 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
#
#      http://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.

import google.api_core.exceptions
from google.cloud import dataplex_v1


def create_data_quality_scan_global(
    project_id: str,
    dataset_id: str,
    table_id: str,
    location: str,
    column_id_1: str,
    column_id_2: str,
) -> None:
    """Creates a Dataplex Data Quality Scan using global API endpoint routing.

    Args:
        project_id (str): Google Cloud project ID where the scan is created.
        dataset_id (str): Target BigQuery dataset ID.
        table_id (str): Target BigQuery table ID to scan.
        location (str): Google Cloud region where serverless compute runs.
        column_id_1 (str): Name of the first column to evaluate.
        column_id_2 (str): Name of the second column to evaluate.
    """
    client = dataplex_v1.DataScanServiceClient()

    parent = client.common_location_path(project=project_id, location=location)

    # A bigquery table with at least 2 columns is assumed.
    bigquery_table = (
        f"//bigquery.googleapis.com/projects/{project_id}"
        f"/datasets/{dataset_id}/tables/{table_id}"
    )

    data_quality_spec = dataplex_v1.DataQualitySpec(
        rules=[
            dataplex_v1.DataQualityRule(
                name="global-null-assertion",
                dimension="COMPLETENESS",
                description="Fails if any row contains a null value",
                sql_assertion=dataplex_v1.DataQualityRule.SqlAssertion(
                    # Use ${data()} as the placeholder for the table Dataplex is scanning
                    sql_statement=(
                        "SELECT * FROM ${data()} "
                        f"WHERE {column_id_1} IS NULL OR {column_id_2} IS NULL"
                    )
                ),
            )
        ]
    )

    data_scan = dataplex_v1.DataScan(
        display_name="Global Data Quality Scan",
        data=dataplex_v1.DataSource(resource=bigquery_table),
        data_quality_spec=data_quality_spec,
    )

    request = dataplex_v1.CreateDataScanRequest(parent=parent, data_scan=data_scan)

    try:
        operation = client.create_data_scan(request=request)
        print(operation.result())
    except google.api_core.exceptions.AlreadyExists:
        print("A scan with this ID already exists.")
    except google.api_core.exceptions.InvalidArgument as e:
        print(f"Your scan configuration is invalid: {e}")
    except google.api_core.exceptions.GoogleAPIError as e:
        print(f"Unexpected exception: {e}")

Ruby

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para criar uma verificação de qualidade de dados, use o método dataScans.create.

A solicitação a seguir cria uma verificação única de qualidade de dados:

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
    }
  ],
  "filter": "FILTER_CONDITION"
}
}

Substitua:

PROJECT_ID: o ID do projeto.
LOCATION: a região em que a verificação de qualidade de dados será criada.
DATASCAN_ID: o ID da verificação de qualidade de dados.
DATASET_ID: o ID do conjunto de dados do BigQuery.
TABLE_ID: o ID da tabela do BigQuery.
COLUMN_NAME: o nome da coluna da regra.
DIMENSION: a dimensão da regra, por exemplo, VALIDITY.
FILTER_CONDITION: uma string de filtro AIP-160 opcional para executar regras de maneira seletiva (por exemplo, name = \"RULE_NAME\").

Se você quiser criar regras para a verificação de qualidade de dados usando recomendações de regras baseadas nos resultados de uma verificação do perfil de dados, chame o método dataScans.jobs.generateDataQualityRules na verificação do perfil de dados para receber as recomendações.

Observação:se a tabela do BigQuery estiver configurada com a opção Exigir filtro de partição definida como true, use a coluna de partição do BigQuery como o filtro de linha da verificação de qualidade de dados ou a coluna de carimbo de data/hora.

Executar uma verificação de qualidade de dados

Console

No console do Google Cloud , na página Curadoria de metadados do BigQuery, acesse a guia Qualidade e criação do perfil de dados.

Acessar "Qualidade e perfilamento de dados"
Clique na verificação de qualidade de dados para executar.
Clique em Executar agora.

gcloud

Para executar uma verificação de qualidade de dados, use o comando gcloud dataplex datascans run:

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

Substitua as seguintes variáveis:

LOCATION: a Google Cloud região em que a verificação de qualidade de dados foi criada.
DATASCAN: o nome da verificação de qualidade de dados.

C#

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.


//go:build examples

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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

# 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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para executar uma verificação de qualidade de dados, use o método dataScans.run.

Airflow

Para executar uma verificação de qualidade de dados usando um gráfico acíclico dirigido (DAG) no Serviço Gerenciado para Apache Airflow (Cloud Composer), use o DataplexRunDataQualityScanOperator:

from datetime import datetime
from airflow import DAG
from airflow.providers.google.cloud.operators.dataplex import DataplexRunDataQualityScanOperator

with DAG(
  "dataplex_auto_dq_scan",
  start_date=datetime(2026, 1, 1),
  schedule_interval="@daily",
  catchup=False,
) as dag:

  run_dq_scan = DataplexRunDataQualityScanOperator(
      task_id="run_dataplex_dq_scan",
      project_id="PROJECT_ID",
      region="REGION",
      data_scan_id="DATASCAN_ID",
  )

Substitua:

PROJECT_ID: o ID do projeto do Google Cloud .
REGION: a região Google Cloud em que a verificação de qualidade de dados foi criada.
DATASCAN_ID: o ID da verificação de qualidade de dados.

Ver resultados da verificação de qualidade de dados

Console

No console do Google Cloud , na página Curadoria de metadados do BigQuery, acesse a guia Qualidade e criação do perfil de dados.

Acessar "Qualidade e perfilamento de dados"
Clique no nome de uma verificação de qualidade de dados.
- A seção Visão geral mostra informações sobre os jobs mais recentes, incluindo quando a verificação foi executada, o número de registros verificados em cada job, se todas as verificações de qualidade de dados foram aprovadas e, se houver falhas, o número de verificações de qualidade de dados que falharam.
- A seção Configuração da verificação de qualidade de dados exibe detalhes sobre a verificação.
Para ver informações detalhadas sobre um job, como pontuações de qualidade de dados que indicam a porcentagem de regras aprovadas, quais regras falharam e os registros de jobs, clique na guia Histórico de jobs. Em seguida, clique em um ID da tarefa.

gcloud

Para ver os resultados de um job de verificação de qualidade de dados, use o comando gcloud dataplex datascans jobs describe:

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

Substitua as seguintes variáveis:

JOB: O ID da tarefa do job de verificação da qualidade de dados.
LOCATION: a região Google Cloud em que a verificação de qualidade de dados foi criada.
DATASCAN: o nome da verificação de qualidade de dados a que o job pertence.
--view=FULL: para conferir o resultado do job de verificação, especifique FULL.

C#

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.


//go:build examples

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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

# 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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para ver os resultados de uma verificação de qualidade de dados, use o método dataScans.get.

Ver resultados publicados

Se os resultados da verificação de qualidade de dados forem publicados como metadados do Knowledge Catalog, será possível conferir os resultados mais recentes nas páginas do BigQuery e do Knowledge Catalog no consoleGoogle Cloud , na guia Qualidade de dados da tabela de origem.

No console do Google Cloud , acesse a página BigQuery.

Acessar o BigQuery
No painel à esquerda, clique em Explorer:

Se o painel esquerdo não aparecer, clique em Expandir painel esquerdo para abrir.
No painel Explorer, clique em Conjuntos de dados e, em seguida, clique no seu conjunto de dados.
Clique em Visão geral > Tabelas e selecione a tabela com os resultados da verificação de qualidade de dados que você quer ver.
Clique na guia Qualidade dos dados.

Os resultados publicados mais recentes são mostrados.

Observação :os resultados publicados podem não estar disponíveis se uma verificação estiver sendo executada pela primeira vez.

Ver o histórico de resultados das verificações

O Knowledge Catalog salva o histórico de verificação de qualidade de dados dos últimos 300 jobs ou do ano anterior, o que ocorrer primeiro.

Console

No console do Google Cloud , na página Curadoria de metadados do BigQuery, acesse a guia Qualidade e criação do perfil de dados.

Acessar "Qualidade e perfilamento de dados"
Clique no nome de uma verificação de qualidade de dados.
Clique na guia Histórico de jobs.

A guia Histórico de jobs fornece informações sobre jobs anteriores, como o número de registros verificados em cada job, o status do job, o horário em que o job foi executado e se cada regra foi aprovada ou reprovada.
Para ver informações detalhadas sobre um job, clique em qualquer um deles na coluna código da tarefa.

gcloud

Para conferir os jobs históricos de verificação de qualidade de dados, use o comando gcloud dataplex datascans jobs list:

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

Substitua as seguintes variáveis:

LOCATION: a região Google Cloud em que a verificação de qualidade de dados foi criada.
DATASCAN: o nome da verificação de qualidade de dados para conferir os jobs históricos.

C#

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.


//go:build examples

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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

# 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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para ver os jobs históricos de verificação da qualidade de dados, use o método dataScans.jobs.list.

Status dos jobs

Os jobs de verificação de dados podem ter os seguintes status:

PENDING: o job foi criado, mas ainda não começou a ser executado. Nesse estado, a verificação configura ativamente a infraestrutura ou adquire slots. Essa fase pode levar de 10 a 20 segundos ou mais, dependendo da complexidade do esquema e da contenção de recursos.
RUNNING: o job está em execução.
CANCELING: o job está sendo cancelado.
CANCELLED: o job foi cancelado.
SUCCEEDED: o job é concluído com sucesso. O status de conclusão pode atrasar a conclusão real da consulta em até 60 segundos devido a etapas de pós-processamento, como agregação e sincronização de metadados.
FAILED: o job falha devido a um erro. O status de conclusão pode atrasar a conclusão real da consulta em até 60 segundos devido a etapas de pós-processamento, como agregação e sincronização de metadados.
SUCCEEDED_WITH_ERRORS: o job é concluído, mas alguns erros ocorrem durante a execução.

Práticas recomendadas de monitoramento

Ao monitorar os jobs de verificação de dados, lembre-se das seguintes práticas recomendadas:

Evite sondagens agressivas: evite sondagens agressivas (por exemplo, chamar GetJob ou equivalente a cada 1 a 5 segundos). A sondagem agressiva desperdiça a cota da API e não acelera as transições de estado.
Use a espera exponencial: se a sondagem repetitiva for inevitável, use a espera exponencial começando em 10 a 15 segundos.
Use o desacoplamento assíncrono orientado por eventos (recomendado): em vez de pesquisas síncronas de API, use gatilhos do Eventarc que detectam os Registros de auditoria do Cloud (cloudaudit.googleapis.com). É possível usar esses gatilhos para iniciar fluxos de trabalho downstream imediatamente após os eventos de conclusão do job do DataScan. Essa abordagem ignora os limites de sondagem da API, conserva a cota e reduz a latência percebida.

Conceder acesso aos resultados da verificação de qualidade de dados

Para permitir que os usuários da sua organização vejam os resultados da verificação, faça o seguinte:

No console do Google Cloud , na página Curadoria de metadados do BigQuery, acesse a guia Qualidade e criação do perfil de dados.

Acessar "Qualidade e perfilamento de dados"
Clique na verificação de qualidade de dados cujos resultados você quer compartilhar.
Clique na guia Permissões.
Faça o seguinte:
- Para conceder acesso a um principal, clique em Conceder acesso. Conceda o papel Leitor de dados do DataScan do Dataplex ao principal associado.
- Para remover o acesso de um principal, selecione o principal de quem você quer remover o papel Leitor de dados do DataScan do Dataplex. Clique em Remover acesso e confirme quando solicitado.

Resolver uma falha de qualidade de dados

É possível definir alertas para falhas de qualidade de dados usando os registros no Cloud Logging. Para mais informações, incluindo exemplos de consultas, consulte Definir alertas no Cloud Logging.

Para cada job com regras no nível da linha que falham, o Knowledge Catalog fornece uma consulta para receber os registros com falha. Execute esta consulta para ver os registros que não correspondem à regra.

Console

No console do Google Cloud , na página Curadoria de metadados do BigQuery, acesse a guia Qualidade e criação do perfil de dados.

Acessar "Qualidade e perfilamento de dados"
Clique no nome da verificação de qualidade de dados cujos registros você quer resolver problemas.
Clique na guia Histórico de jobs.
Clique no ID da tarefa do job que identificou falhas na qualidade de dados.
Na janela de resultados do job que é aberta, na seção Regras, encontre a coluna Consulta para receber registros com falha. Clique em Copiar consulta para a área de transferência na regra com falha.
Execute a consulta no BigQuery para ver os registros que causaram a falha do job.

gcloud

Incompatível.

REST

Para acessar o job que identificou as falhas de qualidade de dados, use o método dataScans.get.

No objeto de resposta, o campo failingRowsQuery mostra a consulta.
Execute a consulta no BigQuery para ver os registros que causaram a falha do job.

O Knowledge Catalog também executa a consulta de depuração, desde que ela tenha sido incluída durante a criação da regra. Os resultados da consulta de depuração são incluídos na saída de cada regra. Esse recurso está na visualização.

Console

Incompatível.

gcloud

Incompatível.

REST

Para acessar o job que identificou as falhas de qualidade de dados, use o método dataScans.get. No objeto de resposta, o campo debugQueriesResultSets mostra os resultados das consultas de depuração.

Gerenciar verificações de qualidade de dados para uma tabela específica

As etapas neste documento mostram como gerenciar verificações de qualidade de dados no seu projeto usando a página do BigQuery Curadoria de metadados > Qualidade e criação do perfil de dados no console do Google Cloud .

Também é possível criar e gerenciar verificações de qualidade de dados ao trabalhar com uma tabela específica. No console do Google Cloud , na página do BigQuery da tabela, use a guia Qualidade de dados. Faça o seguinte:

No console do Google Cloud , acesse a página BigQuery.

Acessar o BigQuery

No painel Explorer (à esquerda), clique em Conjuntos de dados e, em seguida, no seu conjunto de dados. Clique em Visão geral > Tabelas e selecione a tabela com os resultados da verificação de qualidade de dados que você quer ver.
Clique na guia Qualidade dos dados.
Dependendo se a tabela tem uma verificação de qualidade de dados com resultados publicados como metadados do Knowledge Catalog, é possível trabalhar com as verificações de qualidade de dados da tabela das seguintes maneiras:
- Os resultados da verificação de qualidade de dados são publicados: os resultados da verificação mais recente são exibidos na página.
  
  Para gerenciar as verificações de qualidade de dados dessa tabela, clique em Verificação de qualidade de dados e selecione uma das seguintes opções:
  - Criar nova verificação: crie uma nova verificação de qualidade de dados. Para mais informações, consulte a seção Criar uma verificação de qualidade de dados deste documento. Quando você cria uma verificação na página de detalhes de uma tabela, ela é pré-selecionada.
  - Executar agora: execute a verificação.
  - Editar configuração da verificação: edite as configurações, incluindo o nome de exibição, os filtros e a programação.
    
    Para editar as regras de qualidade de dados, na guia Qualidade de dados, clique na guia Regras. Clique em Modificar regras. Atualize as regras e clique em Salvar.
  - Gerenciar permissões de verificação: controle quem pode acessar os resultados da verificação. Para mais informações, consulte a seção Conceder acesso aos resultados da verificação de qualidade de dados deste documento.
  - Ver resultados históricos: confira informações detalhadas sobre jobs anteriores de verificação da qualidade de dados. Para mais informações, consulte as seções Ver resultados da verificação de qualidade de dados e Ver resultados históricos da verificação deste documento.
  - Ver todas as verificações: confira uma lista de verificações de qualidade de dados que se aplicam a essa tabela.
- Os resultados da verificação de qualidade de dados não são publicados: selecione uma das seguintes opções:
  - Criar verificação de qualidade de dados: crie uma nova verificação de qualidade de dados. Para mais informações, consulte a seção Criar uma verificação de qualidade de dados deste documento. Quando você cria uma verificação na página de detalhes de uma tabela, ela é pré-selecionada.
  - Ver as verificações atuais: confira uma lista de verificações de qualidade de dados que se aplicam a esta tabela.

Ver as verificações de qualidade de dados de uma tabela

Para conferir as verificações de qualidade de dados que se aplicam a uma tabela específica, faça o seguinte:

No console do Google Cloud , na página Curadoria de metadados do BigQuery, acesse a guia Qualidade e criação do perfil de dados.

Acessar "Qualidade e perfilamento de dados"
Filtre a lista por nome da tabela e tipo de verificação.

Atualizar uma verificação de qualidade de dados

É possível editar várias configurações de uma verificação de qualidade de dados, como o nome de exibição, os filtros, a programação e as regras de qualidade de dados.

Console

No console do Google Cloud , na página Curadoria de metadados do BigQuery, acesse a guia Qualidade e criação do perfil de dados.

Acessar "Qualidade e perfilamento de dados"
Clique no nome de uma verificação de qualidade de dados.
Para editar as configurações, incluindo o nome de exibição, os filtros e a programação, clique em Editar. Edite os valores e clique em Salvar.
Para editar as regras de qualidade de dados, na página de detalhes da verificação, clique na guia Regras atuais. Clique em Modificar regras. Atualize as regras e clique em Salvar.

gcloud

Para atualizar a descrição de uma verificação de qualidade de dados, use o comando gcloud dataplex datascans update data-quality:

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

Substitua:

DATASCAN: o nome da verificação de qualidade de dados a ser atualizada.
LOCATION: a região Google Cloud em que a verificação de qualidade de dados foi criada.
DESCRIPTION: a nova descrição da verificação de qualidade de dados.

C#

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.


//go:build examples

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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para editar uma verificação de qualidade de dados, use o método dataScans.patch.

Excluir uma verificação de qualidade de dados

Console

No console do Google Cloud , na página Curadoria de metadados do BigQuery, acesse a guia Qualidade e criação do perfil de dados.

Acessar "Qualidade e perfilamento de dados"
Clique na verificação que você quer excluir.
Clique em Excluir e confirme quando solicitado.

gcloud

Para excluir uma verificação de qualidade de dados, use o comando gcloud dataplex datascans delete:

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

Substitua as seguintes variáveis:

DATASCAN: o nome da verificação de qualidade de dados a ser excluída.
LOCATION: a região Google Cloud em que a verificação de qualidade de dados foi criada.

C#

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.


//go:build examples

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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

# 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

Para autenticar no BigQuery, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para excluir uma verificação de qualidade de dados, use o método dataScans.delete.

A seguir

Saiba mais sobre a governança de dados no BigQuery.