Delen via


Verbinding maken met dbt Cloud

dbt (data build tool) is een ontwikkelomgeving waarmee gegevensanalisten en gegevensengineers data kunnen transformeren door simpelweg select-instructies te schrijven. dbt verwerkt het omzetten van deze select-instructies in tabellen en weergaven. dbt compileert uw code in onbewerkte SQL en voert die code vervolgens uit in de opgegeven database in Azure Databricks. dbt biedt ondersteuning voor samenwerkende coderingspatronen en aanbevolen procedures, zoals versiebeheer, documentatie en modulariteit.

dbt extraheert of laadt geen gegevens. dbt is alleen gericht op de transformatiestap, met behulp van een 'transformatie na belasting'-architectuur. dbt gaat ervan uit dat u al een kopie van uw gegevens in uw database hebt.

Dit artikel is gericht op dbt Cloud. dbt Cloud wordt geleverd met kant-en-klare ondersteuning voor het plannen van taken, CI/CD, het leveren van documentatie, bewaking en waarschuwingen en een IDE (Integrated Development Environment).

Er is ook een lokale versie van dbt met de naam dbt Core beschikbaar. met dbt Core kunt u op uw lokale ontwikkelcomputer dbt-code schrijven in de teksteditor of IDE van uw keuze en vervolgens dbt uitvoeren vanaf de opdrachtregel. dbt Core bevat de dbt-opdrachtregelinterface (CLI). De dbt CLI is gratis te gebruiken en open source. Zie Verbinding maken met dbt Core voor meer informatie.

Omdat dbt Cloud en dbt Core gehoste Git-opslagplaatsen kunnen gebruiken (bijvoorbeeld op GitHub, GitLab of BitBucket), kunt u dbt Cloud gebruiken om een dbt-project te maken en het vervolgens beschikbaar te maken voor uw dbt Cloud- en dbt Core-gebruikers. Zie Een dbt-project maken en een bestaand project gebruiken op de dbt-website voor meer informatie.

Bekijk de volgende YouTube-video (26 minuten) voor een algemeen overzicht van dbt.

Verbinding maken met dbt Cloud met behulp van Partner Connect

In deze sectie wordt beschreven hoe u een Databricks SQL Warehouse verbindt met dbt Cloud met behulp van Partner Connect en vervolgens dbt Cloud leestoegang geeft tot uw gegevens.

Verschillen tussen standaardverbindingen en dbt Cloud

Als u verbinding wilt maken met dbt Cloud met behulp van Partner Connect, volgt u de stappen in Verbinding maken met partners voor gegevensvoorbereiding met behulp van Partner Connect. De dbt Cloud-verbinding verschilt van standaardverbindingen voor gegevensvoorbereiding en transformatie op de volgende manieren:

  • Naast een service-principal en een persoonlijk toegangstoken maakt Partner Connect standaard een SQL Warehouse (voorheen SQL-eindpunt) met de naam DBT_CLOUD_ENDPOINT .

Stappen om verbinding te maken

Ga als volgt te werk om verbinding te maken met dbt Cloud met behulp van Partner Connect:

  1. Maak verbinding met gegevensvoorbereidingspartners via Partner Connect.

  2. Nadat u verbinding hebt gemaakt met dbt Cloud, wordt uw dbt Cloud-dashboard weergegeven. Als u uw dbt Cloud-project wilt verkennen, selecteert u in de menubalk naast het dbt-logo de naam van uw dbt-account in de eerste vervolgkeuzelijst als dit niet wordt weergegeven en selecteert u vervolgens het Databricks Partner Connect Trial-project in de tweede vervolgkeuzelijst als dit niet wordt weergegeven.

    Tip

    Als u de instellingen van uw project wilt weergeven, klikt u op het menu 'drie strepen' of 'hamburger', klikt u op Accountinstellingenprojecten >en klikt u op de naam van het project. Als u de verbindingsinstellingen wilt weergeven, klikt u op de koppeling naast Verbinding. Als u instellingen wilt wijzigen, klikt u op Bewerken.

    Als u de persoonlijke toegangstokengegevens van Azure Databricks voor dit project wilt weergeven, klikt u op het pictogram 'persoon' op de menubalk, klikt u op De databricks Partner Connect-proefversie van profielreferenties > > en klikt u op de naam van het project. Als u een wijziging wilt aanbrengen, klikt u op Bewerken.

