Conectar-se ao dbt Cloud

Artigo
09/04/2024

o dbt (ferramenta de compilação de dados) é um ambiente de desenvolvimento que permite que analistas de dados e engenheiros de dados transformem dados simplesmente escrevendo instruções selecionadas. O dbt trata de transformar essas instruções de seleção em tabelas e exibições. O dbt compila seu código em SQL bruto e, em seguida, executa esse código no banco de dados especificado em Azure Databricks. O dbt dá suporte a padrões de codificação colaborativa e melhores práticas, como controle de versão, documentação, e modularidade.

O dbt não extrai nem carrega dados. O dbt se concentra apenas na etapa de transformação, usando uma arquitetura de "transformação após o carregamento". O dbt pressupõe que você já tem uma cópia dos seus dados em seu banco de dado.

Este artigo se concentra no dbt Cloud. O dbt Cloud vem equipado com suporte completo para agendar trabalhos, CI/CD, fornecer documentação, monitoramento e alertas e um IDE (ambiente de desenvolvimento integrado).

Uma versão local do dbt chamada dbt Core também está disponível. O dbt Core permite escrever código dbt no editor de texto ou IDE de sua escolha no computador de desenvolvimento local e, em seguida, executar o dbt na linha de comando. O dbt Core inclui a CLI (interface de linha de comando) do dbt. A CLI do dbt é gratuita para usar e código aberto. Para saber mais, confira Conectar-se ao dbt Cloud.

Como o dbt Cloud e o dbt Core podem usar repositórios git hospedados (por exemplo, no GitHub, no GitLab ou no BitBucket), você pode usar o dbt Cloud para criar um projeto dbt e, em seguida, torná-lo disponível para os usuários do dbt Core. Para obter mais informações, consulte criando um projeto dbt e usando um projeto existente no site do dbt.

Para obter uma visão geral do dbt, assista ao vídeo do YouTube a seguir (26 minutos).

Conectar-se ao dbt Cloud usando o Partner Connect

Essa seção descreve como conectar seu workspace do Azure Databricks ao dbt Cloud usando o Partner Connect e, em seguida, fornecer acesso de leitura do dbt Cloud aos seus dados.

Diferenças entre conexões padrão e dbt Cloud

Para se conectar ao dbt Cloud usando o Partner Connect, siga as etapas em Conectar-se a parceiros de preparação de dados usando o Partner Connect. A conexão do dbt Cloud é diferente das conexões de transformação e preparação de dados padrão das seguintes maneiras:

Além de uma entidade de serviço e um token de acesso pessoal, o Partner Connect cria um warehouse SQL (antigo ponto de extremidade SQL) chamado DBT_CLOUD_ENDPOINT por padrão.

Etapas para se conectar

Para se conectar ao dbt Cloud usando o Partner Connect, faça o seguinte:

Conecte-se a parceiros de preparação de dados usando o Partner Connect.
Depois de se conectar ao dbt Cloud, o painel do dbt Cloud será exibido. Para explorar seu projeto do dbt Cloud, na barra de menus, ao lado do logotipo do dbt, selecione o nome da conta dbt na primeira lista suspensa se ele não for exibido e selecione o projeto Avaliação do Partner Connect do Databricks no segundo menu suspenso se ele não for exibido.

Dica

Para exibir as configurações do seu projeto, clique no menu de “três etapas” ou de “hambúrguer”, em Configuração de conta > Projetos e clique no nome do projeto. Para exibir as configurações de conexão, clique no link próximo a Conexão. Para alterar as configurações, clique em Editar.

Para exibir as informações de token de acesso pessoal do Azure Databricks para este projeto, clique no ícone "pessoa" na barra de menus, clique em Perfil > credenciais >Avaliação do Partner Connect do Databricks e clique no nome do projeto. Para fazer uma alteração, clique em Editar.

Etapas para fornecer acesso de leitura do dbt Cloud aos seus dados

O Partner Connect fornece permissão somente de criação para a entidade de serviço DBT_CLOUD_USER somente no catálogo padrão. Siga estas etapas no workspace do Azure Databricks para fornecer à entidade de serviço DBT_CLOUD_USER acesso de leitura aos dados escolhidos.

