Pular para o conteúdo principal

Conectar-se ao dbt Cloud

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

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

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

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

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

Para obter uma visão geral da dbt, assista ao seguinte vídeo do YouTube (26 minutos).

Conecte-se ao dbt Cloud usando o Partner Connect

Esta seção descreve como conectar um armazém Databricks SQL à cloud dbt usando o Partner Connect e, em seguida, conceder acesso de leitura à cloud dbt aos seus dados.

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

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

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

Etapas para se conectar

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

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

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

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

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

atenção

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

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

  2. Selecione o endereço SQL warehouse (DBT_CLOUD_ENDPOINT ) 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 vê seu catálogo, banco de dados ou tabela listado, insira qualquer parte do nome nas caixas Selecionar catálogo , Selecionar banco de dados ou Filtrar tabelas , respectivamente, para restringir a lista.

Filtrar tabelas

  1. Clique em Permissões .

  2. Clique em Conceder .

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

dica

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

  1. Conceda acesso de leitura somente selecionando SELECT e READ METADATA.

  2. Clique em OK .

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

Solucionar problemas de conexão com o dbt Cloud

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

Conectar-se ao dbt Cloud manualmente

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

important

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

Requisitos

nota

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

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

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

    As passos neste artigo criam um novo ambiente que usa a versão mais recente do dbt. Para obter informações sobre como atualizar a versão do dbt para um ambiente existente, consulte Atualizando para a versão mais recente do dbt na nuvem na documentação do dbt.

Etapa 1: Inscreva-se no dbt Cloud

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

Etapa 2: Criar um projeto dbt

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

  1. Faça login no dbt Cloud.

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

  3. Clique em Novo projeto .

  4. Em Nome , insira um nome exclusivo para seu projeto e clique em Continuar .

  5. Selecione uma conexão Databricks compute no menu suspenso Choose a connection (Escolher uma conexão ) ou crie uma nova conexão:

    1. Clique em Adicionar nova conexão .

      O assistente Add new connection é aberto em um novo endereço tab.

    2. Clique em Databricks e, em seguida, clique em Next .

nota

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

  1. Em Configurações , em Nome do host do servidor , insira o valor do nome do host do servidor a partir dos requisitos.

  2. Em Caminho HTTP , insira o valor do caminho HTTP dos requisitos.

  3. Se o site workspace estiver habilitado para o Unity Catalog, em Optional Settings (Configurações opcionais ), digite o nome do catálogo a ser usado pelo site dbt.

  4. Clique em Salvar .

  5. Retorne ao assistente de Novo projeto e selecione a conexão que você acabou de criar no menu suspenso Conexão .

  6. Em Credenciais de desenvolvimento , para tokens , insira os tokens de acesso pessoal dos requisitos.

  7. Em Schema , digite o nome do esquema no qual o senhor deseja que o dbt crie as tabelas e visualizações.

  8. Clique em Testar conexão .

  9. Se o teste for concluído com êxito, clique em Salvar .

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

dica

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

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

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

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

tutorial

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

Etapa 1: Criar e executar modelos

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

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

SQL
DROP TABLE IF EXISTS diamonds;

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

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

  1. Com o projeto aberto, clique em Desenvolver na parte superior da interface do usuário.

  2. Clique em Initialize dbt project .

  3. Clique em commit and sync , digite uma mensagem commit e clique em commit .

  4. Clique em Criar filial , insira um nome para sua filial e clique em Enviar .

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

  6. No editor de texto, digite a seguinte instrução SQL. Essa declaração seleciona somente os detalhes de quilate, corte, cor e clareza de cada diamante da tabela diamonds. O bloco config instrui o dbt a criar uma tabela no banco de dados com base nessa declaração.

    {{ config(
    materialized='table',
    file_format='delta'
    ) }}
    SQL
    select carat, cut, color, clarity
    from diamonds
