Conecte-se ao dbt Cloud

Artigo
04/19/2024

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.
1. Em Gerenciador de Catálogos, selecione o catálogo que contém o banco de dados para sua tabela.
2. Selecione o banco de dados que contém sua tabela.
3. Selecione 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 e READ 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:
1. 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.
2. Clique em Desenvolvedor.
3. Ao lado de Tokens de acesso, clique em Gerenciar.
4. Clique em Gerar novo token.
5. (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).
6. Clique em Generate (Gerar).
7. 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:
- Habilitar ou desabilitar a autenticação de token de acesso pessoal para o espaço de trabalho
- Permissões de token de acesso pessoal
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.

Vá para dbt Cloud - Inscreva-se e insira seu e-mail, nome e informações da empresa. Crie uma palavra-passe e clique em Criar a minha conta.

Etapa 2: Criar um projeto dbt

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

Faça login no dbt Cloud.
Clique no ícone de configurações e, em seguida, clique em Configurações de conta.
Clique em Novo Projeto.
Em Nome, insira um nome exclusivo para seu projeto e clique em Continuar.
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-databricksdo , que suporta o Unity Catalog, em vez de dbt-spark. Por padrão, novos projetos usam dbt-databrickso . Para migrar um projeto existente para o dbt-databricks, consulte Migrando de dbt-spark para dbt-databricks na documentação do dbt.
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. O config 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 a merge estratégia incremental, consulte Configurações do Databricks na documentação do dbt.
Clique em Salvar como.
Para o nome do arquivo, digite models/diamonds_four_cs.sql e clique em Criar.
Crie um segundo modelo: Clique em (Criar novo arquivo) no canto superior direito.
No editor de texto, insira a seguinte instrução SQL. Esta instrução seleciona valores exclusivos da colors coluna na diamonds_four_cs tabela, classificando os resultados em ordem alfabética do primeiro ao último. Como não há nenhum config bloco, esse modelo instrui o dbt a criar uma exibição no banco de dados com base nessa instrução.
```
select distinct color
from diamonds_four_cs
sort by color asc
```
Clique em Salvar como.
Para o nome do arquivo, digite models/diamonds_list_colors.sqle clique em Criar.
Crie um terceiro modelo: Clique em (Criar novo arquivo) no canto superior direito.
No editor de texto, insira a seguinte instrução SQL. Esta declaração calcula a média dos preços dos diamantes por cor, classificando os resultados por preço médio do mais alto para o mais baixo. Este modelo instrui o dbt a criar uma exibição no banco de dados com base nessa instrução.
```
select color, avg(price) as price
from diamonds
group by color
order by price desc
```
Clique em Salvar como.
Para o nome do arquivo, digite models/diamonds_prices.sql e clique em Criar.

Execute os modelos: Na linha de comando, execute o dbt run comando com os caminhos para os três arquivos anteriores. No banco de dados, o default dbt cria uma tabela nomeada diamonds_four_cs e duas exibições nomeadas diamonds_list_colors e diamonds_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.

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), o default dbt cria uma tabela nomeada zzz_game_details e uma exibição chamada zzz_win_loss_records. O DBT obtém esses nomes de exibição e tabela de seus nomes de arquivo 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.

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

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

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

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

Clique em Salvar como.
Para o nome do arquivo, digite tests/zzz_game_details_check_dates.sqle clique em Criar.
Criar um segundo teste de dados: Clique em (Criar novo arquivo) no canto superior direito.

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

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

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

Clique em Salvar como.
Para o nome do arquivo, digite tests/zzz_game_details_check_scores.sqle clique em Criar.
Crie um terceiro teste de dados: Clique em (Criar novo arquivo) no canto superior direito.
No editor de texto, insira a seguinte instrução SQL. Este ficheiro inclui um teste de dados para determinar se alguma equipa teve registos negativos de vitórias ou derrotas, se teve mais registos de vitórias ou derrotas do que os jogos disputados ou se jogou mais jogos do que o permitido.
```
-- Each team participated in 4 games this season.
-- For this test to pass, this query must return no results.

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

Passo 4: Limpar

Você pode excluir as tabelas e exibições criadas para este exemplo executando o seguinte código SQL.

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

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

Próximos passos

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

Partilhar via

Conecte-se ao dbt Cloud

Conecte-se ao dbt Cloud usando o Partner Connect

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

Etapas para se conectar

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

Solucionar problemas de conexão dbt Cloud

Conecte-se ao dbt Cloud manualmente

Requerimentos

Etapa 2: Criar um projeto dbt

Tutorial

Etapa 1: Criar e executar modelos

Etapa 2: Criar e executar modelos mais complexos

Etapa 3: Criar e executar testes

Passo 4: Limpar

Próximos passos

Recursos adicionais

Comentários

Recursos adicionais

Partilhar via

Conecte-se ao dbt Cloud

Conecte-se ao dbt Cloud usando o Partner Connect

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

Etapas para se conectar

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

Solucionar problemas de conexão dbt Cloud

Conecte-se ao dbt Cloud manualmente

Requerimentos

Passo 1: Inscreva-se no dbt Cloud

Etapa 2: Criar um projeto dbt

Tutorial

Etapa 1: Criar e executar modelos

Etapa 2: Criar e executar modelos mais complexos

Etapa 3: Criar e executar testes

Passo 4: Limpar

Próximos passos

Recursos adicionais

Comentários

Recursos adicionais