Aviso

Você pode adaptar essas etapas para fornecer acesso adicional ao dbt Cloud a catálogos, bancos de dados e tabelas em seu workspace. No entanto, como uma melhor prática de segurança, o Databricks aconselha que você dê acesso apenas às tabelas individuais com as quais você precisa que a entidade de serviço DBT_CLOUD_USER trabalhe e acesso de leitura somente a essas tabelas.

Clique em Catálogo na barra lateral.
Selecione o SQL warehouse (DBT_CLOUD_ENDPOINT) na lista suspensa no canto superior direito.
1. No Explorador de Catálogos , selecione o catálogo que contém o banco de dados para sua tabela.
2. Selecione o banco de dados que contém sua tabela.
3. Selecione sua tabela.
Dica

Se você não encontrar o seu catálogo, banco de dados ou tabela listado, insira uma parte do nome nos campos Selecionar Catálogo, Selecionar Banco de Dados ou Filtrar tabelas, respectivamente, para restringir a lista.
Clique em Permissões.
Clique em Conceder.
Em Digitar para adicionar vários usuários ou grupos, selecione DBT_CLOUD_USER. Essa é a entidade de serviço do Azure Databricks que o Partner Connect criou para você na seção anterior.

Dica

Se você não encontrar o DBT_CLOUD_USER, comece a digitar DBT_CLOUD_USER no campo Digitar para adicionar vários usuários ou grupos até que ele apareça na lista e selecione-o.
Conceda somente acesso de leitura selecionando SELECT e READ METADATA.
Clique em OK.

Repita as etapas de 4 a 9 para cada tabela adicional à qual você deseja conceder acesso de leitura ao dbt Cloud.

Solucionar problemas da conexão do dbt Cloud

Se alguém excluir o projeto no dbt Cloud para essa conta e você clicar no bloco dbt, uma mensagem de erro será exibida, informando que o projeto não pode ser encontrado. Para corrigir isso, clique em Excluir conexão e, em seguida, comece a partir do início deste procedimento para criar a conexão novamente.

Conectar-se ao dbt Cloud manualmente

Esta seção descreve como conectar um cluster do Azure Databricks ou um SQL warehouse do Databricks em seu workspace do Azure Databricks ao dbt Cloud.

Importante

O Databricks recomenda conectar-se a um SQL warehouse. Se você não tiver o direito de acesso do Databricks SQL ou se quiser executar modelos do Python, poderá se conectar a um cluster.

Requisitos

Um cluster ou SQL warehouse do workspace do Azure Databricks.
- Referência de configuração de computação.
- Criar um SQL warehouse.
Os detalhes da conexão do cluster ou do SQL warehouse, especificamente os valores nome do Host do Servidor, Porta e Caminho HTTP.
- Obter detalhes de conexão para um recurso de computação do Azure Databricks.
Um token de acesso pessoal do Azure Databricks ou um token do Microsoft Entra ID (antigo Azure Active Directory). Para criar um token de acesso pessoal, siga as etapas em Tokens de acesso pessoal do Azure Databricks para usuários do workspace.

Observação

Como melhor prática de segurança, ao autenticar com ferramentas, sistemas, scripts e aplicativos automatizados, o Databricks recomenda que você use tokens de acesso pertencentes às entidades de serviço e não aos usuários do workspace. Para criar tokens para entidades de serviço, consulte Gerenciar tokens para uma entidade de serviço.
Para conectar o dbt Cloud aos dados gerenciados pelo Catálogo do Unity, dbt versão 1.1 ou superior.

As etapas neste artigo criam um novo ambiente que usa a versão mais recente do dbt. Para obter informações sobre como atualizar a versão do dbt para um ambiente existente, consulte Atualizando para a versão mais recente do dbt in Cloud na documentação do dbt.

Vá para DBT Cloud – Inscrição e insira seu email, nome e informações da empresa. Crie uma senha e clique em Criar minha conta.

Etapa 2: Criar um projeto dbt

Nesta etapa, você cria um projeto dbt, que contém uma conexão com um cluster do Azure Databricks ou um SQL warehouse, um repositório que contém seu código-fonte e um ou mais ambientes (como ambientes de teste e produção).