dica

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

  1. Clique em Salvar como .

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

  3. Crie um segundo modelo: clique em Ícone Criar novo arquivo ( Criar novo arquivo ) no canto superior direito.

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

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

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

  7. Crie um terceiro modelo: clique em Ícone Criar novo arquivo ( Criar novo arquivo ) no canto superior direito.

  8. No editor de texto, digite a seguinte instrução SQL. Esta declaração calcula a média dos preços dos diamantes por cor, classificando os resultados por preço médio, do maior para o menor. Esse modelo instrui o site dbt a criar um view no banco de dados com base nessa declaração.

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

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

  11. Execute os modelos: Na linha de comando, execute o comando dbt run com os caminhos para os três arquivos anteriores. No banco de dados default, dbt cria uma tabela chamada diamonds_four_cs e duas visualizações chamadas diamonds_list_colors e diamonds_prices. dbt obtém esses view e nomes de tabelas dos nomes de arquivos .sql relacionados.

    Bash
    dbt run --model models/diamonds_four_cs.sql models/diamonds_list_colors.sql models/diamonds_prices.sql
    Console
    ...
    ... | 1 of 3 START table model default.diamonds_four_cs.................... [RUN]
    ... | 1 of 3 OK created table model default.diamonds_four_cs............... [OK ...]
    ... | 2 of 3 START view model default.diamonds_list_colors................. [RUN]
    ... | 2 of 3 OK created view model default.diamonds_list_colors............ [OK ...]
    ... | 3 of 3 START view model default.diamonds_prices...................... [RUN]
    ... | 3 of 3 OK created view model default.diamonds_prices................. [OK ...]
    ... |
    ... | Finished running 1 table model, 2 view models ...

    Completed successfully

    Done. PASS=3 WARN=0 ERROR=0 SKIP=0 TOTAL=3
  12. Execute o seguinte código SQL para listar informações sobre a nova visualização e selecionar todas as linhas da tabela e da visualização.

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

    SQL
    SHOW views IN default
    Console
    +-----------+----------------------+-------------+
    | namespace | viewName | isTemporary |
    +===========+======================+=============+
    | default | diamonds_list_colors | false |
    +-----------+----------------------+-------------+
    | default | diamonds_prices | false |
    +-----------+----------------------+-------------+
    SQL
    SELECT * FROM diamonds_four_cs
    Console
    +-------+---------+-------+---------+
    | carat | cut | color | clarity |
    +=======+=========+=======+=========+
    | 0.23 | Ideal | E | SI2 |
    +-------+---------+-------+---------+
    | 0.21 | Premium | E | SI1 |
    +-------+---------+-------+---------+
    ...
    SQL
    SELECT * FROM diamonds_list_colors
    Console
    +-------+
    | color |
    +=======+
    | D |
    +-------+
    | E |
    +-------+
    ...
    SQL
    SELECT * FROM diamonds_prices
    Console
    +-------+---------+
    | color | price |
    +=======+=========+
    | J | 5323.82 |
    +-------+---------+
    | I | 5091.87 |
    +-------+---------+
    ...

