Conecte-se ao dbt Cloud
O dbt (data build tool) é um ambiente de desenvolvimento que permite que analistas de dados e engenheiros de dados transformem dados simplesmente escrevendo instruções select. O dbt transforma essas instruções select em tabelas e vistas. 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 conexões padrão e 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 dbt Cloud é diferente das conexões padrão de preparação e transformação de dados 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, selecione o nome da conta dbt na primeira lista suspensa, se não for exibido, e selecione 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 Projetos 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 exibir as informações do token de acesso pessoal do Azure Databricks para este projeto, clique no ícone "pessoa" na barra de menus, clique em Avaliação do Databricks Partner Connect de Credenciais >de Perfil > e 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 catálogo padrã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 catálogos, bancos de dados e tabelas em seu espaço de trabalho. No entanto, como prática recomendada de segurança, o Databricks recomenda que você conceda acesso apenas às tabelas individuais com as quais você precisa que a entidade de serviço DBT_CLOUD_USER trabalhe e somente acesso de leitura a essas tabelas.
Clique em
Catálogo na barra lateral.
Selecione o SQL warehouse (DBT_CLOUD_ENDPOINT) na lista suspensa no canto superior direito.
- Em Gerenciador de Catálogos, selecione o catálogo que contém o banco de dados para sua tabela.
- Selecione o banco de dados que contém sua tabela.
- Selecione a sua tabela.
Gorjeta
Se você não vir seu catálogo, banco de dados ou tabela listados, 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.
Em Tipo para adicionar vários usuários ou grupos, selecione DBT_CLOUD_USER. Esta é a entidade de serviço do Azure Databricks que o Partner Connect criou para você na seção anterior.
Gorjeta
Se não vir DBT_CLOUD_USER, comece a escrever
DBT_CLOUD_USER
na caixa Escrever para adicionar vários utilizadores ou grupos até aparecer na lista e, em seguida, selecione-a.Conceda acesso de leitura somente selecionando
SELECT
eREAD METADATA
.Clique em OK.
Repita as etapas 4 a 9 para cada tabela adicional à qual você deseja 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 os valores Nome do host do servidor, Porta e Caminho HTTP.
- Obtenha 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, faça o seguinte:
- No seu espaço de trabalho do Azure Databricks, clique no seu nome de utilizador do Azure Databricks na barra superior e, em seguida, selecione Definições na lista pendente.
- Clique em Desenvolvedor.
- Ao lado de Tokens de acesso, clique em Gerenciar.
- Clique em Gerar novo token.
- (Opcional) Insira um comentário que o ajude a identificar esse token no futuro e altere o tempo de vida padrão do token de 90 dias. Para criar um token sem tempo de vida (não recomendado), deixe a caixa Tempo de vida (dias) vazia (em branco).
- Clique em Generate (Gerar).
- Copie o token exibido para um local seguro e clique em Concluído.
Nota
Certifique-se de salvar o token copiado em um local seguro. Não partilhe o seu token copiado com outras pessoas. Se você perder o token copiado, não poderá regenerar exatamente o mesmo token. Em vez disso, você deve repetir esse procedimento para criar um novo token. Se você perder o token copiado ou acreditar que o token foi comprometido, o Databricks recomenda que você exclua imediatamente esse token do seu espaço de trabalho clicando no ícone da lixeira (Revogar) ao lado do token na página de tokens do Access.
Se você não conseguir criar ou usar tokens em seu espaço de trabalho, isso pode ser porque o administrador do espaço de trabalho desabilitou tokens ou não lhe deu permissão para criar ou usar tokens. Consulte o administrador do espaço de trabalho ou o seguinte:
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 conectar o dbt Cloud aos dados gerenciados pelo Unity Catalog, dbt versão 1.1 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.
Passo 1: Inscreva-se no dbt Cloud
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).
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.
Para Escolha uma conexão, clique em Databricks e, em seguida, clique em Avançar.
Em Nome, insira um nome exclusivo para essa conexão.
Para Selecionar adaptador, clique em Databricks (dbt-databricks).
Nota
O Databricks recomenda o uso
dbt-databricks
do , que suporta o Unity Catalog, em vez dedbt-spark
. Por padrão, novos projetos usamdbt-databricks
o . Para migrar um projeto existente para odbt-databricks
, consulte Migrando de dbt-spark para dbt-databricks na documentação do dbt.Em Configurações, para Nome do host do servidor, insira o valor do nome do host do servidor dos requisitos.
Para Caminho HTTP, insira o valor do caminho HTTP dos requisitos.
Se o seu espaço de trabalho estiver habilitado para Unity Catalog, em Configurações opcionais, insira o nome do catálogo para o dbt Cloud usar.
Em Credenciais de Desenvolvimento, para Token, insira o token de acesso pessoal ou o token de ID do Microsoft Entra dos requisitos.
Em Schema, insira o nome do esquema onde você deseja que o dbt Cloud crie as tabelas e exibições (por exemplo,
default
).Clique em Testar Ligação.
Se o teste for bem-sucedido, clique em Avançar.
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 Projetos 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 Credenciais de Perfil > 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 configurar 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 select
instruções que criam uma nova exibição (o padrão) ou uma nova tabela em um banco de dados, com base em dados existentes nesse mesmo banco de dados. Este procedimento cria um modelo baseado na tabela de exemplo diamonds
dos conjuntos de dados de exemplo.
Use o código a seguir para criar esta tabela.
DROP TABLE IF EXISTS diamonds;
CREATE TABLE diamonds USING CSV OPTIONS (path "/databricks-datasets/Rdatasets/data-001/csv/ggplot2/diamonds.csv", header "true")
Este procedimento pressupõe que esta tabela já tenha sido criada no banco de default
dados 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 sincronizar, insira uma mensagem de confirmação e 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 da
diamonds
tabela. Oconfig
bloco instrui o dbt a criar uma tabela 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 amerge
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 valores exclusivos da
colors
coluna nadiamonds_four_cs
tabela, classificando os resultados em ordem alfabética do primeiro ao último. Como não há nenhumconfig
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.sql
e 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, odefault
dbt cria uma tabela nomeadadiamonds_four_cs
e duas exibições nomeadasdiamonds_list_colors
ediamonds_prices
. O DBT obtém esses nomes de exibição e tabela de seus nomes de arquivo relacionados.sql
.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 listar informações sobre os novos modos de exibição e selecionar todas as linhas da tabela e modos de exibição.
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 um conjunto de tabelas de dados relacionadas. Estas tabelas de dados contêm informações sobre uma liga desportiva fictícia de três equipas que jogam uma época 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 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.
As tabelas e exibições nesta etapa começam com
zzz_
para ajudar a identificá-las como parte deste exemplo. Você não precisa seguir esse padrão para suas próprias tabelas e exibições.DROP TABLE IF EXISTS zzz_game_opponents; DROP TABLE IF EXISTS zzz_game_scores; DROP TABLE IF EXISTS zzz_games; DROP TABLE IF EXISTS zzz_teams; CREATE TABLE zzz_game_opponents ( game_id INT, home_team_id INT, visitor_team_id INT ) USING DELTA; INSERT INTO zzz_game_opponents VALUES (1, 1, 2); INSERT INTO zzz_game_opponents VALUES (2, 1, 3); INSERT INTO zzz_game_opponents VALUES (3, 2, 1); INSERT INTO zzz_game_opponents VALUES (4, 2, 3); INSERT INTO zzz_game_opponents VALUES (5, 3, 1); INSERT INTO zzz_game_opponents VALUES (6, 3, 2); -- Result: -- +---------+--------------+-----------------+ -- | game_id | home_team_id | visitor_team_id | -- +=========+==============+=================+ -- | 1 | 1 | 2 | -- +---------+--------------+-----------------+ -- | 2 | 1 | 3 | -- +---------+--------------+-----------------+ -- | 3 | 2 | 1 | -- +---------+--------------+-----------------+ -- | 4 | 2 | 3 | -- +---------+--------------+-----------------+ -- | 5 | 3 | 1 | -- +---------+--------------+-----------------+ -- | 6 | 3 | 2 | -- +---------+--------------+-----------------+ CREATE TABLE zzz_game_scores ( game_id INT, home_team_score INT, visitor_team_score INT ) USING DELTA; INSERT INTO zzz_game_scores VALUES (1, 4, 2); INSERT INTO zzz_game_scores VALUES (2, 0, 1); INSERT INTO zzz_game_scores VALUES (3, 1, 2); INSERT INTO zzz_game_scores VALUES (4, 3, 2); INSERT INTO zzz_game_scores VALUES (5, 3, 0); INSERT INTO zzz_game_scores VALUES (6, 3, 1); -- Result: -- +---------+-----------------+--------------------+ -- | game_id | home_team_score | visitor_team_score | -- +=========+=================+====================+ -- | 1 | 4 | 2 | -- +---------+-----------------+--------------------+ -- | 2 | 0 | 1 | -- +---------+-----------------+--------------------+ -- | 3 | 1 | 2 | -- +---------+-----------------+--------------------+ -- | 4 | 3 | 2 | -- +---------+-----------------+--------------------+ -- | 5 | 3 | 0 | -- +---------+-----------------+--------------------+ -- | 6 | 3 | 1 | -- +---------+-----------------+--------------------+ CREATE TABLE zzz_games ( game_id INT, game_date DATE ) USING DELTA; INSERT INTO zzz_games VALUES (1, '2020-12-12'); INSERT INTO zzz_games VALUES (2, '2021-01-09'); INSERT INTO zzz_games VALUES (3, '2020-12-19'); INSERT INTO zzz_games VALUES (4, '2021-01-16'); INSERT INTO zzz_games VALUES (5, '2021-01-23'); INSERT INTO zzz_games VALUES (6, '2021-02-06'); -- Result: -- +---------+------------+ -- | game_id | game_date | -- +=========+============+ -- | 1 | 2020-12-12 | -- +---------+------------+ -- | 2 | 2021-01-09 | -- +---------+------------+ -- | 3 | 2020-12-19 | -- +---------+------------+ -- | 4 | 2021-01-16 | -- +---------+------------+ -- | 5 | 2021-01-23 | -- +---------+------------+ -- | 6 | 2021-02-06 | -- +---------+------------+ CREATE TABLE zzz_teams ( team_id INT, team_city VARCHAR(15) ) USING DELTA; INSERT INTO zzz_teams VALUES (1, "San Francisco"); INSERT INTO zzz_teams VALUES (2, "Seattle"); INSERT INTO zzz_teams VALUES (3, "Amsterdam"); -- Result: -- +---------+---------------+ -- | team_id | team_city | -- +=========+===============+ -- | 1 | San Francisco | -- +---------+---------------+ -- | 2 | Seattle | -- +---------+---------------+ -- | 3 | Amsterdam | -- +---------+---------------+
Crie o primeiro modelo: Clique em
(Criar novo arquivo) no canto superior direito.
No editor de texto, insira a seguinte instrução SQL. Esta declaração cria uma tabela que fornece os detalhes de cada jogo, como nomes e pontuações das equipas. O
config
bloco instrui o dbt a criar uma tabela 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 (conforme especificado nas configurações do projeto), odefault
dbt cria uma tabela nomeadazzz_game_details
e uma exibição chamadazzz_win_loss_records
. O DBT obtém esses nomes de exibição e tabela de seus nomes de arquivo relacionados.sql
.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 listar informações sobre o novo modo de exibição e selecionar todas as linhas da tabela e exibição.
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 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. Os testes de esquema, 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.
Crie os testes de esquema: Clique em
(Criar novo arquivo) no canto superior direito.
No editor de texto, insira o seguinte conteúdo. Esse arquivo inclui testes de esquema que determinam se as colunas especificadas têm valores exclusivos, não são nulas, têm apenas os valores especificados ou uma combinação.
version: 2 models: - name: zzz_game_details columns: - name: game_id tests: - unique - not_null - name: home tests: - not_null - accepted_values: values: ['Amsterdam', 'San Francisco', 'Seattle'] - name: visitor tests: - not_null - accepted_values: values: ['Amsterdam', 'San Francisco', 'Seattle'] - name: home_score tests: - not_null - name: visitor_score tests: - not_null - name: winner tests: - not_null - accepted_values: values: ['Amsterdam', 'San Francisco', 'Seattle'] - name: date tests: - not_null - name: zzz_win_loss_records columns: - name: team tests: - unique - not_null - relationships: to: ref('zzz_game_details') field: home - name: wins tests: - not_null - name: losses tests: - not_null
Clique em Salvar como.
Para o nome do arquivo, 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, 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.sql
e 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.sql
e 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.sql
e clique em Criar.Execute os testes: Na linha de comando, execute o
dbt test
comando.
Passo 4: Limpar
Você pode excluir as tabelas e exibições criadas para este exemplo executando o seguinte código SQL.
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.
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.