Entre no DBT Cloud.
Clique no ícone de configurações e clique em Configurações da Conta.
Clique em Novo Projeto.
Em Nome, insira um nome exclusivo para seu projeto e clique em Continuar.
Para Escolher uma conexão, clique em Databricks e, em seguida, clique em Avançar.
Para Nome, insira um nome exclusivo para essa conexão.
Para Selecionar o Adaptador, clique em Databricks (dbt-databricks).

Observação

O Databricks recomenda utilizar dbt-databricks, que suporta o Catálogo do Unity, em vez de dbt-spark. Por padrão, os novos projetos utilizam dbt-databricks. Para migrar um projeto existente para dbt-databricks, confira Migrando do dbt-spark para o dbt-databricks na documentação do dbt.
Em Configurações, para Nome do host do servidor, insira o valor do nome do host do servidor de acordo com os requisitos.
Em Caminho HTTP, insira o valor do caminho HTTP obtido nos requisitos.
Se o workspace estiver habilitado para o Catálogo do Unity, em Configurações Opcionais, insira o nome do catálogo para o dbt Cloud usar.
Em Credenciais de Desenvolvimento, para o Token, insira o token de acesso pessoal ou o token do Microsoft Entra ID dos requisitos.
Para Esquema, insira o nome do esquema em que você deseja que o dbt Cloud crie as tabelas e exibições (por exemplo, default).
Clique em Testar Conexão.
Se o teste for bem-sucedido, clique em Avançar.

Para obter mais informações, consulte Conectando-se ao ODBC do Databricks no site dbt.

Dica

Para exibir ou alterar as configurações deste projeto ou excluir o projeto completamente, clique no ícone de configurações, clique em Configurações da Conta > Projetos e clique no nome do projeto. Para alterar as configurações, clique em Editar. Para excluir o projeto, clique em Editar > Excluir Project.

Para exibir ou alterar o valor do token de acesso pessoal do Azure Databricks para este projeto, clique no ícone “pessoa“, clique em Perfil > Credenciais e clique no nome do projeto. Para fazer uma alteração, clique em Editar.

Depois de conectar você a um cluster do Azure Databricks ou a um warehouse SQL do Databricks, siga as instruções na tela para Configurar um Repositório e clique em Continuar.

Depois de configurar o repositório, siga as instruções na tela para convidar os usuários e clique em Concluir. Ou clique em ignorar e Concluir.

Tutorial

Nesta seção, você usará o projeto do dbt Cloud para trabalhar com alguns dados de exemplo. Esta seção pressupõe que você já tenha criado o projeto e tenha o IDE do dbt Cloud aberto para esse projeto.

Etapa 1: Criar e executar modelos

Nesta etapa, você usa IDE Cloud dbt para criar e executar modelos, que são instruções select que criam uma nova exibição (o padrão) ou uma nova tabela em um banco de dados, com base nos dados existentes nesse mesmo banco de dados. Esse procedimento cria um modelo baseado na tabela de amostra diamonds dos conjuntos de dados de amostra.

Use o código a seguir para criar essa tabela.

DROP TABLE IF EXISTS diamonds;

CREATE TABLE diamonds USING CSV OPTIONS (path "/databricks-datasets/Rdatasets/data-001/csv/ggplot2/diamonds.csv", header "true")

Este procedimento pressupõe que esta tabela já foi criada no banco de dados default do seu espaço de trabalho.

Com o projeto aberto, clique em Develop na parte superior da interface do usuário.
Clique em Inicializar projeto dbt.
Clique em Confirmar e Sincronizar, insira uma mensagem de confirmação e clique em Confirmar.
Clique em Criar ramificação, insira um nome para a ramificação e clique em Enviar.
Crie o primeiro modelo: Clique em Criar Arquivo.
No editor de texto, insira a seguinte instrução SQL. Essa instrução seleciona apenas os detalhes de quilate, recorte, cor e clareza para cada losango da tabela diamonds. O bloco config instrui o dbt a criar uma tabela no banco de dados com base nesta instrução.
```
{{ config(
  materialized='table',
  file_format='delta'
) }}
```
```
select carat, cut, color, clarity
from diamonds
```
Dica