Etapa 2: Criar e executar modelos mais complexos

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

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

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

    As tabelas e view nesta passo começam com zzz_ para ajudar a identificá-las como parte deste exemplo. Você não precisa seguir esse padrão para suas próprias tabelas e view.

    SQL
    DROP TABLE IF EXISTS zzz_game_opponents;
    DROP TABLE IF EXISTS zzz_game_scores;
    DROP TABLE IF EXISTS zzz_games;
    DROP TABLE IF EXISTS zzz_teams;

    CREATE TABLE zzz_game_opponents (
    game_id INT,
    home_team_id INT,
    visitor_team_id INT
    ) USING DELTA;

    INSERT INTO zzz_game_opponents VALUES (1, 1, 2);
    INSERT INTO zzz_game_opponents VALUES (2, 1, 3);
    INSERT INTO zzz_game_opponents VALUES (3, 2, 1);
    INSERT INTO zzz_game_opponents VALUES (4, 2, 3);
    INSERT INTO zzz_game_opponents VALUES (5, 3, 1);
    INSERT INTO zzz_game_opponents VALUES (6, 3, 2);

    -- Result:
    -- +---------+--------------+-----------------+
    -- | game_id | home_team_id | visitor_team_id |
    -- +=========+==============+=================+
    -- | 1 | 1 | 2 |
    -- +---------+--------------+-----------------+
    -- | 2 | 1 | 3 |
    -- +---------+--------------+-----------------+
    -- | 3 | 2 | 1 |
    -- +---------+--------------+-----------------+
    -- | 4 | 2 | 3 |
    -- +---------+--------------+-----------------+
    -- | 5 | 3 | 1 |
    -- +---------+--------------+-----------------+
    -- | 6 | 3 | 2 |
    -- +---------+--------------+-----------------+

    CREATE TABLE zzz_game_scores (
    game_id INT,
    home_team_score INT,
    visitor_team_score INT
    ) USING DELTA;

    INSERT INTO zzz_game_scores VALUES (1, 4, 2);
    INSERT INTO zzz_game_scores VALUES (2, 0, 1);
    INSERT INTO zzz_game_scores VALUES (3, 1, 2);
    INSERT INTO zzz_game_scores VALUES (4, 3, 2);
    INSERT INTO zzz_game_scores VALUES (5, 3, 0);
    INSERT INTO zzz_game_scores VALUES (6, 3, 1);

    -- Result:
    -- +---------+-----------------+--------------------+
    -- | game_id | home_team_score | visitor_team_score |
    -- +=========+=================+====================+
    -- | 1 | 4 | 2 |
    -- +---------+-----------------+--------------------+
    -- | 2 | 0 | 1 |
    -- +---------+-----------------+--------------------+
    -- | 3 | 1 | 2 |
    -- +---------+-----------------+--------------------+
    -- | 4 | 3 | 2 |
    -- +---------+-----------------+--------------------+
    -- | 5 | 3 | 0 |
    -- +---------+-----------------+--------------------+
    -- | 6 | 3 | 1 |
    -- +---------+-----------------+--------------------+

    CREATE TABLE zzz_games (
    game_id INT,
    game_date DATE
    ) USING DELTA;

    INSERT INTO zzz_games VALUES (1, '2020-12-12');
    INSERT INTO zzz_games VALUES (2, '2021-01-09');
    INSERT INTO zzz_games VALUES (3, '2020-12-19');
    INSERT INTO zzz_games VALUES (4, '2021-01-16');
    INSERT INTO zzz_games VALUES (5, '2021-01-23');
    INSERT INTO zzz_games VALUES (6, '2021-02-06');

    -- Result:
    -- +---------+------------+
    -- | game_id | game_date |
    -- +=========+============+
    -- | 1 | 2020-12-12 |
    -- +---------+------------+
    -- | 2 | 2021-01-09 |
    -- +---------+------------+
    -- | 3 | 2020-12-19 |
    -- +---------+------------+
    -- | 4 | 2021-01-16 |
    -- +---------+------------+
    -- | 5 | 2021-01-23 |
    -- +---------+------------+
    -- | 6 | 2021-02-06 |
    -- +---------+------------+

    CREATE TABLE zzz_teams (
    team_id INT,
    team_city VARCHAR(15)
    ) USING DELTA;

    INSERT INTO zzz_teams VALUES (1, "San Francisco");
    INSERT INTO zzz_teams VALUES (2, "Seattle");
    INSERT INTO zzz_teams VALUES (3, "Amsterdam");

    -- Result:
    -- +---------+---------------+
    -- | team_id | team_city |
    -- +=========+===============+
    -- | 1 | San Francisco |
    -- +---------+---------------+
    -- | 2 | Seattle |
    -- +---------+---------------+
    -- | 3 | Amsterdam |
    -- +---------+---------------+
  2. Crie o primeiro modelo: clique em Ícone Criar novo arquivo ( Criar novo arquivo ) no canto superior direito.

  3. No editor de texto, digite a seguinte instrução SQL. Essa declaração cria uma tabela que fornece os detalhes de cada jogo, como nomes e pontuações das equipes. O bloco config instrui o dbt a criar uma tabela no banco de dados com base nessa declaração.

    SQL
    -- Create a table that provides full details for each game, including
    -- the game ID, the home and visiting teams' city names and scores,
    -- the game winner's city name, and the game date.
    {{ config(
    materialized='table',
    file_format='delta'
    ) }}
    SQL
    -- Step 4 of 4: Replace the visitor team IDs with their city names.
    select
    game_id,
    home,
    t.team_city as visitor,
    home_score,
    visitor_score,
    -- Step 3 of 4: Display the city name for each game's winner.
    case
    when
    home_score > visitor_score
    then
    home
    when
    visitor_score > home_score
    then
    t.team_city
    end as winner,
    game_date as date
    from (
    -- Step 2 of 4: Replace the home team IDs with their actual city names.
    select
    game_id,
    t.team_city as home,
    home_score,
    visitor_team_id,
    visitor_score,
    game_date
    from (
    -- Step 1 of 4: Combine data from various tables (for example, game and team IDs, scores, dates).
    select
    g.game_id,
    go.home_team_id,
    gs.home_team_score as home_score,
    go.visitor_team_id,
    gs.visitor_team_score as visitor_score,
    g.game_date
    from
    zzz_games as g,
    zzz_game_opponents as go,
    zzz_game_scores as gs
    where
    g.game_id = go.game_id and
    g.game_id = gs.game_id
    ) as all_ids,
    zzz_teams as t
    where
    all_ids.home_team_id = t.team_id
    ) as visitor_ids,
    zzz_teams as t
    where
    visitor_ids.visitor_team_id = t.team_id
    order by game_date desc
  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 Ícone Criar novo arquivo ( Criar novo arquivo ) no canto superior direito.

  7. No editor de texto, digite a seguinte instrução SQL. Essa declaração cria um view que lista os registros de vitórias e derrotas da equipe na temporada.

    SQL
    -- Create a view that summarizes the season's win and loss records by team.

    -- Step 2 of 2: Calculate the number of wins and losses for each team.
    select
    winner as team,
    count(winner) as wins,
    -- Each team played in 4 games.
    (4 - count(winner)) as losses
    from (
    -- Step 1 of 2: Determine the winner and loser for each game.
    select
    game_id,
    winner,
    case
    when
    home = winner
    then
    visitor
    else
    home
    end as loser
    from zzz_game_details
    )
    group by winner
    order by wins desc
  8. Clique em Salvar como .

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

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

    Bash
    dbt run --model models/zzz_game_details.sql models/zzz_win_loss_records.sql
    Console
    ...
    ... | 1 of 2 START table model default.zzz_game_details.................... [RUN]
    ... | 1 of 2 OK created table model default.zzz_game_details............... [OK ...]
    ... | 2 of 2 START view model default.zzz_win_loss_records................. [RUN]
    ... | 2 of 2 OK created view model default.zzz_win_loss_records............ [OK ...]
    ... |
    ... | Finished running 1 table model, 1 view model ...

    Completed successfully

    Done. PASS=2 WARN=0 ERROR=0 SKIP=0 TOTAL=2
  11. Execute o seguinte código SQL para listar informações sobre o novo view e para selecionar todas as linhas da tabela e view.

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

    SQL
    SHOW VIEWS FROM default LIKE 'zzz_win_loss_records';
    Console
    +-----------+----------------------+-------------+
    | namespace | viewName | isTemporary |
    +===========+======================+=============+
    | default | zzz_win_loss_records | false |
    +-----------+----------------------+-------------+
    SQL
    SELECT * FROM zzz_game_details;
    Console
    +---------+---------------+---------------+------------+---------------+---------------+------------+
    | game_id | home | visitor | home_score | visitor_score | winner | date |
    +=========+===============+===============+============+===============+===============+============+
    | 1 | San Francisco | Seattle | 4 | 2 | San Francisco | 2020-12-12 |
    +---------+---------------+---------------+------------+---------------+---------------+------------+
    | 2 | San Francisco | Amsterdam | 0 | 1 | Amsterdam | 2021-01-09 |
    +---------+---------------+---------------+------------+---------------+---------------+------------+
    | 3 | Seattle | San Francisco | 1 | 2 | San Francisco | 2020-12-19 |
    +---------+---------------+---------------+------------+---------------+---------------+------------+
    | 4 | Seattle | Amsterdam | 3 | 2 | Seattle | 2021-01-16 |
    +---------+---------------+---------------+------------+---------------+---------------+------------+
    | 5 | Amsterdam | San Francisco | 3 | 0 | Amsterdam | 2021-01-23 |
    +---------+---------------+---------------+------------+---------------+---------------+------------+
    | 6 | Amsterdam | Seattle | 3 | 1 | Amsterdam | 2021-02-06 |
    +---------+---------------+---------------+------------+---------------+---------------+------------+
    SQL
    SELECT * FROM zzz_win_loss_records;
    Console
    +---------------+------+--------+
    | team | wins | losses |
    +===============+======+========+
    | Amsterdam | 3 | 1 |
    +---------------+------+--------+
    | San Francisco | 2 | 2 |
    +---------------+------+--------+
    | Seattle | 1 | 3 |
    +---------------+------+--------+