Stappen om dbt Cloud leestoegang te geven tot uw gegevens

Partner Connect geeft alleen machtigingen voor het maken van de DBT_CLOUD_USER service-principal in de standaardcatalogus. Volg deze stappen in uw Azure Databricks-werkruimte om de DBT_CLOUD_USER service-principal leestoegang te geven tot de gegevens die u kiest.

Waarschuwing

U kunt deze stappen aanpassen om dbt Cloud extra toegang te geven tot catalogi, databases en tabellen in uw werkruimte. Databricks raadt echter ten zeerste aan om alleen toegang te verlenen tot de afzonderlijke tabellen waarvoor u de DBT_CLOUD_USER service-principal nodig hebt om mee te werken en alleen leestoegang tot deze tabellen.

  1. Klik op Cataloguspictogram Catalogus in de zijbalk.

  2. Selecteer het SQL Warehouse (DBT_CLOUD_ENDPOINT) in de vervolgkeuzelijst rechtsboven.

    Magazijn selecteren

    1. Selecteer onder Catalog Explorer de catalogus die de database voor uw tabel bevat.
    2. Selecteer de database die de tabel bevat.
    3. Selecteer uw tabel.

    Tip

    Als uw catalogus, database of tabel niet wordt weergegeven, voert u een deel van de naam in de vakken Catalogus selecteren, Database selecteren of Filteren in om de lijst te verfijnen.

    Tabellen filteren

  3. Klik op Machtigingen.

  4. Klik op Verlenen.

  5. Als u meerdere gebruikers of groepen wilt toevoegen, selecteert u DBT_CLOUD_USER. Dit is de Azure Databricks-service-principal die Partner Connect in de vorige sectie voor u heeft gemaakt.

    Tip

    Als u DBT_CLOUD_USER niet ziet, begint u te typen DBT_CLOUD_USER in het vak Type om meerdere gebruikers of groepen toe te voegen totdat deze wordt weergegeven in de lijst en selecteert u het.

  6. Geef alleen leestoegang door te SELECT selecteren en READ METADATA.

  7. Klik op OK.

Herhaal stap 4-9 voor elke extra tabel waartoe u dbt Cloud leestoegang wilt geven.

Problemen met de dbt Cloud-verbinding oplossen

Als iemand het project verwijdert in dbt Cloud voor dit account en u op de dbt-tegel klikt, wordt er een foutbericht weergegeven met de mededeling dat het project niet kan worden gevonden. U kunt dit oplossen door op Verbinding verwijderen te klikken en vervolgens te beginnen vanaf het begin van deze procedure om de verbinding opnieuw te maken.

Handmatig verbinding maken met dbt Cloud

In deze sectie wordt beschreven hoe u een Azure Databricks-cluster of een Databricks SQL-warehouse in uw Azure Databricks-werkruimte verbindt met dbt Cloud.

Belangrijk

Databricks raadt aan verbinding te maken met een SQL-warehouse. Als u geen toegangsrechten voor Databricks SQL hebt of als u Python-modellen wilt uitvoeren, kunt u in plaats daarvan verbinding maken met een cluster.

