Como automatizar Data Quality Rules em Governação de Dados: passo a passo

João Barros 16 de September de 2026 5 min de leitura

Este tutorial mostra como automatizar Data Quality Rules em Governação de Dados para validar, registar e notificar problemas de qualidade. Automatizar regras traz consistência, deteta regressões cedo e facilita a auditoria da qualidade de dados.

Pré-requisitos

Conta com acesso a um ambiente SQL (ex.: Azure SQL ou SQL Server).
PowerShell instalado (ou acesso a Azure Automation) para agendar tarefas.
Permissões para criar tabelas e jobs no servidor SQL.
Conhecimentos básicos de SQL e scripts PowerShell.

Passo 1: Definir as Data Quality Rules

Comece por listar regras concretas e mensuráveis. Exemplos comuns: não-nulos, formatos (email), intervalos numéricos, unicidade. Cada regra deve ter: nome, expressão SQL, severidade e frequência de execução.

-- Exemplo de regras numa tabela de referência
-- rule_id | rule_name         | sql_check                                  | severity
INSERT INTO data_quality_rules (rule_id, rule_name, sql_check, severity)
VALUES
 (1, 'CustomerEmailNotNull', 'SELECT COUNT(*) FROM dbo.Customer WHERE Email IS NULL', 'High'),
 (2, 'OrderAmountPositive', 'SELECT COUNT(*) FROM dbo.Orders WHERE Amount <= 0', 'Medium');

Passo 2: Criar uma tabela de regras e um repositório de resultados

Guarda as regras e os resultados das execuções para auditoria e tendência. A tabela de resultados deve registar timestamp, rule_id, count_violations e mensagem.

CREATE TABLE dbo.data_quality_rules (
  rule_id INT PRIMARY KEY,
  rule_name NVARCHAR(200),
  sql_check NVARCHAR(MAX),
  severity NVARCHAR(50)
);

CREATE TABLE dbo.data_quality_results (
  result_id INT IDENTITY(1,1) PRIMARY KEY,
  rule_id INT,
  run_time DATETIME2 DEFAULT SYSUTCDATETIME(),
  violations INT,
  details NVARCHAR(MAX)
);

Passo 3: Script SQL para executar uma única regra

Cria uma stored procedure que executa a expressão sql_check dinamicamente, captura o número de violações e grava o resultado. Isto permite centralizar a lógica de execução.

CREATE PROCEDURE dbo.ExecuteDataQualityRule @rule_id INT
AS
BEGIN
  SET NOCOUNT ON;
  DECLARE @sql NVARCHAR(MAX); DECLARE @violations INT; DECLARE @details NVARCHAR(MAX);

  SELECT @sql = sql_check FROM dbo.data_quality_rules WHERE rule_id = @rule_id;
  IF @sql IS NULL
  BEGIN
    RAISERROR('Regra não encontrada', 16, 1); RETURN;
  END

  -- Executa a query que devolve um COUNT(*) como resultado
  DECLARE @execSql NVARCHAR(MAX) = 'DECLARE @cnt INT; SET @cnt = 0; ' + @sql + '; SELECT @cnt = (SELECT TOP 1 * FROM (SELECT 1) AS t);';
  -- Simples abordagem alternativa: assume que sql_check é 'SELECT COUNT(*) FROM ...'
  INSERT INTO dbo.data_quality_results (rule_id, violations, details)
  EXEC('DECLARE @v INT; ' + @sql + '; SELECT @v = (SELECT COUNT(*) FROM (SELECT 1) as x);');
END;

Passo 4: Script PowerShell para orquestrar e notificar

Usa PowerShell para ler as regras, executar a stored procedure por cada regra, e enviar notificação (email ou webhook) quando houver violações acima de um limiar.

# Exemplo simplificado PowerShell
$server = 'myserver.database.windows.net'
$database = 'MyDB'
$user = 'admin'
$pwd = 'P@ssw0rd'

$connStr = "Server=$server;Database=$database;User ID=$user;Password=$pwd;Encrypt=True;"

Import-Module SqlServer
$rules = Invoke-Sqlcmd -Query "SELECT rule_id, rule_name FROM dbo.data_quality_rules" -ConnectionString $connStr

foreach ($r in $rules) {
  Invoke-Sqlcmd -Query "EXEC dbo.ExecuteDataQualityRule $($r.rule_id)" -ConnectionString $connStr
}

# Verificar resultados e enviar alerta
$results = Invoke-Sqlcmd -Query "SELECT r.rule_name, res.violations FROM dbo.data_quality_results res JOIN dbo.data_quality_rules r ON res.rule_id=r.rule_id WHERE res.run_time > DATEADD(hour,-1,sysutcdatetime())" -ConnectionString $connStr
foreach ($row in $results) {
  if ($row.violations -gt 0) {
    # Exemplo: registar ou chamar um webhook/Enviar email
    Write-Output "ALERTA: $($row.rule_name) tem $($row.violations) violações"
  }
}

Passo 5: Agendar a execução automática

Para automatizar, cria um Job do SQL Agent (SQL Server) ou uma Runbook no Azure Automation / Azure Logic Apps que execute o script PowerShell com a frequência necessária (horária, diária, etc.).

-- Exemplo: criar um SQL Agent Job que executa um PowerShell step
-- (esta parte faz-se via SSMS GUI ou T-SQL system stored procedures para jobs)
-- Alternativa: colocar o PowerShell num Runbook e agendar no Azure Automation.

Verificar o resultado

Confirma que as regras foram executadas consultando dbo.data_quality_results. Verifica timestamps recentes, número de violações e detalhes. Testa com dados que violem as regras e com dados limpos para confirmar que o sistema deteta ambos os cenários.

SELECT r.rule_name, res.run_time, res.violations, res.details
FROM dbo.data_quality_results res
JOIN dbo.data_quality_rules r ON res.rule_id = r.rule_id
ORDER BY res.run_time DESC;

Conclusão

Automatizar Data Quality Rules em Governação de Dados permite detetar problemas cedo e criar um histórico de qualidade. Próximos passos: melhorar os detalhes das violações (ex.: gravação de chaves de linha afectadas), integrar com Power BI para dashboards e adicionar thresholds por severidade. Dica: começa com poucas regras críticas e expande gradualmente — qual a primeira regra que vais automatizar?