Skip to content
CAI
Software that uses CAICheck a score

dbt-labs/dbt-core

49.0

Weak · 14 November 2026

621.7k

lines of production code

Rust

with TypeScript

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Exasol adapter support to dbt-loader

This change introduces the dbt-exasol adapter macros into the dbt-loader crate, enabling users to run dbt models against Exasol databases. The included macros cover core adapter operations (schema and table creation, renaming, dropping), materialization strategies (incremental microbatch, merge, snapshot), and utility functions (hashing, date arithmetic, type casting) tailored to Exasol's SQL dialect and system catalog views.

_crates/dbt-loader/src/dbt\_macro\assets/dbt-exasol · high confidence

Add Postgres adapter macros for dbt integration

This change introduces the Postgres-specific macro library (dbt-postgres) into the dbt-loader, enabling the system to load, parse, and execute dbt models against PostgreSQL databases. The new files provide the core adapter logic required for data transformation, including table and view creation/replacement, materialized view management (create, drop, refresh, rename), incremental strategies, snapshot merging, and catalog generation. It also includes utility macros for date/time operations (datediff, dateadd, listagg) and relation handling, allowing users to run dbt projects targeting Postgres through this loader.

_crates/dbt-loader/src/dbt\_macro\assets/dbt-postgres · high confidence

Add Rust client for dbt Cloud API v3

Introduces a new Rust API client for the dbt Cloud API v3, generated from the OpenAPI specification. This client provides programmatic access to account administration endpoints, including listing and retrieving projects, managing credentials, handling account connections, and listing users. It supports authentication via Personal Access Tokens (PAT) and includes models and methods for interacting with the v3 API surface.

crates/dbt-cloud-api · high confidence

Add Salesforce metadata adapter stub

A new Salesforce metadata adapter has been added to the dbt-adapter crate. This implementation provides the \SalesforceMetadataAdapter\ struct which implements the \MetadataAdapter\ trait, registering itself as the \Salesforce\ adapter type. Currently, the adapter serves as a stub: most metadata retrieval methods (such as building schemas from stats or listing relations) return empty results or are marked as unimplemented, and progress reporting for relations is explicitly disabled. This lays the groundwork for future Salesforce-specific metadata integration.

crates/dbt-adapter/src/metadata/salesforce · high confidence

Add dbt adapter macros for Microsoft Fabric Spark

The dbt loader now includes a new \dbt-fabricspark\ adapter package, providing the necessary macros to support Microsoft Fabric Spark as a target. This addition enables users to run dbt models against Fabric Spark warehouses and lakehouses, implementing support for table, view, incremental, seed, snapshot, and clone materializations, along with specific SQL dialect adjustments for operations like column management, grants, and data type handling.

_crates/dbt-loader/src/dbt\_macro\assets/dbt-fabricspark · high confidence

Add dbt-clickhouse adapter macro package

This change embeds the dbt-clickhouse macro package into the dbt-loader, enabling users to run dbt models against ClickHouse databases. The included macros provide full adapter support, including materializations for standard tables, distributed tables, materialized views (with external target and standard modes), dictionaries, and incremental models (with schema evolution and multiple strategies). It also adds support for seeds, catalog generation, and S3 data sources, along with cluster-aware operations and connection settings.

_crates/dbt-loader/src/dbt\_macro\assets/dbt-clickhouse · high confidence

Add support for Microsoft Fabric as a dbt adapter

Users can now run dbt models against Microsoft Fabric data warehouses. This change introduces a new adapter implementation in the \dbt-fabric\ package, providing materializations for tables, views, incremental models, clones, seeds, and snapshots, along with the necessary SQL macros for schema management, cataloging, grants, and column operations specific to the Fabric environment.

_crates/dbt-loader/src/dbt\_macro\assets/dbt-fabric · high confidence

Added Jinja built-in type definitions for adapter functions

The \minijinja-typecheck-builtins\ crate now includes a new asset file (\builtins.sdf.yml\) and corresponding Rust code to define type signatures for Jinja built-ins, specifically focusing on the \adapter\ object. This adds static type checking support for adapter methods such as \get\_relation\, \dispatch\, \execute\, and \quote\, allowing the type checker to validate arguments and return types for these database interaction functions.

crates/minijinja-typecheck-builtins · high confidence

Added SQL keyword lists for BigQuery, Databricks, DuckDB, Redshift, Snowflake, and Trino

The dbt-sql-keywords crate now includes generated keyword definitions for BigQuery, BigQueryUnTyped, Databricks, DuckDB, Redshift, Snowflake, and Trino. These files define reserved, strict non-reserved, and non-reserved keywords for each dialect, enabling the parser and linter to correctly identify and handle SQL syntax specific to these databases.

crates/dbt-sql-keywords/src/generated · high confidence

Added Windows-specific file security primitives for owner-only access

The \dbt-file-security\ crate now includes a Windows implementation that provides functions to create files and directories with protected, owner-only discretionary access control lists (DACLs). This adds \open\_owner\_only\, \owner\_only\_tempfile\_in\, and \ensure\_owner\_only\_dir\ to the public API, ensuring that sensitive files created on Windows are inaccessible to other users, thereby enhancing security for secret storage on this platform.

crates/dbt-file-security · high confidence

Added code-signing and intermediate certificates

The repository now includes the public code-signing certificate for dbt Labs, Inc. (issued by DigiCert) and the corresponding DigiCert Trusted G4 Code Signing RSA SHA384 2021 CA1 intermediate certificate. These additions support the verification of signed artifacts or builds associated with the dbt Labs product.

certificates · high confidence

Append-only parquet metadata storage for catalog, lineage, and compilation data

The \dbt-metadata-parquet\ crate now persists dbt metadata as epoch-appended Parquet files under \target/metadata\, replacing previous storage mechanisms. This change introduces structured, versioned storage for catalog column types and comments, warehouse catalog statistics, column-level lineage edges, compile-time column types, compiled node states (including SQL and grain metadata), and invocation records. Each module implements an append-only or latest-wins strategy with automatic compaction to manage file counts and disk usage, providing a durable, queryable history of metadata changes across dbt runs.

crates/dbt-metadata-parquet · high confidence

BigQuery relation configuration module added

A new configuration module for BigQuery relations has been introduced, establishing the structural foundation for handling BigQuery-specific table and view settings. This change adds the core module file along with test helpers that define schemas and metadata structures for BigQuery entities, including support for partitioning, clustering, labels, and materialized view properties.

crates/dbt-adapter/src/relation/bigquery/config · high confidence

Bundled Snowflake adapter macros for dbt-loader

The dbt-loader now includes a bundled set of Snowflake-specific macros (dbt\_project.yml and macro files) that enable Snowflake model materializations, catalog generation, and incremental strategies within the loader environment. This addition provides support for dynamic tables, interactive tables, and catalog-linked databases (such as Iceberg via Glue), along with specific handling for grants, column comments, and temporary relations in Snowflake.

_crates/dbt-loader/src/dbt\_macro\_assets/dbt-bigquery, crates/dbt-loader/src/dbt\_macro\_assets/dbt-databricks, crates/dbt-loader/src/dbt\_macro\assets/dbt-snowflake · high confidence

Bundled dbt-adapter macros for local loading

The dbt-loader now includes a bundled set of dbt-adapter macros (located in \crates/dbt-loader/src/dbt\_macro\_assets/dbt-adapters\) to support local project loading. This addition introduces the core adapter interface macros, including \apply\_grants\ for managing table/view permissions, \persist\_docs\ for maintaining column and relation comments, and \get\_columns\_in\_relation\ for schema introspection. It also provides the standard generic test implementations (\unique\, \not\_null\, \relationships\, \accepted\_values\) and utility macros for handling timestamps, schema creation, and relation naming, ensuring the loader has the necessary macro definitions to execute dbt projects without relying on external package installations.

_crates/dbt-loader/src/dbt\_macro\assets/dbt-adapters · high confidence

Bundled dbt-spark adapter macros for Spark and Databricks

The dbt-loader now includes a bundled set of dbt-spark macros (located in crates/dbt-loader/src/dbt\_macro\_assets/dbt-spark) to support Spark and Databricks data warehouses. This addition provides the core adapter logic for materializing tables, views, seeds, snapshots, and incremental models (including append, merge, insert\_overwrite, and microbatch strategies). It also implements Spark-specific SQL utilities for date/time arithmetic, string manipulation, and array operations, along with a profile template to simplify connection configuration.

_crates/dbt-loader/src/dbt\_macro\assets/dbt-spark · high confidence

Centralized environment configuration and Vortex logging integration

This change introduces a new \dbt-env\ crate that centralizes the resolution of cloud configuration and environment variables, specifically handling fields like account, project, and job identifiers by prioritizing structured cloud config over legacy environment variable fallbacks. It also adds a \dbt-vortex\ crate that provides a unified, non-blocking interface for logging telemetry messages to the Vortex service, managing the underlying producer client and worker thread lifecycle automatically.

crates/dbt-env · high confidence

Databricks adapter introduces typed constraint support and shallow clone detection

The Databricks adapter now includes a new \TypedConstraint\ enum that supports check, primary key, foreign key, and custom constraints, complete with validation logic and DDL rendering for CREATE/ALTER TABLE statements. This change also exposes constraint details to Jinja templates via a custom Object implementation to ensure correct property access. Additionally, the adapter adds constants for default Databricks system schemas (hive\_metastore, system, information\_schema) and implements a helper function to detect shallow clone table types, enabling better handling of shallow clones in materializations.

crates/dbt-adapter/src/relation/databricks · high confidence

DuckDB SQL lexer support added

The dbt-lexer-duckdb crate now includes generated lexer files for DuckDB SQL, enabling the system to tokenize DuckDB-specific syntax. This change introduces the necessary components for parsing DuckDB queries, including token definitions and the lexer implementation, which are generated from the DuckDB grammar using ANTLR 4.13.2.

crates/dbt-sql/dbt-lexer-duckdb · high confidence

Exasol metadata adapter implementation for schema and catalog operations

The Exasol metadata adapter now provides specific logic for schema creation preflight, per-relation schema fetching via zero-row probes, and catalog parsing for \compile --write-catalog\. This enables dbt to correctly handle Exasol's two-part naming system and quote policies during metadata-based operations, while relation-cache hydration remains intentionally empty to fall back to standard macros.

crates/dbt-adapter/src/metadata/exasol · high confidence

Homebrew formula rendering and publishing automation

Added a new Homebrew integration module that automates the creation and distribution of Homebrew formulae. The \render\ component generates \.rb\ formula files from pre-built release tarballs, supporting multiple platforms (macOS ARM/Intel, Linux ARM/Intel) and deriving metadata from \pyproject.toml\. The \publish\ component handles pushing the rendered formula to a Homebrew tap repository, managing git cloning, committing, and pushing via HTTPS with secure token authentication, while supporting dry-run modes and configurable commit identities.

crates/dbt-ci/src/homebrew · high confidence

Initial Salesforce adapter macro definitions

The Salesforce adapter is bootstrapped with a set of dbt macros that define how models are materialized and how utility functions behave. Table and incremental model materializations are implemented to write data via the ADBC driver, requiring a single primary key and allowing specific categories. Several utility macros for dates, casting, and array construction are provided, while many other adapter features (such as grants, schemas, views, and seeds) are explicitly marked as not implemented to prevent unsupported operations.

_crates/dbt-loader/src/dbt\_macro\assets/dbt-salesforce · high confidence

Initial implementation of Fabric metadata adapter

Added the \FabricMetadataAdapter\ and its \list\_relations\ function in \crates/dbt-adapter/src/metadata/fabric/mod.rs\, enabling the system to discover tables and views in Microsoft Fabric by executing the \sp\_tables\ stored procedure and mapping the results to internal relation types. The adapter also implements schema building logic to parse table and column metadata from SQL query results, integrating with the existing \AdapterEngine\ and \Relation\ structures.

crates/dbt-adapter/src/metadata/fabric · high confidence

Initial import of the MiniJinja Jinja2 engine crate

The \crates/dbt-jinja\ directory has been added, introducing the MiniJinja template engine as a dependency for dbt. This import includes the full source code for the engine (version 2.6.0), along with comprehensive CI/CD workflows for building wheels, publishing to crates.io and PyPI, and running tests across multiple Rust versions and targets (including WASI and 32-bit). It also establishes the development environment with configuration for Clippy, Rustfmt, and VS Code, ensuring the engine is integrated into the dbt build and release pipeline.

crates/dbt-jinja · high confidence

