Compartir a través de

Conexión a dbt Cloud

  • Artículo

dbt (herramienta de compilación de datos) es un entorno de desarrollo que permite a los analistas e ingenieros de datos transformar datos simplemente escribiendo instrucciones select. dbt controla la conversión de estas instrucciones select en tablas y vistas. dbt compila el código en SQL sin procesar y, después, ejecuta ese código en la base de datos especificada en Azure Databricks. dbt admite patrones de codificación y procedimientos recomendados para la colaboración, como el control de versiones, la documentación y la modularidad.

dbt no extrae ni carga datos. dbt se centra solo en el paso de transformación, mediante una arquitectura de "transformación después de la carga". dbt supone que ya tiene una copia de los datos en la base de datos.

Este artículo se centra en dbt Cloud. dbt Cloud incluye compatibilidad llave en mano para programar trabajos, CI/CD, documentación de servicio, supervisión y alertas, y un entorno de desarrollo integrado (IDE).

También está disponible una versión local de dbt denominada dbt Core. dbt Core permite escribir código dbt en el editor de texto o el IDE que prefiera en la máquina de desarrollo local y, luego, ejecutar dbt desde la línea de comandos. dbt Core incluye la interfaz de la línea de comandos (CLI) de dbt. La CLI de dbt es gratuita y de código abierto. Para más información, consulte Conexión a dbt Core.

Dado que dbt Cloud y dbt Core pueden usar repositorios git hospedados (por ejemplo, en GitHub, GitLab o BitBucket), puede usar dbt Cloud para crear un proyecto de dbt y, después, hacer que esté disponible para los usuarios de dbt Cloud y dbt Core. Para más información, consulte Creación de un proyecto de dbt y Uso de un proyecto existente en el sitio web de dbt.

Para información general sobre dbt, vea el siguiente vídeo de YouTube (26 minutos).

Conexión a dbt Cloud mediante Partner Connect

En esta sección se describe cómo conectar el almacén de Databricks SQL a dbt Cloud mediante Partner Connect y, a continuación, proporcionar a dbt Cloud acceso de lectura a los datos.

Diferencias entre las conexiones estándar y dbt Cloud

Para conectarse a dbt Cloud mediante Partner Connect, siga los pasos descritos en Conexión a partners de preparación de datos con Partner Connect. La conexión dbt Cloud es diferente de las conexiones estándar de preparación y transformación de datos de las maneras siguientes:

  • Además de una entidad principal de servicio y un token de acceso personal, Partner Connect crea por defecto un almacén SQL (antes punto final SQL) denominado DBT_CLOUD_ENDPOINT.

Pasos para establecer la conexión

Para conectarse a dbt Cloud mediante Partner Connect, haga lo siguiente:

  1. Conexión a partners de preparación de datos con Partner Connect.

  2. Después de conectarse a dbt Cloud, aparece el panel de dbt Cloud. Para explorar el proyecto de dbt Cloud, en la barra de menús, junto al logotipo de dbt, seleccione el nombre de la cuenta de dbt en la primera lista desplegable si no se muestra y, después, seleccione el proyecto Databricks Partner Connect Trial en el segundo menú desplegable si no se muestra.

    Sugerencia

    Para ver la configuración del proyecto, haga clic en el menú de las "tres franjas" o de la "hamburguesa", luego en Account Settings > Projects y, finalmente, en el nombre del proyecto. Para ver la configuración de la conexión, haga clic en el vínculo que hay junto a Connection. Para cambiar cualquier valor de configuración, haga clic en Edit.

    Para ver la información del token de acceso personal de Azure Databricks de este proyecto, haga clic en el icono de "persona" de la barra de menús, haga clic en Profile > Credentials > Databricks Partner Connect Trial y haga clic en el nombre del proyecto. Para hacer un cambio, haga clic en Editar.

Pasos para dar a dbt Cloud acceso de lectura a sus datos

Partner Connect concede permiso de solo creación a la entidad de servicio DBT_CLOUD_USER solo en el catálogo predeterminado. Siga estos pasos en el área de trabajo de Azure Databricks para conceder a la entidad de servicio DBT_CLOUD_USER acceso de lectura a los datos que elija.

Advertencia