Eisen

  • Een cluster of SQL Warehouse in uw Azure Databricks-werkruimte.

  • De verbindingsgegevens voor uw cluster of SQL Warehouse, met name de serverhostnaam, poort en HTTP-padwaarden .

  • Een persoonlijk toegangstoken van Azure Databricks of een Microsoft Entra ID-token (voorheen Azure Active Directory).. Ga als volgt te werk om een persoonlijk toegangstoken te maken:

    1. Klik in uw Azure Databricks-werkruimte op uw Azure Databricks-gebruikersnaam in de bovenste balk en selecteer vervolgens Instellingen in de vervolgkeuzelijst.
    2. Klik op Ontwikkelaars.
    3. Klik naast Access-tokens op Beheren.
    4. Klik op Nieuw token genereren.
    5. (Optioneel) Voer een opmerking in waarmee u dit token in de toekomst kunt identificeren en de standaardlevensduur van het token van 90 dagen kunt wijzigen. Als u een token zonder levensduur wilt maken (niet aanbevolen), laat u het vak Levensduur (dagen) leeg (leeg).
    6. Klik op Genereren.
    7. Kopieer het weergegeven token naar een veilige locatie en klik vervolgens op Gereed.

    Notitie

    Zorg ervoor dat u het gekopieerde token op een veilige locatie opslaat. Deel uw gekopieerde token niet met anderen. Als u het gekopieerde token kwijtraakt, kunt u dat token niet opnieuw genereren. In plaats daarvan moet u deze procedure herhalen om een nieuw token te maken. Als u het gekopieerde token kwijtraakt of als u denkt dat het token is aangetast, raadt Databricks u ten zeerste aan dat u dat token onmiddellijk uit uw werkruimte verwijdert door te klikken op het prullenbakpictogram (Intrekken) naast het token op de pagina Toegangstokens .

    Als u geen tokens in uw werkruimte kunt maken of gebruiken, kan dit komen doordat uw werkruimtebeheerder tokens heeft uitgeschakeld of u geen toestemming hebt gegeven om tokens te maken of te gebruiken. Raadpleeg uw werkruimtebeheerder of de volgende onderwerpen:

    Notitie

    Als best practice voor beveiliging, wanneer u zich verifieert met geautomatiseerde hulpprogramma's, systemen, scripts en apps, raadt Databricks u aan om persoonlijke toegangstokens te gebruiken die behoren tot service-principals in plaats van werkruimtegebruikers. Zie Tokens voor een service-principal beheren om tokens voor service-principals te maken.

  • Dbt Cloud verbinden met gegevens die worden beheerd door Unity Catalog, dbt versie 1.1 of hoger.

    Met de stappen in dit artikel maakt u een nieuwe omgeving die gebruikmaakt van de nieuwste dbt-versie. Zie Upgraden naar de nieuwste versie van dbt in Cloud in de dbt-documentatie voor meer informatie over het upgraden van de dbt-versie voor een bestaande omgeving.

Stap 1: Registreren voor dbt Cloud

Ga naar dbt Cloud: registreer u en voer uw e-mailadres, naam en bedrijfsgegevens in. Maak een wachtwoord en klik op Mijn account maken.

Stap 2: Een dbt-project maken

In deze stap maakt u een dbt-project, dat een verbinding bevat met een Azure Databricks-cluster of een SQL-warehouse, een opslagplaats met uw broncode en een of meer omgevingen (zoals testen en productieomgevingen).

  1. Meld u aan bij dbt Cloud.

  2. Klik op het pictogram Instellingen en klik vervolgens op Accountinstellingen.

  3. Klik op Nieuw project.

  4. Voer voor Naam een unieke naam in voor uw project en klik vervolgens op Doorgaan.

  5. Als u een verbinding wilt kiezen, klikt u op Databricks en vervolgens op Volgende.

  6. Voer bij Naam een unieke naam in voor deze verbinding.

  7. Klik voor Adapter selecteren op Databricks (dbt-databricks).

    Notitie

    Databricks raadt aan om Unity Catalog te gebruiken dbt-databricksin plaats van dbt-spark. Standaard wordt gebruikgemaakt van dbt-databricksnieuwe projecten. Als u een bestaand project wilt dbt-databricksmigreren, raadpleegt u Migreren van dbt-spark naar dbt-databricks in de dbt-documentatie.

  8. Voer onder Instellingen voor serverhostnaam de waarde van de serverhostnaam in van de vereisten.

  9. Voer voor HTTP-pad de WAARDE van het HTTP-pad in van de vereisten.

  10. Als uw werkruimte is ingeschakeld voor Unity Catalog, voert u onder Optionele instellingen de naam in van de catalogus voor dbt Cloud die u wilt gebruiken.

  11. Voer onder Ontwikkelingsreferenties voor token het persoonlijke toegangstoken of het Microsoft Entra ID-token in van de vereisten.

  12. Voer voor Schema de naam in van het schema waarin u wilt dat dbt Cloud de tabellen en weergaven maakt (bijvoorbeelddefault).

  13. Klik op Verbinding testen.

  14. Als de test slaagt, klikt u op Volgende.