Para obter opções adicionais de config, como a estratégia incremental merge, confira configurações do Databricks na documentação do dbt.
Clique em Salvar como.
Para o nome do arquivo, insira models/diamonds_four_cs.sql e clique em Criar.
Crie um segundo modelo: clique no ícone (Criar Arquivo) no canto superior direito.
No editor de texto, insira a seguinte instrução SQL. Essa instrução seleciona valores exclusivos da coluna colors na tabela diamonds_four_cs, classificando os resultados em ordem alfabética primeiro para último. Como não há nenhum bloco config, esse modelo instrui o dbt a criar uma exibição no banco de dados com base nessa instrução.
```
select distinct color
from diamonds_four_cs
sort by color asc
```
Clique em Salvar como.
Para o nome do arquivo, insira models/diamonds_list_colors.sql e clique em Criar.
Crie um terceiro modelo: Clique no ícone (Criar Arquivo) no canto superior direito.
No editor de texto, insira a seguinte instrução SQL. Essa instrução média os preços de losango por cor, classificação dos resultados por preço médio do mais alto para o mais baixo. Esse modelo instrui o dbt a criar uma exibição no banco de dados com base nesta instrução.
```
select color, avg(price) as price
from diamonds
group by color
order by price desc
```
Clique em Salvar como.
Para o nome do arquivo, insira models/diamonds_prices.sql e clique em Criar.

Execute os modelos: na linha de comando, execute o comando dbt run com os caminhos para os três arquivos anteriores. No banco de dados default, dbt cria uma tabela chamada diamonds_four_cs e duas exibições chamadas diamonds_list_colors e diamonds_prices. O dbt obtém esses nomes de exibição e tabela de seus nomes de arquivo .sql relacionados.

dbt run --model models/diamonds_four_cs.sql models/diamonds_list_colors.sql models/diamonds_prices.sql

...
... | 1 of 3 START table model default.diamonds_four_cs.................... [RUN]
... | 1 of 3 OK created table model default.diamonds_four_cs............... [OK ...]
... | 2 of 3 START view model default.diamonds_list_colors................. [RUN]
... | 2 of 3 OK created view model default.diamonds_list_colors............ [OK ...]
... | 3 of 3 START view model default.diamonds_prices...................... [RUN]
... | 3 of 3 OK created view model default.diamonds_prices................. [OK ...]
... |
... | Finished running 1 table model, 2 view models ...

Completed successfully

Done. PASS=3 WARN=0 ERROR=0 SKIP=0 TOTAL=3

Execute o código SQL a seguir para listar informações sobre as novas exibições e selecionar todas as linhas da tabela e exibições.

Se estiver se conectando a um cluster, poderá executar esse código SQL de um notebook que está anexado ao cluster, especificando o SQL como o idioma padrão para o notebook. Se estiver se conectando a um SQL warehouse, poderá executar esse código SQL em uma consulta.

SHOW views IN default

+-----------+----------------------+-------------+
| namespace | viewName             | isTemporary |
+===========+======================+=============+
| default   | diamonds_list_colors | false       |
+-----------+----------------------+-------------+
| default   | diamonds_prices      | false       |
+-----------+----------------------+-------------+

SELECT * FROM diamonds_four_cs

+-------+---------+-------+---------+
| carat | cut     | color | clarity |
+=======+=========+=======+=========+
| 0.23  | Ideal   | E     | SI2     |
+-------+---------+-------+---------+
| 0.21  | Premium | E     | SI1     |
+-------+---------+-------+---------+
...

SELECT * FROM diamonds_list_colors

+-------+
| color |
+=======+
| D     |
+-------+
| E     |
+-------+
...

SELECT * FROM diamonds_prices

+-------+---------+
| color | price   |
+=======+=========+
| J     | 5323.82 |
+-------+---------+
| I     | 5091.87 |
+-------+---------+
...

Etapa 2: Criar e executar modelos mais complexos

Nesta etapa, você cria modelos mais complexos para um conjunto de tabelas de dados relacionadas. Essas tabelas de dados contêm informações sobre uma equipe de esportes fictícias de três equipes que jogaram uma temporada de seis jogos. Este procedimento cria as tabelas de dados, cria os modelos e executa os modelos.

