Conecte-se à nuvem dbt

dbt (data build tool) é um ambiente de desenvolvimento que permite que o analista de dados e o engenheiro de dados transformem os dados simplesmente escrevendo instruções select. dbt lida com a transformação dessas instruções select em tabelas e view. dbt compila seu código em SQL bruto e, em seguida, executa esse código no banco de dados especificado no 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 na cloud dbt. O dbt cloud vem equipado com suporte pronto para uso para programar Job, CI/CD, documentação de serviço, monitoramento e alerta 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 você escreva o código dbt no editor de texto ou IDE de sua escolha em sua máquina de desenvolvimento local e, em seguida, execute o dbt na linha de comando. O dbt Core inclui a interface de linha de comando (CLI) dbt. O dbt CLI é gratuito e de código aberto. Para obter mais informações, consulte Conectar 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 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 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 à cloud dbt usando o Partner Connect, siga as passos 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 e transformação de dados nas seguintes formas:

  • 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.

passos para conectar

Para se conectar à cloud dbt usando o Partner Connect, faça o seguinte:

  1. Conecte-se a parceiros de preparação de dados usando o Partner Connect.

  2. Depois de se conectar ao dbt cloud, o painel do dbt cloud é exibido. Para explorar seu projeto cloud dbt, na barra de menus, ao lado do logotipo dbt, selecione o nome da sua account dbt no primeiro menu suspenso, se não for exibido, e selecione o projeto Databricks Partner Connect Trial no segundo menu suspenso menu se não for exibido.

    Dica

    Para view as configurações do seu projeto, clique no menu “três listras” ou “hambúrguer”, clique em Configuraçõesaccount > Projetos e clique no nome do projeto. Para view as configurações de conexão, clique no link ao lado de Conexão. Para alterar qualquer configuração, clique em Editar.

    Para view as informações dos access tokens pessoal do Databricks para este projeto, clique no ícone “pessoa” na barra de menus, clique em Perfil > Credenciais > Databricks Partner Connect Trial e clique no nome do projeto. Para fazer uma alteração, clique em Editar.

passos para dar ao 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.

Aviso

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.

  1. Clique Ícone de catálogo Catálogo na barra lateral.

  2. Selecione o SQL warehouse (cloud) na lista suspensa no canto superior direito.

    Selecione o armazém
    1. Em Catalog Explorer, selecione o catálogo que contém o banco de dados da sua tabela.

    2. Selecione o banco de dados que contém sua tabela.

    3. Selecione sua mesa.

    Dica

    Se você não vir seu catálogo, banco de dados ou tabela listado, digite qualquer parte do nome nas caixas Selecionar Catálogo, Selecionar Banco de Dados ou Filtrar Tabelas , respectivamente, para restringir a lista.

    Filtrar tabelas
  3. Clique em Permissões.

  4. Clique em Conceder.

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

    Dica

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

  6. Conceda acesso de leitura apenas selecionando SELECT e READ METADATA.

  7. 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 dbt Cloud

Se alguém excluir o projeto na cloud dbt para esta account 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, comece desde o início deste procedimento para criar a conexão novamente.

Conecte-se ao dbt Cloud manualmente

Esta seção descreve como conectar clusters Databricks ou um databricks SQL warehouse em seu workspace Databricks para dbt cloud.

Importante

Databricks recomenda conectar-se a um SQL warehouse. Se você não tiver o direito de acesso Databricks SQL ou se quiser executar modelos Python, poderá se conectar a um clusters .