Puede adaptar estos pasos para proporcionar a dbt Cloud acceso adicional en los catálogos, bases de datos y tablas del área de trabajo. Sin embargo, como procedimiento recomendado de seguridad, Databricks recomienda encarecidamente conceder acceso solo a las tablas individuales con las que necesite que la entidad de servicio DBT_CLOUD_USER trabaje y solo acceso de lectura a esas tablas.

  1. Haga clic en icono del catálogo Catálogo en la barra lateral.

  2. Seleccione el almacén de SQL (DBT_CLOUD_ENDPOINT) de la lista desplegable de la parte superior derecha.

    Seleccione almacén

    1. En Explorador de catálogo, seleccione el catálogo que contiene la base de datos de la tabla.
    2. Seleccione la base de datos que contiene la tabla.
    3. Seleccione la tabla.

    Sugerencia

    Si no ve el catálogo, la base de datos o la tabla enumerados, escriba cualquier parte del nombre en los cuadros Select Catalog, Select Database o Filter tables, respectivamente, para restringir la lista.

    Tablas de filtros

  3. Haga clic en Permisos.

  4. Haga clic en Conceder.

  5. En Type to add multiple users or groups, seleccione DBT_CLOUD_USER. Esta es la entidad de servicio de Azure Databricks que Partner Connect creó automáticamente en la sección anterior.

    Sugerencia

    Si no ve DBT_CLOUD_USER, empiece a escribir DBT_CLOUD_USER en el cuadro Type to add multiple users or groups hasta que aparezca en la lista y, después, selecciónelo.

  6. Conceda acceso de lectura solamente mediante la selección de SELECT y READ METADATA.

  7. Haga clic en OK.

Repita los pasos del 4 al 9 para cada tabla adicional a la que desee conceder a dbt Cloud acceso de lectura.

Solución de problemas de la conexión dbt Cloud

Si alguien elimina el proyecto en dbt Cloud para esta cuenta y hace clic en el icono de dbt, aparece un mensaje de error, lo que indica que no se encuentra el proyecto. Para corregirlo, haga clic en Delete connection y, después, comience desde el principio de este procedimiento para volver a crear la conexión.

Conexión manual a dbt Cloud

Esta sección describe cómo conectar un clúster de Azure Databricks o un almacén de Databricks SQL en el área de trabajo de Azure Databricks a dbt Cloud.

Importante

Databricks recomienda conectarse a un almacén de SQL. Si no tiene el derecho de acceso a Databricks SQL o si desea ejecutar modelos de Python, puede conectarse a un clúster en su lugar.

Requisitos

  • Un clúster o almacén SQL en el área de trabajo de Azure Databricks.

  • Los detalles de la conexión del clúster o almacén SQL, concretamente los valores Nombre de host del servidor, Puerto y Ruta de acceso HTTP.

  • Un token de acceso personal de Azure Databricks o un token de Microsoft Entra ID (anteriormente, Azure Active Directory). Para crear un token de acceso personal, haga lo siguiente:

    1. En el área de trabajo de Azure Databricks, haga clic en el nombre de usuario de Azure Databricks de la barra superior y, a continuación, seleccione Configuración en la lista desplegable.
    2. Haga clic en Desarrollador.
    3. Junto a Tokens de acceso, haga clic en Administrar.
    4. Haga clic en Generate new token (Generar nuevo token).
    5. (Opcional) Escriba un comentario que le ayude a identificar este token en el futuro y cambie la duración predeterminada del token de 90 días. Para crear un token sin duración (no recomendado), deje el cuadro Duración (días) vacío (en blanco).
    6. Haga clic en Generar.
    7. Copie el token mostrado en una ubicación segura y, a continuación, haga clic en Listo.

    Nota:

    Asegúrese de guardar el token copiado en una ubicación segura. No comparta el token copiado con otros usuarios. Si pierde el token copiado, no podrá volver a generar ese mismo token. Debe repetir el procedimiento para crear un nuevo token. Si pierde el token copiado o cree que el token se ha visto comprometido, Databricks recomienda eliminar inmediatamente ese token del área de trabajo haciendo clic en el icono de papelera (Revocar) situado junto al token en la página Tokens de acceso.

    Si no puede crear o usar tokens en el área de trabajo, puede deberse a que el administrador del área de trabajo tiene tokens deshabilitados o no le ha concedido permiso para crear o usar tokens. Consulte el administrador del área de trabajo o lo siguiente:

    Nota:

    Como procedimiento recomendado de seguridad, cuando se autentique con herramientas, sistemas, scripts y aplicaciones automatizados, Databricks recomienda usar los tokens de acceso personal pertenecientes a las entidades de servicio en lugar de a los usuarios del área de trabajo. Para crear tókenes para entidades de servicio, consulte Administración de tokens de acceso para una entidad de servicio.

  • Para conectar dbt Cloud a los datos administrados por Unity Catalog, dbt versión 1.1 o posterior.

    Los pasos de este artículo crean un nuevo entorno que usa la versión más reciente de dbt. Para obtener información sobre cómo actualizar la versión de dbt para un entorno existente, consulte Actualización a la versión más reciente de dbt en la nube en la documentación de dbt.