Execute o código SQL a seguir para criar as tabelas de dados necessárias.

As tabelas e exibições nesta etapa começam com zzz_ para ajudar a identificá-las como parte deste exemplo. Você não precisa seguir esse padrão para suas próprias tabelas e exibições.

DROP TABLE IF EXISTS zzz_game_opponents;
DROP TABLE IF EXISTS zzz_game_scores;
DROP TABLE IF EXISTS zzz_games;
DROP TABLE IF EXISTS zzz_teams;

CREATE TABLE zzz_game_opponents (
game_id INT,
home_team_id INT,
visitor_team_id INT
) USING DELTA;

INSERT INTO zzz_game_opponents VALUES (1, 1, 2);
INSERT INTO zzz_game_opponents VALUES (2, 1, 3);
INSERT INTO zzz_game_opponents VALUES (3, 2, 1);
INSERT INTO zzz_game_opponents VALUES (4, 2, 3);
INSERT INTO zzz_game_opponents VALUES (5, 3, 1);
INSERT INTO zzz_game_opponents VALUES (6, 3, 2);

-- Result:
-- +---------+--------------+-----------------+
-- | game_id | home_team_id | visitor_team_id |
-- +=========+==============+=================+
-- | 1       | 1            | 2               |
-- +---------+--------------+-----------------+
-- | 2       | 1            | 3               |
-- +---------+--------------+-----------------+
-- | 3       | 2            | 1               |
-- +---------+--------------+-----------------+
-- | 4       | 2            | 3               |
-- +---------+--------------+-----------------+
-- | 5       | 3            | 1               |
-- +---------+--------------+-----------------+
-- | 6       | 3            | 2               |
-- +---------+--------------+-----------------+

CREATE TABLE zzz_game_scores (
game_id INT,
home_team_score INT,
visitor_team_score INT
) USING DELTA;

INSERT INTO zzz_game_scores VALUES (1, 4, 2);
INSERT INTO zzz_game_scores VALUES (2, 0, 1);
INSERT INTO zzz_game_scores VALUES (3, 1, 2);
INSERT INTO zzz_game_scores VALUES (4, 3, 2);
INSERT INTO zzz_game_scores VALUES (5, 3, 0);
INSERT INTO zzz_game_scores VALUES (6, 3, 1);

-- Result:
-- +---------+-----------------+--------------------+
-- | game_id | home_team_score | visitor_team_score |
-- +=========+=================+====================+
-- | 1       | 4               | 2                  |
-- +---------+-----------------+--------------------+
-- | 2       | 0               | 1                  |
-- +---------+-----------------+--------------------+
-- | 3       | 1               | 2                  |
-- +---------+-----------------+--------------------+
-- | 4       | 3               | 2                  |
-- +---------+-----------------+--------------------+
-- | 5       | 3               | 0                  |
-- +---------+-----------------+--------------------+
-- | 6       | 3               | 1                  |
-- +---------+-----------------+--------------------+

CREATE TABLE zzz_games (
game_id INT,
game_date DATE
) USING DELTA;

INSERT INTO zzz_games VALUES (1, '2020-12-12');
INSERT INTO zzz_games VALUES (2, '2021-01-09');
INSERT INTO zzz_games VALUES (3, '2020-12-19');
INSERT INTO zzz_games VALUES (4, '2021-01-16');
INSERT INTO zzz_games VALUES (5, '2021-01-23');
INSERT INTO zzz_games VALUES (6, '2021-02-06');

-- Result:
-- +---------+------------+
-- | game_id | game_date  |
-- +=========+============+
-- | 1       | 2020-12-12 |
-- +---------+------------+
-- | 2       | 2021-01-09 |
-- +---------+------------+
-- | 3       | 2020-12-19 |
-- +---------+------------+
-- | 4       | 2021-01-16 |
-- +---------+------------+
-- | 5       | 2021-01-23 |
-- +---------+------------+
-- | 6       | 2021-02-06 |
-- +---------+------------+

CREATE TABLE zzz_teams (
team_id INT,
team_city VARCHAR(15)
) USING DELTA;

