The Complete dbt Certification Course

Define dbt sources in a sources.yaml entry named eth with schema eth_schema and tables contracts, token transfers, and transactions. Test source with a test model and verify lineage in dbt.

Create an enriched transactions model in dbt by selecting hash, block number, date, from and to addresses, value, receipt contract address, and input from the transactions source, aliased as t.

This lecture explains Ethereum transaction fields: hash, block number, confirmation date, from and received contract address, and input data; contrast contract creation with interaction on ERC20 tokens like USDT.

Explore how dbt models classify ethereum transactions into contract creation, token transfers (ERC20), and plain ether transfers, using transaction hashes and transfer counts to analyze activity.

Create an eth activity per day dbt model by date and category, counting transactions and summing ETH value (wei to ETH) using transactions and reach table. Visualize with Snowflake charts.

Analyze daily stablecoin activity in the Ethereum ecosystem by modeling token transfers for USDT and USDC, converting token values using decimals to total USD, and aggregating results by date.

Learn to identify and verify raw object dependencies in dbt by using ref to link previous models and the source function to reference external data, ensuring clear lineage.

Create a staging model for every source in your dbt project (stg_<source>) to shield downstream models from schema drift, using ref to centralize source changes.

Explore the four types of materializations: views, tables, incremental models, and ephemeral models. Learn how to set and prioritize materialization precedence using dbt project file and the model's config block.

Learn when to materialize as tables or views in dbt, and how incremental and ephemeral models fit the trade-off between physical storage and re-computed logic for up-to-date results.

Explore incremental models in dbt, configuring materialization as incremental, leveraging the isIncremental macro, and applying the append strategy to efficiently process new data in large datasets like the Ethereum blockchain.

Explore the four dbt materializations: tables, views, incremental models, and ephemeral models. Ephemeral models aren't materialized or queryable; they're used by child models as cte logic to support dry code.

Learn how incremental models handle adding a new field with on schema change parameters, ignoring, failing, or syncing all columns, and when to use a full refresh to backfill records.

Explore modular dbt design by organizing models, applying naming conventions, and using dry principles to avoid repetition, while writing models with ctes and macros for reusable logic.

Learn how to organize a dbt project with modular layers and clear naming: base, staging, and marts, using stg_ prefixes and fct/dim prefixes for reusable, traceable SQL logic.

Apply DBT's common table expressions to write modular SQL, improving readability and reusability; promote repeated logic to CTEs, views, or ephemeral models to avoid repetition.

Learn dry principles in dbt project configurations by defining general materialization and tags in the project yaml, then applying specific configs to individual models.

Explore how dbt macros, powered by the jinja templating language, implement dry principles by invoking macros for sql output and using {% %} for conditional control flow.

Learn to write and use macros to convert ethereum and stablecoin values, avoiding repetition, in dbt projects by creating conversion utilities and calling them with double curly braces.

Learn to build and call dbt macros using jinja templates, use the log and set macros to create and log queries, and run macros solo with the dbt run operation.

Build and run a macro with run_query, log the results, extract values from the returned data frame, and understand the parse and execute phases of dbt runs.

Use the if execute guard to run macro code only in the execution phase of dbt runs. Learn to build dynamic sql with for loops, tilde concatenation, and pipe join.

Apply dry principles by cleaning up a macro and removing the all filter used to demonstrate macro interaction with dbt models, and proceed to the next subsection.

Convert business logic into performant sql queries by building simple, single-task dbt models that follow dry principles, reuse blocks, and apply cte-based joins and efficient materializations.

Master dbt run with full project execution, select specific models using dash dash select, and use empty and fail fast flags to validate and speed up development.

Define schema tests in dbt by creating a schema.yaml for models, applying not null and unique checks on the transactions hash column, and running dbt test to verify data quality.

learn to document your dbt models with dbt docs by adding model and column descriptions, using multi-line yaml blocks, and generating and serving a local catalog.

Learn how to use dbt seed to load a stablecoins csv into a seeds table, then join it to your activity per day model and apply dimension-only seed best practices.

Explore dbt commands such as compile, ls, clean, and build to understand model parsing, resource listing, cleaning the targets folder, and running tests in a project.

Master a logical flow of dbt models by organizing into base, staging, and marts layers and using tags, folders, and selective runs to build clean, acyclic DAGs.

