[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill-dbt-labs-using-dbt-state":3,"mdc-vnpyc4-key":35,"related-org-dbt-labs-using-dbt-state":1803,"related-repo-dbt-labs-using-dbt-state":1962},{"slug":4,"name":4,"fn":5,"description":6,"org":7,"tags":11,"stars":24,"repoUrl":25,"updatedAt":26,"license":27,"forks":28,"topics":29,"repo":30,"sourceUrl":33,"mdContent":34},"using-dbt-state","configure and optimize dbt state","Use when a user is enabling, configuring, optimizing, or debugging dbt State (the server-backed reuse mechanism that clones or skips nodes instead of rebuilding them). Use when they conflate dbt State with the `state:modified` selector or `--state` deferral. Use when asked about models rebuilding unexpectedly, views with `select *` rebuilding, volatile SQL (`current_timestamp()`, `random()`) rebuilding or not, cross-developer cloning, lag_tolerance.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},"dbt-labs","dbt Labs","https:\u002F\u002Fpexgzepcugksgbtrxkhf.supabase.co\u002Fstorage\u002Fv1\u002Fobject\u002Fpublic\u002Forg-logos\u002Fdbt-labs.png",[12,16,19,22],{"name":13,"slug":14,"type":15},"Performance","performance","tag",{"name":17,"slug":18,"type":15},"Data Engineering","data-engineering",{"name":20,"slug":21,"type":15},"Data Pipeline","data-pipeline",{"name":23,"slug":23,"type":15},"dbt",623,"https:\u002F\u002Fgithub.com\u002Fdbt-labs\u002Fdbt-agent-skills","2026-06-25T07:12:16.623154",null,52,[],{"repoUrl":25,"stars":24,"forks":28,"topics":31,"description":32},[],"A curated collection of Agent Skills for working with dbt, to help AI agents understand and execute dbt workflows more effectively.","https:\u002F\u002Fgithub.com\u002Fdbt-labs\u002Fdbt-agent-skills\u002Ftree\u002FHEAD\u002Fskills\u002Fdbt\u002Fskills\u002Fusing-dbt-state","---\nname: using-dbt-state\ndescription: Use when a user is enabling, configuring, optimizing, or debugging dbt State (the server-backed reuse mechanism that clones or skips nodes instead of rebuilding them). Use when they conflate dbt State with the `state:modified` selector or `--state` deferral. Use when asked about models rebuilding unexpectedly, views with `select *` rebuilding, volatile SQL (`current_timestamp()`, `random()`) rebuilding or not, cross-developer cloning, lag_tolerance.\nuser-invocable: false\nmetadata:\n  author: dbt-labs\n---\n\n# Using dbt State\n\ndbt State is a **server-backed reuse mechanism**. It should not be conflated with dbt's `state:modified` selector or `--state` deferral.\n\nBefore building each selected node, dbt asks the dbt State server whether the object can be **skipped** (reuse from the target schema), **cloned** (reuse from another schema), or must be **built**. It is the successor to State-Aware Orchestration, but works in dbt Core, in development, and in CI — not just Fusion in production.\n\ndbt State is a paid product, but it does not require a dbt platform (fka dbt Cloud) subscription.\n\n## Common Misconceptions\n\n| Misconception | Reality |\n|---|---|\n| \"dbt State is just `state:modified` \u002F `--state`\" | **No.** `state:modified` hashes **file contents** against a manifest *you* manage (and must keep fresh — e.g. via `dbt parse` or similar) and rebuilds `state:modified+` (all descendants). dbt State manages state automatically on a server and **does not require maintaining a fresh comparison manifest** — it **parses SQL into a syntax tree and compares semantic hashes**, considers **upstream data freshness**, and rebuilds a descendant **only if it actually depends on the change** (not the whole `+` subtree). |\n| \"It's Fusion-only \u002F production-only\" | Works in dbt **Core, the dbt platform, and Fusion**, across **dev, CI, and production**, with any orchestrator. |\n| \"dbt Core users can't use it\" | They can. dbt Core **1.7–1.11** require `pip install dbt-state`. It's **baked into dbt Core 1.12 \u002F v2.0 and Fusion**. |\n| \"It's free \u002F it's local\" | It calls the dbt State **server** and requires authentication via a **dbt platform account** or a **standalone dbt State account** ([app.state.dbt.com](https:\u002F\u002Fapp.state.dbt.com)). Reuse is metered in **DATTs — daily active target tables** (see Billing below). |\n| \"It sends my data to dbt Labs\" | It sends **last-modified timestamps** and **SQL text**. The SQL is **hashed then discarded** — dbt Labs cannot read query contents after hashing, and can never access raw data. |\n\n## How the reuse decision works\n\nFor each selected node, dbt State picks the cheapest valid option:\n\n1. **Skip** — object exists in the **target schema**, its semantic hash is unchanged, and no parent has fresher data beyond `lag_tolerance`. Does nothing.\n2. **Clone** — a matching object (same hash, fresh data) exists in **another schema** (e.g. production, or a teammate's dev schema). Clones it, marked **Reused**. Uses zero-copy clone if supported by the warehouse, or runs a CTAS statement to copy the transformed data from elsewhere if not. Test results are reused too — a **failing test still surfaces** even though it wasn't re-executed.\n3. **Build** — no valid reuse. Builds normally, auto-deferring unselected upstream nodes.\n\nIf a node is selected for execution but its inputs do not exist in the target schema, dbt State uses deferral as normal. If a `manifest.json` is present it will use that, otherwise it will make a [best-effort guess](https:\u002F\u002Fdocs.getdbt.com\u002Freference\u002Fresource-configs\u002Fdefer-to-target#caveats-to-dbt-state-without-a-manifest) at the correct FQN based on the `generate_*_name` macros. Deferral does not consume DATTs. The `defer_to_target` config in `profiles.yml` can be used to specify which schema to defer to for self-managed users. It is not necessary for dbt platform users.\n\nTo get freshness, dbt fetches warehouse metadata (or `loaded_at_field`\u002F`loaded_at_query`) for each input relation. For views without a `loaded_at` config, it traverses upstream until it finds a real table.\n\n## Query normalization & why models rebuild\n\ndbt State hashes a **parsed syntax tree**, so it ignores cosmetic changes — whitespace, comments, table aliases, `dbt lint --fix` reformatting. A model rebuilds only when its **logic or data** changes.\n\n**Volatile SQL** (`current_timestamp()`, `getdate()`, `random()`): by default treated as **logic** — the hash uses the function *name*, not its runtime value, so it does **not** invalidate the model every run (otherwise nothing downstream of `getdate()` could ever be reused). To make a model rebuild when the value changes:\n- Set `evaluate_volatile_sql: true` (preferred — covers all functions in the model, inheritable like any config). dbt State emulates the function's value into the hash.\n- Or use a **Jinja** equivalent (e.g. `{{ run_started_at }}`) — Jinja renders *before* parsing, so it changes the compiled SQL each run.\n\n**Non-deterministic Jinja** (e.g. `dbt_utils.get_relations_by_pattern` returning relations in varying order) produces a different compiled hash and triggers rebuilds even when logic is unchanged.\n\n**Config changes:** only **build-relevant** configs affect the hash (`materialized`, `on_schema_change`, `severity`, …). Cosmetic configs (`meta`, `tags`) are ignored. If a post-hook mutates tables based on ignored fields (e.g. applying `meta` as warehouse tags), set `execute_hooks_on_any_reuse: true` so hooks run on reuse.\n\n## Configs quick reference\n\nSet under `models: +state:` in `dbt_project.yml`, in `schema.yml` `config.state`, or in `{{ config(state={...}) }}`.\n\n| Config | Default | Purpose |\n|---|---|---|\n| `lag_tolerance` | `45m` | How stale data may be before a node is eligible to rebuild. **Data freshness only** — SQL changes rebuild regardless. |\n| `require_fresh_data_from` | `any` | Whether `any` or `all` direct parents need fresh data to trigger a rebuild. |\n| `evaluate_volatile_sql` | `false` | Hash the runtime *value* of volatile functions instead of the name. |\n| `pre_clone` | `if_missing` | Pre-populate incremental models\u002Fsnapshots by cloning prod before a run (`never` \u002F `if_missing` \u002F `always`). |\n| `execute_hooks_on_any_reuse` | `false` | Run pre\u002Fpost-hooks even when a node is reused. |\n| `defer_to_target` | `prod` | (Self-managed only, profile) Which profile target to defer\u002Fclone from. |\n| `metadata_warehouse` | profile `warehouse` | (Snowflake only, profile) Separate warehouse for metadata lookups. |\n\nSupported warehouses: Snowflake, Databricks, BigQuery, Redshift.\n\n## Billing: daily active target tables (DATT)\n\ndbt State usage is metered in **DATTs (daily active target tables)**, not by \"models built\".\n\n- A **target table** is a database object managed by your project (per database + schema): seeds, snapshots, models (incl. incremental), **and each distinct test** — even tests not stored in the database (`store_failures` off). Example: `dim_customers` with `not_null` and `unique` on `id` = **3 target tables** (the model + 2 tests).\n- A target table becomes a **DATT** when dbt State performs at least one **skip, clone, or test reuse** on it on a given day (UTC). **All reuses of the same target table in one day count as a single DATT.** A full build is not a reuse.\n- Views are never billed as DATTs, even if reused or cloned. Tests attached to a view will be billed as normal.\n\nIf asked about pricing details, refer the user to https:\u002F\u002Fwww.getdbt.com\u002Fproduct\u002Fdbt-state.\n\n\n## Optimizations for best results\n\n- **`lag_tolerance` per environment** — in dev, set it high (e.g. a week) so dbt does nothing when data is only slightly stale; cloning is cheap but doing nothing is cheaper. Example:\n  ```yaml\n  # dbt_project.yml\n  models:\n    +state:\n      lag_tolerance: \"{{ '4h' if target.name == 'prod' else '7d' }}\"\n  ```\n- **Keep using selectors in development.** Any target table dbt State reuses **counts as a DATT** for that day (even one inside its lag-tolerance window). Select only the nodes you're working on so plain deferral handles the rest — untouched, unselected nodes incur no dbt State usage.\n- **Reduce complex selector usage in production.** dbt State makes most jobs collapse toward plain `dbt build`; let it decide what to rebuild instead of hand-tuning per-job selection. Specify lag_tolerance to prevent overbuilding.\n- **Specify columns instead of `select *` to increase likelihood of reuse**. If dbt State can't prove a `table.*` or similar has the same column set, it will rebuild to be sure. This is particularly relevant for views. Fusion's static analysis is not currently used for this.\n\n## Diagnosing confusing behavior\n\n| Symptom | Cause \u002F fix |\n|---|---|\n| A model with `current_timestamp()` keeps rebuilding | Likely `evaluate_volatile_sql: true` somewhere, or a Jinja value (e.g. `run_started_at`) changing the compiled SQL. If you *want* reuse, leave volatile SQL as default (logic). |\n| Model rebuilds despite \"no change\" | Cosmetic change isn't the cause (those are normalized away). Look for non-deterministic Jinja (unordered macro output), a build-relevant config change, or fresher upstream data past `lag_tolerance`. Metadata tables can consider a table modified by an insert command even if no new rows were added. Consider using `loaded_at_field`, but this may be more costly in the warehouse - metadata queries are often free but `loaded_at_field` will be a standard paid query. |\n| Post-hooks didn't run on a reused model | Hooks don't run on reuse by default — set `execute_hooks_on_any_reuse: true`. |\n| Want to know *why* a node was reused\u002Frebuilt | Use the **`dbt-state explain`** command (dbt v1.7–1.12) to inspect the decision. |\n| Need authentication \u002F access | Log in via your **dbt platform** account or a **standalone dbt State** account. For an org, set `state-org-id` under `dbt-cloud:` in `dbt_project.yml`. |\n\n## v1 (Python) vs v2 (Rust\u002FFusion)\n\n| | dbt Core 1.7–1.11 | dbt Core 1.12 \u002F v2.0 | Fusion |\n|---|---|---|---|\n| Install | `pip install dbt-state` required | Built in | Built in |\n\n- dbt v1.7-1.11 users must install the separate `dbt-state` package to use dbt State.\n- dbt v1.12+ users have the `dbt-state` package included automatically.\n- dbt v2.0+ (either Core or Fusion distributions) have the Rust implementation of the client logic built in, so no separate install is needed.\n\nThe reuse behavior, configs, and query normalization are server-side and behave consistently across all engines. The main v1 difference is the separate `dbt-state` install for 1.7–1.11. The `dbt-state explain` diagnostic is not available in dbt v2.\n\n## Related docs\n\n- Overview: `\u002Fdocs\u002Fdeploy\u002Fdbt-state-about`\n- Setup: `\u002Fdocs\u002Fdeploy\u002Fdbt-state-setup` · Examples: `\u002Fdocs\u002Fdeploy\u002Fdbt-state-examples`\n- Monitor activity: `\u002Fdocs\u002Fdeploy\u002Fdbt-state-interface` · Deferral: `\u002Fdocs\u002Fdeploy\u002Fdbt-state-deferral` · CI\u002FCD: `\u002Fdocs\u002Fdeploy\u002Fdbt-state-cicd`\n- Configs: `\u002Freference\u002Fresource-configs\u002Fdbt-state-configs` · `lag_tolerance` · `defer_to_target`\n",{"data":36,"body":39},{"name":4,"description":6,"user-invocable":37,"metadata":38},false,{"author":8},{"type":40,"children":41},"root",[42,50,81,107,112,119,401,407,412,483,529,558,564,591,651,695,713,782,788,831,1089,1094,1100,1112,1211,1223,1229,1390,1396,1592,1598,1655,1688,1707,1713,1797],{"type":43,"tag":44,"props":45,"children":46},"element","h1",{"id":4},[47],{"type":48,"value":49},"text","Using dbt State",{"type":43,"tag":51,"props":52,"children":53},"p",{},[54,56,62,64,71,73,79],{"type":48,"value":55},"dbt State is a ",{"type":43,"tag":57,"props":58,"children":59},"strong",{},[60],{"type":48,"value":61},"server-backed reuse mechanism",{"type":48,"value":63},". It should not be conflated with dbt's ",{"type":43,"tag":65,"props":66,"children":68},"code",{"className":67},[],[69],{"type":48,"value":70},"state:modified",{"type":48,"value":72}," selector or ",{"type":43,"tag":65,"props":74,"children":76},{"className":75},[],[77],{"type":48,"value":78},"--state",{"type":48,"value":80}," deferral.",{"type":43,"tag":51,"props":82,"children":83},{},[84,86,91,93,98,100,105],{"type":48,"value":85},"Before building each selected node, dbt asks the dbt State server whether the object can be ",{"type":43,"tag":57,"props":87,"children":88},{},[89],{"type":48,"value":90},"skipped",{"type":48,"value":92}," (reuse from the target schema), ",{"type":43,"tag":57,"props":94,"children":95},{},[96],{"type":48,"value":97},"cloned",{"type":48,"value":99}," (reuse from another schema), or must be ",{"type":43,"tag":57,"props":101,"children":102},{},[103],{"type":48,"value":104},"built",{"type":48,"value":106},". It is the successor to State-Aware Orchestration, but works in dbt Core, in development, and in CI — not just Fusion in production.",{"type":43,"tag":51,"props":108,"children":109},{},[110],{"type":48,"value":111},"dbt State is a paid product, but it does not require a dbt platform (fka dbt Cloud) subscription.",{"type":43,"tag":113,"props":114,"children":116},"h2",{"id":115},"common-misconceptions",[117],{"type":48,"value":118},"Common Misconceptions",{"type":43,"tag":120,"props":121,"children":122},"table",{},[123,142],{"type":43,"tag":124,"props":125,"children":126},"thead",{},[127],{"type":43,"tag":128,"props":129,"children":130},"tr",{},[131,137],{"type":43,"tag":132,"props":133,"children":134},"th",{},[135],{"type":48,"value":136},"Misconception",{"type":43,"tag":132,"props":138,"children":139},{},[140],{"type":48,"value":141},"Reality",{"type":43,"tag":143,"props":144,"children":145},"tbody",{},[146,253,280,315,367],{"type":43,"tag":128,"props":147,"children":148},{},[149,169],{"type":43,"tag":150,"props":151,"children":152},"td",{},[153,155,160,162,167],{"type":48,"value":154},"\"dbt State is just ",{"type":43,"tag":65,"props":156,"children":158},{"className":157},[],[159],{"type":48,"value":70},{"type":48,"value":161}," \u002F ",{"type":43,"tag":65,"props":163,"children":165},{"className":164},[],[166],{"type":48,"value":78},{"type":48,"value":168},"\"",{"type":43,"tag":150,"props":170,"children":171},{},[172,177,179,184,186,191,193,199,201,207,209,215,217,222,224,229,231,236,238,243,245,251],{"type":43,"tag":57,"props":173,"children":174},{},[175],{"type":48,"value":176},"No.",{"type":48,"value":178}," ",{"type":43,"tag":65,"props":180,"children":182},{"className":181},[],[183],{"type":48,"value":70},{"type":48,"value":185}," hashes ",{"type":43,"tag":57,"props":187,"children":188},{},[189],{"type":48,"value":190},"file contents",{"type":48,"value":192}," against a manifest ",{"type":43,"tag":194,"props":195,"children":196},"em",{},[197],{"type":48,"value":198},"you",{"type":48,"value":200}," manage (and must keep fresh — e.g. via ",{"type":43,"tag":65,"props":202,"children":204},{"className":203},[],[205],{"type":48,"value":206},"dbt parse",{"type":48,"value":208}," or similar) and rebuilds ",{"type":43,"tag":65,"props":210,"children":212},{"className":211},[],[213],{"type":48,"value":214},"state:modified+",{"type":48,"value":216}," (all descendants). dbt State manages state automatically on a server and ",{"type":43,"tag":57,"props":218,"children":219},{},[220],{"type":48,"value":221},"does not require maintaining a fresh comparison manifest",{"type":48,"value":223}," — it ",{"type":43,"tag":57,"props":225,"children":226},{},[227],{"type":48,"value":228},"parses SQL into a syntax tree and compares semantic hashes",{"type":48,"value":230},", considers ",{"type":43,"tag":57,"props":232,"children":233},{},[234],{"type":48,"value":235},"upstream data freshness",{"type":48,"value":237},", and rebuilds a descendant ",{"type":43,"tag":57,"props":239,"children":240},{},[241],{"type":48,"value":242},"only if it actually depends on the change",{"type":48,"value":244}," (not the whole ",{"type":43,"tag":65,"props":246,"children":248},{"className":247},[],[249],{"type":48,"value":250},"+",{"type":48,"value":252}," subtree).",{"type":43,"tag":128,"props":254,"children":255},{},[256,261],{"type":43,"tag":150,"props":257,"children":258},{},[259],{"type":48,"value":260},"\"It's Fusion-only \u002F production-only\"",{"type":43,"tag":150,"props":262,"children":263},{},[264,266,271,273,278],{"type":48,"value":265},"Works in dbt ",{"type":43,"tag":57,"props":267,"children":268},{},[269],{"type":48,"value":270},"Core, the dbt platform, and Fusion",{"type":48,"value":272},", across ",{"type":43,"tag":57,"props":274,"children":275},{},[276],{"type":48,"value":277},"dev, CI, and production",{"type":48,"value":279},", with any orchestrator.",{"type":43,"tag":128,"props":281,"children":282},{},[283,288],{"type":43,"tag":150,"props":284,"children":285},{},[286],{"type":48,"value":287},"\"dbt Core users can't use it\"",{"type":43,"tag":150,"props":289,"children":290},{},[291,293,298,300,306,308,313],{"type":48,"value":292},"They can. dbt Core ",{"type":43,"tag":57,"props":294,"children":295},{},[296],{"type":48,"value":297},"1.7–1.11",{"type":48,"value":299}," require ",{"type":43,"tag":65,"props":301,"children":303},{"className":302},[],[304],{"type":48,"value":305},"pip install dbt-state",{"type":48,"value":307},". It's ",{"type":43,"tag":57,"props":309,"children":310},{},[311],{"type":48,"value":312},"baked into dbt Core 1.12 \u002F v2.0 and Fusion",{"type":48,"value":314},".",{"type":43,"tag":128,"props":316,"children":317},{},[318,323],{"type":43,"tag":150,"props":319,"children":320},{},[321],{"type":48,"value":322},"\"It's free \u002F it's local\"",{"type":43,"tag":150,"props":324,"children":325},{},[326,328,333,335,340,342,347,349,358,360,365],{"type":48,"value":327},"It calls the dbt State ",{"type":43,"tag":57,"props":329,"children":330},{},[331],{"type":48,"value":332},"server",{"type":48,"value":334}," and requires authentication via a ",{"type":43,"tag":57,"props":336,"children":337},{},[338],{"type":48,"value":339},"dbt platform account",{"type":48,"value":341}," or a ",{"type":43,"tag":57,"props":343,"children":344},{},[345],{"type":48,"value":346},"standalone dbt State account",{"type":48,"value":348}," (",{"type":43,"tag":350,"props":351,"children":355},"a",{"href":352,"rel":353},"https:\u002F\u002Fapp.state.dbt.com",[354],"nofollow",[356],{"type":48,"value":357},"app.state.dbt.com",{"type":48,"value":359},"). Reuse is metered in ",{"type":43,"tag":57,"props":361,"children":362},{},[363],{"type":48,"value":364},"DATTs — daily active target tables",{"type":48,"value":366}," (see Billing below).",{"type":43,"tag":128,"props":368,"children":369},{},[370,375],{"type":43,"tag":150,"props":371,"children":372},{},[373],{"type":48,"value":374},"\"It sends my data to dbt Labs\"",{"type":43,"tag":150,"props":376,"children":377},{},[378,380,385,387,392,394,399],{"type":48,"value":379},"It sends ",{"type":43,"tag":57,"props":381,"children":382},{},[383],{"type":48,"value":384},"last-modified timestamps",{"type":48,"value":386}," and ",{"type":43,"tag":57,"props":388,"children":389},{},[390],{"type":48,"value":391},"SQL text",{"type":48,"value":393},". The SQL is ",{"type":43,"tag":57,"props":395,"children":396},{},[397],{"type":48,"value":398},"hashed then discarded",{"type":48,"value":400}," — dbt Labs cannot read query contents after hashing, and can never access raw data.",{"type":43,"tag":113,"props":402,"children":404},{"id":403},"how-the-reuse-decision-works",[405],{"type":48,"value":406},"How the reuse decision works",{"type":43,"tag":51,"props":408,"children":409},{},[410],{"type":48,"value":411},"For each selected node, dbt State picks the cheapest valid option:",{"type":43,"tag":413,"props":414,"children":415},"ol",{},[416,442,473],{"type":43,"tag":417,"props":418,"children":419},"li",{},[420,425,427,432,434,440],{"type":43,"tag":57,"props":421,"children":422},{},[423],{"type":48,"value":424},"Skip",{"type":48,"value":426}," — object exists in the ",{"type":43,"tag":57,"props":428,"children":429},{},[430],{"type":48,"value":431},"target schema",{"type":48,"value":433},", its semantic hash is unchanged, and no parent has fresher data beyond ",{"type":43,"tag":65,"props":435,"children":437},{"className":436},[],[438],{"type":48,"value":439},"lag_tolerance",{"type":48,"value":441},". Does nothing.",{"type":43,"tag":417,"props":443,"children":444},{},[445,450,452,457,459,464,466,471],{"type":43,"tag":57,"props":446,"children":447},{},[448],{"type":48,"value":449},"Clone",{"type":48,"value":451}," — a matching object (same hash, fresh data) exists in ",{"type":43,"tag":57,"props":453,"children":454},{},[455],{"type":48,"value":456},"another schema",{"type":48,"value":458}," (e.g. production, or a teammate's dev schema). Clones it, marked ",{"type":43,"tag":57,"props":460,"children":461},{},[462],{"type":48,"value":463},"Reused",{"type":48,"value":465},". Uses zero-copy clone if supported by the warehouse, or runs a CTAS statement to copy the transformed data from elsewhere if not. Test results are reused too — a ",{"type":43,"tag":57,"props":467,"children":468},{},[469],{"type":48,"value":470},"failing test still surfaces",{"type":48,"value":472}," even though it wasn't re-executed.",{"type":43,"tag":417,"props":474,"children":475},{},[476,481],{"type":43,"tag":57,"props":477,"children":478},{},[479],{"type":48,"value":480},"Build",{"type":48,"value":482}," — no valid reuse. Builds normally, auto-deferring unselected upstream nodes.",{"type":43,"tag":51,"props":484,"children":485},{},[486,488,494,496,503,505,511,513,519,521,527],{"type":48,"value":487},"If a node is selected for execution but its inputs do not exist in the target schema, dbt State uses deferral as normal. If a ",{"type":43,"tag":65,"props":489,"children":491},{"className":490},[],[492],{"type":48,"value":493},"manifest.json",{"type":48,"value":495}," is present it will use that, otherwise it will make a ",{"type":43,"tag":350,"props":497,"children":500},{"href":498,"rel":499},"https:\u002F\u002Fdocs.getdbt.com\u002Freference\u002Fresource-configs\u002Fdefer-to-target#caveats-to-dbt-state-without-a-manifest",[354],[501],{"type":48,"value":502},"best-effort guess",{"type":48,"value":504}," at the correct FQN based on the ",{"type":43,"tag":65,"props":506,"children":508},{"className":507},[],[509],{"type":48,"value":510},"generate_*_name",{"type":48,"value":512}," macros. Deferral does not consume DATTs. The ",{"type":43,"tag":65,"props":514,"children":516},{"className":515},[],[517],{"type":48,"value":518},"defer_to_target",{"type":48,"value":520}," config in ",{"type":43,"tag":65,"props":522,"children":524},{"className":523},[],[525],{"type":48,"value":526},"profiles.yml",{"type":48,"value":528}," can be used to specify which schema to defer to for self-managed users. It is not necessary for dbt platform users.",{"type":43,"tag":51,"props":530,"children":531},{},[532,534,540,542,548,550,556],{"type":48,"value":533},"To get freshness, dbt fetches warehouse metadata (or ",{"type":43,"tag":65,"props":535,"children":537},{"className":536},[],[538],{"type":48,"value":539},"loaded_at_field",{"type":48,"value":541},"\u002F",{"type":43,"tag":65,"props":543,"children":545},{"className":544},[],[546],{"type":48,"value":547},"loaded_at_query",{"type":48,"value":549},") for each input relation. For views without a ",{"type":43,"tag":65,"props":551,"children":553},{"className":552},[],[554],{"type":48,"value":555},"loaded_at",{"type":48,"value":557}," config, it traverses upstream until it finds a real table.",{"type":43,"tag":113,"props":559,"children":561},{"id":560},"query-normalization-why-models-rebuild",[562],{"type":48,"value":563},"Query normalization & why models rebuild",{"type":43,"tag":51,"props":565,"children":566},{},[567,569,574,576,582,584,589],{"type":48,"value":568},"dbt State hashes a ",{"type":43,"tag":57,"props":570,"children":571},{},[572],{"type":48,"value":573},"parsed syntax tree",{"type":48,"value":575},", so it ignores cosmetic changes — whitespace, comments, table aliases, ",{"type":43,"tag":65,"props":577,"children":579},{"className":578},[],[580],{"type":48,"value":581},"dbt lint --fix",{"type":48,"value":583}," reformatting. A model rebuilds only when its ",{"type":43,"tag":57,"props":585,"children":586},{},[587],{"type":48,"value":588},"logic or data",{"type":48,"value":590}," changes.",{"type":43,"tag":51,"props":592,"children":593},{},[594,599,600,606,608,614,615,621,623,628,630,635,637,642,644,649],{"type":43,"tag":57,"props":595,"children":596},{},[597],{"type":48,"value":598},"Volatile SQL",{"type":48,"value":348},{"type":43,"tag":65,"props":601,"children":603},{"className":602},[],[604],{"type":48,"value":605},"current_timestamp()",{"type":48,"value":607},", ",{"type":43,"tag":65,"props":609,"children":611},{"className":610},[],[612],{"type":48,"value":613},"getdate()",{"type":48,"value":607},{"type":43,"tag":65,"props":616,"children":618},{"className":617},[],[619],{"type":48,"value":620},"random()",{"type":48,"value":622},"): by default treated as ",{"type":43,"tag":57,"props":624,"children":625},{},[626],{"type":48,"value":627},"logic",{"type":48,"value":629}," — the hash uses the function ",{"type":43,"tag":194,"props":631,"children":632},{},[633],{"type":48,"value":634},"name",{"type":48,"value":636},", not its runtime value, so it does ",{"type":43,"tag":57,"props":638,"children":639},{},[640],{"type":48,"value":641},"not",{"type":48,"value":643}," invalidate the model every run (otherwise nothing downstream of ",{"type":43,"tag":65,"props":645,"children":647},{"className":646},[],[648],{"type":48,"value":613},{"type":48,"value":650}," could ever be reused). To make a model rebuild when the value changes:",{"type":43,"tag":652,"props":653,"children":654},"ul",{},[655,668],{"type":43,"tag":417,"props":656,"children":657},{},[658,660,666],{"type":48,"value":659},"Set ",{"type":43,"tag":65,"props":661,"children":663},{"className":662},[],[664],{"type":48,"value":665},"evaluate_volatile_sql: true",{"type":48,"value":667}," (preferred — covers all functions in the model, inheritable like any config). dbt State emulates the function's value into the hash.",{"type":43,"tag":417,"props":669,"children":670},{},[671,673,678,680,686,688,693],{"type":48,"value":672},"Or use a ",{"type":43,"tag":57,"props":674,"children":675},{},[676],{"type":48,"value":677},"Jinja",{"type":48,"value":679}," equivalent (e.g. ",{"type":43,"tag":65,"props":681,"children":683},{"className":682},[],[684],{"type":48,"value":685},"{{ run_started_at }}",{"type":48,"value":687},") — Jinja renders ",{"type":43,"tag":194,"props":689,"children":690},{},[691],{"type":48,"value":692},"before",{"type":48,"value":694}," parsing, so it changes the compiled SQL each run.",{"type":43,"tag":51,"props":696,"children":697},{},[698,703,705,711],{"type":43,"tag":57,"props":699,"children":700},{},[701],{"type":48,"value":702},"Non-deterministic Jinja",{"type":48,"value":704}," (e.g. ",{"type":43,"tag":65,"props":706,"children":708},{"className":707},[],[709],{"type":48,"value":710},"dbt_utils.get_relations_by_pattern",{"type":48,"value":712}," returning relations in varying order) produces a different compiled hash and triggers rebuilds even when logic is unchanged.",{"type":43,"tag":51,"props":714,"children":715},{},[716,721,723,728,730,736,737,743,744,750,752,758,759,765,767,772,774,780],{"type":43,"tag":57,"props":717,"children":718},{},[719],{"type":48,"value":720},"Config changes:",{"type":48,"value":722}," only ",{"type":43,"tag":57,"props":724,"children":725},{},[726],{"type":48,"value":727},"build-relevant",{"type":48,"value":729}," configs affect the hash (",{"type":43,"tag":65,"props":731,"children":733},{"className":732},[],[734],{"type":48,"value":735},"materialized",{"type":48,"value":607},{"type":43,"tag":65,"props":738,"children":740},{"className":739},[],[741],{"type":48,"value":742},"on_schema_change",{"type":48,"value":607},{"type":43,"tag":65,"props":745,"children":747},{"className":746},[],[748],{"type":48,"value":749},"severity",{"type":48,"value":751},", …). Cosmetic configs (",{"type":43,"tag":65,"props":753,"children":755},{"className":754},[],[756],{"type":48,"value":757},"meta",{"type":48,"value":607},{"type":43,"tag":65,"props":760,"children":762},{"className":761},[],[763],{"type":48,"value":764},"tags",{"type":48,"value":766},") are ignored. If a post-hook mutates tables based on ignored fields (e.g. applying ",{"type":43,"tag":65,"props":768,"children":770},{"className":769},[],[771],{"type":48,"value":757},{"type":48,"value":773}," as warehouse tags), set ",{"type":43,"tag":65,"props":775,"children":777},{"className":776},[],[778],{"type":48,"value":779},"execute_hooks_on_any_reuse: true",{"type":48,"value":781}," so hooks run on reuse.",{"type":43,"tag":113,"props":783,"children":785},{"id":784},"configs-quick-reference",[786],{"type":48,"value":787},"Configs quick reference",{"type":43,"tag":51,"props":789,"children":790},{},[791,793,799,801,807,809,815,816,822,824,830],{"type":48,"value":792},"Set under ",{"type":43,"tag":65,"props":794,"children":796},{"className":795},[],[797],{"type":48,"value":798},"models: +state:",{"type":48,"value":800}," in ",{"type":43,"tag":65,"props":802,"children":804},{"className":803},[],[805],{"type":48,"value":806},"dbt_project.yml",{"type":48,"value":808},", in ",{"type":43,"tag":65,"props":810,"children":812},{"className":811},[],[813],{"type":48,"value":814},"schema.yml",{"type":48,"value":178},{"type":43,"tag":65,"props":817,"children":819},{"className":818},[],[820],{"type":48,"value":821},"config.state",{"type":48,"value":823},", or in ",{"type":43,"tag":65,"props":825,"children":827},{"className":826},[],[828],{"type":48,"value":829},"{{ config(state={...}) }}",{"type":48,"value":314},{"type":43,"tag":120,"props":832,"children":833},{},[834,855],{"type":43,"tag":124,"props":835,"children":836},{},[837],{"type":43,"tag":128,"props":838,"children":839},{},[840,845,850],{"type":43,"tag":132,"props":841,"children":842},{},[843],{"type":48,"value":844},"Config",{"type":43,"tag":132,"props":846,"children":847},{},[848],{"type":48,"value":849},"Default",{"type":43,"tag":132,"props":851,"children":852},{},[853],{"type":48,"value":854},"Purpose",{"type":43,"tag":143,"props":856,"children":857},{},[858,890,931,964,1011,1036,1061],{"type":43,"tag":128,"props":859,"children":860},{},[861,869,878],{"type":43,"tag":150,"props":862,"children":863},{},[864],{"type":43,"tag":65,"props":865,"children":867},{"className":866},[],[868],{"type":48,"value":439},{"type":43,"tag":150,"props":870,"children":871},{},[872],{"type":43,"tag":65,"props":873,"children":875},{"className":874},[],[876],{"type":48,"value":877},"45m",{"type":43,"tag":150,"props":879,"children":880},{},[881,883,888],{"type":48,"value":882},"How stale data may be before a node is eligible to rebuild. ",{"type":43,"tag":57,"props":884,"children":885},{},[886],{"type":48,"value":887},"Data freshness only",{"type":48,"value":889}," — SQL changes rebuild regardless.",{"type":43,"tag":128,"props":891,"children":892},{},[893,902,911],{"type":43,"tag":150,"props":894,"children":895},{},[896],{"type":43,"tag":65,"props":897,"children":899},{"className":898},[],[900],{"type":48,"value":901},"require_fresh_data_from",{"type":43,"tag":150,"props":903,"children":904},{},[905],{"type":43,"tag":65,"props":906,"children":908},{"className":907},[],[909],{"type":48,"value":910},"any",{"type":43,"tag":150,"props":912,"children":913},{},[914,916,921,923,929],{"type":48,"value":915},"Whether ",{"type":43,"tag":65,"props":917,"children":919},{"className":918},[],[920],{"type":48,"value":910},{"type":48,"value":922}," or ",{"type":43,"tag":65,"props":924,"children":926},{"className":925},[],[927],{"type":48,"value":928},"all",{"type":48,"value":930}," direct parents need fresh data to trigger a rebuild.",{"type":43,"tag":128,"props":932,"children":933},{},[934,943,952],{"type":43,"tag":150,"props":935,"children":936},{},[937],{"type":43,"tag":65,"props":938,"children":940},{"className":939},[],[941],{"type":48,"value":942},"evaluate_volatile_sql",{"type":43,"tag":150,"props":944,"children":945},{},[946],{"type":43,"tag":65,"props":947,"children":949},{"className":948},[],[950],{"type":48,"value":951},"false",{"type":43,"tag":150,"props":953,"children":954},{},[955,957,962],{"type":48,"value":956},"Hash the runtime ",{"type":43,"tag":194,"props":958,"children":959},{},[960],{"type":48,"value":961},"value",{"type":48,"value":963}," of volatile functions instead of the name.",{"type":43,"tag":128,"props":965,"children":966},{},[967,976,985],{"type":43,"tag":150,"props":968,"children":969},{},[970],{"type":43,"tag":65,"props":971,"children":973},{"className":972},[],[974],{"type":48,"value":975},"pre_clone",{"type":43,"tag":150,"props":977,"children":978},{},[979],{"type":43,"tag":65,"props":980,"children":982},{"className":981},[],[983],{"type":48,"value":984},"if_missing",{"type":43,"tag":150,"props":986,"children":987},{},[988,990,996,997,1002,1003,1009],{"type":48,"value":989},"Pre-populate incremental models\u002Fsnapshots by cloning prod before a run (",{"type":43,"tag":65,"props":991,"children":993},{"className":992},[],[994],{"type":48,"value":995},"never",{"type":48,"value":161},{"type":43,"tag":65,"props":998,"children":1000},{"className":999},[],[1001],{"type":48,"value":984},{"type":48,"value":161},{"type":43,"tag":65,"props":1004,"children":1006},{"className":1005},[],[1007],{"type":48,"value":1008},"always",{"type":48,"value":1010},").",{"type":43,"tag":128,"props":1012,"children":1013},{},[1014,1023,1031],{"type":43,"tag":150,"props":1015,"children":1016},{},[1017],{"type":43,"tag":65,"props":1018,"children":1020},{"className":1019},[],[1021],{"type":48,"value":1022},"execute_hooks_on_any_reuse",{"type":43,"tag":150,"props":1024,"children":1025},{},[1026],{"type":43,"tag":65,"props":1027,"children":1029},{"className":1028},[],[1030],{"type":48,"value":951},{"type":43,"tag":150,"props":1032,"children":1033},{},[1034],{"type":48,"value":1035},"Run pre\u002Fpost-hooks even when a node is reused.",{"type":43,"tag":128,"props":1037,"children":1038},{},[1039,1047,1056],{"type":43,"tag":150,"props":1040,"children":1041},{},[1042],{"type":43,"tag":65,"props":1043,"children":1045},{"className":1044},[],[1046],{"type":48,"value":518},{"type":43,"tag":150,"props":1048,"children":1049},{},[1050],{"type":43,"tag":65,"props":1051,"children":1053},{"className":1052},[],[1054],{"type":48,"value":1055},"prod",{"type":43,"tag":150,"props":1057,"children":1058},{},[1059],{"type":48,"value":1060},"(Self-managed only, profile) Which profile target to defer\u002Fclone from.",{"type":43,"tag":128,"props":1062,"children":1063},{},[1064,1073,1084],{"type":43,"tag":150,"props":1065,"children":1066},{},[1067],{"type":43,"tag":65,"props":1068,"children":1070},{"className":1069},[],[1071],{"type":48,"value":1072},"metadata_warehouse",{"type":43,"tag":150,"props":1074,"children":1075},{},[1076,1078],{"type":48,"value":1077},"profile ",{"type":43,"tag":65,"props":1079,"children":1081},{"className":1080},[],[1082],{"type":48,"value":1083},"warehouse",{"type":43,"tag":150,"props":1085,"children":1086},{},[1087],{"type":48,"value":1088},"(Snowflake only, profile) Separate warehouse for metadata lookups.",{"type":43,"tag":51,"props":1090,"children":1091},{},[1092],{"type":48,"value":1093},"Supported warehouses: Snowflake, Databricks, BigQuery, Redshift.",{"type":43,"tag":113,"props":1095,"children":1097},{"id":1096},"billing-daily-active-target-tables-datt",[1098],{"type":48,"value":1099},"Billing: daily active target tables (DATT)",{"type":43,"tag":51,"props":1101,"children":1102},{},[1103,1105,1110],{"type":48,"value":1104},"dbt State usage is metered in ",{"type":43,"tag":57,"props":1106,"children":1107},{},[1108],{"type":48,"value":1109},"DATTs (daily active target tables)",{"type":48,"value":1111},", not by \"models built\".",{"type":43,"tag":652,"props":1113,"children":1114},{},[1115,1180,1206],{"type":43,"tag":417,"props":1116,"children":1117},{},[1118,1120,1125,1127,1132,1134,1140,1142,1148,1150,1156,1157,1163,1165,1171,1173,1178],{"type":48,"value":1119},"A ",{"type":43,"tag":57,"props":1121,"children":1122},{},[1123],{"type":48,"value":1124},"target table",{"type":48,"value":1126}," is a database object managed by your project (per database + schema): seeds, snapshots, models (incl. incremental), ",{"type":43,"tag":57,"props":1128,"children":1129},{},[1130],{"type":48,"value":1131},"and each distinct test",{"type":48,"value":1133}," — even tests not stored in the database (",{"type":43,"tag":65,"props":1135,"children":1137},{"className":1136},[],[1138],{"type":48,"value":1139},"store_failures",{"type":48,"value":1141}," off). Example: ",{"type":43,"tag":65,"props":1143,"children":1145},{"className":1144},[],[1146],{"type":48,"value":1147},"dim_customers",{"type":48,"value":1149}," with ",{"type":43,"tag":65,"props":1151,"children":1153},{"className":1152},[],[1154],{"type":48,"value":1155},"not_null",{"type":48,"value":386},{"type":43,"tag":65,"props":1158,"children":1160},{"className":1159},[],[1161],{"type":48,"value":1162},"unique",{"type":48,"value":1164}," on ",{"type":43,"tag":65,"props":1166,"children":1168},{"className":1167},[],[1169],{"type":48,"value":1170},"id",{"type":48,"value":1172}," = ",{"type":43,"tag":57,"props":1174,"children":1175},{},[1176],{"type":48,"value":1177},"3 target tables",{"type":48,"value":1179}," (the model + 2 tests).",{"type":43,"tag":417,"props":1181,"children":1182},{},[1183,1185,1190,1192,1197,1199,1204],{"type":48,"value":1184},"A target table becomes a ",{"type":43,"tag":57,"props":1186,"children":1187},{},[1188],{"type":48,"value":1189},"DATT",{"type":48,"value":1191}," when dbt State performs at least one ",{"type":43,"tag":57,"props":1193,"children":1194},{},[1195],{"type":48,"value":1196},"skip, clone, or test reuse",{"type":48,"value":1198}," on it on a given day (UTC). ",{"type":43,"tag":57,"props":1200,"children":1201},{},[1202],{"type":48,"value":1203},"All reuses of the same target table in one day count as a single DATT.",{"type":48,"value":1205}," A full build is not a reuse.",{"type":43,"tag":417,"props":1207,"children":1208},{},[1209],{"type":48,"value":1210},"Views are never billed as DATTs, even if reused or cloned. Tests attached to a view will be billed as normal.",{"type":43,"tag":51,"props":1212,"children":1213},{},[1214,1216,1222],{"type":48,"value":1215},"If asked about pricing details, refer the user to ",{"type":43,"tag":350,"props":1217,"children":1220},{"href":1218,"rel":1219},"https:\u002F\u002Fwww.getdbt.com\u002Fproduct\u002Fdbt-state",[354],[1221],{"type":48,"value":1218},{"type":48,"value":314},{"type":43,"tag":113,"props":1224,"children":1226},{"id":1225},"optimizations-for-best-results",[1227],{"type":48,"value":1228},"Optimizations for best results",{"type":43,"tag":652,"props":1230,"children":1231},{},[1232,1329,1346,1364],{"type":43,"tag":417,"props":1233,"children":1234},{},[1235,1245,1247],{"type":43,"tag":57,"props":1236,"children":1237},{},[1238,1243],{"type":43,"tag":65,"props":1239,"children":1241},{"className":1240},[],[1242],{"type":48,"value":439},{"type":48,"value":1244}," per environment",{"type":48,"value":1246}," — in dev, set it high (e.g. a week) so dbt does nothing when data is only slightly stale; cloning is cheap but doing nothing is cheaper. Example:\n",{"type":43,"tag":1248,"props":1249,"children":1254},"pre",{"className":1250,"code":1251,"language":1252,"meta":1253,"style":1253},"language-yaml shiki shiki-themes material-theme-lighter material-theme material-theme-palenight","# dbt_project.yml\nmodels:\n  +state:\n    lag_tolerance: \"{{ '4h' if target.name == 'prod' else '7d' }}\"\n","yaml","",[1255],{"type":43,"tag":65,"props":1256,"children":1257},{"__ignoreMap":1253},[1258,1270,1286,1299],{"type":43,"tag":1259,"props":1260,"children":1263},"span",{"class":1261,"line":1262},"line",1,[1264],{"type":43,"tag":1259,"props":1265,"children":1267},{"style":1266},"--shiki-light:#90A4AE;--shiki-light-font-style:italic;--shiki-default:#546E7A;--shiki-default-font-style:italic;--shiki-dark:#676E95;--shiki-dark-font-style:italic",[1268],{"type":48,"value":1269},"# dbt_project.yml\n",{"type":43,"tag":1259,"props":1271,"children":1273},{"class":1261,"line":1272},2,[1274,1280],{"type":43,"tag":1259,"props":1275,"children":1277},{"style":1276},"--shiki-light:#E53935;--shiki-default:#F07178;--shiki-dark:#F07178",[1278],{"type":48,"value":1279},"models",{"type":43,"tag":1259,"props":1281,"children":1283},{"style":1282},"--shiki-light:#39ADB5;--shiki-default:#89DDFF;--shiki-dark:#89DDFF",[1284],{"type":48,"value":1285},":\n",{"type":43,"tag":1259,"props":1287,"children":1289},{"class":1261,"line":1288},3,[1290,1295],{"type":43,"tag":1259,"props":1291,"children":1292},{"style":1276},[1293],{"type":48,"value":1294},"  +state",{"type":43,"tag":1259,"props":1296,"children":1297},{"style":1282},[1298],{"type":48,"value":1285},{"type":43,"tag":1259,"props":1300,"children":1302},{"class":1261,"line":1301},4,[1303,1308,1313,1318,1324],{"type":43,"tag":1259,"props":1304,"children":1305},{"style":1276},[1306],{"type":48,"value":1307},"    lag_tolerance",{"type":43,"tag":1259,"props":1309,"children":1310},{"style":1282},[1311],{"type":48,"value":1312},":",{"type":43,"tag":1259,"props":1314,"children":1315},{"style":1282},[1316],{"type":48,"value":1317}," \"",{"type":43,"tag":1259,"props":1319,"children":1321},{"style":1320},"--shiki-light:#91B859;--shiki-default:#C3E88D;--shiki-dark:#C3E88D",[1322],{"type":48,"value":1323},"{{ '4h' if target.name == 'prod' else '7d' }}",{"type":43,"tag":1259,"props":1325,"children":1326},{"style":1282},[1327],{"type":48,"value":1328},"\"\n",{"type":43,"tag":417,"props":1330,"children":1331},{},[1332,1337,1339,1344],{"type":43,"tag":57,"props":1333,"children":1334},{},[1335],{"type":48,"value":1336},"Keep using selectors in development.",{"type":48,"value":1338}," Any target table dbt State reuses ",{"type":43,"tag":57,"props":1340,"children":1341},{},[1342],{"type":48,"value":1343},"counts as a DATT",{"type":48,"value":1345}," for that day (even one inside its lag-tolerance window). Select only the nodes you're working on so plain deferral handles the rest — untouched, unselected nodes incur no dbt State usage.",{"type":43,"tag":417,"props":1347,"children":1348},{},[1349,1354,1356,1362],{"type":43,"tag":57,"props":1350,"children":1351},{},[1352],{"type":48,"value":1353},"Reduce complex selector usage in production.",{"type":48,"value":1355}," dbt State makes most jobs collapse toward plain ",{"type":43,"tag":65,"props":1357,"children":1359},{"className":1358},[],[1360],{"type":48,"value":1361},"dbt build",{"type":48,"value":1363},"; let it decide what to rebuild instead of hand-tuning per-job selection. Specify lag_tolerance to prevent overbuilding.",{"type":43,"tag":417,"props":1365,"children":1366},{},[1367,1380,1382,1388],{"type":43,"tag":57,"props":1368,"children":1369},{},[1370,1372,1378],{"type":48,"value":1371},"Specify columns instead of ",{"type":43,"tag":65,"props":1373,"children":1375},{"className":1374},[],[1376],{"type":48,"value":1377},"select *",{"type":48,"value":1379}," to increase likelihood of reuse",{"type":48,"value":1381},". If dbt State can't prove a ",{"type":43,"tag":65,"props":1383,"children":1385},{"className":1384},[],[1386],{"type":48,"value":1387},"table.*",{"type":48,"value":1389}," or similar has the same column set, it will rebuild to be sure. This is particularly relevant for views. Fusion's static analysis is not currently used for this.",{"type":43,"tag":113,"props":1391,"children":1393},{"id":1392},"diagnosing-confusing-behavior",[1394],{"type":48,"value":1395},"Diagnosing confusing behavior",{"type":43,"tag":120,"props":1397,"children":1398},{},[1399,1415],{"type":43,"tag":124,"props":1400,"children":1401},{},[1402],{"type":43,"tag":128,"props":1403,"children":1404},{},[1405,1410],{"type":43,"tag":132,"props":1406,"children":1407},{},[1408],{"type":48,"value":1409},"Symptom",{"type":43,"tag":132,"props":1411,"children":1412},{},[1413],{"type":48,"value":1414},"Cause \u002F fix",{"type":43,"tag":143,"props":1416,"children":1417},{},[1418,1460,1494,1513,1544],{"type":43,"tag":128,"props":1419,"children":1420},{},[1421,1433],{"type":43,"tag":150,"props":1422,"children":1423},{},[1424,1426,1431],{"type":48,"value":1425},"A model with ",{"type":43,"tag":65,"props":1427,"children":1429},{"className":1428},[],[1430],{"type":48,"value":605},{"type":48,"value":1432}," keeps rebuilding",{"type":43,"tag":150,"props":1434,"children":1435},{},[1436,1438,1443,1445,1451,1453,1458],{"type":48,"value":1437},"Likely ",{"type":43,"tag":65,"props":1439,"children":1441},{"className":1440},[],[1442],{"type":48,"value":665},{"type":48,"value":1444}," somewhere, or a Jinja value (e.g. ",{"type":43,"tag":65,"props":1446,"children":1448},{"className":1447},[],[1449],{"type":48,"value":1450},"run_started_at",{"type":48,"value":1452},") changing the compiled SQL. If you ",{"type":43,"tag":194,"props":1454,"children":1455},{},[1456],{"type":48,"value":1457},"want",{"type":48,"value":1459}," reuse, leave volatile SQL as default (logic).",{"type":43,"tag":128,"props":1461,"children":1462},{},[1463,1468],{"type":43,"tag":150,"props":1464,"children":1465},{},[1466],{"type":48,"value":1467},"Model rebuilds despite \"no change\"",{"type":43,"tag":150,"props":1469,"children":1470},{},[1471,1473,1478,1480,1485,1487,1492],{"type":48,"value":1472},"Cosmetic change isn't the cause (those are normalized away). Look for non-deterministic Jinja (unordered macro output), a build-relevant config change, or fresher upstream data past ",{"type":43,"tag":65,"props":1474,"children":1476},{"className":1475},[],[1477],{"type":48,"value":439},{"type":48,"value":1479},". Metadata tables can consider a table modified by an insert command even if no new rows were added. Consider using ",{"type":43,"tag":65,"props":1481,"children":1483},{"className":1482},[],[1484],{"type":48,"value":539},{"type":48,"value":1486},", but this may be more costly in the warehouse - metadata queries are often free but ",{"type":43,"tag":65,"props":1488,"children":1490},{"className":1489},[],[1491],{"type":48,"value":539},{"type":48,"value":1493}," will be a standard paid query.",{"type":43,"tag":128,"props":1495,"children":1496},{},[1497,1502],{"type":43,"tag":150,"props":1498,"children":1499},{},[1500],{"type":48,"value":1501},"Post-hooks didn't run on a reused model",{"type":43,"tag":150,"props":1503,"children":1504},{},[1505,1507,1512],{"type":48,"value":1506},"Hooks don't run on reuse by default — set ",{"type":43,"tag":65,"props":1508,"children":1510},{"className":1509},[],[1511],{"type":48,"value":779},{"type":48,"value":314},{"type":43,"tag":128,"props":1514,"children":1515},{},[1516,1528],{"type":43,"tag":150,"props":1517,"children":1518},{},[1519,1521,1526],{"type":48,"value":1520},"Want to know ",{"type":43,"tag":194,"props":1522,"children":1523},{},[1524],{"type":48,"value":1525},"why",{"type":48,"value":1527}," a node was reused\u002Frebuilt",{"type":43,"tag":150,"props":1529,"children":1530},{},[1531,1533,1542],{"type":48,"value":1532},"Use the ",{"type":43,"tag":57,"props":1534,"children":1535},{},[1536],{"type":43,"tag":65,"props":1537,"children":1539},{"className":1538},[],[1540],{"type":48,"value":1541},"dbt-state explain",{"type":48,"value":1543}," command (dbt v1.7–1.12) to inspect the decision.",{"type":43,"tag":128,"props":1545,"children":1546},{},[1547,1552],{"type":43,"tag":150,"props":1548,"children":1549},{},[1550],{"type":48,"value":1551},"Need authentication \u002F access",{"type":43,"tag":150,"props":1553,"children":1554},{},[1555,1557,1562,1564,1569,1571,1577,1579,1585,1586,1591],{"type":48,"value":1556},"Log in via your ",{"type":43,"tag":57,"props":1558,"children":1559},{},[1560],{"type":48,"value":1561},"dbt platform",{"type":48,"value":1563}," account or a ",{"type":43,"tag":57,"props":1565,"children":1566},{},[1567],{"type":48,"value":1568},"standalone dbt State",{"type":48,"value":1570}," account. For an org, set ",{"type":43,"tag":65,"props":1572,"children":1574},{"className":1573},[],[1575],{"type":48,"value":1576},"state-org-id",{"type":48,"value":1578}," under ",{"type":43,"tag":65,"props":1580,"children":1582},{"className":1581},[],[1583],{"type":48,"value":1584},"dbt-cloud:",{"type":48,"value":800},{"type":43,"tag":65,"props":1587,"children":1589},{"className":1588},[],[1590],{"type":48,"value":806},{"type":48,"value":314},{"type":43,"tag":113,"props":1593,"children":1595},{"id":1594},"v1-python-vs-v2-rustfusion",[1596],{"type":48,"value":1597},"v1 (Python) vs v2 (Rust\u002FFusion)",{"type":43,"tag":120,"props":1599,"children":1600},{},[1601,1625],{"type":43,"tag":124,"props":1602,"children":1603},{},[1604],{"type":43,"tag":128,"props":1605,"children":1606},{},[1607,1610,1615,1620],{"type":43,"tag":132,"props":1608,"children":1609},{},[],{"type":43,"tag":132,"props":1611,"children":1612},{},[1613],{"type":48,"value":1614},"dbt Core 1.7–1.11",{"type":43,"tag":132,"props":1616,"children":1617},{},[1618],{"type":48,"value":1619},"dbt Core 1.12 \u002F v2.0",{"type":43,"tag":132,"props":1621,"children":1622},{},[1623],{"type":48,"value":1624},"Fusion",{"type":43,"tag":143,"props":1626,"children":1627},{},[1628],{"type":43,"tag":128,"props":1629,"children":1630},{},[1631,1636,1646,1651],{"type":43,"tag":150,"props":1632,"children":1633},{},[1634],{"type":48,"value":1635},"Install",{"type":43,"tag":150,"props":1637,"children":1638},{},[1639,1644],{"type":43,"tag":65,"props":1640,"children":1642},{"className":1641},[],[1643],{"type":48,"value":305},{"type":48,"value":1645}," required",{"type":43,"tag":150,"props":1647,"children":1648},{},[1649],{"type":48,"value":1650},"Built in",{"type":43,"tag":150,"props":1652,"children":1653},{},[1654],{"type":48,"value":1650},{"type":43,"tag":652,"props":1656,"children":1657},{},[1658,1671,1683],{"type":43,"tag":417,"props":1659,"children":1660},{},[1661,1663,1669],{"type":48,"value":1662},"dbt v1.7-1.11 users must install the separate ",{"type":43,"tag":65,"props":1664,"children":1666},{"className":1665},[],[1667],{"type":48,"value":1668},"dbt-state",{"type":48,"value":1670}," package to use dbt State.",{"type":43,"tag":417,"props":1672,"children":1673},{},[1674,1676,1681],{"type":48,"value":1675},"dbt v1.12+ users have the ",{"type":43,"tag":65,"props":1677,"children":1679},{"className":1678},[],[1680],{"type":48,"value":1668},{"type":48,"value":1682}," package included automatically.",{"type":43,"tag":417,"props":1684,"children":1685},{},[1686],{"type":48,"value":1687},"dbt v2.0+ (either Core or Fusion distributions) have the Rust implementation of the client logic built in, so no separate install is needed.",{"type":43,"tag":51,"props":1689,"children":1690},{},[1691,1693,1698,1700,1705],{"type":48,"value":1692},"The reuse behavior, configs, and query normalization are server-side and behave consistently across all engines. The main v1 difference is the separate ",{"type":43,"tag":65,"props":1694,"children":1696},{"className":1695},[],[1697],{"type":48,"value":1668},{"type":48,"value":1699}," install for 1.7–1.11. The ",{"type":43,"tag":65,"props":1701,"children":1703},{"className":1702},[],[1704],{"type":48,"value":1541},{"type":48,"value":1706}," diagnostic is not available in dbt v2.",{"type":43,"tag":113,"props":1708,"children":1710},{"id":1709},"related-docs",[1711],{"type":48,"value":1712},"Related docs",{"type":43,"tag":652,"props":1714,"children":1715},{},[1716,1727,1746,1773],{"type":43,"tag":417,"props":1717,"children":1718},{},[1719,1721],{"type":48,"value":1720},"Overview: ",{"type":43,"tag":65,"props":1722,"children":1724},{"className":1723},[],[1725],{"type":48,"value":1726},"\u002Fdocs\u002Fdeploy\u002Fdbt-state-about",{"type":43,"tag":417,"props":1728,"children":1729},{},[1730,1732,1738,1740],{"type":48,"value":1731},"Setup: ",{"type":43,"tag":65,"props":1733,"children":1735},{"className":1734},[],[1736],{"type":48,"value":1737},"\u002Fdocs\u002Fdeploy\u002Fdbt-state-setup",{"type":48,"value":1739}," · Examples: ",{"type":43,"tag":65,"props":1741,"children":1743},{"className":1742},[],[1744],{"type":48,"value":1745},"\u002Fdocs\u002Fdeploy\u002Fdbt-state-examples",{"type":43,"tag":417,"props":1747,"children":1748},{},[1749,1751,1757,1759,1765,1767],{"type":48,"value":1750},"Monitor activity: ",{"type":43,"tag":65,"props":1752,"children":1754},{"className":1753},[],[1755],{"type":48,"value":1756},"\u002Fdocs\u002Fdeploy\u002Fdbt-state-interface",{"type":48,"value":1758}," · Deferral: ",{"type":43,"tag":65,"props":1760,"children":1762},{"className":1761},[],[1763],{"type":48,"value":1764},"\u002Fdocs\u002Fdeploy\u002Fdbt-state-deferral",{"type":48,"value":1766}," · CI\u002FCD: ",{"type":43,"tag":65,"props":1768,"children":1770},{"className":1769},[],[1771],{"type":48,"value":1772},"\u002Fdocs\u002Fdeploy\u002Fdbt-state-cicd",{"type":43,"tag":417,"props":1774,"children":1775},{},[1776,1778,1784,1786,1791,1792],{"type":48,"value":1777},"Configs: ",{"type":43,"tag":65,"props":1779,"children":1781},{"className":1780},[],[1782],{"type":48,"value":1783},"\u002Freference\u002Fresource-configs\u002Fdbt-state-configs",{"type":48,"value":1785}," · ",{"type":43,"tag":65,"props":1787,"children":1789},{"className":1788},[],[1790],{"type":48,"value":439},{"type":48,"value":1785},{"type":43,"tag":65,"props":1793,"children":1795},{"className":1794},[],[1796],{"type":48,"value":518},{"type":43,"tag":1798,"props":1799,"children":1800},"style",{},[1801],{"type":48,"value":1802},"html .light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}html.light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}",{"items":1804,"total":1961},[1805,1818,1838,1849,1863,1878,1890,1905,1919,1931,1943,1954],{"slug":1806,"name":1806,"fn":1807,"description":1808,"org":1809,"tags":1810,"stars":24,"repoUrl":25,"updatedAt":1817},"adding-dbt-unit-test","add dbt unit tests","Creates unit test YAML definitions that mock upstream model inputs and validate expected outputs. Use when adding unit tests for a dbt model or practicing test-driven development (TDD) in dbt.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1811,1812,1815],{"name":23,"slug":23,"type":15},{"name":1813,"slug":1814,"type":15},"Testing","testing",{"name":1816,"slug":1252,"type":15},"YAML","2026-04-06T18:09:14.01391",{"slug":1819,"name":1819,"fn":1820,"description":1821,"org":1822,"tags":1823,"stars":24,"repoUrl":25,"updatedAt":1837},"answering-natural-language-questions-with-dbt","answer business questions using dbt Semantic Layer","Writes and executes SQL queries against the data warehouse using dbt's Semantic Layer or ad-hoc SQL to answer business questions. Use when a user asks about analytics, metrics, KPIs, or data (e.g., \"What were total sales last quarter?\", \"Show me top customers by revenue\"). NOT for validating, testing, or building dbt models during development.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1824,1827,1830,1831,1834],{"name":1825,"slug":1826,"type":15},"Analytics","analytics",{"name":1828,"slug":1829,"type":15},"Data Analysis","data-analysis",{"name":23,"slug":23,"type":15},{"name":1832,"slug":1833,"type":15},"Metrics","metrics",{"name":1835,"slug":1836,"type":15},"SQL","sql","2026-04-06T18:09:07.651959",{"slug":1839,"name":1839,"fn":1840,"description":1841,"org":1842,"tags":1843,"stars":24,"repoUrl":25,"updatedAt":1848},"building-dbt-semantic-layer","build dbt Semantic Layer components","Use when creating or modifying dbt Semantic Layer components — semantic models, metrics, dimensions, entities, measures, or time spines. Covers MetricFlow configuration, metric types (simple, derived, cumulative, ratio, conversion), and validation for both latest and legacy YAML specs.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1844,1845,1846,1847],{"name":1825,"slug":1826,"type":15},{"name":17,"slug":18,"type":15},{"name":23,"slug":23,"type":15},{"name":1832,"slug":1833,"type":15},"2026-07-18T05:12:20.387564",{"slug":1850,"name":1850,"fn":1851,"description":1852,"org":1853,"tags":1854,"stars":24,"repoUrl":25,"updatedAt":1862},"configuring-dbt-mcp-server","configure dbt MCP server","Generates MCP server configuration JSON, resolves authentication setup, and validates server connectivity for dbt. Use when setting up, configuring, or troubleshooting the dbt MCP server for AI tools like Claude Desktop, Claude Code, Cursor, or VS Code.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1855,1858,1859],{"name":1856,"slug":1857,"type":15},"Agent Context","agent-context",{"name":23,"slug":23,"type":15},{"name":1860,"slug":1861,"type":15},"MCP","mcp","2026-04-06T18:09:12.757804",{"slug":1864,"name":1864,"fn":1865,"description":1866,"org":1867,"tags":1868,"stars":24,"repoUrl":25,"updatedAt":1877},"creating-mermaid-dbt-dag","generate Mermaid diagrams of dbt model lineage","Generates a Mermaid flowchart diagram of dbt model lineage using MCP tools, manifest.json, or direct code parsing as fallbacks. Use when visualizing dbt model lineage and dependencies as a Mermaid diagram in markdown format.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1869,1870,1871,1874],{"name":20,"slug":21,"type":15},{"name":23,"slug":23,"type":15},{"name":1872,"slug":1873,"type":15},"Diagrams","diagrams",{"name":1875,"slug":1876,"type":15},"Documentation","documentation","2026-04-06T18:09:15.270247",{"slug":1879,"name":1879,"fn":1880,"description":1881,"org":1882,"tags":1883,"stars":24,"repoUrl":25,"updatedAt":1889},"fetching-dbt-docs","search dbt documentation","Retrieves and searches dbt documentation pages in LLM-friendly markdown format. Use when fetching dbt documentation, looking up dbt features, or answering questions about dbt Cloud, dbt Core, or the dbt Semantic Layer.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1884,1885,1886],{"name":23,"slug":23,"type":15},{"name":1875,"slug":1876,"type":15},{"name":1887,"slug":1888,"type":15},"Reference","reference","2026-04-06T18:09:06.36975",{"slug":1891,"name":1891,"fn":1892,"description":1893,"org":1894,"tags":1895,"stars":24,"repoUrl":25,"updatedAt":1904},"migrating-dbt-core-to-fusion","triage dbt-core to Fusion migration errors","Use when a user needs help triaging dbt-core to Fusion migration errors. Runs dbt-autofix first, then classifies remaining errors into actionable categories (auto-fixable, guided fixes, needs input, blocked).",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1896,1897,1898,1901],{"name":17,"slug":18,"type":15},{"name":23,"slug":23,"type":15},{"name":1899,"slug":1900,"type":15},"Migration","migration",{"name":1902,"slug":1903,"type":15},"Triage","triage","2026-04-06T18:09:01.250175",{"slug":1906,"name":1906,"fn":1907,"description":1908,"org":1909,"tags":1910,"stars":24,"repoUrl":25,"updatedAt":1918},"migrating-dbt-project-across-platforms","migrate dbt projects across data platforms","Use when migrating a dbt project from one data platform or data warehouse to another (e.g., Snowflake to Databricks, Databricks to Snowflake) using dbt Fusion's real-time compilation to identify and fix SQL dialect differences.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1911,1912,1915,1916,1917],{"name":17,"slug":18,"type":15},{"name":1913,"slug":1914,"type":15},"Database","database",{"name":23,"slug":23,"type":15},{"name":1899,"slug":1900,"type":15},{"name":1835,"slug":1836,"type":15},"2026-04-06T18:09:02.513828",{"slug":1920,"name":1920,"fn":1921,"description":1922,"org":1923,"tags":1924,"stars":24,"repoUrl":25,"updatedAt":1930},"running-dbt-commands","run dbt CLI commands","Formats and executes dbt CLI commands, selects the correct dbt executable, and structures command parameters. Use when running models, tests, builds, compiles, or show queries via dbt CLI. Use when unsure which dbt executable to use or how to format command parameters.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1925,1928,1929],{"name":1926,"slug":1927,"type":15},"CLI","cli",{"name":17,"slug":18,"type":15},{"name":23,"slug":23,"type":15},"2026-04-06T18:09:03.791122",{"slug":1932,"name":1932,"fn":1933,"description":1934,"org":1935,"tags":1936,"stars":24,"repoUrl":25,"updatedAt":1942},"troubleshooting-dbt-job-errors","troubleshoot dbt job errors","Diagnoses dbt Cloud\u002Fplatform job failures by analyzing run logs, querying the Admin API, reviewing git history, and investigating data issues. Use when a dbt Cloud\u002Fplatform job fails and you need to diagnose the root cause, especially when error messages are unclear or when intermittent failures occur. Do not use for local dbt development errors.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1937,1938,1939],{"name":20,"slug":21,"type":15},{"name":23,"slug":23,"type":15},{"name":1940,"slug":1941,"type":15},"Debugging","debugging","2026-04-06T18:09:05.065669",{"slug":1944,"name":1944,"fn":1945,"description":1946,"org":1947,"tags":1948,"stars":24,"repoUrl":25,"updatedAt":1953},"using-dbt-for-analytics-engineering","build dbt models and tests","Builds and modifies dbt models, writes SQL transformations using ref() and source(), creates tests, and validates results with dbt show. Use when doing any dbt work - building or modifying models, debugging errors, exploring unfamiliar data sources, writing tests, or evaluating impact of changes.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1949,1950,1951,1952],{"name":1825,"slug":1826,"type":15},{"name":17,"slug":18,"type":15},{"name":23,"slug":23,"type":15},{"name":1835,"slug":1836,"type":15},"2026-04-06T18:09:11.455851",{"slug":4,"name":4,"fn":5,"description":6,"org":1955,"tags":1956,"stars":24,"repoUrl":25,"updatedAt":26},{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1957,1958,1959,1960],{"name":17,"slug":18,"type":15},{"name":20,"slug":21,"type":15},{"name":23,"slug":23,"type":15},{"name":13,"slug":14,"type":15},16,{"items":1963,"total":2011},[1964,1970,1978,1985,1991,1998,2004],{"slug":1806,"name":1806,"fn":1807,"description":1808,"org":1965,"tags":1966,"stars":24,"repoUrl":25,"updatedAt":1817},{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1967,1968,1969],{"name":23,"slug":23,"type":15},{"name":1813,"slug":1814,"type":15},{"name":1816,"slug":1252,"type":15},{"slug":1819,"name":1819,"fn":1820,"description":1821,"org":1971,"tags":1972,"stars":24,"repoUrl":25,"updatedAt":1837},{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1973,1974,1975,1976,1977],{"name":1825,"slug":1826,"type":15},{"name":1828,"slug":1829,"type":15},{"name":23,"slug":23,"type":15},{"name":1832,"slug":1833,"type":15},{"name":1835,"slug":1836,"type":15},{"slug":1839,"name":1839,"fn":1840,"description":1841,"org":1979,"tags":1980,"stars":24,"repoUrl":25,"updatedAt":1848},{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1981,1982,1983,1984],{"name":1825,"slug":1826,"type":15},{"name":17,"slug":18,"type":15},{"name":23,"slug":23,"type":15},{"name":1832,"slug":1833,"type":15},{"slug":1850,"name":1850,"fn":1851,"description":1852,"org":1986,"tags":1987,"stars":24,"repoUrl":25,"updatedAt":1862},{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1988,1989,1990],{"name":1856,"slug":1857,"type":15},{"name":23,"slug":23,"type":15},{"name":1860,"slug":1861,"type":15},{"slug":1864,"name":1864,"fn":1865,"description":1866,"org":1992,"tags":1993,"stars":24,"repoUrl":25,"updatedAt":1877},{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[1994,1995,1996,1997],{"name":20,"slug":21,"type":15},{"name":23,"slug":23,"type":15},{"name":1872,"slug":1873,"type":15},{"name":1875,"slug":1876,"type":15},{"slug":1879,"name":1879,"fn":1880,"description":1881,"org":1999,"tags":2000,"stars":24,"repoUrl":25,"updatedAt":1889},{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[2001,2002,2003],{"name":23,"slug":23,"type":15},{"name":1875,"slug":1876,"type":15},{"name":1887,"slug":1888,"type":15},{"slug":1891,"name":1891,"fn":1892,"description":1893,"org":2005,"tags":2006,"stars":24,"repoUrl":25,"updatedAt":1904},{"slug":8,"name":9,"logoUrl":10,"githubOrg":8},[2007,2008,2009,2010],{"name":17,"slug":18,"type":15},{"name":23,"slug":23,"type":15},{"name":1899,"slug":1900,"type":15},{"name":1902,"slug":1903,"type":15},13]