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.
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.
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.
-
Em Catalog Explorer , selecione o catálogo que contém o banco de dados da sua tabela.
-
Selecione o banco de dados que contém sua tabela.
-
Selecione sua mesa.
-
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.
-
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.
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
eREAD 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.
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.
-
Os detalhes da conexão para seu clustering ou SQL warehouse, especificamente os valores de Server Hostname , Port e HTTP Path .
-
A Databricks tokens de acesso pessoal. Para criar tokens de acesso pessoal, siga as etapas em Databricks personal access tokens para usuários workspace.
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).
-
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:
-
Clique em Adicionar nova conexão .
O assistente Add new connection é aberto em um novo endereço tab.
-
Clique em Databricks e, em seguida, clique em Next .
-
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.
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.
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 blococonfig
instrui o dbt a criar uma tabela no banco de dados com base nessa declaração.{{ config(
materialized='table',
file_format='delta'
) }}SQLselect carat, cut, color, clarity
from diamonds
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 tabeladiamonds_four_cs
, classificando os resultados em ordem alfabética do primeiro ao último. Como não há um blococonfig
, esse modelo instrui o site dbt a criar um view no banco de dados com base nessa declaração.SQLselect 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.
SQLselect 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 dadosdefault
, dbt cria uma tabela chamadadiamonds_four_cs
e duas visualizações chamadasdiamonds_list_colors
ediamonds_prices
. dbt obtém esses view e nomes de tabelas dos nomes de arquivos.sql
relacionados.Bashdbt 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.
SQLSHOW views IN default
Console+-----------+----------------------+-------------+
| namespace | viewName | isTemporary |
+===========+======================+=============+
| default | diamonds_list_colors | false |
+-----------+----------------------+-------------+
| default | diamonds_prices | false |
+-----------+----------------------+-------------+SQLSELECT * FROM diamonds_four_cs
Console+-------+---------+-------+---------+
| carat | cut | color | clarity |
+=======+=========+=======+=========+
| 0.23 | Ideal | E | SI2 |
+-------+---------+-------+---------+
| 0.21 | Premium | E | SI1 |
+-------+---------+-------+---------+
...SQLSELECT * FROM diamonds_list_colors
Console+-------+
| color |
+=======+
| D |
+-------+
| E |
+-------+
...SQLSELECT * 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.
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.
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.SQLDROP 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 dadosdefault
(conforme especificado nas configurações do projeto), o site dbt cria uma tabela chamadazzz_game_details
e uma view chamadazzz_win_loss_records
. dbt obtém esses view e nomes de tabela dos nomes de arquivo.sql
relacionados.Bashdbt 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.
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.
SQLSHOW VIEWS FROM default LIKE 'zzz_win_loss_records';
Console+-----------+----------------------+-------------+
| namespace | viewName | isTemporary |
+===========+======================+=============+
| default | zzz_win_loss_records | false |
+-----------+----------------------+-------------+SQLSELECT * 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 |
+---------+---------------+---------------+------------+---------------+---------------+------------+SQLSELECT * 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.
YAMLversion: 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.
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.
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.