Conecte-se ao dbt Cloud

Artigo
12/27/2024

DBT (Data Build Tool) é um ambiente de desenvolvimento que permite que analistas de dados e engenheiros de dados transformem dados simplesmente escrevendo select instruções. O dbt lida com a transformação dessas declarações select em tables e views. O dbt compila o seu código em SQL não processado e, em seguida, executa-o código na base de dados especificada no Azure Databricks. O dbt suporta padrões de codificação colaborativa e melhores práticas, como controlo de versões, 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 carregamento". O dbt assume que já tem uma cópia dos dados na sua base de dados.

Este artigo se concentra no dbt Cloud. O dbt Cloud vem equipado com suporte chave na mão para agendamento de tarefas, CI/CD, fornecimento de documentação, monitorização e alertas, e um ambiente de desenvolvimento integrado (IDE).

Uma versão local do dbt chamada dbt Core também está disponível. O dbt Core permite que escreva código dbt num editor de texto ou IDE à sua escolha no seu computador de desenvolvimento local e, em seguida, execute o dbt a partir da linha de comandos. O dbt Core inclui a interface de linha de comandos (CLI) do dbt. A CLI do dbt é de utilização livre e open source. Para obter mais informações, consulte Conectar-se ao dbt Core.

Como o dbt Cloud e o dbt Core podem usar repositórios git hospedados (por exemplo, no GitHub, GitLab ou BitBucket), você pode usar o dbt Cloud para criar um projeto dbt e, em seguida, disponibilizá-lo para seus usuários dbt Cloud e dbt Core. Para obter mais informações, consulte Criando um projeto dbt e Usando um projeto existente no site dbt.

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

Conecte-se ao dbt Cloud usando o Partner Connect

Esta seção descreve como conectar um armazém SQL Databricks ao dbt Cloud usando o Partner Connect e, em seguida, conceder acesso de leitura ao dbt Cloud aos seus dados.

Diferenças entre o connections padrão e o dbt Cloud

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

Além de uma entidade de serviço e um token de acesso pessoal, o Partner Connect cria um armazém SQL (anteriormente ponto de extremidade SQL) denominado 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, seu painel dbt Cloud será exibido. Para explorar seu projeto dbt Cloud, na barra de menus, ao lado do logotipo dbt, select o nome da sua conta dbt na primeira lista suspensa, se não for exibida, e select o projeto de avaliação do Databricks Partner Connect no segundo menu suspenso, se ele não for exibido.

Gorjeta

Para visualizar as configurações do seu projeto, clique no menu "três listras" ou "hambúrguer", clique em > de Configurações de Conta e clique no nome do projeto. Para exibir as configurações de conexão, clique no link ao lado de Conexão. Para alterar as configurações, clique em Editar.

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

Etapas para dar ao dbt Cloud acesso de leitura aos seus dados

O Partner Connect concede permissão somente de criação para a entidade de serviço DBT_CLOUD_USER somente no catalogpadrão. Siga estas etapas em seu espaço de trabalho do Azure Databricks para dar à entidade de serviço DBT_CLOUD_USER acesso de leitura aos dados que você escolher.

Aviso

Você pode adaptar essas etapas para dar ao dbt Cloud acesso adicional em catalogs, bancos de dados e tables em seu espaço de trabalho. No entanto, como uma prática recomendada de segurança, a Databricks recomenda que o utilizador dê acesso apenas aos tables individuais com os quais precisa que a entidade de serviço DBT_CLOUD_USER trabalhe e apenas acesso de leitura a esses tables.

Clique no ícone Catalog na barra lateral.
Select o SQL warehouse (DBT_CLOUD_ENDPOINT) no list suspenso no canto superior direito.
1. Em Catalog Explorer, select o catalog que contém a base de dados para a sua table.
2. Select o banco de dados que contém seus table.
3. Select o seu table.
Gorjeta