Zie Verbinding maken met Databricks ODBC op de dbt-website voor meer informatie.

Tip

Als u de instellingen voor dit project wilt weergeven of wijzigen, of als u het project helemaal wilt verwijderen, klikt u op het instellingenpictogram, klikt u op Accountinstellingenprojecten >en klikt u op de naam van het project. Als u de instellingen wilt wijzigen, klikt u op Bewerken. Als u het project wilt verwijderen, klikt u op Project verwijderen bewerken>.

Als u de persoonlijke toegangstokenwaarde van Azure Databricks voor dit project wilt weergeven of wijzigen, klikt u op het pictogram Persoon, klikt u op Profielreferenties >en klikt u op de naam van het project. Als u een wijziging wilt aanbrengen, klikt u op Bewerken.

Nadat u verbinding hebt gemaakt met een Azure Databricks-cluster of een Databricks SQL Warehouse, volgt u de instructies op het scherm om een opslagplaats in te stellen en klikt u vervolgens op Doorgaan.

Nadat u de opslagplaats hebt ingesteld, volgt u de instructies op het scherm om gebruikers uit te nodigen en klikt u vervolgens op Voltooien. Of klik op Overslaan en voltooien.

Zelfstudie

In deze sectie gebruikt u uw dbt Cloud-project om met enkele voorbeeldgegevens te werken. In deze sectie wordt ervan uitgegaan dat u uw project al hebt gemaakt en dat de dbt Cloud IDE is geopend voor dat project.

Stap 1: Modellen maken en uitvoeren

In deze stap gebruikt u de dbt Cloud IDE om modellen te maken en uit te voeren. Dit zijn select instructies voor het maken van een nieuwe weergave (de standaardinstelling) of een nieuwe tabel in een database, op basis van bestaande gegevens in diezelfde database. Met deze procedure maakt u een model op basis van de voorbeeldtabel op basis van de voorbeeldgegevenssets.diamonds

Gebruik de volgende code om deze tabel te maken.

DROP TABLE IF EXISTS diamonds;

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

In deze procedure wordt ervan uitgegaan dat deze tabel al is gemaakt in de database van default uw werkruimte.

  1. Klik terwijl het project is geopend op Ontwikkelen boven aan de gebruikersinterface.

  2. Klik op Dbt-project initialiseren.

  3. Klik op Doorvoeren en synchroniseren, voer een doorvoerbericht in en klik vervolgens op Doorvoeren.

  4. Klik op Vertakking maken, voer een naam in voor uw vertakking en klik vervolgens op Verzenden.

  5. Het eerste model maken: klik op Nieuw bestand maken.

  6. Voer in de teksteditor de volgende SQL-instructie in. Met deze instructie selecteert u alleen de details van het carat, knippen, kleuren en helderheid voor elke ruit uit de diamonds tabel. Het config blok geeft dbt opdracht om een tabel in de database te maken op basis van deze instructie.

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

    Tip

    Zie Databricks-configuraties in de dbt-documentatie voor aanvullende config opties, zoals de merge incrementele strategie.

  7. Klik op Opslaan als.

  8. Voer de bestandsnaam in models/diamonds_four_cs.sql en klik vervolgens op Maken.

  9. Maak een tweede model: Klik Pictogram Nieuw bestand maken (Nieuw bestand maken) in de rechterbovenhoek.

  10. Voer in de teksteditor de volgende SQL-instructie in. Met deze instructie worden unieke waarden uit de colors kolom in de diamonds_four_cs tabel geselecteerd, waarbij de resultaten eerst in alfabetische volgorde worden gesorteerd. Omdat er geen config blok is, geeft dit model dbt opdracht om een weergave in de database te maken op basis van deze instructie.

    select distinct color
    from diamonds_four_cs
    sort by color asc
    
  11. Klik op Opslaan als.

  12. Voer voor de bestandsnaam de naam in models/diamonds_list_colors.sqlen klik vervolgens op Maken.

  13. Maak een derde model: Klik Pictogram Nieuw bestand maken (Nieuw bestand maken) in de rechterbovenhoek.

  14. Voer in de teksteditor de volgende SQL-instructie in. Met deze verklaring worden de diamantprijzen gemiddelden per kleur, en worden de resultaten gesorteerd op gemiddelde prijs van hoog naar laag. Met dit model wordt dbt geïnstrueerd om een weergave in de database te maken op basis van deze instructie.

    select color, avg(price) as price
    from diamonds
    group by color
    order by price desc
    
  15. Klik op Opslaan als.

  16. Voer de bestandsnaam in models/diamonds_prices.sql en klik op Maken.

  17. Voer de modellen uit: Voer in de opdrachtregel de dbt run opdracht uit met de paden naar de drie voorgaande bestanden. In de default database maakt dbt één tabel met de naam diamonds_four_cs en twee weergaven met de naam diamonds_list_colors en diamonds_prices. dbt haalt deze weergave- en tabelnamen op uit hun gerelateerde .sql bestandsnamen.

    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. Voer de volgende SQL-code uit om informatie over de nieuwe weergaven weer te geven en om alle rijen in de tabel en weergaven te selecteren.

    Als u verbinding maakt met een cluster, kunt u deze SQL-code uitvoeren vanuit een notebook dat is gekoppeld aan het cluster, waarbij SQL wordt opgegeven als de standaardtaal voor het notebook. Als u verbinding maakt met een SQL-warehouse, kunt u deze SQL-code uitvoeren vanuit een query.

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