INSERT INTO zzz_teams VALUES (1, "San Francisco");
INSERT INTO zzz_teams VALUES (2, "Seattle");
INSERT INTO zzz_teams VALUES (3, "Amsterdam");

-- Result:
-- +---------+---------------+
-- | team_id | team_city     |
-- +=========+===============+
-- | 1       | San Francisco |
-- +---------+---------------+
-- | 2       | Seattle       |
-- +---------+---------------+
-- | 3       | Amsterdam     |
-- +---------+---------------+

Crie o primeiro modelo: clique no ícone (Criar Arquivo) no canto superior direito.

No editor de texto, insira a seguinte instrução SQL. Essa instrução cria uma tabela que fornece os detalhes de cada jogo, como nomes de equipe e pontuações. O bloco config instrui o dbt a criar uma tabela no banco de dados com base nesta instrução.

-- Create a table that provides full details for each game, including
-- the game ID, the home and visiting teams' city names and scores,
-- the game winner's city name, and the game date.

{{ config(
  materialized='table',
  file_format='delta'
) }}

-- Step 4 of 4: Replace the visitor team IDs with their city names.
select
  game_id,
  home,
  t.team_city as visitor,
  home_score,
  visitor_score,
  -- Step 3 of 4: Display the city name for each game's winner.
  case
    when
      home_score > visitor_score
        then
          home
    when
      visitor_score > home_score
        then
          t.team_city
  end as winner,
  game_date as date
from (
  -- Step 2 of 4: Replace the home team IDs with their actual city names.
  select
    game_id,
    t.team_city as home,
    home_score,
    visitor_team_id,
    visitor_score,
    game_date
  from (
    -- Step 1 of 4: Combine data from various tables (for example, game and team IDs, scores, dates).
    select
      g.game_id,
      go.home_team_id,
      gs.home_team_score as home_score,
      go.visitor_team_id,
      gs.visitor_team_score as visitor_score,
      g.game_date
    from
      zzz_games as g,
      zzz_game_opponents as go,
      zzz_game_scores as gs
    where
      g.game_id = go.game_id and
      g.game_id = gs.game_id
  ) as all_ids,
    zzz_teams as t
  where
    all_ids.home_team_id = t.team_id
) as visitor_ids,
  zzz_teams as t
where
  visitor_ids.visitor_team_id = t.team_id
order by game_date desc

Clique em Salvar como.
Para o nome do arquivo, insira models/zzz_game_details.sql e clique em Criar.
Crie um segundo modelo: clique no ícone (Criar Arquivo) no canto superior direito.

No editor de texto, insira a seguinte instrução SQL. Essa instrução cria uma exibição que lista os registros de perda de vitória da equipe para a temporada.

-- Create a view that summarizes the season's win and loss records by team.

-- Step 2 of 2: Calculate the number of wins and losses for each team.
select
  winner as team,
  count(winner) as wins,
  -- Each team played in 4 games.
  (4 - count(winner)) as losses
from (
  -- Step 1 of 2: Determine the winner and loser for each game.
  select
    game_id,
    winner,
    case
      when
        home = winner
          then
            visitor
      else
        home
    end as loser
  from zzz_game_details
)
group by winner
order by wins desc

Clique em Salvar como.
Para o nome do arquivo, insira models/zzz_win_loss_records.sql e clique em Criar.

Execute os modelos: na linha de comando, execute o comando dbt run com os caminhos para os dois arquivos anteriores. No banco de dados default (conforme especificado nas configurações do projeto), o dbt cria uma tabela chamada zzz_game_details e uma exibição chamada zzz_win_loss_records. O dbt obtém esses nomes de exibição e tabela de seus nomes de arquivo .sql relacionados.

dbt run --model models/zzz_game_details.sql models/zzz_win_loss_records.sql

...
... | 1 of 2 START table model default.zzz_game_details.................... [RUN]
... | 1 of 2 OK created table model default.zzz_game_details............... [OK ...]
... | 2 of 2 START view model default.zzz_win_loss_records................. [RUN]
... | 2 of 2 OK created view model default.zzz_win_loss_records............ [OK ...]
... |
... | Finished running 1 table model, 1 view model ...

