Conectar-se ao dbt Cloud

dbt (ferramenta de criação de dados) é um ambiente de desenvolvimento que permite que analistas de dados e engenheiros de dados transformem dados simplesmente escrevendo instruções de seleção. dbt lida com a transformação desses comandos select em tabelas e visualizações. dbt compila seu código em SQL bruto e, em seguida, executa esse código no banco de dados especificado em Databricks. O dbt oferece suporte a padrões de codificação colaborativa e práticas recomendadas, como controle de versão, documentação e modularidade.

dbt não extrai ou carrega dados. O dbt foca apenas na passo da transformação, usando uma arquitetura de “transformação após carga”. dbt assume que você já tem uma cópia de seus dados em seu banco de dados.

Este artigo se concentra em dbt Cloud. dbt Cloud vem equipado com suporte turnkey para programar Job, CI/CD, documentação de serviço, monitoramento e alerta, além de um ambiente de desenvolvimento integrado (IDE).

Também está disponível uma versão local do dbt chamada dbt Core. dbt Core permite que o senhor escreva o código dbt no editor de texto ou IDE de sua preferência no computador de desenvolvimento local e, em seguida, execute dbt a partir da linha de comando. O dbt Core inclui a interface de linha de comando (CLI) do dbt. A CLI do dbt é de uso gratuito e de código aberto. Para obter mais informações, consulte Connect to dbt Core.

Como dbt Cloud e dbt Core podem usar repositórios git hospedados (por exemplo, em GitHub, GitLab ou Bitbucket), o senhor pode usar dbt Cloud para criar um projeto dbt e disponibilizá-lo para os usuários dbt Cloud e dbt Core. Para obter mais informações, consulte Criação de um projeto dbt e Uso de um projeto existente no site dbt.

Para obter uma visão geral da 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 Databricks SQL à cloud dbt usando o Partner Connect e, em seguida, conceder acesso de leitura à cloud dbt aos seus dados.

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

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

Além de um principal de serviço e access tokenss pessoal, o Partner Connect cria um SQL warehouse (anteriormente SQL endpoint) denominado cloud por default.

Etapas para se conectar

Para se conectar à cloud dbt 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 é exibido. Para explorar seu projeto cloud dbt, na barra de menus, ao lado do logotipo dbt, selecione o nome da sua account dbt no primeiro menu suspenso, se não for exibido, e selecione o projeto Databricks Partner Connect Trial no segundo menu suspenso menu se não for exibido.

dica

Para view as configurações de seu projeto, clique no menu "três listras" ou "hambúrguer", clique em Account Settings > Projects e clique no nome do projeto. Para view as configurações de conexão, clique no link ao lado de Connection (Conexão ). Para alterar qualquer configuração, clique em Editar .

Para view as informações dos tokens de acesso pessoal Databricks para esse projeto, clique no ícone "pessoa" na barra de menus, clique em Profile > Credentials > Databricks Partner Connect Trial e clique no nome do projeto. Para fazer uma alteração, clique em Editar .

Etapas para conceder à dbt Cloud acesso de leitura aos seus dados

Partner Connect concede permissão somente de criação para a entidade de serviço cloud apenas no catálogo default . Siga estas passos em seu workspace do Databricks para fornecer ao principal do serviço cloud acesso de leitura aos dados que você escolher.

atenção

Você pode adaptar essas passos para fornecer acesso adicional ao dbt cloud em catálogos, bancos de dados e tabelas em seu workspace. No entanto, como uma prática recomendada de segurança, Databricks recomenda enfaticamente que você dê acesso apenas às tabelas individuais com as quais você precisa que a entidade de serviço cloud trabalhe e apenas leia o acesso a essas tabelas.

Clique em Catálogo na barra lateral.
Selecione o endereço SQL warehouse (DBT_CLOUD_ENDPOINT ) na lista suspensa no canto superior direito.
1. Em Catalog Explorer , selecione o catálogo que contém o banco de dados da sua tabela.
2. Selecione o banco de dados que contém sua tabela.
3. Selecione sua mesa.

dica

Se você não vê seu catálogo, banco de dados ou tabela listado, insira qualquer parte do nome nas caixas Selecionar catálogo , Selecionar banco de dados ou Filtrar tabelas , respectivamente, para restringir a lista.

Filtrar tabelas

Clique em Permissões .
Clique em Conceder .
Para Tipo para adicionar vários usuários ou grupos , selecione cloud . Esta é a entidade de serviço Databricks que os Partner Connect criaram para você na seção anterior.

dica

Se você não vê DBT_CLOUD_USER , comece a digitar DBT_CLOUD_USER na caixa Tipo para adicionar vários usuários ou grupos até que ela apareça na lista e, em seguida, selecione-a.

Conceda acesso de leitura somente selecionando SELECT e READ METADATA.
Clique em OK .

Repita as passos 4 a 9 para cada tabela adicional à qual deseja conceder acesso de leitura ao dbt cloud .

Solucionar problemas de conexão com o dbt Cloud

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

Conectar-se ao dbt Cloud manualmente