Paso 1: Suscripción a dbt Cloud

Vaya a la página de registro de dbt Cloud y escriba su dirección de correo electrónico, su nombre y la información de la empresa. Cree una contraseña y haga clic en Crear mi cuenta.

Paso 2: Creación de un proyecto de dbt

En este paso, se crea un proyecto de dbt que contiene una conexión a un clúster de Azure Databricks o un almacén de SQL, un repositorio que contiene el código fuente y uno o varios entornos (como entornos de prueba y producción).

  1. Inicie sesión en dbt Cloud.

  2. Haga clic en el icono de configuración y, luego, haga clic en Configuración de la cuenta.

  3. Haga clic en Nuevo proyecto.

  4. En Nombre, escriba un nombre único para el proyecto y haga clic en Continuar.

  5. En Elegir una conexión, haga clic en Databricks y, luego, haga clic en Siguiente.

  6. En Nombre, escriba un nombre único para esta conexión.

  7. En Seleccionar adaptador, haga clic en Databricks (dbt-databricks).

    Nota:

    Databricks recomienda usar dbt-databricks, que admite el catálogo de Unity, en lugar de dbt-spark. De forma predeterminada, los nuevos proyectos usan dbt-databricks. Para migrar un proyecto existente a dbt-databricks, consulte Migración de dbt-spark a dbt-databricks en la documentación de dbt.

  8. En Configuración, para Nombre de host del servidor, escriba el valor de nombre de host del servidor de los requisitos.

  9. En el campo Ruta de acceso HTTP, escriba el valor de Ruta de acceso HTTP que obtuvo al cumplir los requisitos.

  10. Si el área de trabajo está habilitada para Unity Catalog, en Configuración opcional, escriba el nombre del catálogo para que dbt Cloud lo use.

  11. En Credenciales de desarrollo, en Token, escriba el token de acceso personal o el token de Microsoft Entra ID de los requisitos.

  12. En Esquema, escriba el nombre del esquema donde quiera que dbt Cloud cree las tablas y vistas (por ejemplo, default).

  13. Haga clic en Probar conexión.

  14. Cuando la prueba se realice correctamente, haga clic en Siguiente.

Para obtener más información, consulte Conexión a ODBC de Databricks en el sitio web de dbt.

Sugerencia

Para ver o cambiar la configuración de este proyecto, o para eliminar el proyecto por completo, haga clic en el icono de configuración, clic en Configuración de la cuenta > Proyectos y el nombre del proyecto. Para cambiar la configuración, haga clic en Editar. Para eliminar el proyecto, haga clic en Editar > Eliminar proyecto.

Para ver o cambiar el valor del token de acceso personal de Azure Databricks para este proyecto, haga clic en el icono de persona, Perfil > Credenciales y el nombre del proyecto. Para hacer un cambio, haga clic en Editar.

Después de conectarse a un clúster de Azure Databricks o a un almacén de Databricks SQL, siga las instrucciones en pantalla para la Configuración de un repositorio y haga clic en Continuar.

Después de configurar el repositorio, siga las instrucciones en pantalla para invitar a usuarios y haga clic en Completar. También puede hacer clic en Omitir y completar.

Tutorial

En esta sección, usará el proyecto dbt Cloud para trabajar con varios datos de ejemplo. En esta sección se da por hecho que ya ha creado el proyecto y que el IDE de dbt Cloud está abierto a ese proyecto.

Paso 1: Creación y ejecución de modelos

En este paso, usará el IDE de dbt Cloud para crear y ejecutar modelos, que son instrucciones select que crean una nueva vista (el valor predeterminado) o una nueva tabla en una base de datos en función de los datos existentes en la base de datos en cuestión. En este procedimiento se crea un modelo basado en la tabla diamonds de ejemplo a partir de los conjuntos de datos de ejemplo.

Use el código siguiente para crear esta tabla.

DROP TABLE IF EXISTS diamonds;

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