Requisitos

  • Um clusters ou SQL warehouse em seu workspace do Databricks.

  • Os detalhes de conexão para seus clusters ou SQL warehouse, especificamente os valores Server hostname, Port e HTTP Path .

  • Um site pessoal da Databricks access token. Para criar um access token pessoal, faça o seguinte:

    1. No workspace do Databricks, clique no nome de usuário do Databricks na barra superior e selecione Configurações do usuário na lista suspensa.

    2. Clique em Desenvolvedor.

    3. Ao lado do access token, clique em gerenciar.

    4. Clique em Gerar novos tokens.

    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 vida útil (não recomendado), deixe a caixa Duração (dias) vazia (em branco).

    6. Clique em Gerar.

    7. Copie o token exibido em um local seguro e clique em Concluído.

    Observação

    Certifique-se de salvar os tokens copiados em um local seguro. Não compartilhe seus tokens copiados com outras pessoas. Se você perder os tokens copiados, não poderá regenerar exatamente os mesmos tokens. Em vez disso, você deve repetir este procedimento para criar novos tokens. Se você perder os tokens copiados ou acreditar que os tokens foram comprometidos, o Databricks recomenda fortemente que você exclua imediatamente esses tokens do seu workspace clicando no ícone da lixeira (Revogar) ao lado dos tokens na página access tokens .

    Se não for possível criar ou usar tokens no seu workspace, isso pode ocorrer porque o administrador do workspace desativou os tokens ou não lhe deu permissão para criar ou usar tokens. Consulte o administrador do workspace ou o seguinte:

    Observação

    Como prática recomendada de segurança, ao autenticar com ferramentas, sistemas, scripts e aplicativos automatizados, a Databricks recomenda que você use access token pessoal pertencente à entidade 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 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.

passo 1: Inscreva-se no dbt Cloud

Vá para dbt cloud - Cadastre-se e digite seu email, nome e informações da empresa. Crie uma senha e clique em Criar minha account.

passo 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).

  1. Entre no dbt Cloud.

  2. Clique no ícone de configurações e, em seguida, clique em Configuraçõesaccount .

  3. Clique em Novo Projeto.

  4. Em Name, insira um nome exclusivo para seu projeto e clique em Continue.

  5. Para Escolher uma conexão, clique em Databricks e, em seguida, clique em Avançar.

  6. Para Name, insira um nome exclusivo para esta conexão.

  7. Para Selecionar Adaptador, clique em Databricks (dbt-databricks).

    Observação

    Databricks recomenda usar dbt-databricks, que oferece suporte ao Unity Catalog, em vez de dbt-spark. Por default, novos projetos usam dbt-databricks. Para migrar um projeto existente para dbt-databricks, consulte Migrando de dbt-spark para dbt-databricks na documentação do dbt.

  8. Em Configurações, para hostnamedo servidor, insira o valor hostname do servidor dos requisitos.

  9. Para HTTP Path, insira o valor do caminho HTTP dos requisitos.

  10. Se o seu workspace for habilitado para Unity Catalog, em Configurações opcionais, insira o nome do catálogo para dbt cloud usar.

  11. Em Credenciais de desenvolvimento, para tokens, insira o access token pessoal dos requisitos.

  12. Para Esquema, insira o nome do esquema no qual deseja que o dbt cloud crie as tabelas e view (por exemplo, default).

  13. Clique em Testar conexão.

  14. Se o teste for bem-sucedido, clique em Avançar.

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

Dica

Para view ou alterar as configurações deste projeto ou para excluir o projeto completamente, clique no ícone de configurações, clique em Configuraçõesaccount > Projetos 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 access tokens pessoal do Databricks para este projeto, clique no ícone “pessoa”, clique em Perfil > Credenciais e clique no nome do projeto. Para fazer uma alteração, clique em Editar.

Depois de conectar-se a clusters Databricks ou a um databricks SQL warehouse, siga as instruções na tela para Configurar um repositório e, em seguida, 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 e Concluir.

Tutorial

Nesta seção, você usará 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.

passo 1: Criar e executar modelos