Esta seção descreve como conectar um Databricks clustering ou um Databricks SQL warehouse em seu Databricks workspace a dbt Cloud.

important

Databricks Recomenda-se conectar a um site SQL warehouse. Se o senhor não tiver o direito de acesso Databricks SQL ou se quiser executar modelos Python, poderá se conectar a um clustering.

Requisitos

Um agrupamento ou SQL warehouse em seu Databricks workspace.
- referência de configuração de computação.
- Crie um SQL warehouse.
Os detalhes da conexão para seu clustering ou SQL warehouse, especificamente os valores de Server Hostname , Port e HTTP Path .
- Obtenha detalhes de conexão para um recurso Databricks compute.
A Databricks tokens de acesso pessoal. Para criar tokens de acesso pessoal, siga as etapas em Databricks personal access tokens para usuários workspace.

nota

Como prática recomendada de segurança ao se autenticar com ferramentas, sistemas, scripts e aplicativos automatizados, a Databricks recomenda que você use tokens OAuth.

Se o senhor usar a autenticação de tokens de acesso pessoal, a Databricks recomenda usar o acesso pessoal tokens pertencente à entidade de serviço em vez de usuários workspace. Para criar tokens o site para uma entidade de serviço, consulte gerenciar tokens para uma entidade de serviço.

Para conectar dbt cloud a dados gerenciados pelo Unity Catalog, dbt versão 1.1 ouacima.

As passos 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 na nuvem na documentação do dbt.

Etapa 1: Inscreva-se no dbt Cloud

Acesse dbt Cloud - Signup e digite seu email, nome e informações da empresa. Crie uma senha e clique em Create my account (Criar minha conta ).

Etapa 2: Criar um projeto dbt

Nesta passo, você cria um projeto dbt, que contém uma conexão com clusters 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 da conta .
Clique em Novo projeto .
Em Nome , insira um nome exclusivo para seu projeto e clique em Continuar .
Selecione uma conexão Databricks compute no menu suspenso Choose a connection (Escolher uma conexão ) ou crie uma nova conexão:
1. Clique em Adicionar nova conexão .
  
  O assistente Add new connection é aberto em um novo endereço tab.
2. Clique em Databricks e, em seguida, clique em Next .

nota

A Databricks recomenda o uso do site dbt-databricks, que oferece suporte ao Unity Catalog, em vez do site dbt-spark. Em default, os novos projetos usam dbt-databricks. Para migrar um projeto existente para dbt-databricks, consulte Migração do dbt-spark para o dbt-databricks na documentação do dbt.

Em Configurações , em Nome do host do servidor , insira o valor do nome do host do servidor a partir dos requisitos.
Em Caminho HTTP , insira o valor do caminho HTTP dos requisitos.
Se o site workspace estiver habilitado para o Unity Catalog, em Optional Settings (Configurações opcionais ), digite o nome do catálogo a ser usado pelo site dbt.
Clique em Salvar .
Retorne ao assistente de Novo projeto e selecione a conexão que você acabou de criar no menu suspenso Conexão .
Em Credenciais de desenvolvimento , para tokens , insira os tokens de acesso pessoal dos requisitos.
Em Schema , digite o nome do esquema no qual o senhor deseja que o dbt crie as tabelas e visualizações.
Clique em Testar conexão .
Se o teste for concluído com êxito, clique em Salvar .

Para obter mais informações, consulte Connecting to Databricks ODBCno site dbt.

dica

Para view ou alterar as configurações desse projeto, ou para excluí-lo completamente, clique no ícone de configurações, clique na conta Settings > Projects e clique no nome do projeto. Para alterar as configurações, clique em Editar . Para excluir o projeto, clique em Editar > Excluir projeto .

Para view ou alterar o valor de seus tokens de acesso pessoal Databricks para esse projeto, clique no ícone "pessoa", clique em Profile > Credentials (Perfil > Credenciais ) e clique no nome do projeto. Para fazer uma alteração, clique em Editar .

Depois de se conectar a um clustering Databricks ou a um warehouse Databricks SQL, siga as instruções na tela para Configurar um Repositório e clique em Continue .

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

tutorial

Nesta seção, use o projeto dbt Cloud para trabalhar com alguns dados de amostra. Esta seção pressupõe que o senhor já tenha criado o seu projeto e que o dbt Cloud IDE esteja aberto para esse projeto.

Etapa 1: Criar e executar modelos

Nesta etapa, o senhor usa o IDE dbt Cloud para criar e executar modelos , que são instruções select que criam um novo view (o default) ou uma nova tabela em um banco de dados, com base nos dados existentes nesse mesmo banco de dados. Esse procedimento cria um modelo com base na tabela de amostra diamonds do conjunto de dados Sample (Amostra).

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

SQL
DROP TABLE IF EXISTS diamonds;

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

Esse procedimento pressupõe que essa tabela já tenha sido criada no banco de dados default do site workspace.

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

dica