En este procedimiento se da por supuesto que esta tabla ya se ha creado en la base de datos default del área de trabajo.

  1. Con el proyecto abierto, haga clic en Desarrollar en la parte superior de la interfaz de usuario.

  2. Haga clic en Inicializar proyecto de dbt.

  3. Haga clic en Confirmar y sincronizar, escriba un mensaje de confirmación y, a continuación, haga clic en Confirmar.

  4. Haga clic en Crear rama, escriba un nombre para la rama y, a continuación, haga clic en Enviar.

  5. Cree el primer modelo: haga clic en Crear nuevo archivo.

  6. En el editor de texto, escriba la siguiente instrucción SQL. Esta instrucción selecciona solo los detalles de quilates, corte, color y claridad de cada diamante de la tabla diamonds. El bloque config indica a dbt que cree una tabla en la base de datos a partir de esta instrucción.

    {{ config(
  materialized='table',
  file_format='delta'
) }}

    select carat, cut, color, clarity
from diamonds

    Sugerencia

    Para ver opciones adicionales config, como la estrategia incremental merge, consulte Configuración de Databricks en la documentación de dbt.

  7. Haga clic en Guardar como.

  8. En el nombre de archivo, escriba models/diamonds_four_cs.sql y, a continuación, haga clic en Crear.

  9. Cree el segundo modelo: haga clic en icono Crear nuevo archivo (Crear nuevo archivo) en la esquina superior derecha.

  10. En el editor de texto, escriba la siguiente instrucción SQL. Esta instrucción selecciona valores únicos de la columna colors de la tabla diamonds_four_cs y ordena los resultados en orden alfabético del primero al último. Dado que no hay ningún bloque config, este modelo indica a dbt que cree una vista en la base de datos basada en esta instrucción.

    select distinct color
from diamonds_four_cs
sort by color asc

  11. Haga clic en Guardar como.

  12. En el nombre de archivo, escriba models/diamonds_list_colors.sql y, a continuación, haga clic en Crear.

  13. Cree el tercer modelo: haga clic en icono Crear nuevo archivo (Crear nuevo archivo) en la esquina superior derecha.

  14. En el editor de texto, escriba la siguiente instrucción SQL. Esta instrucción hace un promedio de los precios de los diamantes por color y ordena los resultados por precio medio de mayor a menor. Este modelo indica a dbt que cree una vista en la base de datos basada en esta instrucción.

    select color, avg(price) as price
from diamonds
group by color
order by price desc

  15. Haga clic en Guardar como.

  16. En el nombre de archivo, escriba models/diamonds_prices.sql y haga clic en Crear.

  17. Ejecute los modelos: en la línea de comandos, ejecute el comando dbt run con las rutas de acceso a los tres archivos anteriores. En la base de datos default, dbt crea una tabla denominada diamonds_four_cs y dos vistas denominadas diamonds_list_colors y diamonds_prices. dbt obtiene estos nombres de vista y de tabla de sus nombres de archivo .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. Ejecute el siguiente código SQL para mostrar información sobre las nuevas vistas y para seleccionar todas las filas de la tabla y las vistas.

    Si se conecta a un clúster, puede ejecutar este código SQL desde un cuaderno asociado al clúster, especificando SQL como idioma predeterminado para el cuaderno. Si se conecta a un almacén de SQL, puede ejecutar este código SQL desde una 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 |
+-------+---------+
...

Paso 2: Creación y ejecución de modelos más complejos

En este paso, creará modelos más complejos para un conjunto de tablas de datos relacionadas. Estas tablas de datos contienen información sobre una liga deportiva ficticia con tres equipos que jugarán una temporada de seis partidos. Este procedimiento crea las tablas de datos y crea y ejecuta los modelos.

  1. Ejecute el siguiente código SQL para crear las tablas de datos necesarias.

    Si se conecta a un clúster, puede ejecutar este código SQL desde un cuaderno asociado al clúster, especificando SQL como idioma predeterminado para el cuaderno. Si se conecta a un almacén de SQL, puede ejecutar este código SQL desde una consulta.

    Las tablas y vistas de este paso comienzan por zzz_ para ayudar a identificarlas como parte de este ejemplo. No es necesario seguir este patrón para sus propias tablas y vistas.

    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. Cree el primer modelo: haga clic en icono Crear nuevo archivo (Crear nuevo archivo) en la esquina superior derecha.

  3. En el editor de texto, escriba la siguiente instrucción SQL. Esta instrucción crea una tabla que proporciona los detalles de cada partido, como los nombres y las puntuaciones de los equipos. El bloque config indica a dbt que cree una tabla en la base de datos a partir de esta instrucción.

    -- 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. Haga clic en Guardar como.

  5. En el nombre de archivo, escriba models/zzz_game_details.sql y, a continuación, haga clic en Crear.

  6. Cree el segundo modelo: haga clic en icono Crear nuevo archivo (Crear nuevo archivo) en la esquina superior derecha.

  7. En el editor de texto, escriba la siguiente instrucción SQL. Esta instrucción crea una vista que enumera los registros de victorias y derrotas de los equipos de la 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. Haga clic en Guardar como.

  9. En el nombre de archivo, escriba models/zzz_win_loss_records.sql y, a continuación, haga clic en Crear.

  10. Ejecute los modelos: en la línea de comandos, ejecute el comando dbt run con las rutas de acceso a los dos archivos anteriores. En la base de datos default (como se especifica en la configuración del proyecto), dbt crea una tabla denominada zzz_game_details y una vista con el nombre zzz_win_loss_records. dbt obtiene estos nombres de vista y tabla de sus nombres de archivo .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. Ejecute el código SQL siguiente para enumerar la información sobre la nueva vista y seleccionar todas las filas de la tabla y la vista.

    Si se conecta a un clúster, puede ejecutar este código SQL desde un cuaderno asociado al clúster, especificando SQL como idioma predeterminado para el cuaderno. Si se conecta a un almacén de SQL, puede ejecutar este código SQL desde una 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      |