Stap 2: Complexere modellen maken en uitvoeren

In deze stap maakt u complexere modellen voor een set gerelateerde gegevenstabellen. Deze gegevenstabellen bevatten informatie over een fictieve sportcompetitie van drie teams die een seizoen van zes wedstrijden spelen. Met deze procedure worden de gegevenstabellen gemaakt, worden de modellen gemaakt en worden de modellen uitgevoerd.

  1. Voer de volgende SQL-code uit om de benodigde gegevenstabellen te maken.

    Als u verbinding maakt met een cluster, kunt u deze SQL-code uitvoeren vanuit een notebook dat is gekoppeld aan het cluster, waarbij SQL wordt opgegeven als de standaardtaal voor het notebook. Als u verbinding maakt met een SQL-warehouse, kunt u deze SQL-code uitvoeren vanuit een query.

    De tabellen en weergaven in deze stap beginnen met zzz_ het identificeren ervan als onderdeel van dit voorbeeld. U hoeft dit patroon niet te volgen voor uw eigen tabellen en weergaven.

    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. Maak het eerste model: Klik Pictogram Nieuw bestand maken (Nieuw bestand maken) in de rechterbovenhoek.

  3. Voer in de teksteditor de volgende SQL-instructie in. Met deze instructie maakt u een tabel met de details van elke wedstrijd, zoals teamnamen en scores. Het config blok geeft dbt opdracht om een tabel in de database te maken op basis van deze instructie.

    -- 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. Klik op Opslaan als.

  5. Voer de bestandsnaam in models/zzz_game_details.sql en klik vervolgens op Maken.

  6. Maak een tweede model: Klik Pictogram Nieuw bestand maken (Nieuw bestand maken) in de rechterbovenhoek.

  7. Voer in de teksteditor de volgende SQL-instructie in. Met deze instructie wordt een weergave gemaakt waarin records voor teamwinstverlies voor het seizoen worden vermeld.

    -- 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. Klik op Opslaan als.

  9. Voer de bestandsnaam in models/zzz_win_loss_records.sql en klik vervolgens op Maken.

  10. Voer de modellen uit: Voer in de opdrachtregel de dbt run opdracht uit met de paden naar de twee voorgaande bestanden. In de default database (zoals opgegeven in uw projectinstellingen), maakt dbt één tabel met de naam zzz_game_details en één weergave met de naam zzz_win_loss_records. dbt haalt deze weergave- en tabelnamen op uit hun gerelateerde .sql bestandsnamen.

    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. Voer de volgende SQL-code uit om informatie over de nieuwe weergave weer te geven en om alle rijen in de tabel en weergave te selecteren.

    Als u verbinding maakt met een cluster, kunt u deze SQL-code uitvoeren vanuit een notebook dat is gekoppeld aan het cluster, waarbij SQL wordt opgegeven als de standaardtaal voor het notebook. Als u verbinding maakt met een SQL-warehouse, kunt u deze SQL-code uitvoeren vanuit een query.

    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      |
    +---------------+------+--------+
    