Se não vir o seu catalog, banco de dados ou table listados, insira qualquer parte do nome nas caixas Select Catalog, Select Banco de Dados, ou Filtro tables, respetivamente, para restringir o list.
Clique em Permissões.
Clique em Grant.
Para Tipo para adicionar vários usuários ou grupos, selectDBT_CLOUD_USER. Esta é a entidade de serviço do Azure Databricks que o Partner Connect criou para você na seção anterior.

Gorjeta

Se você não vir DBT_CLOUD_USER, comece a digitar DBT_CLOUD_USER na caixa Tipo de para adicionar vários usuários ou grupos até que ela apareça no liste, em seguida, select-a.
Grant acesso de leitura somente selecionando SELECT e READ METADATA.
Clique em OK.

Repita as etapas 4 a 9 para cada table adicional ao qual pretenda dar acesso de leitura ao dbt Cloud.

Solucionar problemas de conexão 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, inicie a partir do início deste procedimento para criar a conexão novamente.

Conecte-se ao dbt Cloud manualmente

Esta seção descreve como conectar um cluster do Azure Databricks ou um armazém SQL do Databricks em seu espaço de trabalho 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 ao Databricks SQL ou se quiser executar modelos Python, poderá se conectar a um cluster.

Requerimentos

Um cluster ou armazém SQL no seu espaço de trabalho do Azure Databricks.
- Referência de configuração de computação.
- Crie um armazém SQL.
Os detalhes de conexão para seu cluster ou SQL warehouse, especificamente o Server Hostname, Porte HTTP Pathvalues.
- Get detalhes de conexão para um recurso de computação do Azure Databricks.
Um token de acesso pessoal do Azure Databricks ou um token de ID do Microsoft Entra (anteriormente Azure Ative Directory). Para criar um token de acesso pessoal, siga as etapas em Tokens de acesso pessoal do Azure Databricks para usuários do espaço de trabalho.

Nota

Como prática recomendada de segurança, quando você se autentica com ferramentas, sistemas, scripts e aplicativos automatizados, o Databricks recomenda que você use tokens de acesso pessoal pertencentes a entidades de serviço em vez de usuários do espaço de trabalho. Para criar tokens para entidades de serviço, consulte Gerenciar tokens para uma entidade de serviço.
Para ligar o dbt Cloud aos dados geridos pelo Unity Catalog, é necessário usar a versão 1.1 do dbt ou superior.

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

Vá para dbt Cloud - Inscreva-se e insira seu e-mail, nome e informações da empresa. Crie uma palavra-passe e clique em Criar a 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).

Faça login no dbt Cloud.
Clique no ícone de configurações e, em seguida, clique em Configurações de conta.
Clique em Novo Projeto.
Em Nome, insira um nome exclusivo para seu projeto e clique em Continuar.
Select uma conexão de computação do Azure Databricks a partir do menu pendente Escolha uma conexão ou crie uma nova conexão:
1. Clique Adicionar nova conexão.
  
  O assistente Adicionar nova ligação abre-se num novo separador.
2. Clique em Databrickse, em seguida, clique em Avançar.
  
  Nota
  
  A Databricks recomenda o uso do dbt-databricks, que suporta Unity Catalog, em vez de dbt-spark. Por padrão, novos projetos usam dbt-databrickso . Para migrar um projeto existente para o dbt-databricks, consulte Migrando de dbt-spark para dbt-databricks na documentação do dbt.
3. Em Configurações, para Nome do host do servidor, insira o valor do nome do host do servidor dos requisitos.
4. Para Caminho HTTP, insira o valor do caminho HTTP dos requisitos.
5. Se o seu espaço de trabalho estiver com Unity Catalogativado, em Configurações Opcionais , insira o nome do catalog que o dbt deve usar.
6. Clique Salvar.
7. Retorne ao assistente de Novo projeto e a conexão que você acabou de criar no menu suspenso Conexão .
Em Development Credentials, para Token, insira o token de acesso pessoal ou o token do Microsoft Entra ID dos requisitos.
Para Schema, insira o nome do schemawhere para que o dbt possa criar o tables e o views.
Clique em Testar Ligação.
Se o teste for concluído com êxito, clique em Salvar.

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