Completed successfully

Done. PASS=2 WARN=0 ERROR=0 SKIP=0 TOTAL=2

Execute o código SQL a seguir para listar informações sobre as nova exibição e selecionar todas as linhas da tabela e exibição.

SHOW VIEWS FROM default LIKE 'zzz_win_loss_records';

+-----------+----------------------+-------------+
| namespace | viewName             | isTemporary |
+===========+======================+=============+
| default   | zzz_win_loss_records | false       |
+-----------+----------------------+-------------+

SELECT * FROM zzz_game_details;

+---------+---------------+---------------+------------+---------------+---------------+------------+
| game_id | home          | visitor       | home_score | visitor_score | winner        | date       |
+=========+===============+===============+============+===============+===============+============+
| 1       | San Francisco | Seattle       | 4          | 2             | San Francisco | 2020-12-12 |
+---------+---------------+---------------+------------+---------------+---------------+------------+
| 2       | San Francisco | Amsterdam     | 0          | 1             | Amsterdam     | 2021-01-09 |
+---------+---------------+---------------+------------+---------------+---------------+------------+
| 3       | Seattle       | San Francisco | 1          | 2             | San Francisco | 2020-12-19 |
+---------+---------------+---------------+------------+---------------+---------------+------------+
| 4       | Seattle       | Amsterdam     | 3          | 2             | Seattle       | 2021-01-16 |
+---------+---------------+---------------+------------+---------------+---------------+------------+
| 5       | Amsterdam     | San Francisco | 3          | 0             | Amsterdam     | 2021-01-23 |
+---------+---------------+---------------+------------+---------------+---------------+------------+
| 6       | Amsterdam     | Seattle       | 3          | 1             | Amsterdam     | 2021-02-06 |
+---------+---------------+---------------+------------+---------------+---------------+------------+

SELECT * FROM zzz_win_loss_records;

+---------------+------+--------+
| team          | wins | losses |
+===============+======+========+
| Amsterdam     | 3    | 1      |
+---------------+------+--------+
| San Francisco | 2    | 2      |
+---------------+------+--------+
| Seattle       | 1    | 3      |
+---------------+------+--------+

Etapa 3: Criar e executar testes

Nesta etapa, você cria testes, que são declarações que você faz sobre seus modelos. Ao executar esses testes, o dbt informa se cada teste em seu projeto for aprovado ou falhar.

Há dois tipos de testes. Os testes de esquema, gravados em YAML, retornam o número de registros que não passam por uma asserção. Quando esse número é zero, todos os registros são aprovados, portanto, os testes são aprovados. Os testes de dados são consultas específicas que devem retornar zero registros para passar.

Criar os testes de esquema: clique no ícone (Criar Arquivo) no canto superior direito.

No editor de texto, insira o seguinte conteúdo. Esse arquivo inclui testes de esquema que determinam se as colunas especificadas têm valores exclusivos, não são nulos, têm apenas os valores especificados ou uma combinação.

version: 2

models:
  - name: zzz_game_details
    columns:
      - name: game_id
        tests:
          - unique
          - not_null
      - name: home
        tests:
          - not_null
          - accepted_values:
              values: ['Amsterdam', 'San Francisco', 'Seattle']
      - name: visitor
        tests:
          - not_null
          - accepted_values:
              values: ['Amsterdam', 'San Francisco', 'Seattle']
      - name: home_score
        tests:
          - not_null
      - name: visitor_score
        tests:
          - not_null
      - name: winner
        tests:
          - not_null
          - accepted_values:
              values: ['Amsterdam', 'San Francisco', 'Seattle']
      - name: date
        tests:
          - not_null
  - name: zzz_win_loss_records
    columns:
      - name: team
        tests:
          - unique
          - not_null
          - relationships:
              to: ref('zzz_game_details')
              field: home
      - name: wins
        tests:
          - not_null
      - name: losses
        tests:
          - not_null

Clique em Salvar como.
Para o nome do arquivo, insira models/schema.yml e clique em Criar.
Crie o primeiro teste de dados: clique no ícone (Criar Arquivo) no canto superior direito.