Neste passo, você usa o IDE dbt cloud para criar e executar modelos, que são instruções select que criam uma nova view (o default) ou uma nova tabela em um banco de dados, com base nos dados existentes nesse mesmo banco de dados. Este procedimento cria um modelo baseado na tabela de amostra diamonds dos conjuntos de dados de amostra, conforme descrito na seção Criar uma tabela do Tutorial: Query dados com Notebook. Este procedimento assume que esta tabela já foi criada no banco de dados default do seu workspace .

  1. Com o projeto aberto, clique em Desenvolver na parte superior da IU.

  2. Clique em Inicializar projeto dbt.

  3. Clique em commit e sincronizar, insira uma mensagem commit e clique em commit.

  4. Clique em Criar ramificação, digite um nome para sua ramificação e clique em Enviar.

  5. Crie o primeiro modelo: Clique em Criar novo arquivo.

  6. No editor de texto, insira a seguinte instrução SQL. Esta declaração seleciona apenas os detalhes de quilate, corte, cor e clareza para cada diamante da tabela diamonds . O bloco config 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
    

    Dica

    Para opções config adicionais, como a estratégia incremental merge , consulte as configurações do Databricks na documentação dbt.

  7. Clique em Salvar como.

  8. Para o nome do arquivo, digite models/diamonds_four_cs.sql e clique em Criar.

  9. Crie um segundo modelo: clique em Criar novo ícone de arquivo (Criar novo arquivo) no canto superior direito.

  10. No editor de texto, insira a seguinte instrução SQL. Esta instrução seleciona valores exclusivos da coluna colors na tabela diamonds_four_cs , classificando os resultados em ordem alfabética do primeiro ao último. Como não há bloco config, esse modelo instrui o dbt a criar uma view no banco de dados com base nessa instrução.

    select distinct color
    from diamonds_four_cs
    sort by color asc
    
  11. Clique em Salvar como.

  12. Para o nome do arquivo, digite models/diamonds_list_colors.sql e clique em Criar.

  13. Crie um terceiro modelo: clique em Criar novo ícone de arquivo (Criar novo arquivo) no canto superior direito.

  14. 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 maior para o menor. Esse modelo instrui o dbt a criar uma view no banco de dados com base nessa instrução.

    select color, avg(price) as price
    from diamonds
    group by color
    order by price desc
    
  15. Clique em Salvar como.

  16. Para o nome do arquivo, digite models/diamonds_prices.sql e clique em Criar.

  17. execução dos modelos: Na linha de comando, execute o comando dbt run com os caminhos para os três arquivos anteriores. No banco de dados default, dbt cria uma tabela denominada diamonds_four_cs e duas view denominadas diamonds_list_colors e diamonds_prices. dbt obtém esses nomes de view e tabela de seus nomes de arquivo .sql relacionados.

    dbt run --model models/diamonds_four_cs.sql models/diamonds_list_colors.sql models/diamonds_prices.sql
    
    ...
    ... | 1 of 3 START table model default.diamonds_four_cs.................... [RUN]
    ... | 1 of 3 OK created table model default.diamonds_four_cs............... [OK ...]
    ... | 2 of 3 START view model default.diamonds_list_colors................. [RUN]
    ... | 2 of 3 OK created view model default.diamonds_list_colors............ [OK ...]
    ... | 3 of 3 START view model default.diamonds_prices...................... [RUN]
    ... | 3 of 3 OK created view model default.diamonds_prices................. [OK ...]
    ... |
    ... | Finished running 1 table model, 2 view models ...
    
    Completed successfully
    
    Done. PASS=3 WARN=0 ERROR=0 SKIP=0 TOTAL=3
    
  18. executar o seguinte código SQL para listar informações sobre a nova view e selecionar todas as linhas da tabela e view.

    Se você estiver se conectando a clusters, poderá executar esse código SQL a partir de um Notebook anexado aos clusters, especificando SQL como o idioma default para o Notebook. 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 |
    +-------+---------+
    ...
    