Para obter opções adicionais do site config, como a estratégia incremental merge, consulte as 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, digite 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 do primeiro ao último. Como não há um bloco config, esse modelo instrui o site dbt a criar um view no banco de dados com base nessa declaração.
SQL
```
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.sql e clique em Criar.
Crie um terceiro modelo: clique em ( Criar novo arquivo ) no canto superior direito.
No editor de texto, digite 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 maior para o menor. Esse modelo instrui o site dbt a criar um view no banco de dados com base nessa declaração.
SQL
```
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 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 visualizações chamadas diamonds_list_colors e diamonds_prices. dbt obtém esses view e nomes de tabelas dos nomes de arquivos .sql relacionados.

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

Console
...
... | 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 listar informações sobre a nova visualização e selecionar todas as linhas da tabela e da visualização.

Se estiver se conectando a um cluster, o senhor pode executar esse código SQL a partir de um Notebook anexado ao cluster, especificando SQL como o idioma default do Notebook. Se o senhor estiver se conectando a um site SQL warehouse, poderá executar esse código SQL a partir de uma consulta.

SQL
SHOW views IN default

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

SQL
SELECT * FROM diamonds_four_cs

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

SQL
SELECT * FROM diamonds_list_colors

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

SQL
SELECT * FROM diamonds_prices

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

Etapa 2: Criar e executar modelos mais complexos

Nesta passo, você cria modelos mais complexos para um conjunto de tabelas de dados relacionadas. Essas tabelas de dados contêm informações sobre uma liga esportiva fictícia de três times jogando uma temporada de seis jogos. Este procedimento cria as tabelas de dados, cria os modelos e executa os modelos.

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

As tabelas e view nesta passo 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 view.

SQL
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, digite a seguinte instrução SQL. Essa declaração cria uma tabela que fornece os detalhes de cada jogo, como nomes e pontuações das equipes. O bloco config instrui o dbt a criar uma tabela no banco de dados com base nessa declaração.

SQL
-- 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'
) }}

SQL
-- 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, digite a seguinte instrução SQL. Essa declaração cria um view que lista os registros de vitórias e derrotas da equipe na temporada.

SQL
-- 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 comando dbt run com os caminhos para os dois arquivos anteriores. No banco de dados default (conforme especificado nas configurações do projeto), o site dbt cria uma tabela chamada zzz_game_details e uma view chamada zzz_win_loss_records. dbt obtém esses view e nomes de tabela dos nomes de arquivo .sql relacionados.

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

Console
...
... | 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 listar informações sobre o novo view e para selecionar todas as linhas da tabela e view.

SQL
SHOW VIEWS FROM default LIKE 'zzz_win_loss_records';

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

SQL
SELECT * FROM zzz_game_details;

Console
+---------+---------------+---------------+------------+---------------+---------------+------------+
| 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 |
+---------+---------------+---------------+------------+---------------+---------------+------------+

SQL
SELECT * FROM zzz_win_loss_records;

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

Etapa 3: Criar e executar testes

Nesta passo, você cria testes , que são asserções que você faz sobre seus modelos. Quando você executa esses testes, dbt informa se cada teste em seu projeto foi aprovado ou reprovado.

Existem dois tipos de testes. Os testes de esquema , escritos em YAML, retornam o número de registros que não passam por uma afirmaçã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 precisam retornar zero registros para serem aprovadas.

Crie os testes de esquema: clique em ( Criar novo arquivo ) no canto superior direito.

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

YAML
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.yml e clique em Criar.
Crie o primeiro teste de dados: clique em ( Criar novo arquivo ) no canto superior direito.

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

SQL
-- 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.sql e clique em Criar.
Crie um segundo teste de dados: clique em ( Criar novo arquivo ) no canto superior direito.

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

SQL
-- 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.sql e clique em Criar.
Crie um terceiro teste de dados: clique em ( Criar novo arquivo ) no canto superior direito.
No editor de texto, digite a seguinte instrução SQL. Esse arquivo inclui um teste de dados para determinar se alguma equipe teve recordes negativos de vitórias ou derrotas, teve mais recordes de vitórias ou derrotas do que jogos disputados ou jogou mais jogos do que o permitido.
SQL
```
-- 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.sql e clique em Criar.
executar os testes: Na linha de comando, execute o dbt test comando.

Etapa 4: limpar

O senhor pode excluir as tabelas e a visualização que criou para este exemplo executando o seguinte código SQL.

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óximas etapas

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

Conecte-se ao dbt Cloud usando o Partner Connect​

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

Etapas para se conectar​

Etapas para conceder à dbt Cloud acesso de leitura aos seus dados​

Solucionar problemas de conexão com o dbt Cloud​

Conectar-se ao dbt Cloud manualmente​

Requisitos​

Etapa 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​

Etapa 4: limpar​

Próximas etapas​

Recurso adicional​

Conecte-se ao dbt Cloud usando o Partner Connect

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

Etapas para se conectar

Etapas para conceder à dbt Cloud acesso de leitura aos seus dados

Solucionar problemas de conexão com o dbt Cloud

Conectar-se ao dbt Cloud manualmente

Requisitos

Etapa 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

Etapa 4: limpar

Próximas etapas

Recurso adicional