dbt-labs/dbt-core
49.0
Weak · 14 November 2026
621.7k
lines of production code
Rust
with TypeScript
5
measurements over time
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
Added skills symlink in .claude directory
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.