Etapa 3: Criar e executar testes

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

Existem dois tipos de testes. Os testes de esquema , escritos em YAML, retornam o número de registros que não passam por uma afirmação. Quando esse número é zero, todos os registros são aprovados, portanto, os testes são aprovados. Os testes de dados são consultas específicas que precisam retornar zero registros para serem aprovadas.

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

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

    YAML
    version: 2

    models:
    - name: zzz_game_details
    columns:
    - name: game_id
    tests:
    - unique
    - not_null
    - name: home
    tests:
    - not_null
    - accepted_values:
    values: ['Amsterdam', 'San Francisco', 'Seattle']
    - name: visitor
    tests:
    - not_null
    - accepted_values:
    values: ['Amsterdam', 'San Francisco', 'Seattle']
    - name: home_score
    tests:
    - not_null
    - name: visitor_score
    tests:
    - not_null
    - name: winner
    tests:
    - not_null
    - accepted_values:
    values: ['Amsterdam', 'San Francisco', 'Seattle']
    - name: date
    tests:
    - not_null
    - name: zzz_win_loss_records
    columns:
    - name: team
    tests:
    - unique
    - not_null
    - relationships:
    to: ref('zzz_game_details')
    field: home
    - name: wins
    tests:
    - not_null
    - name: losses
    tests:
    - not_null
  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 Ícone Criar novo arquivo ( Criar novo arquivo ) no canto superior direito.

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

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

    select date
    from zzz_game_details
    where date < '2020-12-12'
    or date > '2021-02-06'
  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 Ícone Criar novo arquivo ( Criar novo arquivo ) no canto superior direito.

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

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

    select home_score, visitor_score
    from zzz_game_details
    where home_score < 0
    or visitor_score < 0
    or home_score = visitor_score
  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 Ícone Criar novo arquivo ( Criar novo arquivo ) no canto superior direito.

  14. No editor de texto, digite a seguinte instrução SQL. Esse arquivo inclui um teste de dados para determinar se alguma equipe teve recordes negativos de vitórias ou derrotas, teve mais recordes de vitórias ou derrotas do que jogos disputados ou jogou mais jogos do que o permitido.

    SQL
    -- Each team participated in 4 games this season.
    -- For this test to pass, this query must return no results.

    select wins, losses
    from zzz_win_loss_records
    where wins < 0 or wins > 4
    or losses < 0 or losses > 4
    or (wins + losses) > 4
  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. executar os testes: Na linha de comando, execute o dbt test comando.

Etapa 4: limpar

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

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

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

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

Próximas etapas

Recurso adicional