Master the dbt_project.yml as the single source of truth and control center for your dbt project, governing models, tests, seeds, and macros.

Explore defining configurations in dbt_project.yml with YAML basics, including dictionaries, inline and multiline syntax, lists with dashes or square brackets, and multi-line strings.

explore configuring dbt projects in dbt_project.yml, using the plus sign to distinguish paths from configurations, and apply additive tags with model level precedence, and see how schemas can be defined.

Learn how to define custom schemas in dbt_project.yml, how target schemas concatenate with a custom schema name, and how seeds and databases interact in a dbt project.

Learn to define and variabilize variables in dbt_project.yml using the var macro for the token activity per day model, including token address and decimals, with proper quoting.

Explore alias configuration in dbt_project.yml and model-level aliases to materialize models with meaningful warehouse names; leverage variables and jinja for dynamic token activity per day.

Configure sources in dbt by defining a sources block in a yaml under the models folder, using name, table, database, schema, and the identifier and quoting options.

Learn to use dbt packages, focusing on the code gen package from dbt hub. Install via packages.yaml, manage dependencies with dbt devs, and generate sources and models using macros.

Explore how the dbt-utils package extends dbt with reusable macros like the star macro to select all columns, with options like except and dispatch to prioritize project-specific macros.

Explore using Audit Helper dbt package to compare tables at row level with the compare relations macro, and learn how to configure and integrate dbt packages in your project.

Learn to install dbt packages from private git repos using personal access tokens and environment variables, including handling dbt deps, project yaml, and the distinction between packages.yaml and dependencies.yaml.

Initialize a git repository to manage your dbt project, track changes with git status, stage with git add, and commit with a message. Use a .gitignore and push to GitHub.

Protect the master branch by enabling rules and requiring pull requests, then create a dev branch, push changes, and merge via a pull request to update master.

Simulate a merge conflict when multiple developers edit the same dbt project yaml; learn to resolve conflicts locally or via remote pull requests, choosing current or incoming changes.

Explore essential git concepts for dbt projects, including repos, branches, checkout, commits, and merge conflicts. Learn remote vs local workflows, pull requests, and commit often with descriptive messages.

Learn to create python models in dbt, leveraging python libraries like pandas and numpy, with table or incremental materialization, and using dbt.ref and dbt.source for dependencies.

Import and configure python packages in dbt models, convert snowpark to pandas, and compute is_holiday for dates. Note platform constraints, especially snowflake, and potential blockers with dbt fusion.

Learn how dbt manages grants in Snowflake by assigning roles, granting table access, ensuring schema and database usage, and enabling warehouse access for specific models.

Learn how dbt grants config assigns privileges using post-hooks and pre-hooks, with on run start or on run end, granting usage on database and schema, including snowflake-specific considerations.

Explore grants and hooks in dbt, learn additive versus config grants, plus how to grant, revoke, and manage permissions for roles like Testa and BA across databases and schemas.

Explore managing environments in dbt, creating a prod environment separate from dev, configuring profiles.yaml, targets, and seeds, and understanding how databases and schemas organize production data.

Create a prod environment in profiles.yaml and use target.name to tailor database and schema per environment, then dbt compile and run to limit data in dev or prod.

Learn how dbt contracts enforce a schema on models by defining column names and data types, with setup in schema.yaml and code gen for generation.

Use the codegen macro to generate model yaml for dbt, define schemas in schema.yaml, and enforce contracts true to lock column names and data types for models exposed to customers.

Explore subtleties of dbt contracts, including alias types mapping, default true behavior, and how strings and varchars map to warehouse types, plus enforcement on tables, views, and incremental models.

Learn how to manage evolving dbt contracts with versioning by creating v1 and v2 schemas, using the latest version view and post hooks to run alongside consumers.

Set a deprecation date for dbt model versions to warn teams and guide migrations, manage v1 and v2 contracts, and run specific versions to verify changes.

Learn to structure a dbt project for fraud detection by organizing analytics and fraud domains in Mars, and build a staging fraud model to flag contract creation with bytecode.

Explore dbt model access through groups, using private, protected, and public policies to control which models reference others, demonstrated by analytics engineering and fraud platform groups configured in YAML.

Learn about model access levels—private, protected, and public—and how references work within a dbt project. Understand governance and grouping, and how restrict access controls cross-project references.