No editor de texto, insira a seguinte instrução SQL. Esse arquivo inclui um teste de dados para determinar se algum jogo ocorreu fora da temporada regular.

-- This season's games happened between 2020-12-12 and 2021-02-06.
-- For this test to pass, this query must return no results.

select date
from zzz_game_details
where date < '2020-12-12'
or date > '2021-02-06'

Clique em Salvar como.
Para o nome do arquivo, insira tests/zzz_game_details_check_dates.sql e clique em Criar.
Crie um segundo teste de dados: clique no ícone (Criar Arquivo) no canto superior direito.

No editor de texto, insira a seguinte instrução SQL. Esse arquivo inclui um teste de dados para determinar se as pontuações foram negativas ou se algum jogo foi vinculado.

-- This sport allows no negative scores or tie games.
-- For this test to pass, this query must return no results.

select home_score, visitor_score
from zzz_game_details
where home_score < 0
or visitor_score < 0
or home_score = visitor_score

Clique em Salvar como.
Para o nome do arquivo, insira tests/zzz_game_details_check_scores.sql e clique em Criar.
Crie um terceiro teste de dados: clique no ícone (Criar Arquivo) no canto superior direito.
No editor de texto, insira a seguinte instrução SQL. Esse arquivo inclui um teste de dados para determinar se as equipes tiveram registros negativos de vitória ou perda, tiveram mais registros de vitória ou perda do que os jogos disputados ou se jogaram mais jogos do que eram permitidos.
```
-- Each team participated in 4 games this season.
-- For this test to pass, this query must return no results.

select wins, losses
from zzz_win_loss_records
where wins < 0 or wins > 4
or losses < 0 or losses > 4
or (wins + losses) > 4
```
Clique em Salvar como.
Para o nome do arquivo, insira tests/zzz_win_loss_records_check_records.sql e clique em Criar.
Execute os testes: na linha de comando, execute o comando dbt test.

Etapa 4: Limpeza

É possível excluir as tabelas e exibições criadas para este exemplo executando o código SQL a seguir.

DROP TABLE zzz_game_opponents;
DROP TABLE zzz_game_scores;
DROP TABLE zzz_games;
DROP TABLE zzz_teams;
DROP TABLE zzz_game_details;
DROP VIEW zzz_win_loss_records;

DROP TABLE diamonds;
DROP TABLE diamonds_four_cs;
DROP VIEW diamonds_list_colors;
DROP VIEW diamonds_prices;

Próximas etapas

Saiba mais sobre modelosde dbt.
Saiba como testar seus projetos dbt.
Saiba como usar o Jinja, uma linguagem de modelagem, para programação do SQL em seus projetos de dbt.
Saiba mais sobre as melhores práticas de dbt.

Compartilhar via

Conectar-se ao dbt Cloud

Conectar-se ao dbt Cloud usando o Partner Connect

Diferenças entre conexões padrão e dbt Cloud

Etapas para se conectar

Etapas para fornecer acesso de leitura do dbt Cloud aos seus dados

Solucionar problemas da conexão do dbt Cloud

Conectar-se ao dbt Cloud manualmente

Requisitos

Etapa 2: Criar um projeto dbt

Tutorial

Etapa 1: Criar e executar modelos

Etapa 2: Criar e executar modelos mais complexos

Etapa 3: Criar e executar testes

Etapa 4: Limpeza

Próximas etapas

Recursos adicionais

Comentários

Recursos adicionais

Compartilhar via

Conectar-se ao dbt Cloud

Conectar-se ao dbt Cloud usando o Partner Connect

Diferenças entre conexões padrão e dbt Cloud

Etapas para se conectar

Etapas para fornecer acesso de leitura do dbt Cloud aos seus dados

Solucionar problemas da conexão do dbt Cloud

Conectar-se ao dbt Cloud manualmente

Requisitos

Etapa 1: Inscrever-se no dbt Cloud

Etapa 2: Criar um projeto dbt

Tutorial

Etapa 1: Criar e executar modelos

Etapa 2: Criar e executar modelos mais complexos

Etapa 3: Criar e executar testes

Etapa 4: Limpeza

Próximas etapas

Recursos adicionais

Comentários

Recursos adicionais