Install agent skills from packages during \`dbt deps\`

dbt now automatically discovers and installs agent skills (directories containing a \SKILL.md\) from the root project and any installed packages when running \dbt deps\. Skills are resolved using the \skills:\ configuration block in \dbt\_project.yml\ (with the root project overriding package configs) and are copied into the destination directories specified by the \ai\_provider\ setting (e.g., \.agents/skills/\ or \.claude/skills/\). The system handles skill validation, metadata injection for tracking, and pruning of obsolete installs, ensuring that skills from packages are available to configured AI providers without manual intervention.

crates/dbt-skills · high confidence

Interactive profile setup wizard for \`dbt init\`

The \dbt init\ command now includes an interactive profile setup wizard that guides users through configuring their database connection. Users can choose to create a new profile from scratch, pre-populate one using credentials from their \dbt\_cloud.yml\ file, reuse an existing profile from \profiles.yml\, or skip setup entirely. The wizard supports a wide range of adapters, including Snowflake, Databricks, BigQuery, ClickHouse, Exasol, Postgres, Redshift, and Fabric. Additionally, the command now offers embedded project templates (Jaffle Shop and Moms Flower Shop) and automatically recommends the dbt VS Code extension in the project's \.vscode/extensions.json\ file.

crates/dbt-init/src · high confidence

Introduce Databricks relation configuration and test helpers

This change adds the initial configuration structures and test utilities for Databricks relations in the dbt adapter. It defines metadata keys for fetching relation details (such as tags, constraints, and column masks) and provides test helpers to mock Databricks-specific model configurations, including support for dynamic table features like scheduling (cron, every, on\_update), liquid clustering, row filters, and column masks.

crates/dbt-adapter/src/relation/databricks/config · high confidence

Introduce DuckDB metadata adapter implementation

Added a new \DuckDBMetadataAdapter\ in the \crates/dbt-adapter/src/metadata/duckdb\ module to handle DuckDB-specific metadata operations. This implementation provides methods for building schemas from statistics SQL and extracting column metadata, utilizing the \AdapterImpl\ and \AdapterEngine\ abstractions. It also includes a \list\_relations\_schemas\_inner\ method that queries DuckDB using \DESCRIBE\ statements to retrieve table schemas, supporting execution phases and cancellation tokens.

crates/dbt-adapter/src/metadata/duckdb · high confidence

Introduce Python model support in the parser

The parser now supports Python models. It validates that each Python file contains exactly one \model(dbt, session)\ function and extracts dependencies (\ref\, \source\) and configuration (\config\, \config.get\, \config.meta\_get\) by analyzing the Python AST. This allows dbt to parse, resolve, and render Python-based models alongside SQL.

crates/dbt-parser/src · high confidence

Introduce Relation Config v2 and BigQuery Materialized View support

The \dbt-adapter\ crate now uses a new \config\_v2\ system for describing and diffing relation configurations, replacing the legacy \config.rs\ implementation. This change introduces a component-based architecture where relation settings (like partitioning, clustering, and refresh policies) are handled as distinct, diffable objects. Specifically, BigQuery materialized views are now supported via a dedicated \materialized\_view.rs\ loader that parses and diffs components such as cluster-by, partition-by, and refresh intervals. The \RelationObject\ and \RelationStatic\ implementations have been updated to integrate with this new config system, ensuring that Jinja templates receive the correct configuration values and that changesets accurately reflect the difference between desired and current states for BigQuery materialized views.

crates/dbt-adapter/src/relation · high confidence

Introduce Rust-based run-cache service integration in dbt-tasks-core

This change adds the \run\_cache\ module to \crates/dbt-tasks-core\, establishing the Rust-side implementation for the dbt State service shadow path. It introduces \run\_cache\_dev\_clone.rs\ to handle dev-clone decisions for incremental models and snapshots, \run\_cache\_request.rs\ to translate task-layer state (such as microbatch windows, persisted docs hashes, and semantic extras) into service requests, and \run\_cache\_service.rs\ to manage the execution lifecycle, including submitting requests, interpreting service decisions (Execute, Clone, Skip), and confirming results. This provides the core wiring for remote task execution and cache reuse within the Rust runtime.

_crates/dbt-tasks-core/src/run\cache · high confidence

Introduce SQL statement splitter with malformed-statement handling

The \dbt-sql-utils\ crate now includes a new SQL statement splitter that identifies statement boundaries by locating semicolons via the \dbt\_antlr4\ lexer. It supports multiple dialects (BigQuery, Redshift, Snowflake, Databricks, and Trino as default) and specifically handles malformed input: if an unpaired token (such as an unclosed quote or comment) is detected, the splitter stops splitting and returns the remainder of the input as a single statement rather than silently dropping it. Tests verify basic splitting, preservation of comments, and dialect-specific behaviors like Snowflake's terminal flow syntax.

crates/dbt-sql/dbt-sql-utils/src/splitter · high confidence

Introduce SQL type parsing and rendering logic in dbt-adapter-sql

The \dbt-adapter-sql\ crate now includes a comprehensive module for handling SQL data types, providing the ability to parse column descriptions into structured \SqlType\ representations and render them back to SQL strings tailored to specific database backends. This change introduces support for a wide range of data types including integers, decimals, strings, binary data, dates, times, and timestamps, with backend-specific logic for time zone specifications (e.g., handling \WITH TIME ZONE\ vs \WITHOUT TIME ZONE\ in PostgreSQL vs BigQuery) and precision. This functionality serves as the foundation for type conversion and description parsing across the dbt adapter ecosystem. Also in this area: 2 commits (1 fix) modifying crates/dbt-adapter-sql.

crates/dbt-adapter-sql/src/types · medium confidence · unverified

Introduce Storybook for dbt Docs v2 UI components

Developers can now use Storybook to view, test, and interact with dbt Docs v2 UI components in isolation. This includes a Storybook configuration that mirrors the application's provider stack (React Router, React Query, theme context) and a suite of stories for the main App shell and Markdown overview component, covering various states such as loading, errors, and different data sources.

crates/dbt-docs-server/web/src · high confidence

Introduce Time Machine record/replay system for adapter compatibility testing

The \crates/dbt-adapter/src/time\_machine\ module now provides a unified infrastructure for recording and replaying adapter-level behavior, enabling backward compatibility testing across Fusion versions. It captures synchronous Jinja \adapter.xxx()\ calls and asynchronous \MetadataAdapter\ operations (such as schema discovery and freshness checks) via an MPSC channel to a background writer, storing them as compressed NDJSON files. During replay, the system supports both strict ordering and semantic modes—where read-only queries like \SELECT\ or \SHOW\ can be matched flexibly to handle minor reordering—while sanitizing non-deterministic elements like temporary table suffixes and UUIDs to ensure reliable cross-version validation.

_crates/dbt-adapter/src/time\machine · high confidence

Introduce \`dbt login\` and \`dbt login status\` commands

This change introduces the \dbt login\ and \dbt login status\ commands, implemented in the new \crates/dbt-login\ crate. The \dbt login\ command performs an interactive OAuth authentication flow, combining browser-based authorization for both dbt State and the dbt platform into a single session, while respecting the \DBT\_OAUTH\_SCOPES\ environment variable for custom scope requirements. The \dbt login status\ command displays the current authentication state, identifying the source of credentials (environment variables, OAuth session, or YAML config) and showing expiration details for OAuth tokens. Post-login, the system provides guidance on enabling dbt State if it is available for the account but not yet configured locally.

crates/dbt-login · high confidence

Introduce \`dbt source freshness\` command for open-source engine

Users can now run the \dbt source freshness\ command to evaluate the freshness of configured data sources. This new capability, implemented in the \crates/dbt-freshness\ module, allows users to verify that their source data is up-to-date by measuring the age of the most recently loaded records against defined freshness thresholds (warn/error). The command supports filtering by resource type and integrates with the existing dbt runtime for concurrent query execution and result artifact generation.

crates/dbt-freshness · high confidence

Introduce behavior flags for controlled feature toggles

The \dbt-common\ crate now includes a behavior flag system that allows features to be enabled or disabled with optional user overrides. This infrastructure supports gradual rollouts and deprecation warnings, giving users control over specific behavioral changes without requiring immediate code updates.

crates/dbt-common/src · high confidence

Introduce centralized dbt platform authentication crate

The new \dbt-platform-auth\ crate provides a unified credential resolution system for authenticating with the dbt platform. It introduces an \AuthChain\ that attempts to resolve credentials from environment variables, cached OAuth sessions, or \dbt\_cloud.yml\ configuration files in a defined order. For interactive contexts, the chain can be extended with a browser-based OAuth login flow. The crate also defines specific credential types (ServiceToken, Pat, OAuth) and a structured error model to handle authentication states like expiration or missing scopes.

crates/dbt-platform-auth · high confidence

Introduce centralized distribution info and telemetry hydration providers

The dbt-docs-core crate now provides a \DistInfoProvider\ trait and a \Providers\ bundle to centralize server metadata and analytics telemetry. This allows the server to authoritatively hydrate fields like distribution name, version, and login status onto every analytics event, ensuring the client cannot spoof this data. The default implementation assumes an OSS distribution, while the provider architecture enables environment-specific overrides for cloud identifiers.

crates/dbt-docs-core · high confidence

Introduce custom CSV parser for dbt seeds with agate-compatible type inference

A new \dbt-csv\ crate has been added to handle CSV reading for dbt seeds, replacing the previous generic CSV reader. This custom parser implements type inference logic that mirrors Python's agate library, ensuring that data types (Integer, Number, Date, DateTime, Boolean, Text) are detected with the same priority and rules as the Python ecosystem. Key behaviors include mapping DateTime and ISODateTime values to microsecond-precision timestamps, treating only 'true'/'false' as valid booleans, and allowing users to force specific columns to be treated as Text via configuration. This change ensures that seed data loaded into the warehouse matches the schema expectations defined in dbt projects.

crates/dbt-csv/src · high confidence

Introduce dbt Docs v2 UI pages and Storybook integration

The documentation interface has been updated to the v2 design, introducing new page components for the project overview, resource filtering, search, and resource details, along with a catch-all 404 page. The Overview page now serves as a dashboard landing page that displays project assets, suggested commands, and resource counts, while gracefully falling back to this default if no custom \\_\overview\\_\ block is authored. The Search page now supports cross-type queries with active filter chips and structured error handling for issues like query length or expired cursors. The ResourceDetails page manages loading and not-found states for specific resource types, and the ResourceFilter page narrows the asset list view based on route parameters. To support this new UI, Storybook stories have been added for all page components to facilitate visual testing and development.

crates/dbt-docs-server/web/src/pages · high confidence

Introduce dbt Platform metadata SDK for accounts, projects, and catalog

Added a new Rust SDK (\crates/dbt-platform\) that provides authenticated access to the dbt platform. The SDK introduces \PlatformClient\ with automatic credential resolution and refresh (including handling OAuth token expiry and 401 retries), scoped account support via \for\_account\, and specific APIs for user identity (\whoami\), project listing/retrieval (\list\_projects\, \get\_project\), and catalog exploration (\list\_catalog\_models\ via the Discovery GraphQL API).

crates/dbt-platform · high confidence

Introduce dbt State client with gRPC protocol and OAuth authentication

This change introduces the \dbt-state\ crate, providing the client-side implementation for dbt State reuse. It establishes the gRPC communication layer by compiling a new set of Protocol Buffers (including services for SQL execution, cloning, state selection, and telemetry) and adds a build script to manage these definitions. The crate also implements a complete OAuth 2.0 authentication flow, featuring PKCE-based browser login, token caching, and scope validation to securely manage access to the dbt State service. Also in this area: 2 commits (1 fix) modifying crates/dbt-state; Optimized BigQuery freshness prefetching with schema-level coalescing.

crates/dbt-state/src, crates/dbt-state/src/explain · medium confidence · unverified

Introduce dbt-adapter-core crate with AdapterType enum and config alias canonicalization

The new \dbt-adapter-core\ crate centralizes adapter identification via the \AdapterType\ enum (including variants like Snowflake, Bigquery, Databricks, Postgres, ClickHouse, and LakeCompute) and provides logic to canonicalize adapter-specific configuration key aliases (e.g., mapping \catalog\ to \database\ for Databricks) to ensure consistent config merging. It also defines static lists for non-experimental adapters, supported adapters for static analysis and microbatch concurrency, and adapter-specific settings such as default thread counts and SQL quote characters.

crates/dbt-adapter-core/src · high confidence

Introduce dbt-agate as a Rust-based Agate table implementation

This change adds the \dbt-agate\ crate, providing a Rust implementation of the Python agate library's core table and column abstractions. It introduces new modules for handling column operations, data type definitions, Arrow-to-minijinja value conversion, and row hashing/grouping, enabling agate-style table manipulation within the dbt adapter ecosystem.

crates/dbt-agate/src · high confidence

Introduce dbt-csv, a custom CSV parser for conformance

A new custom CSV reader module has been added to the \dbt-csv\ crate to replace the previous implementation, ensuring parsing behavior matches Python's agate library and dbt expectations. This reader implements agate-compatible type inference (prioritizing Integer \> Number \> Date \> DateTime \> ISODateTime \> Boolean \> Text), treats only 'true'/'false' as valid booleans, and recognizes empty strings and 'null' (case-insensitive) as NULL values. It also includes specific handling for empty headers, duplicate headers, truncated rows, and correct emission of empty records on newlines via a dedicated state machine.

crates/dbt-csv/src/reader · high confidence

Introduce dbt-lease crate for secure, concurrent local credential caching

A new \dbt-lease\ crate has been added to provide a file-based lease mechanism for coordinating access to shared local files across independent OS processes. This implementation, ported from the Snowflake Go driver, uses time-to-live (TTL) leases to prevent deadlocks if a process crashes, ensuring that sensitive data like credentials can be cached securely. It also includes OS-appropriate cache directory resolution (e.g., \\~/.cache\ on Linux, \\~/Library/Caches\ on macOS) with restrictive permissions (0700) to protect cached credentials. Also in this area: 3 commits (1 fix) modifying crates/dbt-adbc; 1 commit (1 fix) fixing crates/dbt-adbc; Updated ADBC drivers and improved local driver loading priority; Updated Spark and BigQuery Foundry driver versions; BigQuery adapter fixes and configuration support.

crates/dbt-adbc · medium confidence · unverified

Introduce generic dbt-tracing crate for structured telemetry

A new \dbt-tracing\ crate has been created to host generic, reusable telemetry infrastructure, including the \TelemetryDataLayer\ that bridges native \tracing\ spans and events into a structured pipeline, middleware and consumer traits for processing and exporting data, and support for JSONL, Parquet, and OTLP serialization. This change moves foundational record types, output layers, Arrow serialization, and subscriber filter policies out of application-specific code into this shared library, while keeping dbt-specific configuration, event schemas, and formatters in \dbt-common::tracing\ and telemetry schema crates.

crates/dbt-tracing · high confidence

Introduce in-process Python runner and typed artifact schemas

Users can now invoke dbt programmatically from Python using the new \dbtRunner\ API, which executes commands in-process and returns strongly typed dataclass artifacts (such as \RunResultsArtifact\, \Manifest\, \CatalogArtifact\, and \FreshnessResultsArtifact\) instead of raw JSON or strings. This change also adds a CLI entry point and integrates with the Rust engine via a PyO3 extension, ensuring that the Python-side artifact shapes match the on-disk JSON outputs.

crates/dbt-sa-python · high confidence

Introduce multi-adapter support with lazy adapter store and factory

The adapter subsystem now supports running models against multiple database adapters within a single project. A new \AdapterStore\ manages a registry of declared adapters, building them lazily on first use to avoid unnecessary connection overhead. A new \AdapterFactory\ trait and \DefaultAdapterFactory\ implementation handle the creation of \Adapter\ instances, mapping \AdapterType\ to specific backends and configuring engines, authentication, and statement splitters. This infrastructure allows nodes to be dispatched to the correct adapter implementation based on their configuration, rather than relying on a single default adapter for the entire run.

crates/dbt-adapter/src/adapter · high confidence

Introduce selection override capability for dbt-scheduler

The dbt-scheduler crate now supports an externally supplied node set that replaces the computed selection outright. When a \selection\_override\ is provided, the scheduler ignores standard \--select\, \--exclude\, \--resource-type\, and \--exclude-resource-type\ inputs, using the supplied IDs instead while still applying schedulability filters. This is implemented via new \SchedulerArgs\ configuration, \Instructions\ for SQL and logical plan execution, and updated \node\_selector\ and \schedule\ logic to handle the override and state-based selection results.

crates/dbt-scheduler · high confidence

Introduce semantic manifest schema with metrics, saved queries, and project configuration

The semantic layer now includes a new \SemanticManifest\ structure that aggregates semantic models, metrics, saved queries, and project configuration into a single serializable output. This change adds support for serializing metrics (including optional time granularity), saved queries (with export configurations), and project-level settings such as time spine definitions and DSI package version. Users can now access a consolidated semantic manifest that includes these previously separate or stubbed components, enabling better compatibility with downstream tools that expect a unified semantic layer representation.

_crates/dbt-schemas/src/schemas/semantic\layer · high confidence

Introduce shared SQL adapter utilities for identifier handling and statement classification

The \dbt-adapter-sql\ crate now provides shared infrastructure for SQL dialects, including an \Ident\ type that preserves quoting information to ensure correct case-sensitivity and character handling across backends like Snowflake and PostgreSQL. It also introduces keyword resolution via \dbt-sql-keywords\ for reserved and non-reserved terms, a tokenizer for parsing SQL tokens, and statement classification logic that specifically identifies BigQuery DML/DDL operations and excludes ClickHouse read statements.

crates/dbt-adapter-sql/src · high confidence

Introduce standalone Rust CLI and compiler for MetricFlow semantic queries

This change adds a new \dbt-metricflow\ crate that provides a standalone Rust-based CLI and semantic query compiler. Users can now execute the \dbt\_metricflow\ binary to compile metric queries into SQL for various dialects (defaulting to DuckDB) using a dbt semantic manifest. The CLI supports commands like \compile\ with arguments for specifying metrics, group-by clauses, where filters (with shorthand expansion), order-by, limits, and time constraints. The underlying library exposes a \MetricStore\ trait for metadata abstraction and an \InMemoryMetricStore\ for testing, enabling integration with external systems or embedding within other applications.

crates/dbt-metricflow/src · high confidence

Introduce standalone dbt-profile crate for profiles.yml resolution

A new \dbt-profile\ crate has been added to provide a lightweight, standalone resolver for dbt \profiles.yml\ files, suitable for use in \dbt-db-runner\ and other tools without pulling in the full dbt compilation stack. This crate handles parsing and validation of connection lists (supporting both legacy single-connection mappings and new flat list shapes), resolves Jinja templates for \env\_var\ and \var\ functions, and manages adapter type canonicalization (including rejecting retired names like \alt\ and \lake\_compute\ in favor of \lakecompute\). It exposes public APIs for resolving profiles, targets, and metadata, along with detailed error types for profile not found, missing outputs, invalid connection structures, and unrecognized adapter types.

crates/dbt-profile/src · high confidence

Introduces Python interface glue code for dbt core

Adds the \dbt-python-core\ crate, which provides the foundational glue code for the dbt Python extension module. This includes the \DbtRunner\ and \DbtRunnerResult\ classes exposed to Python, along with utilities for serializing artifacts to msgpack and managing process-wide tracing and feature stacks. This change establishes the mechanism by which the Rust core engine is invoked and results are returned to Python consumers. Also in this area: Support for optional sidecar packages in dbt distributions.

crates/dbt-python-core · high confidence

Introduces a dedicated blocking thread pool for Jinja and database operations

The \dbt-runtime\ crate now provides a dedicated thread pool to handle blocking tasks, specifically Jinja template rendering and database queries. This pool is configured via a builder that allows setting the maximum number of worker threads (defaulting to 48), thread naming, and idle keep-alive timeouts. The runtime exposes macros (\\#\[dbt\_runtime::main\]\, \\#\[dbt\_runtime::test\]\, and \\#\[dbt\_runtime::worker\_test\]\) to simplify setup, ensuring that blocking work is offloaded from the main async executor to prevent deadlocks and improve concurrency for I/O-bound operations.

crates/dbt-runtime · high confidence

Introduces a pluggable backend abstraction for the in-binary docs server

The \dbt-index-core\ crate now exposes a \Backend\ trait that provides read-only SQL access over the parquet index artifacts, enabling the in-binary docs server to query node listings, project info, and catalog stats without hardcoding the data source. This abstraction includes a \DuckDbViewsBackend\ implementation that opens an in-memory DuckDB instance, registers canonical views over the index directory, and supports capability detection via \is\_available\ and \table\_has\_rows\. A default \UnavailableBackend\ stub ensures graceful degradation (reporting features as unavailable) when the proprietary \dbt-index\ distribution is not installed, allowing the server to render a PLG upsell rather than crashing. The module also defines the \Db\ struct for managing DuckDB connections via ADBC and establishes the foundational types for column lineage and impact providers.

crates/dbt-index-core · high confidence

Introduces dbt State auto-deferral for unselected nodes

The new \crates/dbt-defer\ crate implements logic to automatically defer relations to a previous run's state when a manifest-backed state is not explicitly provided. It synthesizes defer nodes from the dbt State service configuration for unselected nodes, allowing incremental builds to reference production relations even when those specific nodes were not part of the current selection. This feature ensures that downstream dependencies can resolve correctly against the deferred state without requiring manual state path configuration, degrading gracefully if the state service is unavailable.

crates/dbt-defer · high confidence

Introduces dbt-base crate with stable-hash HashMap and HashSet types

The new \dbt-base\ crate provides foundational utility types for the workspace, specifically \HashMap\ and \HashSet\ variants that use a custom hasher. This hasher is stable across program runs in debug builds to aid in debugging and testing, while remaining DDoS-resistant in release builds. The crate is positioned at the root of the dependency graph and is restricted from depending on other internal fusion crates to minimize bloat.

crates/dbt-base · high confidence

Introduces parquet-backed incremental parse cache for faster partial parsing

The \dbt-metadata\ crate now implements a new incremental parse system that stores parse state in Parquet files (under \target/private/metadata/parse\) instead of the previous format. This change enables significantly faster \--partial-parse\ performance by allowing the system to read only necessary index columns and lazy-load node payloads. The implementation includes a file registry to track input kinds, index-based selector resolution for efficient node lookups, and logic to manage cache epochs and compaction. A benchmark script is also added to measure partial-parse performance across various scenarios.

crates/dbt-metadata · high confidence

Introduces prev\_state module for state comparison logic

Adds the \crates/dbt-schemas/src/schemas/prev\_state\ module, which defines the \StateArtifacts\ struct and associated logic for handling previous manifest state. This includes mechanisms for comparing node modifications (body, config, relation, etc.), indexing test signatures to match nodes across different manifest producers (such as reconciling unique\_id differences between dbt-core and Fusion), and handling manifest load failures via the \OnManifestLoadFailure\ enum.

_crates/dbt-schemas/src/schemas/prev\state · high confidence

Introduction of the dbt-adbc crate with ADBC driver support and CLI tools

The \crates/dbt-adbc\ crate is introduced, providing a new ADBC-based driver infrastructure for dbt. This includes new source files for specific database backends (Athena, BigQuery, ClickHouse, Databricks, Snowflake) defining their respective connection options and authentication types, alongside core ADBC components like \Database\, \Connection\, and \Driver\ implementations. The crate also adds a REPL binary (\repl.rs\) for interactive querying and a synchronization binary (\adbc\_sync.rs\) to manage and verify driver checksums from the CDN, ensuring secure and consistent driver installations across platforms. Also in this area: 3 commits (1 fix) modifying crates/dbt-adbc; 1 commit (1 fix) fixing crates/dbt-adbc; Updated ADBC drivers and improved local driver loading priority; Updated Spark and BigQuery Foundry driver versions; Rename ADBC driver from 'flock' to 'bridge'; and 2 more.

crates/dbt-adbc/src · medium confidence · unverified

New DataFusion provider crate for schema-store-backed catalog and table resolution

The new \crates/dbt-df-providers\ crate introduces a set of DataFusion provider implementations that bridge the dbt schema store with the DataFusion query engine. It replaces default in-memory catalog handling with \SchemaStoreCatalogProviderList\, which lazily provisions catalogs, schemas, and tables from the schema store at query time. A \DelayedDataTableProvider\ defers data registration until execution, allowing the system to represent intermediate tables with schema-only providers during compilation and bind actual data (Parquet/JSON) during the build phase. The crate also provides a custom CSV reader (\dbt\_csv\_mem\_table\) with agate-compatible type inference for dbt seeds, a \LenientSimplifyExpressions\ optimizer rule to prevent planning failures on unparseable literal casts, and helper functions to initialize \SessionContext\ with the schema store and a configurable execution time zone.

crates/dbt-df-providers · high confidence

New Jaffle Shop sample project for dbt init

The \dbt init\ command now generates a new 'Jaffle Shop' sample project instead of the previous default. This template includes a complete e-commerce data model with staging and mart layers, seed data, and unit tests. It is configured to use the \dbt-labs/dbt\_utils\ package (version \>=1.3.0) and enables \static\_analysis: strict\ by default. The project also includes a \.gitignore\ file that excludes \.env\ files, and provides adapter-specific macros for currency conversion.

crates/dbt-init/assets · high confidence

New Jinja utility crate for environment building and context management

The \dbt-jinja-utils\ crate introduces a new \JinjaEnvBuilder\ to configure and construct Minijinja environments, supporting adapter injection, global variables, and replay-mode macro suppression (e.g., no-oping \elementary.upload\_artifacts\_to\_table\). It adds a \Flags\ object for case-insensitive access to dbt flags (like \WARN\_ERROR\ and \STRICT\_MODE\) and an \InvocationArgs\ struct to pass CLI/eval arguments into the Jinja context. A new \info\_schema()\ helper allows parse-time project quality checks to safely read metadata views, while \invocation\_graph\ provides an invocation-scoped scratch space for macros. Additional utilities include \jinja\_arg\_format\ for formatting JSON values as Jinja literals and a \MalformedBlockNameListener\ to warn on invalid snapshot/docs block names.

crates/dbt-jinja-utils/src · high confidence

New Jinja utility functions for contract validation and base context registration

The \dbt-jinja-utils\ crate now exposes a new \functions\ module that registers core Jinja globals and functions, including \otel\_trace\_id\, \otel\_span\_id\, \fromjson\, \tojson\, \fromyaml\, \toyaml\, \set\, \render\, \zip\, \print\, \log\, and \diff\_of\_two\_dicts\. It also introduces a \contract\_error\ module that provides \get\_contract\_mismatches\, enabling Jinja templates to detect and report mismatches between YAML contract definitions and SQL column definitions (e.g., missing columns or data type conflicts) as an Agate table. Additionally, the base context now explicitly registers \None\, \True\, and \False\ globals to align with dbt-core's Python context behavior, preventing undefined variable errors in templates that rely on these capitalized constants.

crates/dbt-jinja-utils/src/functions · high confidence

New Rust-based authentication crate for adapters

The \dbt-auth\ crate has been introduced to centralize adapter authentication logic in Rust. It provides a standardized, zero-copy configuration parsing layer that preserves original input shapes to prevent silent behavior changes, and implements specific authentication handlers for Athena, BigQuery, ClickHouse, Databricks, DuckDB, and Exasol. This change replaces previous Python-based or scattered auth implementations with a unified, type-safe approach that enforces strict input validation and compatibility rules.

crates/dbt-auth · high confidence

New Vortex client library for event ingestion

Introduces the \vortex-client\ crate, providing a \VortexProducerClient\ for sending telemetry events to the Vortex API. The client supports configurable batching, exponential backoff on send failures, and a dev mode that writes events to a local file instead of making HTTP requests. Configuration is abstracted via the \VortexEnv\ trait, allowing hosts to specify service identity and override defaults like the base URL and ingest endpoint.

crates/vortex-client · high confidence

New Vortex telemetry event schemas for Copilot, Beacon, and dbt-index

The \crates/proto-rust\ crate now includes Protocol Buffers definitions for a new set of Vortex telemetry events. These schemas cover agent interactions (tool call permissions, execution, and completion), Beacon UI interactions (split pane opens/closes, canvas parsing, and kickouts), Copilot generation and LLM call metrics, and dbt-index CLI invocations and tool calls. This change establishes the data contracts for these new telemetry surfaces, enabling downstream Rust code generation to capture and send these specific user and system events to the Vortex analytics platform.

crates/proto-rust · high confidence

New agent skills for adapter reference annotation and code review

Added new agent skills in \.agents/skills\ to support adapter development workflows. The \adapters-annotate-references\ skill provides scripts (\annotate.py\, \find\_upstream.py\, \scan\_available.py\) and documentation to automatically annotate Rust adapter methods with upstream Python \@available\ reference links and identify implementation gaps. The \adapters-critic\ skill introduces a code review agent that enforces architectural principles, such as avoiding duplicated code, preventing target-specific free functions in generic modules, and ensuring SQL-processing utilities remain in their designated crates.

.agents/skills · high confidence

New assert\_contains! macro for test assertions

The \crates/dbt-test-primitives\ crate now exports an \assert\_contains!\ macro, allowing tests to verify that a collection or string contains a specific substring or element. The macro supports optional context arguments for clearer failure messages and works with strings, vectors, and hash sets. This simplifies common assertion patterns in the test suite by providing a dedicated, readable way to check for containment.

crates/dbt-test-primitives · high confidence

New dbt distribution detection and upgrade capabilities

The \dbt-dist\ crate now includes a new \dbt-dist-classify\ component that detects installed \dbt\ executables and classifies them by distribution (proprietary \dbt\, open-source \dbt-oss\/\dbt-core\, or Cloud CLI) and generation (v1 or v2). This enables the new \dbt system upgrade-distribution\ command, which allows users on the open-source \dbt-oss\ or legacy \dbt-core\ distributions to upgrade to the proprietary \dbt\ v2 distribution. The upgrade process supports both global installs (replacing the binary) and managed Python projects (updating \pyproject.toml\, \requirements.txt\, etc., and re-running the package manager). Additionally, the system now probes the actual installed package before uninstalling it to ensure accuracy, and handles Windows-specific executable discovery and Python manifest editing.

crates/dbt-dist/src · high confidence

New dbt docs v2 UI components and tests for asset and column lineage views

The docs v2 UI now includes new React components and their corresponding Storybook stories and unit tests for listing and filtering assets. This adds an AnalysisFilterView for ad-hoc analyses, a cross-type AssetListView with client-side filtering and pagination, and a GenericFilterView shell for other resource types. It also introduces a ColumnLineageMini component that renders a per-column lineage subgraph, correctly excluding scan-kind edges and handling gated access states.

crates/dbt-docs-server/web/src/components · high confidence

New dbt docs v2 UI components in the shared library

The shared component library now includes the foundational UI elements for the dbt docs v2 interface, including AssetDetail, AssetHeader, AssetMetadata, AssetColumns, AssetCode, AssetRelationships, CodePreview, CollapsibleSection, and various UI primitives like Badge, AnnotationBadge, and AutoExposureChip. These components provide the visual structure for asset detail pages, code previews with syntax highlighting, and relationship views, forming the core of the new documentation experience.

crates/dbt-docs-server/web/src/shared · high confidence

New dbt-adapter crate with core adapter infrastructure

The \dbt-adapter\ crate has been introduced to centralize adapter logic, providing a unified \AdapterEngine\ interface and a \RelationCache\ for managing database relations. It includes thread-local connection management via \ConnectionGuard\ to optimize resource usage, a \CatalogRelation\ system supporting both v1 and v2 \catalogs.yml\ schemas, and dialect-specific utilities for SQL formatting and identifier quoting. This change establishes the foundational adapter layer that replaces previous scattered implementations.

crates/dbt-adapter/src · high confidence

New dbt-cancel crate for cancellation token management

A new \dbt-cancel\ crate has been introduced to handle cancellation logic, providing \CancellationTokenSource\ and \CancellationToken\ types that allow operations to be cancelled via atomic request IDs or external flags. It also includes a \Cancellable\<E\>\ error type to wrap errors with cancellation states, enabling functions to return \Result\<T, Cancellable\<E\>\>\ and flatten cancellations into underlying error types. The crate is designed to sit at the root of the dependency graph, explicitly prohibiting dependencies on other fusion crates like \dbt-common\ or \dbt-base\ to avoid circular dependencies.

crates/dbt-cancel · high confidence

New dbt-dag crate for dependency management and node scheduling

This change introduces the new \crates/dbt-dag\ crate, which provides core functionality for managing dbt dependency graphs and scheduling node execution. The \deps\_mgmt\ module implements graph algorithms for reversing dependencies, ensuring all nodes are defined, and performing breadth-first searches to slice dependency trees based on sink nodes or custom comparison functions. The \schedule\ module defines the \Schedule\ struct to track selected, excluded, and frontier nodes, and implements the \show\_dbt\_nodes\ method to format node lists for output in various formats (JSON, Selector, Name, Path), including specific handling for JSON output keys and the \depends\_on\ field.

crates/dbt-dag · high confidence

New dbt-frontend-common crate for shared frontend infrastructure

A new \dbt-frontend-common\ crate has been introduced to centralize shared components for the SDF frontend. This includes a structured error handling system with typed \ErrorCode\ codes, \CodeLocation\ tracking, and user-friendly name suggestions; an expression evaluation engine for parsing and evaluating arithmetic, comparison, and function calls (min, max, if); constraint resolution logic for managing variable bindings and conditions; and utilities for identifier formatting and case-sensitivity metadata. The crate also enforces its own dependency boundaries via a \deny.toml\ configuration.

crates/dbt-frontend-common · high confidence

New dbt-schemas crate provides core Rust types and schema generation

The \crates/dbt-schemas\ crate introduces the foundational Rust types and schema-generation logic for dbt. It defines the \RelationType\ enum (including new variants like \DynamicTable\, \StreamingTable\, \MetricView\, and \Dictionary\) and implements adapter-specific mapping logic for BigQuery, Databricks, and Spark. The crate also provides the \MaterializationResolver\ for multi-dispatch macro resolution, utilities for resolving quoting defaults per adapter, and the \--pre-schema\ command-line interface for generating JSON schemas for project and profile configurations.

crates/dbt-schemas/src · high confidence

New dbt-sql-utils crate for SQL parsing and splitting

A new \dbt-sql-utils\ crate has been introduced to provide core SQL parsing and statement-splitting capabilities. This library exposes a \CaseInsensitiveInputStream\ for handling case-insensitive tokenization and a \sql\_lex\_tokens\ function that lexes SQL into tokens with source spans for supported dialects (BigQuery, Databricks, Redshift, Snowflake, and Trino). It also includes utilities for splitting SQL statements, identifying empty/comment-only inputs, and handling specific Snowflake terminal flow statements, serving as a foundational component for SQL processing within the dbt ecosystem.

crates/dbt-sql/dbt-sql-utils/src · high confidence

New dbt-test-containers crate for isolated test environments

A new \dbt-test-containers\ crate has been added to provide infrastructure for running tests in isolated Docker environments. This includes Rust utilities using the \bollard\ library to build, start, and manage containers, along with specific Dockerfiles for \dbt-core\, \dbt\ (with Snowflake adapter), and \postgres\. The setup includes an entrypoint script to automate \dbt deps\ and \dbt compile\ commands, and a PostgreSQL initialization script that creates test roles and databases, enabling tests like \test\_dbt\_compile\ to run against reproducible, containerized dependencies.

crates/dbt-test-containers · high confidence

New declarative profile setup system for supported adapters

The \dbt-profile-schemas\ crate now provides a unified, declarative framework for configuring database profiles, replacing the previous per-adapter setup functions. This change introduces a generic \InteractiveSetup\ trait and a \ConfigProcessor\ that drive both interactive wizards and headless (non-interactive) profile creation. The system supports profile setup for BigQuery, ClickHouse, Databricks, DuckDB, Exasol, Fabric, Postgres, Redshift, and Snowflake, handling specific fields like authentication methods (e.g., Service Account, OAuth, Personal Access Token) and connection parameters through a consistent, condition-based field definition model.

crates/dbt-profile-schemas · high confidence

New package management and dependency resolution infrastructure

This change introduces a new Rust-based implementation for the \dbt-deps\ crate, replacing the previous logic with a modular architecture. It adds a new \dbt deps add\ command to manage \packages.yml\ entries, including parsing various package sources (Hub, Git, Tarball, Local) and handling duplicate detection. The dependency resolution flow is restructured around a \DepsOperationContext\ that manages shared clients for the Package Hub, Git hosts, and private package providers. Git package downloads now support host-specific fast paths (using GitHub's archive endpoint and GraphQL for ref resolution) alongside a generic fallback, with per-run caching for resolved references. The update also introduces Fusion compatibility checks against Package Hub metadata, configurable download verification requirements, and improved error handling and telemetry for package installation.

crates/dbt-deps · high confidence

New parse-phase Jinja environment and context infrastructure

The parse phase now uses a dedicated, typed infrastructure for building and managing the Jinja environment and contexts. A new \JinjaFactory\ trait and its \DefaultJinjaFactory\ implementation encapsulate the creation of the parse-phase Jinja environment, allowing for extensibility via extra function registration. The module introduces specific context builders: \build\_docs\_jinja\_environment\ and \build\_docs\_resolve\_context\ for documentation rendering, and \build\_resolve\_context\ and \build\_resolve\_model\_context\ for model resolution. These contexts provide typed access to globals like \ref\, \source\, \config\, and \this\, ensuring that parse-time operations have the necessary adapter and configuration data. Additionally, a new \SqlResource\ enum is introduced to explicitly track and type resources encountered during SQL and macro rendering, such as sources, refs, functions, metrics, tests, macros, docs, snapshots, and materializations, distinguishing between runtime and static analysis sources.

crates/dbt-jinja-utils/src/phases/parse · high confidence

New proc-macros for error code synchronization and config resolution

This change introduces two new procedural macros in the \dbt-proc-macros\ crate to improve configuration handling and error management. The \\#\[derive(Resolvable)\]\ macro automatically generates a \Resolved{StructName}\ type for config structs, promoting optional fields to required ones based on \\#\[resolved(promote)\]\ annotations and implementing the \ResolvedConfig\ trait to provide uniform accessors for hooks and static analysis settings. Additionally, the \\#\[include\_frontend\_error\_codes\]\ attribute macro automatically syncs error codes from the frontend crate into the CLI crate, mapping internal errors to the 9000 range to prevent manual synchronization efforts.

crates/dbt-proc-macros · high confidence

New record/replay debugging and storage infrastructure

The \adbc-record-replay\ crate now includes a \dump-recordings\ CLI tool to inspect SQLite recording files, a new \RecordReplayError\ type for structured error handling, and a migration to SQLite as the primary storage backend for recordings (with legacy file-based storage marked deprecated). The module also introduces SQL normalization logic to mask volatile identifiers (timestamps, user names, temp table suffixes) ensuring recordings are portable across environments.

crates/adbc-record-replay · high confidence

New release-pipeline tooling for PyPI and Homebrew distribution

A new \dbt-ci\ CLI is introduced to automate the creation and publication of dbt releases. It supports building per-platform Python wheels from pre-built binaries and generating a download-at-install sdist that fetches the correct wheel at install time. The tool also handles publishing to PyPI (including staging and test environments) and manages Homebrew formula rendering and publishing to a tap repository.

crates/dbt-ci/src · high confidence

New schema definitions for dbt artifacts and configuration

The \dbt-schemas\ crate now includes new Rust modules that define the typed structures and validation logic for dbt artifacts and configuration files. This adds schema support for \catalogs.yml\ (including the v2 table-driven validation), \dbt\_cloud.yml\ (for dbt Cloud project and state authentication), data tests (supporting both string and custom test forms with sequence-valued column names), and freshness rules (validating that count and period are provided together). These definitions ensure that the manifest, semantic manifest, and configuration files are parsed and serialized with strict type safety and parity with dbt-core.

crates/dbt-schemas/src/schemas · high confidence

New schema properties for analyses, checks, data tests, functions, and saved queries

The \crates/dbt-schemas/src/schemas/properties\ module now includes dedicated property structs for previously unsupported or loosely defined resource types: \AnalysesProperties\, \CheckProperties\, \DataTestProperties\, \FunctionProperties\ (with support for overloads and volatility), \SavedQueriesProperties\, and \UnitTestProperties\. These additions, alongside the existing model, metric, exposure, source, seed, snapshot, and macro property definitions, expand the schema coverage to allow dbt to parse, validate, and serialize these resource types from YAML properties files. Users can now define analyses, checks, data tests, functions, and saved queries in their project YAML with full schema-backed parsing and configuration inheritance.

crates/dbt-schemas/src/schemas/properties · high confidence

New selector parser crate for dbt YAML definitions

A new \dbt-selector-parser\ crate has been introduced to handle the parsing of \selectors.yml\ files. This component converts YAML-based selector definitions (including atoms, composite expressions, unions, intersections, and exclusions) into the internal \SelectExpression\ structures used by the scheduler, bridging the gap between the schema-defined YAML values and the runtime selection logic.

crates/dbt-selector-parser · high confidence

New telemetry span schemas for Arrow serialization

The telemetry system now includes explicit schema definitions for serializing and deserializing span events to and from Apache Arrow records. This change adds serialization logic for a wide range of event types, including artifacts, assets, dependencies, development traces, generic operations, hooks, invocations, node evaluations and processing, onboarding screens, execution phases, process information, queries, and package updates. Each event type implements the \ArrowSerializableTelemetryEvent\ trait to handle conversion to \ArrowAttributes\ and back, ensuring consistent telemetry data capture and transport. Also in this area: Add manual trait implementations for generated telemetry protocol buffers; Migrate telemetry event definitions to a new generated Protobuf module; Extensible telemetry attribute system with runtime deserialization registry; New Arrow and JSON serialization formats for telemetry data; New telemetry schemas for log events with Arrow serialization and sensitive data handling.

crates/dbt-telemetry · high confidence

New test resolution module in dbt-parser

The dbt-parser crate now includes a new \resolve\_tests\ module that handles the resolution and persistence of generic data tests and unit tests. This module introduces dedicated logic for extracting raw, unrendered test configurations from schema YAML files, computing unique IDs for generic tests to match dbt-core conventions, and resolving unit test dependencies against models. It also provides utilities for handling legacy \tests\ vs \data\_tests\ aliases and managing column-level test inheritance.

_crates/dbt-parser/src/resolve/resolve\tests · high confidence

New test utilities for golden file comparison and environment isolation

The \dbt-test-utils\ crate now provides a comprehensive task-based framework for integration testing, including golden file comparison for compiled SQL, JSON artifacts, and directory manifests, as well as utilities for managing test profiles, environment variables, and record/replay modes.

crates/dbt-test-utils · high confidence

Python adapter module structure for BigQuery, Databricks, and Snowflake

The dbt-adapter crate now exposes a Python module structure that organizes support for BigQuery, Databricks, and Snowflake into separate submodules. This change consolidates the Python-specific adapter logic for these three platforms under a single, unified module path, enabling the system to handle Python models on these specific cloud data warehouses.

crates/dbt-adapter/src/python · high confidence

Python interface for dbt artifacts schemas

Added a new Python package (\dbt.artifacts.schemas\) that provides Python dataclass representations of dbt's core artifact files (manifest, catalog, run results, and sources). These schemas mirror the Rust structs used by the dbt fusion engine, ensuring that the Python interface uses the Rust definitions as the source of truth for field names and serialization behavior (e.g., handling aliases and null-safety). This allows Python-based tools and integrations to parse and interact with dbt artifact JSON files using strongly-typed objects that align with the underlying Rust implementation.

dbt-core · high confidence

Python-compatible datetime module for Jinja templates

The \py\_datetime\ module now provides a full Python-style \datetime\ implementation in Jinja templates, including \datetime\, \date\, \time\, \timedelta\, and \timezone\ objects. Users can construct and manipulate dates and times using Python-native methods such as \strftime\ (with correct microsecond formatting), \strptime\, \fromisocalendar\, and \utcoffset\. The module supports both naive and aware datetimes, fixed-offset timezones, and \pytz\ timezones, ensuring that comparisons, arithmetic, and serialization behave consistently with Python's standard library.

_crates/dbt-jinja/minijinja-contrib/src/modules/py\datetime · high confidence

Redshift materialized view configuration support

The Redshift adapter now includes structured configuration support for materialized views. This change introduces \materialized\_view\_config.rs\ to handle Redshift-specific settings such as distribution styles (even, all, auto, or key) and sort styles (auto, compound, or interleaved), ensuring that materialized views are created with the correct distribution and sorting parameters based on model definitions.

crates/dbt-adapter/src/relation/redshift · high confidence

Redshift metadata adapter implementation

The Redshift adapter now includes a dedicated metadata module that handles relation listing and dependency tracking. It supports listing relations via SHOW TABLES when datasharing is enabled, falling back to the information schema otherwise, and parses relation dependencies using a custom SQL query against pg\_depend to support state reuse and view materialization tracking.

crates/dbt-adapter/src/metadata/redshift · high confidence

Self-hosted dbt docs v2 server with Docker support

Users can now run the next-generation dbt docs (v2) as a self-hosted service using the provided Dockerfile and docker-compose.yml. The server downloads the latest dbt binary from GitHub Releases at build time, serves the static docs site generated by \dbt docs generate\, and queries the parquet artifacts in the browser via DuckDB-WASM. This enables local preview and self-hosted deployment of the interactive docs without requiring a Node.js toolchain or external build steps.

crates/dbt-docs-server · high confidence

Static analysis engine scaffolding and project quality checks

The \dbt-tasks-sa\ crate now provides the core execution infrastructure for the static analysis engine, including a compilation pipeline, a compiled SQL cache, and a new \dbt check\ command that runs user-authored SQL queries against parse-time project metadata to validate data quality. This location also introduces the task runner foundation with barrier and cloneable task implementations for models, seeds, and snapshots, alongside context builders and debug utilities for lake compute integration. Also in this area: 6 commits (2 fixes) modifying crates/dbt-tasks-sa; 2 commits (2 fixes) fixing crates/dbt-tasks-sa; Unified adapter overlay and base context construction for run-phase nodes; Unit test coverage for CSV parsing, BigQuery typing, and incremental schema fetching; Deprecate catalogs.yml v2 code path and promote v1 as default; and 5 more.

crates/dbt-tasks-sa · medium confidence · unverified

Structured tracing integration for dbt-common

The \dbt-common\ crate now includes a comprehensive tracing module that integrates the generic \dbt-tracing\ library with dbt runtime behavior. This change introduces structured telemetry support, replacing legacy logging with a middleware and layer-based architecture. Users benefit from consistent, structured logs across the CLI, file outputs (JSONL, Parquet), and OpenTelemetry (OTLP) exports. The module provides dbt-specific convenience helpers for emitting logs and spans, manages configuration for log paths and verbosity, and ensures graceful shutdown of telemetry resources. This foundational work enables better observability, debugging, and integration with external monitoring systems.

crates/dbt-common/src/tracing · high confidence

Support for multiple Databricks Python model submission methods

The Databricks adapter now supports submitting Python models via four distinct methods: all-purpose cluster, job cluster, serverless cluster, and workflow job. Users can select the desired method using the \submission\_method\ configuration option. This change introduces a new \DatabricksApiClient\ to handle API interactions and updates the adapter's Python model submission logic to route requests appropriately based on the selected method, enabling better integration with Databricks' serverless and job-based execution environments.

crates/dbt-adapter/src/python/databricks · high confidence

dbt docs v2 UI source and build tooling added

The dbt docs v2 user interface source code is now included in the repository under \crates/dbt-docs-server/web\. This location provides the React application, a Vite build configuration that embeds the static bundle into the binary, and a development setup that serves generated artifacts via DuckDB-WASM. It also includes Storybook integration for component testing and the necessary configuration files (Tailwind, ESLint, TypeScript) to build and maintain the UI.

crates/dbt-docs-server/web · high confidence

Architecture

Extract Vortex event logging into a dedicated crate

The Vortex event logging logic has been extracted from the broader Vortex client into a new, standalone \vortex-events\ crate. This change introduces a \DiscreteEventEmitter\ trait with \NoopEventEmitter\ and \DefaultEventEmitter\ implementations, allowing the system to emit structured telemetry events (such as invocation start/end, login, and static analysis) while supporting a no-op mode for testing or disabled states. The extraction also includes a new \proto-rust-macros\ crate providing derive macros (\ProtoEnumSerde\, \ProtoNew\) to simplify serialization and construction of Protobuf message structs used by these events.

crates/vortex-events · high confidence

Extract error handling and classification types into dedicated crates

The error-handling logic and classification data shapes have been extracted from the main codebase into the new \dbt-error\ and \dbt-classification-types\ crates. \dbt-error\ centralizes the \FsError\ type, \ErrorCode\ definitions (including new codes for warn-error options like \JinjaWarnUpgradedToError\ and \ConstraintNotEnforced\), adapter error mapping, and code location tracking. \dbt-classification-types\ provides the public data shapes for classifiers (PII, finance, health) and embeds the Snowflake-specific Jinja macros (\fetch\_snowflake\_column\_tags\, \apply\_snowflake\_column\_tag\) used for tag propagation, separating these lean, compiler-free types from the proprietary engine logic.

crates/dbt-error · high confidence

Extracted in-flight SQL statement tracking into a dedicated crate

The logic for tracking and cancelling in-flight SQL queries has been moved from the existing codebase into a new, standalone \dbt-tracked-stmt\ crate. This module now provides a global registry that monitors active statements and allows the application to cancel them via tokens or by sweeping all tracked entries, ensuring that long-running queries in the wizard Explorer and dbt-index can be properly terminated.

crates/dbt-tracked-stmt · high confidence

Extracted pretty-table formatting logic into a standalone crate

The \pretty\_table.rs\ module has been moved from \dbt-common\ into a new, independent \dbt-pretty-table\ crate. This change decouples the data formatting and display logic (supporting Table, CSV, TSV, JSON, YAML, and other formats) from the core common library, preventing circular dependencies and allowing the formatting utilities to be used independently. The new crate includes its own error types and dependency constraints to ensure it does not rely on \dbt-common\ or \dbt-error\.

crates/dbt-pretty-table · high confidence

Extracted terminal progress bar controller to a separate crate

The terminal progress bar logic has been moved into a new, standalone \dbt-tui-progress\ crate. This provides a thread-safe \ProgressController\ that wraps \indicatif\ to manage multiple concurrent progress bars and spinners, featuring generic ID types for decoupling identity from display text, a background ticker thread for animations, and support for suspending output to cleanly interleave log messages with progress indicators.

crates/dbt-tui-progress · high confidence

Introduce dbt-base utility crate and source-available clap-based CLI parser

This change introduces the \dbt-base\ crate, providing shared utility types including a \CancellationToken\ system for cancellable operations and a \MaybeStableHasher\ that ensures deterministic hashing in debug builds while maintaining DDoS resistance in release builds. It also replaces the previous CLI parsing infrastructure with a new source-available, clap-based parser in \dbt-clap-core\, which defines the core command set (Init, Run, Build, etc.) and maps them to internal execution commands.

crates/dbt-clap-core · high confidence

Introduce dbt-compilation crate for structured compilation pipeline

The new \dbt-compilation\ crate centralizes the dbt compilation logic, providing a structured pipeline for loading, resolving, and compiling projects. It introduces \CompilationConfig\ to manage build cache scheduling and command caching, and \DbtLoadedProject\ to encapsulate the loaded state with adapter and type-operation factories. The crate exposes traits like \CompilationDriver\ and \TaskExecutionDriver\ to standardize how projects are compiled and tasks are executed, while \SchemaHydration\ and \Schedule\ modules handle schema fetching and node selection logic. This refactors the compilation process into a reusable, testable component within the \dbt-compilation\ location.

crates/dbt-compilation/src · high confidence

Introduce dbt-main as the new core execution engine

The \crates/dbt-main\ crate now serves as the central execution engine for dbt, consolidating the CLI entrypoint, compilation pipeline, task execution, and graceful shutdown handling. This change introduces a structured \CompilationPhasesExecutor\ to manage the project load, validation, and compilation phases, and implements a robust Ctrl+C and fail-fast cancellation mechanism via \run\_future\_with\_ctrlc\_support\ that actively cancels tracked database statements. The module also provides the \run\_freshness\_command\ for executing source freshness checks and a \RetryState\ implementation that parses previous \run\_results.json\ to identify and re-execute failed nodes while preserving original command flags like \--full-refresh\. Additionally, it includes logic for handling self-managed vs. package-managed binary uninstallation and initializes the underlying Tokio runtime with configurable thread pools and stack sizes.

crates/dbt-main · high confidence

Introduce dbt-tasks-core crate with run-cache, lake compute, and schema inference foundations

This change establishes the new \dbt-tasks-core\ crate, extracting core task execution infrastructure from \dbt-tasks\ to serve as a shared foundation. It introduces the \TaskRunnerCtx\ and \TaskRunnerCtxFactory\ to manage the runtime context for task execution, including integration with the gRPC run-cache service for dbt State features (defer-to, speculative submits, and telemetry). It also adds extension points for Lake Compute diagnostics (\LakeComputeCatalogAttachChecker\, \LakeComputeMdlsChecker\, \LakeComputePropagationChecker\) to validate credentials and catalog visibility during \dbt debug\, and implements local schema inference for sources with \schema\_origin: local\ by building Arrow schemas from YAML column definitions.

crates/dbt-tasks-core/src · high confidence

Introduce the FeatureStack architecture for dependency injection

The \dbt-features\ crate now defines a \FeatureStack\ that acts as the central dependency graph for the application, consolidating services such as CLI, adapter, tracing, task runner, and lake compute into a single injectable object. A \FeatureStackBuilder\ is provided to construct this stack with default implementations, and individual feature modules (e.g., \adapter\, \cli\, \index\) expose typed slots for their respective services, replacing previous ad-hoc or global dependency patterns.

crates/dbt-features/src · high confidence

New parser resolution module for dbt resource types

The \crates/dbt-parser/src/resolve\ module has been introduced to centralize the resolution logic for dbt resource types. This new location now contains dedicated modules for resolving analyses, checks, exposures, functions, groups, macros, metrics, models, operations, properties, query comments, saved queries, seeds, selectors, semantic models, snapshots, sources, and tests, along with utilities for primary key inference and YAML field pre-processing. This structural change organizes the parsing and resolution of these resources into a single, cohesive location within the parser crate.

crates/dbt-parser/src/resolve · high confidence

dbt-loader source code restructured into new modular crate

The \crates/dbt-loader/src\ directory has been reorganized into a set of distinct modules (\args\, \clean\, \deps\, \loader\, \load\_profiles\, \load\_vars\, \load\_packages\, \cloud\_http\_client\, \upload\_artifact\_ingest\, etc.) that collectively implement the project loading, dependency resolution, profile management, and artifact upload workflows. This change introduces a dedicated \LoadArgs\ structure to centralize CLI and configuration inputs, separates the \dbt deps\ execution logic into its own module to handle package installation without requiring a profile, and moves cloud-specific HTTP client and artifact upload logic into separate files to decouple them from the core loader.

crates/dbt-loader/src · high confidence

Behavioural changes

1 commit (0 fixes) modifying crates/dbt-docs-server

A change to existing behaviour in crates/dbt-docs-server — 1 commit, 17 files: “\[docs v2\] export DuckDB data layer from docs library package”.

crates/dbt-docs-server/web/tests · medium confidence · unverified

1 commit (0 fixes) modifying crates/dbt-pse

A change to existing behaviour in crates/dbt-pse — 1 commit, 24 files: “move pse to oss”.

crates/dbt-pse · medium confidence · unverified

2 commits (0 fixes) modifying crates/dbt-artifact-download

A change to existing behaviour in crates/dbt-artifact-download — 2 commits, 1 file: “\[RD-1307926\]: Make artifact account filters optional”; “\[ORC-4251\] Add binary-only private S3 downloads to Fusion updater”.

crates/dbt-artifact-download · medium confidence · unverified

2 commits (0 fixes) modifying crates/dbt-docs-server/web/src/proto

A change to existing behaviour in crates/dbt-docs-server/web/src/proto — 2 commits, 63 files: “RD-1308030: carry the blocking run ID and show it in the Waiting log line”; “Remove dbt protos dependency”.

crates/dbt-docs-server/web/src/proto · medium confidence · unverified

2 commits (1 fix) modifying crates/dbt-lease

A change to existing behaviour in crates/dbt-lease — 2 commits (1 fix), 2 files: “Complete lake compute auth via JWT and PAT w/ local caching and debug diagnostics”; “Review the dbt-lease implementation, its use in pat\_cache.rs and fix the racy unit tests”.

crates/dbt-lease · medium confidence · unverified

20 commits (5 fixes) modifying crates/dbt-adapter/src/metadata/clickhouse

A change to existing behaviour in crates/dbt-adapter/src/metadata/clickhouse — 20 commits (5 fixs), 1 file: “Migrate all minijinja and database work to the dbt-runtime thread pool”; “\[ClickHouse\] New ADBC driver changes: \?\ character fix, change default database, add connection settings”; “\[ClickHouse\] add get catalog macros to unblock \compile --write-catalog\”; and 17 more (refs \#10388, \#9869).

crates/dbt-adapter/src/metadata/clickhouse · medium confidence · unverified

21 commits (6 fixes) modifying crates/dbt-adapter-engine

A change to existing behaviour in crates/dbt-adapter-engine — 21 commits (6 fixs), 27 files: “dbt-adapter-engine: Review the crate and modularize large sub-modules”; “test(duckdb): record seed type rendering gaps for nested and unsigned columns”; “fix(duckdb): render DuckDB lists, structs and unsigned integers as DuckDB types”; and 18 more.

crates/dbt-adapter-engine · medium confidence · unverified

3 commits (0 fixes) modifying crates/dbt-docs-server/dbt-docs-lib

A change to existing behaviour in crates/dbt-docs-server/dbt-docs-lib — 3 commits, 325 files: “Migrate docs lineage components to shared dbt-docs-lib package”; “\[docs v2\] Migrate shared docs components to dbt-docs-lib”; “\[docs v2\] export DuckDB data layer from docs library package”.

crates/dbt-docs-server/dbt-docs-lib · medium confidence · unverified

3 commits (0 fixes) modifying crates/dbt-goldie

A change to existing behaviour in crates/dbt-goldie — 3 commits, 1 file: “replace deps (part 1)”; “Add \cargo xtask apply-ci-goldies\ command”; “replace deps (part 2): Use similar and similar-asserts instead of diffy and pretty\_assertions, dialoguer instead of inquire”.

crates/dbt-goldie · medium confidence · unverified

3 commits (1 fix) modifying crates/dbt-dist-classify

A change to existing behaviour in crates/dbt-dist-classify — 3 commits (1 fix), 3 files: “fix(wizard): discover dbt on Windows”; “Rename CLI branding from Fusion to dbt v2 (GAP-2086)”; “chore(wizard): remove the freeze check and stale Wizard references”.

crates/dbt-dist-classify · medium confidence · unverified

4 commits (0 fixes) modifying crates/dbt-flags

A change to existing behaviour in crates/dbt-flags — 4 commits, 5 files: “Add dbt-flags feature flag registry and --feature”; “RD-1308029: add the DBT\_ENGINE\_LOCK\_WITH\_STATE gate for dbt State runs”; “docs(plan): the Phase 2 design”; and 1 more.

crates/dbt-flags · medium confidence · unverified

5 commits (0 fixes) modifying crates/dbt-adapter/src/metadata/spark

A change to existing behaviour in crates/dbt-adapter/src/metadata/spark — 5 commits, 1 file: “Use Arc\<Column\> to avoid Column::clones everywhere”; “security(adapter): escape metadata relation names”; “Microsoft Fabric Lakehouse support as a spark platform flavor”; and 2 more.

crates/dbt-adapter/src/metadata/spark · medium confidence · unverified

5 commits (1 fix) modifying crates/dbt-state/proto/query\_cache\_protobuf/query\_cache

A change to existing behaviour in crates/dbt-state/proto/query\_cache\_protobuf/query\_cache — 5 commits (1 fix), 3 files: “chore(dbt-state): update protobuf definitions to match upstream”; “chore(state): Sync protobuf definitions with upstream \fivetran/query-cache@9a35e116\”; “mv fs/sa/crates/dbt-run-cache fs/sa/crates/dbt-state”; and 2 more.

_crates/dbt-state/proto/query\_cache\_protobuf/query\cache · medium confidence · unverified

51 commits (20 fixes) modifying .changes/unreleased

A change to existing behaviour in .changes/unreleased — 51 commits (20 fixs), 49 files: “fix(bigquery): resolve seed files from the package root”; “\[ClickHouse\] Accept the ClickHouse table options on seeds, snapshots and tests”; “Support Iceberg snapshot configuration”; and 48 more (refs \#5016, \#4743, \#5490, \#16323).

.changes/unreleased · medium confidence · unverified

9 commits (1 fix) modifying crates/dbt-state/proto/query\_cache\_protobuf/query\_cache/services

A change to existing behaviour in crates/dbt-state/proto/query\_cache\_protobuf/query\_cache/services — 9 commits (1 fix), 8 files: “chore(dbt-state): update protobuf definitions to match upstream”; “feature(dbt-state): Implement ignore\_external\_modifications”; “feat(dbt-state): speculative submit while dependency prefetch is in flight”; and 6 more.

_crates/dbt-state/proto/query\_cache\_protobuf/query\cache/services · medium confidence · unverified

A new symbolic link named 'skills' has been added to the .claude directory, pointing to the ../.agents/skills directory. This change establishes a local reference to the agents' skills configuration within the .claude scope.

.claude · high confidence

Align as\_bool filter behavior with dbt-core

The \as\_bool\ Jinja filter in the dbt-jinja-filters crate now acts as an identity pass-through, returning the input value unchanged. This change ensures that string values like \"true"\ remain as strings rather than being coerced to booleans, matching the behavior of dbt-core where \as\_bool\ only coerces types during native value rendering, not when rendering text or SQL. This prevents unexpected type conversions in configurations and macro outputs.

crates/dbt-jinja-filters · high confidence

BigQuery Python job submission logic moved to dedicated module

The BigQuery adapter now handles Python job submission (Cluster, Serverless, and BigFrames methods) through a new dedicated module in the dbt-adapter crate. This change centralizes the logic for configuring and executing Python jobs via GCS and Dataproc/BigFrames, ensuring that required profile settings like \compute\_region\ and \gcs\_bucket\ are validated before job execution.

crates/dbt-adapter/src/python/bigquery · high confidence

BigQuery adapter metadata operations migrate to AdapterEngine with structural fixes

The BigQuery metadata adapter has been refactored to delegate connection and relation listing operations to the new AdapterEngine, replacing the previous direct adapter implementation. This change introduces a fallback mechanism for cross-project listings to ensure correct relation discovery when the ADBC driver returns empty results. Additionally, a new nested projection module now generates explicit SQL aliases for BigQuery STRUCT and ARRAY columns to prevent positional misalignment, and object options handling now correctly escapes Unicode characters in descriptions to match Python JSON standards.

crates/dbt-adapter/src/metadata/bigquery · high confidence

BigQuery relation configuration migrated to the v2 component system

The BigQuery adapter now manages relation settings—such as clustering, partitioning, labels, tags, KMS encryption keys, descriptions, and materialized view refresh policies—using the new Relation Config v2 component framework. This change centralizes how these attributes are loaded from both local dbt model configurations and remote table schemas, ensuring consistent diffing and Jinja rendering for BigQuery-specific features.

crates/dbt-adapter/src/relation/bigquery/config/components · high confidence

Centralize dbt Cloud configuration resolution and enforce explicit project linking

The dbt-cloud-config crate now centralizes how dbt Cloud credentials and settings are resolved, applying a strict precedence order: environment variables (e.g., DBT\_CLOUD\_TOKEN, DBT\_CLOUD\_PROJECT\_ID) override settings in dbt\_project.yml, which in turn override the global dbt\_cloud.yml file. A key behavioral change is that dbt platform features now require an explicit project link in dbt\_project.yml; the system no longer falls back to the global active\_project from dbt\_cloud.yml, preventing credential leakage into unlinked projects. Additionally, the crate introduces support for resolving defer\_job\_id, state\_org\_id, and job\_id from both environment variables and project configurations, while adding validation to detect and report mismatches between configured project IDs and available credentials.

crates/dbt-cloud-config · high confidence

Centralized SQL keyword lists for multiple database dialects

The \dbt-sql-keywords\ crate now provides a unified, centralized source of reserved and non-reserved SQL keywords for BigQuery, BigQuery (untyped), Databricks, DuckDB, Exasol, MS SQL, Redshift, Snowflake, and Trino. This change replaces scattered keyword definitions with a single library that exposes dialect-specific keyword lists (including reserved, strict non-reserved, and non-reserved categories) and provides an efficient, allocation-free binary search function for case-insensitive keyword lookups, ensuring consistent parsing behavior across all supported database adapters.

crates/dbt-sql-keywords/src · high confidence

Databricks metadata retrieval now uses DESCRIBE TABLE EXTENDED AS JSON with version-gated capabilities

The Databricks adapter now retrieves relation metadata via the \DESCRIBE TABLE EXTENDED ... AS JSON\ command instead of querying \information\_schema\, significantly reducing the number of metadata round-trips. This change introduces a new capability system (\dbr\_capabilities.rs\) that gates features like \InsertByNameReplaceWhere\ (DBR 18.0+), \Iceberg\ (DBR 14.3+), and \CommentOnColumn\ (DBR 16.1+) based on the Databricks Runtime version or SQL Warehouse context. The adapter also adds support for parsing row filters, column masks, and the VOID column type from the new JSON metadata format.

crates/dbt-adapter/src/metadata/databricks · high confidence

Databricks relation configuration components migrated to config\_v2

The Databricks adapter's relation configuration logic has been restructured into a modular component system under \config\_v2\. This change introduces dedicated modules for managing specific table properties and metadata, including column comments, column masks, column tags, constraints, liquid clustering, partitioning, and view queries. By implementing a standardized \ComponentConfig\ interface with diffing and Jinja serialization capabilities, the adapter now handles these configurations more consistently, ensuring that changes to column-level security (masks/tags), data organization (clustering/partitioning), and integrity (constraints) are correctly detected and applied during model runs.

crates/dbt-adapter/src/relation/databricks/config/components · high confidence

Databricks relation configuration is restructured into granular component loaders

The Databricks adapter now manages relation configurations (for incremental tables, materialized views, metric views, streaming tables, and views) using a new modular component-based system. Instead of monolithic configuration handling, each relation type is defined by a specific set of loaders (e.g., LiquidClusteringLoader, RefreshLoader, ColumnMasksLoader) that individually track changes to properties like clustering, refresh schedules, column masks, and tags. This change ensures that updates to specific components (such as changing a refresh cron or column tags) are detected precisely, allowing the adapter to determine accurately whether a full refresh is required or if the change can be applied incrementally, thereby improving efficiency and reducing unnecessary downtime for Databricks models.

_crates/dbt-adapter/src/relation/databricks/config/relation\types · high confidence

DuckDB adapter bundled with dbt-loader now supports catalogs v2, Iceberg, and advanced incremental strategies

The bundled dbt-duckdb adapter has been updated to support dbt-core v2 catalogs v2, enabling routing to external data sources like AWS Glue and Iceberg REST catalogs. This change introduces new materializations for external files (parquet, JSON, CSV) and a dedicated microbatch incremental strategy that processes data by time windows. It also adds comprehensive support for complex MERGE operations with custom clauses, improved schema change detection for incremental models, and fixes for multi-statement incremental batches and catalog metadata generation.

_crates/dbt-loader/src/dbt\_macro\assets/dbt-duckdb · high confidence

Extracted dbt Jinja variable and environment handling into a standalone crate

The \dbt-jinja-vars\ crate has been introduced to centralize dbt Jinja variable resolution and environment variable access. This change provides the \var()\ and \env\_var()\ Jinja functions, along with \ConfiguredVar\ for package-specific variable namespaces. It ensures that CLI-provided YAML variables (including dates and nulls) are correctly converted to Jinja objects and that environment variables starting with \DBT\_ENV\_SECRET\ or \\_DBT\ are handled according to dbt's security and placeholder rules.

crates/dbt-jinja-vars · high confidence

Implement legacy catalog.json schema and generation logic

The \legacy\_catalog\ module now defines the Rust structs for the dbt \catalog.json\ format (including metadata, table/column stats, and node information) and provides the \build\_catalog\ function to assemble this data. This implementation constructs the catalog by merging resolver state with node statistics, specifically ensuring that fully qualified relation names are consistently lowercased when joining catalog entries to support accurate lookups across models, snapshots, seeds, and tests.

_crates/dbt-schemas/src/schemas/legacy\catalog · high confidence

Introduce ParseAdapterState to track adapter calls during parsing

The dbt-adapter now maintains a dedicated \ParseAdapterState\ in the parse phase to record calls to \get\_relation\ and \get\_columns\_in\_relation\. This allows the system to track which relations and columns are accessed during parsing, enabling better handling of dangling sources and ensuring that relation metadata is correctly populated for nodes that rely on introspection.

crates/dbt-adapter/src/parse · high confidence

Introduce adapter-specific column type handling via ColumnBuilder

The \dbt-adapter\ crate now uses a \ColumnBuilder\ to construct column metadata with logic specific to each database adapter (e.g., Snowflake, BigQuery, Databricks, ClickHouse). This change ensures that type strings, nullability, and precision/scale details are generated correctly for each backend, replacing previous generic handling. For example, ClickHouse-specific wrapper stripping and BigQuery-specific column modes are now explicitly supported in the type resolution pipeline.

crates/dbt-adapter/src/column · high confidence

Introduce compile-time config and node context modules

Added new \compile\_config.rs\ and \compile\_node\_context.rs\ modules to the \dbt-jinja-utils\ crate to manage Jinja context during the compile phase. The \CompileConfig\ object now implements \config.get\ and \config.require\ to check the \meta\ dictionary for custom config keys, emitting deprecation warnings that direct users to use \config.meta\_get\ or \config.meta\_require\ instead. The \compile\_node\_context\ module provides the \build\_compile\_node\_context\ function to construct the Jinja environment for models, including logic to resolve \model.path\ relative to resource roots and configure dependency validation for refs.

crates/dbt-jinja-utils/src/phases/compile · high confidence

Introduce dbt-sa-cli as the new CLI entry point

The \crates/dbt-sa-cli/src/main.rs\ file establishes the new \dbt-sa-cli\ binary entry point, replacing previous initialization logic. This change wires up the CLI using \dbt\_clap\_core\ and \dbt\_features\, explicitly configuring tracing via \FsTraceConfigBuilder\ (with query logs always enabled) and initializing the \FeatureStack\ with anonymous usage stats. It also introduces error handling that prints trimmed errors and exits on tracing initialization failure, marking a structural shift in how the CLI bootstraps its core components.

crates/dbt-sa-cli/src · high confidence

Introduce local OSS equivalents for dbt-dag icons, types, and layout logic

The docs v2 UI no longer depends on the external \@dbt-labs/dbt-dag\ package for resource-type icons, type definitions, and lineage layout. This location provides the local replacements: \resourceType.tsx\ defines the \ResourceType\ union, color palettes, and labels; \accessLevel.tsx\ supplies the \AccessLevelIcon\ component; \dagreLayout.ts\ implements the custom rank-alignment logic for the lineage graph; and \fileTree.tsx\ handles the file-tree structure. These modules are accompanied by comprehensive test suites (\resourceType.test.ts\, \dagreLayout.test.ts\, \fileTree.test.ts\, \accessLevel.tsx\ tests) that verify the new behavior.

crates/dbt-docs-server/web/src/lib · high confidence

Introduce structured tracing formatters for CLI output

The CLI output system has been migrated from legacy direct logging to a new structured tracing formatter module. This change introduces dedicated formatters for all major run components—including node execution, hooks, dependencies, phases, and query logs—ensuring consistent, color-coded, and aligned terminal output. Users will see standardized progress messages, execution summaries, and error reporting that align with the new tracing infrastructure, while legacy progress bar calls and direct log statements have been removed in favor of these structured events.

crates/dbt-common/src/tracing/formatters · high confidence

Introduce typed Jinja contexts and secure secret rendering for the load phase

The load phase now uses a dedicated \LoadCtx\ to provide strongly-typed Jinja variables (such as \env\_var\, \var\, and \target\) instead of generic maps. Additionally, environment variable access is now handled via a \secret\_renderer\ that replaces sensitive values with placeholders during initial rendering and resolves them securely later, preventing accidental exposure of secrets in logs or intermediate states.

crates/dbt-jinja-utils/src/phases/load · high confidence

Introduce typed run-phase Jinja context and config handling

The run phase now uses a dedicated \RunConfig\ object and typed \RunNodeCtx\ to manage Jinja context during execution. \config.get\ and \config.require\ now check the \meta\ dictionary for keys not found in the main config, emitting a deprecation warning that directs users to use \config.meta\_get\ or \config.meta\_require\ instead. The \model\ and \node\ objects are now backed by \LazyModelWrapper\, and column data types are normalized based on the adapter type (e.g., handling \alias\_types\ for contracts). Additionally, \pre\_hook\ and \post\_hook\ are correctly exposed in the run context, supporting both underscored and hyphenated YAML keys.

crates/dbt-jinja-utils/src/phases/run · high confidence

Introduces legacy warn-error option support in dbt-common

The \dbt-common\ crate now includes a new \warn\_error\_options\ module that defines legacy dbt-core event names (such as \JinjaLogWarning\, \RunResultWarning\, and various deprecation warnings) and categorizes them into supported, not-yet-supported, and will-not-support groups. This change enables the system to parse, validate, and resolve \warn-error-options\ configurations using legacy event names alongside new Fusion-specific error codes and groups, ensuring backward compatibility for users migrating their warning configurations.

_crates/dbt-common/src/warn\_error\options · high confidence

Introduces structured compile and run Jinja contexts with deferred relation support

The \dbt-jinja-utils\ crate now provides a new \compile\_and\_run\_context\ module that establishes a shared base context for both compile and run phases, replacing ad-hoc context construction. This change introduces \CompileBaseCtx\ and \OperationCtx\ types to manage Jinja environment variables consistently, including support for \--defer --state\ via the \defer\_nodes\ parameter which populates \defer\_relation\ on graph nodes. The module also exposes \MacroLookupContext\ for macro resolution, integrates \ResultStore\ for load/store operations within Jinja, and ensures \dbt\_metadata\_envs\ are correctly populated from environment variables. Additionally, it provides backward-compatible shims like \build\_operation\_context\_btreemap\ to ease migration for existing callers.

crates/dbt-jinja-utils/src/phases · high confidence

Manifest schema updated to v12 with expanded node types and serialization improvements

The manifest schema has been upgraded from v10/v11 to v12, introducing support for new resource types including functions, saved queries, and operations, while removing legacy unit test structures. This change adds dedicated schema definitions for BigQuery partition configurations, defer relations, and semantic models, and aligns serialization with dbt-core by ensuring resource types are always included in node output. The update also improves manifest size and performance through streaming serialization and the omission of unset adapter-specific config fields.

crates/dbt-schemas/src/schemas/manifest · high confidence

New adapter engine module with ADBC execution and DuckDB catalog support

The adapter engine logic has been reorganized into a new \src/engine/\ module, introducing the \AdbcEngine\ trait and implementation to handle database interactions via the ADBC driver. This change adds support for DuckDB v2 catalogs (including DuckLake and Iceberg REST) through new attach statement composition, and implements widened Arrow \Utf8View\/\BinaryView\ concatenation to prevent panics on large query results. It also includes Databricks-specific features such as per-model compute routing and query tag injection, along with a \NoopConnection\ for mock/replay modes. Also in this area: 5 commits (3 fixes) fixing crates/dbt-adapter; 6 commits (2 fixes) modifying crates/dbt-adapter; Deprecate catalogs.yml v2 code path and promote v1 as default; BigQuery adapter fixes and configuration support.

crates/dbt-adapter/src/engine · medium confidence · unverified

New error-conversion utilities for DataFusion integration

The \dbt-datafusion-errors\ crate now provides explicit conversion functions (\fs\_error\ and \datafusion\_error\) and extension traits (\DatafusionResultExt\ and \FsResultExt\) to translate between DataFusion's native error types and the platform's internal \FsError\ model. This allows code interacting with DataFusion to safely map execution, schema, and I/O errors into user-friendly internal error codes while preserving the original DataFusion error as a cause, facilitating a cleaner separation of concerns between the frontend and the DataFusion execution layer.

crates/dbt-datafusion-errors · high confidence

New project configuration schema and config tree resolution

The project configuration parsing has been restructured to use a new \DbtProjectConfig\ tree that resolves settings by fully qualified name (FQN) rather than file path, allowing more accurate configuration inheritance for nodes like exposures, unit tests, and sources. This change introduces support for new node types including checks, skills, functions, and saved queries in the project manifest, and enforces stricter validation by restricting \target-path\ and \log-path\ to their default values (\target\ and \logs\) while disallowing \+\-prefixed resource paths in configuration trees.

crates/dbt-schemas/src/schemas/project · high confidence

New structured tracing output layers for file logs, JSON compatibility, and TUI

The \dbt-common\ tracing subsystem now includes dedicated consumer layers for structured output: a \FileLogLayer\ that writes timestamped, severity-prefixed log lines to files; a \JsonCompatLayer\ that emits events in a format compatible with dbt-core structured JSON logs for backward compatibility; a \QueryLogLayer\ for dedicated SQL query logging; and a \TuiLayer\ that manages terminal progress bars and console output. These layers replace legacy direct logging calls, ensuring consistent, structured telemetry across file, JSON, and interactive terminal consumers.

crates/dbt-common/src/tracing/layers · high confidence

New tracing middleware pipeline for telemetry and error handling

The tracing subsystem in dbt-common now uses a composable middleware pipeline to process logs and spans. This introduces several behavioral changes: the \warn\_error\_options\ middleware now enforces \--warn-error\ settings and can silence or upgrade warnings to errors; the \markdown\_log\_filter\ downgrades error logs originating from Markdown files to warnings; the \parse\_error\_filter\ adjusts parsing error severity based on beta environment variables and aggregates repeated deprecation warnings from packages; the \node\_warn\_outcome\ middleware automatically marks nodes as having warnings when warn-level logs are emitted; and the \metric\_aggregator\ collects node outcome counts (success, warning, error, skipped, etc.) into invocation-level metrics.

crates/dbt-common/src/tracing/middlewares · high confidence

Redesigned install and uninstall scripts with improved reliability and package selection

The Unix (install.sh, uninstall.sh) and Windows (install.ps1, uninstall.ps1) installation scripts have been rewritten to improve robustness and user control. The Unix installer now automatically installs the jq dependency if it is missing, supports selecting specific packages via the --package flag (dbt, dbt-lsp, or all), and performs atomic binary replacement during updates to prevent corruption. The Windows installer has been refactored to support the --package flag and includes fixes to prevent overwriting existing PowerShell profiles. Both uninstall scripts now support targeted removal of specific components (dbt, dbt-lsp, dbt-db-runner) and handle cases where the main binary has been renamed.

crates/dbt-common/assets · high confidence

Redshift adapter bundled macros now support datasharing, grants, and materialized views

The bundled macros for the Redshift adapter have been updated to support datasharing features, including the use of SHOW COLUMNS, SHOW GRANTS, and SHOW SCHEMAS APIs for cross-database object discovery and permission management. Grants now support groups and roles via extended grant handling, and the catalog generation has been enhanced to include extended table statistics from SVV views. Additionally, the adapter now fully supports materialized views, including creation, alteration, and refresh operations, as well as scalar function materializations and improved incremental model strategies.

_crates/dbt-loader/src/dbt\_macro\assets/dbt-redshift · high confidence

Redshift lexer regenerated for ANTLR 4.13.2 and dbt-antlr4 v2.0

The Redshift SQL lexer has been regenerated to support the updated ANTLR 4.13.2 runtime and the dbt-antlr4 v2.0 framework. This update refreshes the generated lexer code, token definitions, and interpreter files, ensuring compatibility with the new parser infrastructure while maintaining support for Redshift-specific syntax such as POSIX regex operators and dollar-quoting.

crates/dbt-sql/dbt-lexer-redshift · high confidence

Refactored config inheritance with explicit Omissible fields and DefaultTo trait

The project configuration system now uses a new \Omissible\<T\>\ type and \DefaultTo\ trait to distinguish between fields that were not specified in YAML and those explicitly set to null. This change ensures that an explicit null value in a child config overrides a parent's value, whereas an omitted field inherits from the parent. The \\#\[derive(DefaultTo)\]\ macro automates this inheritance logic across all config structs, and specific merge semantics (like union-merge for tags or deep-merge for docs) are handled by custom implementations. This provides more predictable and explicit configuration inheritance behavior for users.

crates/dbt-schemas/src/schemas/project/configs · high confidence

Rust implementation of relation schemas and quoting defaults

The \crates/dbt-schemas/src/schemas/relations\ module has been implemented in Rust, introducing the core data structures for database relations (such as \BaseRelation\, \RelationPattern\, and \Policy\) and establishing adapter-specific quoting defaults. This change defines how identifiers, schemas, and databases are quoted for each adapter type, ensuring that Snowflake and Lake Compute leave identifiers unquoted by default while other adapters quote them, and includes tests to verify these defaults are applied correctly.

crates/dbt-schemas/src/schemas/relations · high confidence

Schema store now uses epoch-append Parquet files instead of per-entry files

The schema store in \crates/dbt-schema-store\ has replaced its legacy per-entry file storage with an epoch-append Parquet cache. Schemas are now persisted in \target/private/metadata/compile/schemas/\ for local analysis and \target/private/metadata/warehouse/schemas/\ for remote sources. This change improves performance by loading all epochs at startup and writing a new epoch file at the end of each run, while ensuring thread safety through atomic writes and providing TTL-based eviction for warehouse-fetched schemas.

crates/dbt-schema-store · high confidence

Snowflake dynamic and interactive table config handling is rewritten for accuracy and stability

The Snowflake adapter now uses a new \config\_v2\ component system to manage dynamic and interactive table settings, replacing the previous approach to prevent spurious changes and refreshes. This update introduces precise diffing for \cluster\_by\ (ignoring Snowflake's \LINEAR\ prefix and case differences), \refresh\_mode\ (defaulting to \AUTO\ and ignoring changes when set to \AUTO\), and \snowflake\_warehouse\ (case-insensitive comparison with proper quote handling). It also adds support for \copy\_grants\, \immutable\_where\, \initialize\, and \row\_access\_policy\ configurations. For interactive tables, the system now correctly handles \target\_lag\-dependent warehouse requirements, dropping inert warehouse settings on static tables to avoid unnecessary \ALTER\ statements, and validates that \transient=true\ is rejected as it is not supported for interactive tables.

crates/dbt-adapter/src/relation/snowflake/config · high confidence

Snowflake dynamic table configuration migrated to config\_v2

The Snowflake adapter now uses the new config\_v2 component system to manage dynamic table settings, replacing the previous implementation. This change introduces dedicated components for key configuration attributes including cluster\_by, copy\_grants, immutable\_where, initialize, refresh\_mode, scheduler, and various warehouse settings (snowflake\_warehouse, refresh\_warehouse, initialization\_warehouse). The migration includes improved handling of Snowflake-specific behaviors such as case-insensitive warehouse name comparison, proper parsing of cluster expressions with balanced parentheses, and correct inference of scheduler state from target\_lag presence. Interactive table warehouse handling has been separated to account for different requirements between static and self-refreshing tables.

crates/dbt-adapter/src/relation/snowflake/config/components · high confidence

Switch Snowflake metadata warehouse once per connection instead of per query

The Snowflake adapter now optimizes metadata queries by switching to a dedicated metadata warehouse only once when a physical connection is established, rather than re-issuing the switch before and after every individual query. This change reduces connection overhead and improves performance for batch metadata operations, such as source freshness checks and catalog downloads, by ensuring the warehouse context is maintained for the lifetime of the connection within a worker thread.

crates/dbt-adapter/src/metadata/snowflake · high confidence

Typed Jinja context structs replace BTreeMap-based context construction

The Jinja context layer now uses composable, typed structs (such as LoadCtx, ResolveBaseCtx, CompileBaseCtx, and RunNodeCtx) instead of the historical pattern of constructing per-phase BTreeMap\<String, MinijinjaValue\> maps. This change ensures that every value available to Jinja templates across the load, resolve, compile, and run phases is defined by a specific struct whose field names drive the Jinja keys via serde serialization. Object identity for callable Jinja values (like ref, source, and config) is preserved through a new JinjaObject wrapper that leverages minijinja's VALUE\_HANDLES round-trip, allowing these callables to survive serialization intact. Additionally, a lightweight AdapterHandle trait has been introduced in a new dbt-handles crate to share dyn-trait handles between dbt-jinja-ctx and adapter crates without pulling in heavy dependencies like arrow or parquet.

crates/dbt-jinja-ctx · high confidence

UI components migrated from Sourdough to Radix and Lucide icons

The UI component library in the docs v2 interface has been rebuilt using Radix primitives and lucide-react icons, replacing the previous Sourdough-based implementation. This migration updates core elements including Button, Badge, Card, Input, Table, and Collapsible, while also introducing a new Shiki-based CodeSnippet for syntax highlighting and a non-virtualized PaginatedFileTree. Users will see consistent styling and behavior across these controls, with improved accessibility and performance, as the underlying UI foundation shifts to the Radix ecosystem.

crates/dbt-docs-server/web/src/components/ui · high confidence

Updated BigQuery and Trino lexer generated files

The generated lexer source files for BigQuery and Trino have been regenerated, updating the token definitions and internal representations to match the current grammar specifications. This ensures the SQL parsers correctly recognize keywords and syntax constructs for these dialects.

crates/dbt-sql/dbt-lexer-bigquery · medium confidence

Updated Databricks SQL lexer to ANTLR 4.13.2

The Databricks SQL lexer has been regenerated using ANTLR 4.13.2, introducing updated token definitions and internal structures for parsing Databricks SQL dialects. This change ensures the lexer remains compatible with the latest grammar specifications and improves the underlying parsing infrastructure for SQL tokenization.

crates/dbt-sql/dbt-lexer-databricks · high confidence

Updated Snowflake lexer to use dbt-antlr4 v2.0

The Snowflake SQL lexer has been regenerated using the dbt-antlr4 library version 2.0 (specifically targeting ANTLR 4.13.2). This update replaces the previous lexer implementation, ensuring that token definitions and parsing logic for Snowflake-specific syntax are aligned with the new ANTLR runtime. Users benefit from consistent token handling for Snowflake keywords and operators within the SQL parsing pipeline.

crates/dbt-sql/dbt-lexer-snowflake · high confidence

Updated syntax highlighting assets for ABAP, ActionScript 3, and Ada

The web distribution now includes updated syntax highlighting definition files for ABAP, ActionScript 3, and Ada. These changes ensure that code snippets within the documentation interface are correctly parsed and displayed with proper language-specific styling and structure.

crates/dbt-docs-server/web/dist · high confidence

Vendored design tokens and Tailwind preset for offline theming

The dbt-docs-server web styles now include a vendored copy of the Biga design tokens (in tokens.css and tokens.js) and a local Tailwind preset (sourdough-preset.cjs) that references these tokens. This change removes the dependency on the private @dbt-labs/biga package, allowing the documentation site to be styled and customized using only local CSS custom properties without requiring external private dependencies.

crates/dbt-docs-server/web/src/styles · high confidence

Verticalized metadata adapter with strategy-based freshness and relation fetching

The metadata layer in the dbt adapter has been restructured to support per-database strategies for fetching relation metadata and checking source freshness. Users benefit from improved handling of source freshness overrides (via \loaded\_at\_field\ or \loaded\_at\_query\) and more robust relation lookups that correctly handle unresolvable views and database-specific SQLSTATEs. This change introduces a \MetadataAdapter\ trait with strategy patterns for listing relations and schemas, allowing the adapter to delegate specific database operations (like \get\_relation\ and freshness checks) to specialized implementations for Snowflake, BigQuery, Databricks, and others, while centralizing common logic like timestamp parsing and Jinja-free template rendering.

crates/dbt-adapter/src/metadata · high confidence

dbt docs serve now serves a static SPA with client-side data queries

The dbt docs server has been refactored to serve the dbt docs v2 interface as a static Single Page Application (SPA) rather than providing a REST API. The server now delivers the SPA bundle (either from a generated site directory or an embedded fallback) and serves the underlying data as Parquet files, which the browser queries directly using DuckDB-WASM. This change removes the previous server-side API endpoints, meaning all data processing and rendering logic now runs client-side. The server also includes improved asset handling, such as secure path resolution to prevent directory traversal, and graceful shutdown support for cleaner process termination.

crates/dbt-docs-server/src · high confidence

dbt-docs-server now exports a static site queried by DuckDB-WASM

The export module in crates/dbt-docs-server/src/export has been rewritten to generate a static site where the browser loads DuckDB-WASM from a CDN and queries parquet artifacts directly, moving computation from the server to the client. This change introduces a bootstrap mechanism (bootstrap.rs) that inlines build-scoped metadata (such as dbt version, distribution, and telemetry consent) into index.html, and enforces strict validation by refusing to export if the information schema is missing or contains no resources. The export also handles copying the versioned information schema directory when the output location differs from the source, ensuring the static site remains self-contained.

crates/dbt-docs-server/src/export · high confidence

Fixes

13 commits (8 fixes) fixing crates/dbt-state/src/auth

A fix in crates/dbt-state/src/auth — 13 commits (8 fixs), 5 files: “fix(dbt-state): don't cache auth token to disk in headless environments”; “fix(dbt-state): clarify error when no org can be determined from token”; “Prepare tests for code requiring the dbt-runtime”; and 10 more.

crates/dbt-state/src/auth · medium confidence · unverified

53 commits (29 fixes) fixing crates/dbt-adapter/src/sql

A fix in crates/dbt-adapter/src/sql — 53 commits (29 fixs), 6 files.

crates/dbt-adapter/src/sql · medium confidence · unverified

Test coverage

18 commits adding/updating tests in crates/dbt-sa-adapter-tests/tests; 65 commits adding/updating tests in crates/dbt-loader/tests/macros; 9 commits adding/updating tests in crates/dbt-state/tests; Added MetricFlow test suite and test infrastructure; Added golden tests for compile and parse commands; Added golden tests for tracing output formatting; Added integration tests for ADBC driver backends; Added integration tests for bundled driver loading; Added integration tests for dbt-sa-cli commands; Added macro test harness for dbt unit testing; Added mock adapter tests for Snowflake type and quoting; Added regression and snapshot tests for DuckDB catalog attachment and Snowflake client cancellation; Added test coverage for compile, parse, and static analysis commands; Added test data for dbt-csv parser edge cases; Added test fixtures for dbt-docs-server resource details; Added tests for Snowflake and Databricks materializations; Added tests for dbt-profile resolution and metadata extraction; Added unit tests for the tracing subsystem; Updated snapshot tests for Jinja environment builder.

Dependencies

dbt Core 2.0.5 workspace manifest and dependency configuration

The root \Cargo.toml\ establishes the dbt Core 2.0.5 workspace, defining the Rust 2024 edition and a comprehensive set of internal crates. It configures workspace-level dependencies for the Arrow ecosystem (version 56.0.0) and DataFusion, while patching \ring\ to 0.17.14 from a fork to resolve a build.rs issue and overriding \sqlparser\ to version 0.58.0 via a fork. Individual crate manifests (e.g., \dbt-adbc\, \dbt-auth\, \dbt-common\) are introduced, specifying their dependencies on these workspace-pinned libraries.

(dependencies) · high confidence

Housekeeping

Placeholder added for new library directory

An empty .keepme file was added to the lib directory to ensure the folder is tracked by version control.

lib · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 48 → 49 (+1.0)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 60 → 46 (-13.8)
  • Architecture 87 → 80 (-6.7)
  • Maturity 69 → 69 (+0.3)
  • Readiness 44 → 57 (+13.2)
  • Security 39 → 41 (+1.2)
  • Domain Modelling 100 → 100 (+0.0)
  • Event-Driven 80 → 80 (+0.0)
  • Event Sourcing 100 → 100 (+0.0)
  • Accessibility 59 → 63 (+4.3)
  • Performance 76 → 76 (+0.0)

Resolved (408)

  • AssetParsed::deserialize (cognitive 22) (crates/dbt-telemetry/src/gen/v1.public.events.fusion.asset.serde.rs)
  • AssetParsed::deserialize (cyclomatic 20) (crates/dbt-telemetry/src/gen/v1.public.events.fusion.asset.serde.rs)
  • CallTrace::deserialize (cognitive 16) (crates/dbt-telemetry/src/gen/v1.public.events.fusion.dev.serde.rs)
  • Change coupling: function_config.rs ↔ model_config.rs (crates/dbt-schemas/src/schemas/project/configs/function_config.rs)
  • Change coupling: model_config.rs ↔ seed_config.rs (crates/dbt-schemas/src/schemas/project/configs/model_config.rs)
  • Change coupling: seed_config.rs ↔ snapshot_config.rs (crates/dbt-schemas/src/schemas/project/configs/seed_config.rs)
  • Change-coupling hub: file_log_layer.rs → json_compat_layer.rs, tui_layer.rs, registry.rs (crates/dbt-common/src/tracing/layers/file_log_layer.rs)
  • Change-coupling hub: keywords.rs → mod.rs, tests.rs, driver.rs, install.rs, lib.rs, lib.rs (crates/dbt-adapter-sql/src/keywords.rs)
  • CompiledCode::deserialize (cognitive 16) (crates/dbt-telemetry/src/gen/v1.public.events.fusion.log.serde.rs)
  • Critical CVE: [GHSA redacted] (crates/dbt-docs-server/dbt-docs-lib/pnpm-lock.yaml)
  • Critical CVE: [GHSA redacted] (crates/dbt-docs-server/dbt-docs-lib/pnpm-lock.yaml)
  • Critical CVE: [GHSA redacted] (crates/dbt-docs-server/dbt-docs-lib/package.json)
  • Critical CVE: [GHSA redacted] (crates/dbt-docs-server/dbt-docs-lib/package.json)
  • DepsAddPackage::deserialize (cognitive 16) (crates/dbt-telemetry/src/gen/v1.public.events.fusion.deps.serde.rs)
  • DepsPackageInstalled::deserialize (cognitive 19) (crates/dbt-telemetry/src/gen/v1.public.events.fusion.deps.serde.rs)
  • DepsPackageInstalled::deserialize (cyclomatic 17) (crates/dbt-telemetry/src/gen/v1.public.events.fusion.deps.serde.rs)
  • DispatchObject::get_search_packages (cognitive 17) (crates/dbt-jinja/minijinja/src/dispatch_object.rs)
  • Duplicated block (10 lines × 2) (crates/dbt-adapter/src/adapter/adapter_impl.rs)
  • Duplicated block (10 lines × 2) (crates/dbt-adapter/src/adapter/mod.rs)
  • Duplicated block (10 lines × 2) (crates/dbt-freshness/src/freshness.rs)
  • …and 388 more

New (771)

  • AdapterImpl::execute_inner (cyclomatic 24) (crates/dbt-adapter/src/adapter/adapter_impl.rs)
  • AdapterImpl::get_adbc_execute_options (cognitive 17) (crates/dbt-adapter/src/adapter/adapter_impl.rs)
  • AdapterResponse::from_record_batch (cognitive 16) (crates/dbt-adapter/src/response.rs)
  • App.App (cognitive 50) (crates/dbt-docs-server/web/src/App.tsx)
  • App.App (cyclomatic 53) (crates/dbt-docs-server/web/src/App.tsx)
  • AssetListView.AssetListView (cognitive 29) (crates/dbt-docs-server/web/src/components/AssetListView.tsx)
  • AssetListView.AssetListView (cyclomatic 27) (crates/dbt-docs-server/web/src/components/AssetListView.tsx)
  • CaseWhenConditionExpr::evaluate (cognitive 19) (crates/dbt-pse/src/coverage.rs)
  • Change coupling: lib.rs ↔ main.rs (crates/dbt-python-core/src/lib.rs)
  • Change coupling: resolve_functions.rs ↔ resolve_snapshots.rs (crates/dbt-parser/src/resolve/resolve_functions.rs)
  • Change coupling: tests.rs ↔ sql_types.rs (crates/dbt-adapter-sql/src/types/tests.rs)
  • Change-coupling hub: file_log_layer.rs → json_compat_layer.rs, tui_layer.rs, registry.rs, v1.public.events.fusion.log.serde.rs (crates/dbt-common/src/tracing/layers/file_log_layer.rs)
  • Change-coupling hub: keywords.rs → tests.rs, driver.rs, install.rs, lib.rs, lib.rs (crates/dbt-adapter-sql/src/keywords.rs)
  • Change-coupling hub: task_spans.rs → node.rs, v1.public.events.fusion.node.serde.rs, node.rs (crates/dbt-tasks-core/src/task_spans.rs)
  • ClassTooLong: RunTask (crates/dbt-tasks-sa/src/runnable/runnable/mod.rs)
  • Critical CVE: [GHSA redacted] (crates/dbt-docs-server/pnpm-lock.yaml)
  • Critical CVE: [GHSA redacted] (crates/dbt-docs-server/pnpm-lock.yaml)
  • Critical CVE: [GHSA redacted] (crates/dbt-docs-server/dbt-docs-lib/package.json)
  • Critical CVE: [GHSA redacted] (crates/dbt-docs-server/dbt-docs-lib/package.json)
  • Critical CVE: [GHSA redacted] (crates/dbt-docs-server/web/package.json)
  • …and 751 more

Changes since last survey

  • 245 commits — 145 feature/other, 100 fixes

By area

  • crates/dbt-adapter — 37 commits
  • crates/dbt-schemas — 22 commits
  • crates/dbt-adbc — 15 commits
  • crates/dbt-loader — 13 commits
  • crates/dbt-tasks-sa — 13 commits
  • crates/dbt-error — 11 commits
  • crates/dbt-parser — 11 commits
  • (root) — 10 commits
  • .changes/unreleased — 10 commits
  • crates/dbt-sa-adapter-tests — 10 commits
  • crates/dbt-agate — 8 commits
  • crates/dbt-jinja — 7 commits
  • crates/dbt-jinja-utils — 7 commits
  • crates/dbt-state — 6 commits
  • crates/dbt-adapter-engine — 5 commits
  • crates/dbt-tasks-core — 5 commits
  • crates/dbt-telemetry — 5 commits
  • crates/dbt-adapter-sql — 4 commits
  • crates/dbt-common — 4 commits
  • crates/dbt-docs-server — 4 commits

Notable commits

  • fix: (dbt-adapter) duckdb: fix normalization gaps in column name and type comparisons which affected incremental on_schema_change strategies
  • fix: Fix "dbt_version" embedded in query comments
  • fix: Fix SCRIPT hanging
  • fix: Fix ephemeral results on run end
  • fix: Fix or simplify all inadequate calls to with_named_option()
  • fix: Fix/14601 databricks geospatial types
  • fix: GA-1043618-Fix-dbt-deps-git-argument-injection
  • fix: Revert "Yaml 1.1: proper timestamp compat" (#15164) and #15506
  • fix: Revert duplicate column name analysis (#14992, #15369)
  • fix: Review the dbt-lease implementation, its use in pat_cache.rs and fix the racy unit tests
  • fix: [ClickHouse] Port v1 fix 750: Fix refreshable MV catchup racing the initial refresh (create with EMPTY, catchup first)
  • fix: [Multi-adapter] fix(jinja): target follows the node at parse, compile and run
  • fix: [Multi-adapter] fix(parser): a LakeCompute node parses with its own dispatch, as it compiles
  • fix: [Multi-adapter] fix(parser): parse render follows the node's adapter when it is known up front
  • fix: [Multi-adapter] fix(parser): read a node's config with its own adapter's alias table
  • fix: [Multi-adapter] fix(run): error on a lakecompute snapshot or function instead of running it on the default
  • fix: [Multi-adapter] fix(run): run a non-default node and create its schema on its own adapter
  • fix: [Multi-adapter] fix(run): under --adapter X, on-run hooks and run-operation render as X
  • fix: [Multi-adapter] fix(seeds): parse a seed's column_types with its own adapter's types
  • fix: [Multi-adapter] fix(show): run show -s on the node's adapter
  • …and 225 more

Architecture

  • Unchanged — 0 containers · 1 contexts · 0 edges

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

dbt-labs/dbt-core was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit bf7d341f34c7f08dd1323f2abb9690be4146da5e — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-e1a3b69fc8ee.