passo 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.

  1. execução do seguinte código SQL para criar as tabelas de dados necessárias.

    Se você estiver se conectando a clusters, poderá executar esse código SQL a partir de um Notebook anexado aos clusters, especificando SQL como o idioma default para o Notebook. Se você estiver se conectando a um 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.

    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     |
    -- +---------+---------------+
    
  2. Crie o primeiro modelo: Clique em Criar novo ícone de arquivo (Criar novo arquivo) no canto superior direito.

  3. No editor de texto, insira a seguinte instrução SQL. Essa instrução cria uma tabela que fornece os detalhes de cada jogo, como nomes de times e pontuações. O bloco config 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
    
  4. Clique em Salvar como.

  5. Para o nome do arquivo, digite models/zzz_game_details.sql e clique em Criar.

  6. Crie um segundo modelo: clique em Criar novo ícone de arquivo (Criar novo arquivo) no canto superior direito.

  7. No editor de texto, insira a seguinte instrução SQL. Essa instrução cria uma view 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
    
  8. Clique em Salvar como.

  9. Para o nome do arquivo, digite models/zzz_win_loss_records.sql e clique em Criar.

  10. execução dos modelos: Na linha de comando, execute o comando dbt run com os caminhos para os dois arquivos anteriores. No banco de dados default (conforme especificado nas configurações do projeto), dbt cria uma tabela denominada zzz_game_details e uma view denominada zzz_win_loss_records. dbt obtém esses nomes de view e tabela de seus nomes de arquivo .sql relacionados.

    dbt run --model models/zzz_game_details.sql models/zzz_win_loss_records.sql
    
    ...
    ... | 1 of 2 START table model default.zzz_game_details.................... [RUN]
    ... | 1 of 2 OK created table model default.zzz_game_details............... [OK ...]
    ... | 2 of 2 START view model default.zzz_win_loss_records................. [RUN]
    ... | 2 of 2 OK created view model default.zzz_win_loss_records............ [OK ...]
    ... |
    ... | Finished running 1 table model, 1 view model ...
    
    Completed successfully
    
    Done. PASS=2 WARN=0 ERROR=0 SKIP=0 TOTAL=2
    
  11. executar o seguinte código SQL para listar informações sobre a nova view e selecionar todas as linhas da tabela e view.

    Se você estiver se conectando a clusters, poderá executar esse código SQL a partir de um Notebook anexado aos clusters, especificando SQL como o idioma default para o Notebook. 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      |
    +---------------+------+--------+
    

passo 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 em uma asserção. Quando esse número é zero, todos os registros passam, portanto os testes passam. Os testes de dados são query específicas que devem retornar zero registros para passar.

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

  2. 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
    
  3. Clique em Salvar como.

  4. Para o nome do arquivo, digite models/schema.yml e clique em Criar.

  5. Crie o primeiro teste de dados: clique em Criar novo ícone de arquivo (Criar novo arquivo) no canto superior direito.

  6. 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'
    
  7. Clique em Salvar como.

  8. Para o nome do arquivo, digite tests/zzz_game_details_check_dates.sql e clique em Criar.

  9. Crie um segundo teste de dados: clique em Criar novo ícone de arquivo (Criar novo arquivo) no canto superior direito.

  10. 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
    
  11. Clique em Salvar como.

  12. Para o nome do arquivo, digite tests/zzz_game_details_check_scores.sql e clique em Criar.

  13. Crie um terceiro teste de dados: clique em Criar novo ícone de arquivo (Criar novo arquivo) no canto superior direito.

  14. No editor de texto, insira a seguinte instrução SQL. Este arquivo inclui um teste de dados para determinar se alguma equipe teve registros negativos de vitórias ou derrotas, teve mais registros de vitórias ou derrotas do que jogos disputados ou 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
    
  15. Clique em Salvar como.

  16. Para o nome do arquivo, digite tests/zzz_win_loss_records_check_records.sql e clique em Criar.

  17. execução dos testes: Na linha de comando, execute o comando dbt test .

passo 4: Limpar

Você pode excluir as tabelas e view criadas para este exemplo executando o código SQL a seguir.

Se você estiver se conectando a clusters, poderá executar esse código SQL a partir de um Notebook anexado aos clusters, especificando SQL como o idioma default para o Notebook. 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