Gorjeta

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

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

Depois de se conectar a um cluster do Azure Databricks ou a um armazém SQL do Databricks, siga as instruções na tela para Configurar um repositório e clique em Continuar.

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

Tutorial

Nesta seção, você usa seu projeto dbt Cloud para trabalhar com alguns dados de exemplo. Esta seção pressupõe que você já criou seu projeto e tem o dbt Cloud IDE aberto para esse projeto.

Etapa 1: Criar e executar modelos

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

Use o código a seguir para criar esse table.

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 esse table já tenha sido criado no banco de dados default do seu espaço de trabalho.

Com o projeto aberto, clique em Desenvolver na parte superior da interface do usuário.
Clique em Inicializar projeto dbt.
Clique em Confirmar e sync, insira uma mensagem de confirmação e, em seguida, clique em Confirmar.
Clique em Criar ramificação, insira um nome para sua ramificação e clique em Enviar.
Crie o primeiro modelo: Clique em Criar novo arquivo.
No editor de texto, insira a seguinte instrução SQL. Esta instrução seleciona apenas os detalhes de quilate, corte, cor e clareza para cada diamante do diamondstable. O bloco config instrui o dbt a criar um table no banco de dados com base nessa instrução.
```
{{ config(
  materialized='table',
  file_format='delta'
) }}
```
```
select carat, cut, color, clarity
from diamonds
```
Gorjeta

Para opções adicionais config , como a merge estratégia incremental, consulte Configurações do Databricks na documentação do dbt.
Clique em Salvar como.
Para o nome do arquivo, digite models/diamonds_four_cs.sql e clique em Criar.
Crie um segundo modelo: Clique em (Criar novo arquivo) no canto superior direito.
No editor de texto, insira a seguinte instrução SQL. Esta instrução seleciona values exclusivos do colorscolumn no diamonds_four_cstable, classificando os resultados em ordem alfabética, da primeira à última posição. Como não há nenhum config bloco, 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, digite models/diamonds_list_colors.sqle clique em Criar.
Crie um terceiro modelo: Clique em (Criar novo arquivo) no canto superior direito.
No editor de texto, insira a seguinte instrução SQL. Esta declaração calcula a média dos preços dos diamantes por cor, classificando os resultados por preço médio do mais alto para o mais baixo. Este modelo instrui o dbt a criar uma exibição no banco de dados com base nessa 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, digite models/diamonds_prices.sql e clique em Criar.

Execute os modelos: Na linha de comando, execute o dbt run comando com os caminhos para os três arquivos anteriores. No banco de dados default, o dbt cria um table chamado diamonds_four_cs e dois views nomeados diamonds_list_colors e diamonds_prices. O DBT obtém esses nomes de exibição e table 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 seguinte código SQL para list informações sobre o novo views e para select todas as linhas do table e views.

Se você estiver se conectando a um cluster, poderá executar esse código SQL a partir de um bloco de anotações anexado ao cluster, especificando SQL como o idioma padrão para o bloco de anotações. Se você estiver se conectando a um SQL warehouse, poderá executar esse código SQL a partir de 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 uma set de dados relacionados tables. Esses dados tables contêm informações sobre uma liga desportiva fictícia de três equipas que jogam uma temporada de seis jogos. Este procedimento cria os dados tables, cria os modelos e executa os modelos.

Execute o seguinte código SQL para criar os dados necessários tables.

Os tables e views nesta etapa começam com zzz_ para ajudar a identificá-los como parte deste exemplo. Você não precisa seguir este padrão para a sua própria tables e views.

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 em (Criar novo arquivo) no canto superior direito.

No editor de texto, insira a seguinte instrução SQL. Esta declaração cria um table que fornece os detalhes de cada jogo, como nomes e pontuações das equipas. O bloco config instrui o dbt a criar um table no banco de dados com base nessa 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, digite models/zzz_game_details.sql e clique em Criar.
Crie um segundo modelo: Clique em (Criar novo arquivo) no canto superior direito.