Stap 3: Tests maken en uitvoeren

In deze stap maakt u tests. Dit zijn beweringen die u maakt over uw modellen. Wanneer u deze tests uitvoert, geeft dbt aan of elke test in uw project is geslaagd of mislukt.

Er zijn twee soorten tests. Schematests, geschreven in YAML, retourneren het aantal records dat geen assertie doorgeeft. Wanneer dit getal nul is, worden alle records doorgegeven, waardoor de tests slagen. Gegevenstests zijn specifieke query's die nul records moeten retourneren die moeten worden doorgegeven.

  1. Maak de schematests: Klik Pictogram Nieuw bestand maken (Nieuw bestand maken) in de rechterbovenhoek.

  2. Voer in de teksteditor de volgende inhoud in. Dit bestand bevat schematests die bepalen of de opgegeven kolommen unieke waarden hebben, niet null zijn, alleen de opgegeven waarden hebben of een combinatie.

    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. Klik op Opslaan als.

  4. Voer voor de bestandsnaam de naam in models/schema.ymlen klik vervolgens op Maken.

  5. Maak de eerste gegevenstest: Klik Pictogram Nieuw bestand maken (Nieuw bestand maken) in de rechterbovenhoek.

  6. Voer in de teksteditor de volgende SQL-instructie in. Dit bestand bevat een gegevenstest om te bepalen of er games plaatsvinden buiten het reguliere seizoen.

    -- 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. Klik op Opslaan als.

  8. Voer voor de bestandsnaam de naam in tests/zzz_game_details_check_dates.sqlen klik vervolgens op Maken.

  9. Maak een tweede gegevenstest: Klik Pictogram Nieuw bestand maken (Nieuw bestand maken) in de rechterbovenhoek.

  10. Voer in de teksteditor de volgende SQL-instructie in. Dit bestand bevat een gegevenstest om te bepalen of scores negatief zijn of games zijn gekoppeld.

    -- 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. Klik op Opslaan als.

  12. Voer voor de bestandsnaam de naam in tests/zzz_game_details_check_scores.sqlen klik vervolgens op Maken.

  13. Maak een derde gegevenstest: Klik Pictogram Nieuw bestand maken (Nieuw bestand maken) in de rechterbovenhoek.

  14. Voer in de teksteditor de volgende SQL-instructie in. Dit bestand bevat een gegevenstest om te bepalen of teams negatieve winst- of verliesrecords hadden, meer winst- of verliesrecords hadden dan gespeelde games of meer games speelden dan was toegestaan.

    -- 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. Klik op Opslaan als.

  16. Voer voor de bestandsnaam de naam in tests/zzz_win_loss_records_check_records.sqlen klik vervolgens op Maken.

  17. Voer de tests uit: Voer dbt test de opdracht uit op de opdrachtregel.

Stap 4: Opschonen

U kunt de tabellen en weergaven die u voor dit voorbeeld hebt gemaakt, verwijderen door de volgende SQL-code uit te voeren.

Als u verbinding maakt met een cluster, kunt u deze SQL-code uitvoeren vanuit een notebook dat is gekoppeld aan het cluster, waarbij SQL wordt opgegeven als de standaardtaal voor het notebook. Als u verbinding maakt met een SQL-warehouse, kunt u deze SQL-code uitvoeren vanuit een query.

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;

Volgende stappen

  • Meer informatie over dbt-modellen.
  • Meer informatie over het testen van uw dbt-projecten.
  • Meer informatie over het gebruik van Jinja, een sjabloontaal, voor het programmeren van SQL in uw dbt-projecten.
  • Meer informatie over aanbevolen procedures voor dbt.

Aanvullende bronnen