+---------------+------+--------+

Paso 3: Creación y ejecución de pruebas

En este paso, creará pruebas, que son aserciones que hace en relación con los modelos. Al ejecutar estas pruebas, dbt le muestra si cada prueba del proyecto se supera o se suspende.

Hay dos tipos de pruebas. Las pruebas de esquema, escritas en YAML, devuelven el número de registros que no superan una instrucción de aserción. Cuando este número es cero, todos los registros son correctos y, por tanto, la prueba se supera. Las pruebas de datos son consultas específicas que deben devolver cero registros para superarse.

  1. Cree las primeras pruebas de esquema: haga clic en icono Crear nuevo archivo (Crear nuevo archivo) en la esquina superior derecha.

  2. En el editor de texto, escriba el siguiente contenido. Este archivo incluye pruebas de esquema que determinan si las columnas especificadas tienen valores únicos, no son valores NULL, solo tienen los valores especificados o una combinación.

    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. Haga clic en Guardar como.

  4. En el nombre de archivo, escriba models/schema.yml y, a continuación, haga clic en Crear.

  5. Cree la primera prueba de datos: haga clic en icono Crear nuevo archivo (Crear nuevo archivo) en la esquina superior derecha.

  6. En el editor de texto, escriba la siguiente instrucción SQL. Este archivo incluye una prueba de datos para determinar si se ha jugado algún partido fuera de la temporada estándar.

    -- 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. Haga clic en Guardar como.

  8. En el nombre de archivo, escriba tests/zzz_game_details_check_dates.sql y, a continuación, haga clic en Crear.

  9. Cree la segunda prueba de datos: haga clic en icono Crear nuevo archivo (Crear nuevo archivo) en la esquina superior derecha.

  10. En el editor de texto, escriba la siguiente instrucción SQL. Este archivo incluye una prueba de datos para determinar si las puntuaciones eran negativas o si hubo algún empate.

    -- 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. Haga clic en Guardar como.

  12. En el nombre de archivo, escriba tests/zzz_game_details_check_scores.sql y, a continuación, haga clic en Crear.

  13. Cree la tercera prueba de datos: haga clic en icono Crear nuevo archivo (Crear nuevo archivo) en la esquina superior derecha.

  14. En el editor de texto, escriba la siguiente instrucción SQL. Este archivo incluye una prueba de datos para determinar si algún equipo tenía registros de victorias o derrotas negativos, más registros de victorias o derrotas que partidos jugados o más partidos jugados de la cuenta.

    -- 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. Haga clic en Guardar como.

  16. En el nombre de archivo, escriba tests/zzz_win_loss_records_check_records.sql y, a continuación, haga clic en Crear.

  17. Ejecute las pruebas: en la línea de comandos, ejecute el comando dbt test.

Paso 4: Limpieza

Puede eliminar las tablas y vistas que creó para este ejemplo ejecutando el código SQL siguiente.

Si se conecta a un clúster, puede ejecutar este código SQL desde un cuaderno asociado al clúster, especificando SQL como idioma predeterminado para el cuaderno. Si se conecta a un almacén de SQL, puede ejecutar este código SQL desde una 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;

Pasos siguientes

  • Más información sobre los modelos de dbt.
  • Obtenga información sobre cómo probar los proyectos de dbt.
  • Aprenda a usar Jinja, un lenguaje de plantillas, para programar SQL en los proyectos de dbt.
  • Más información sobre los procedimientos recomendados para dbt.

Recursos adicionales