No editor de texto, insira a seguinte instrução SQL. Esta declaração cria uma visão que lista os recordes de vitórias e derrotas da equipe na 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, digite models/zzz_win_loss_records.sql e clique em Criar.

Execute os modelos: Na linha de comando, execute o dbt run comando com os caminhos para os dois arquivos anteriores. No banco de dados default (conforme especificado nas configurações do projeto), o dbt cria um table chamado zzz_game_details e um modo de exibição chamado zzz_win_loss_records. O DBT obtém esses nomes de exibição e table 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 seguinte código SQL para list informações sobre a nova vista e para select todas as linhas da table e vista.

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 afirmações que você faz sobre seus modelos. Quando você executa esses testes, dbt informa se cada teste em seu projeto passa ou falha.

Existem dois tipos de testes. Schema testes, escritos em YAML, retornam o número de registros que não passam em uma asserção. Quando esse número é zero, todos os registros passam, portanto, os testes passam. Os testes de dados são consultas específicas que devem retornar zero registros para serem aprovados.

Criar os testes schema: Clique no ícone Criar Novo Arquivo (Criar Novo Arquivo) no canto superior direito.

No editor de texto, insira o seguinte conteúdo. Esse arquivo inclui schema testes que determinam se os columns especificados têm valuesexclusivos, não são nulos, têm apenas o valuesespecificado 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, digite models/schema.ymle clique em Criar.
Crie o primeiro teste de dados: Clique em (Criar novo arquivo) no canto superior direito.

No editor de texto, insira a seguinte instrução SQL. Este arquivo inclui um teste de dados para determinar se algum jogo aconteceu 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, digite tests/zzz_game_details_check_dates.sqle clique em Criar.
Criar um segundo teste de dados: Clique em (Criar novo arquivo) no canto superior direito.

No editor de texto, insira a seguinte instrução SQL. Este arquivo inclui um teste de dados para determinar se alguma pontuação foi negativa ou se algum jogo foi empatado.

-- 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, digite tests/zzz_game_details_check_scores.sqle clique em Criar.
Crie um terceiro teste de dados: Clique em (Criar novo arquivo) no canto superior direito.
No editor de texto, insira a seguinte instrução SQL. Este ficheiro inclui um teste de dados para determinar se alguma equipa teve registos negativos de vitórias ou derrotas, se teve mais registos de vitórias ou derrotas do que os jogos disputados ou se jogou mais jogos do que o permitido.
```
-- 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, digite tests/zzz_win_loss_records_check_records.sqle clique em Criar.
Execute os testes: Na linha de comando, execute o dbt test comando.

Passo 4: Limpar

Você pode excluir os tables e views criados para este exemplo executando o seguinte código SQL.

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óximos passos

Saiba mais sobre os modelos dbt.
Saiba como testar seus projetos dbt.
Aprenda a usar Jinja, uma linguagem de modelagem, para programar SQL em seus projetos dbt.
Saiba mais sobre as melhores práticas de dbt.

Partilhar via

Conecte-se ao dbt Cloud

Conecte-se ao dbt Cloud usando o Partner Connect

Diferenças entre o connections padrão e o dbt Cloud

Etapas para se conectar

Etapas para dar ao dbt Cloud acesso de leitura aos seus dados

Solucionar problemas de conexão dbt Cloud

Conecte-se ao dbt Cloud manualmente

Requerimentos

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

Passo 4: Limpar

Próximos passos

Recursos adicionais

Comentários

Recursos adicionais

Partilhar via

Conecte-se ao dbt Cloud

Conecte-se ao dbt Cloud usando o Partner Connect

Diferenças entre o connections padrão e o dbt Cloud

Etapas para se conectar

Etapas para dar ao dbt Cloud acesso de leitura aos seus dados

Solucionar problemas de conexão dbt Cloud

Conecte-se ao dbt Cloud manualmente

Requerimentos

Passo 1: Inscreva-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

Passo 4: Limpar

Próximos passos

Recursos adicionais

Comentários

Recursos adicionais