dbt-labs/dbt-core

This system is a next-generation, Rust-based implementation of the dbt data transformation tool, designed to replace the legacy Python core with a modular, high-performance architecture. It provides a unified adapter framework that supports execution across diverse data warehouses—including Snowflake, BigQuery, Databricks, and DuckDB—while introducing a new static-site documentation server powered by DuckDB-WASM. The system also encompasses a comprehensive CLI for project management, package dependency resolution, and interactive authentication, alongside structured telemetry and a modern React-based user interface for data lineage and asset exploration.

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

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

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

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

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

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

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

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

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

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

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

Users can now configure BigQuery query reservations at both the model and connection levels, allowing for more granular control over query resource allocation and cost management within dbt projects.

.changes/unreleased · high confidence

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

This change introduces the bundled Snowflake adapter macros into the \dbt-loader\ crate, providing the SQL logic required to materialize and manage Snowflake objects. The included macros cover core operations such as catalog retrieval, grant management, and schema changes, alongside specific materializations for tables, incremental models (including merge, insert\_overwrite, and microbatch strategies), seeds, snapshots, clones, and dynamic tables. It also adds support for interactive tables, scalar and aggregate functions (SQL, Python, and JavaScript), and optimized generic tests like \aggregated\_not\_null\. The implementation handles Snowflake-specific behaviors such as catalog-linked database constraints, transient temporary relations, and query tag management.

_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

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

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

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

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

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

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

The telemetry infrastructure now supports custom, extensible event data types (attributes) via a new registry system. This change introduces a \TelemetryEventTypeRegistry\ that maps event identifiers to specific Arrow and JSON deserializers, allowing downstream users to define and register their own telemetry event schemas. It also adds a \DbtTelemetryContext\ to propagate execution phase and node ID information across spans, and includes test utilities (fakers) to generate deterministic test data for these new extensible event types.

crates/dbt-telemetry/src/attributes · high confidence

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

Added the initial implementation for the Spark adapter, including a new metadata module that parses Spark's \describe extended\ output by truncating column lists at the separator row, and a relation module that defines the default Spark database as an empty string to align with Spark's interchangeable use of database and schema terms.

crates/dbt-adapter/src/metadata/spark, crates/dbt-adapter/src/relation/spark · high confidence

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

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

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

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

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

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

Users can now route specific dbt nodes (models, seeds, and tests) through the LakeCompute execution path instead of the default remote adapter. This change introduces a \RunExecutionPath\ enum with \Remote\, \SideCar\, and \LakeCompute\ variants, allowing the system to leverage LakeCompute's specific capabilities, such as attaching catalog bundles to test statements, while ensuring that other node types fall back to the standard remote path if they do not support the LakeCompute-specific hooks.

crates/dbt-tasks-sa/src/runnable/runnable · high confidence

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

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

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

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

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.

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

The \renderable\ module now includes dedicated typing logic for Snowflake and BigQuery data types, enabling unit tests to correctly recognize and handle specific column types. For Snowflake, this adds support for \timestamp\_ntz\, \timestamp\_ltz\, \timestamp\_tz\, \TIME\, \VARIANT\, \OBJECT\, \GEOGRAPHY\, and \GEOMETRY\ columns, ensuring they are treated as primitive types rather than failing as non-primitive. For BigQuery, the module now supports \NUMERIC\, \GEOGRAPHY\, and \JSON\ types. This change also includes a utility to build unit test overrides for model dependencies.

crates/dbt-tasks-sa/src/renderable · high confidence

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

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

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

The \dbt source freshness\ command is now implemented in Rust (previously Python-only), allowing users to validate the timeliness of their source data against configured freshness thresholds. This change adds the core execution logic for measuring source data age, evaluating pass/warn/error statuses, and generating freshness result artifacts, while maintaining the existing user-facing messaging and schema structure.

crates/dbt-freshness · high confidence

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

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

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

A new \dbt-csv\ crate has been added to handle CSV reading for dbt seeds, replacing the previous standard CSV reader. This new parser implements type inference logic that matches Python's agate library, ensuring consistent data typing between Python-based dbt models and the Rust-based engine. Key behaviors include specific type priority (Integer \> Number \> Date \> DateTime \> ISODateTime \> Boolean \> Text), strict boolean validation (only 'true'/'false'), and support for forcing specific columns to be treated as Text. Timestamps are inferred with microsecond precision, and the parser handles edge cases like empty headers, duplicate headers, and null value representation ('null' or empty strings) to align with agate's behavior.

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

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

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

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.

crates/dbt-state · high confidence

A new \dbt-adapter-core\ crate has been added to centralize adapter identification and configuration handling. It introduces the \AdapterType\ enum, which defines supported databases (including Snowflake, BigQuery, Databricks, Redshift, Postgres, Salesforce, ClickHouse, and others) and marks specific ones like ClickHouse and Salesforce as non-experimental. The crate also implements \config\_aliases\ logic to canonicalize database-specific configuration keys (e.g., mapping \catalog\ to \database\ for Databricks) and enforces architectural boundaries via \deny.toml\ to prevent \dbt-adapter-core\ from depending on \dbt-common\ or \arrow\. This change provides a unified, type-safe foundation for adapter configuration across the system.

crates/dbt-adapter-core · high confidence

A new \dbt-adapter-engine\ crate has been created to host adapter-agnostic code, specifically moving the \MapReduce\ framework from \dbt-adbc\. This framework enables parallel Key-to-Value tasks by running workers in the \dbt-runtime\ blocking thread pool, managing database connections via a \ConnectionFactory\ trait, and reducing results into an accumulator. This change establishes a middle-layer between \dbt-adapter\ and \dbt-adbc\ to reduce circular dependencies and centralize parallel execution logic.

crates/dbt-adapter-engine · high confidence

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

A new \dbt-frontend-common\ crate has been added, providing shared foundational components for the frontend. This includes a \Dialect\ enum supporting Trino, Snowflake, BigQuery, Postgres, DuckDB, and others, along with dialect-specific identifier quoting and escaping rules. The library introduces a lightweight SQL expression evaluator (\expr\ module) capable of parsing and evaluating arithmetic, comparison, and conditional logic (min, max, if) over integer variables, which is utilized by the new \ConstraintMap\ system to resolve and validate model constraints. Additionally, it provides utilities for handling qualified names (\Qualified\, \FullyQualifiedName\), named references, source extraction traits, and type representation helpers.

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

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.

crates/dbt-adbc · high confidence

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

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

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

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

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

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

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

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

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.

crates/dbt-python-core · high confidence

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

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

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

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

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

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.

crates/dbt-adbc/src · high confidence

The telemetry system now supports serializing and deserializing event records into Arrow and JSON formats. This introduces a structured \ArrowAttributes\ schema that maps telemetry fields (such as node details, query outcomes, and error codes) into Arrow columns, enabling efficient columnar storage and processing. Additionally, JSON serialization is implemented to allow telemetry records to be exported and imported as JSON lines, ensuring compatibility with standard text-based data interchange while maintaining round-trip fidelity for public event types.

crates/dbt-telemetry/src/serialize · high confidence

The \dbt-df-providers\ crate introduces a new layer that bridges the dbt schema store with Apache DataFusion. It provides a \SchemaStoreCatalogProviderList\ that lazily provisions catalogs, schemas, and table providers on demand, ensuring consistent schema resolution without pre-registration. A \DelayedDataTableProvider\ defers data registration until execution time, allowing the system to handle intermediate tables during the compile phase by using schema-only placeholders that are populated with actual data (Parquet/JSON) during the build phase. Additionally, it includes custom CSV reading with agate-compatible type inference for dbt seeds, support for reading Parquet/JSON seeds without a DataFusion session context, and utilities for handling empty seeds via zero-row Parquet files.

crates/dbt-df-providers · high confidence

Added a comprehensive set of Protocol Buffer (proto3) definitions in \crates/dbt-telemetry/include\ that establish the structured event schema for the new 'Fusion' telemetry system. These files define the data models for tracking the full dbt execution lifecycle, including invocation metadata, node outcomes (models, tests, seeds, sources), query execution details, hook processing, dependency installation, and logging. The schema also introduces specific event types for asset parsing, artifact writing, onboarding steps, and internal debugging traces, providing the foundational contract for structured telemetry data collection.

crates/dbt-telemetry/include · high confidence

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

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

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

The LineageV2 area now includes a complete set of new React components for rendering the second-generation lineage visualization. This adds the core DAG canvas (BaseDag) powered by React Flow, a Groups view that organizes resources by type with custom connector paths, and supporting UI controls including a hop bar for upstream/downstream depth, a lenses dropdown for filtering, and minimap panels for both views. The change also introduces Storybook stories for visual regression testing of the node cards and a unit test for the connector channel logic, replacing the previous dbt-dag dependency with these local implementations.

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

This change introduces a suite of new React hooks in the \dbt-docs-server\ web client to support the dbt v2 documentation interface. \useAllNodes\ fetches the complete project node list from the bootstrap data, replacing the previous paginated API approach. \useCapabilities\ and \useIdentity\ manage feature flags (such as column-level lineage) and user authentication/telemetry consent derived from the site bootstrap. \useLineageData\, \useHydrateLineageStore\, and \useLayoutWhenMeasured\ handle the asynchronous loading, storage, and layout of the new DAG lineage visualizations. Additional hooks include \useQueryHistory\ for persisting SQL queries in session storage, \useResizable\ for managing panel widths in local storage, and \useTheme\ for handling dark/light/system theme preferences.

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

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

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

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

Added agent context files and skills to guide development of the dbt v2 adapter architecture and the new static-site docs generation system. The \adapters.md\ file documents the verticalized adapter structure (dbt-adbc, dbt-adapter-core, dbt-adapter-sql, dbt-auth, dbt-adapter) and enforces hard rules such as blocking experimental adapters at profile-load time, preventing new dependencies, avoiding platform-specific types, and requiring Jinja object tests. The \dbt-docs-server.md\ file describes the new docs v2 approach: \dbt docs generate\ now produces a static site queried by DuckDB-WASM using the dbt information schema (parquet + views.sql) instead of manifest.json, with specific rules on compile behavior, capability gating, and tech stack details. Additionally, new skills were added: \adapters-annotate-references\ provides scripts to annotate Rust adapter implementations with upstream Python reference links and generate gap reports, while \adapters-critic\ offers a code review checklist for adapter changes focusing on avoiding duplicated code, target-specific free functions, and improper adapter\_type handling. A \telemetry-tracing.md\ file was also added to guide work on the tracing/telemetry infrastructure.

.agents · high confidence

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

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 · high confidence

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

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

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

The \crates/dbt-ci\ crate introduces a new \cargo ci\ CLI to automate dbt release workflows. It adds commands to bump the workspace Cargo version, pack pre-built binaries into per-platform wheels, and publish to PyPI (including a new 'download-at-install' sdist mode that assembles an sdist from published wheels and declares their runtime metadata). It also adds Homebrew support to render and publish formulae to the \homebrew-dbt\ tap, and includes logic to embed install-time notices in pre-release \dbt-core\ sdists to guide users toward the \dbt\ distribution.

crates/dbt-ci · high confidence

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

The \dbt-ident\ crate has been added to provide a dedicated type for SQL identifiers. It introduces an \Ident\ type that preserves case in storage but performs case-insensitive equality and hashing, making it suitable for use as keys in hash maps and lookup tables. The crate also includes a \deny.toml\ configuration to enforce that \dbt-ident\ is treated as an external crate for handling SQL identifiers, excluding \dbt-fusion-workspace-hack\ from dependency graphs.

crates/dbt-ident · high confidence

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

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

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

The \dbt-profile-schemas\ crate now provides a unified, declarative framework for configuring database profiles. It introduces an \InteractiveSetup\ trait and a \ConfigProcessor\ that drive interactive wizards for BigQuery, ClickHouse, Databricks, Exasol, Fabric, Postgres, Redshift, and Snowflake. Each adapter defines its required fields (such as host, credentials, and authentication methods) using a structured schema, enabling consistent, guided setup flows and supporting non-interactive (headless) configuration via the \headless\ module.

crates/dbt-profile-schemas · high confidence

This change introduces the \runnable\ module in \crates/dbt-tasks-sa\, providing the execution logic for dbt nodes. It adds specific runners for models (including microbatch support with concurrency caps for Snowflake), seeds (with improved column-change error hints), snapshots, functions (supporting overloaded UDFs), and tests (with updated verdict logic and caching). These runners handle the actual execution, context extension, and result caching for these node types within the new task architecture.

crates/dbt-tasks-sa/src/runnable · high confidence

Added \crates/dbt-goldie\, a fork of the \goldie\ crate that emits test mismatches as unified diffs wrapped in \BEGIN PATCH\ / \END PATCH\ markers. This allows CI systems to automatically apply golden file updates via \apply\_golden\_patches.py\ or \cargo xtask apply-ci-goldies\ without requiring local test re-runs, while maintaining compatibility with existing golden file paths and the \GOLDIE\_UPDATE\ environment variable for local regeneration.

crates/dbt-goldie · high confidence

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

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

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

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

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

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

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

The \dbt-telemetry\ crate has been introduced to centralize telemetry infrastructure, exposing modules for attributes, implementations, macros, generated protobuf schemas, and serialization. A key addition is the \test\_utils\ module, which provides deterministic, seed-based helpers to generate fake telemetry records (spans and logs) and attributes for testing purposes, relying on types from the \dbt\_tracing\ crate.

crates/dbt-telemetry/src · high confidence

The telemetry system now includes structured schemas for log-related events (compiled code, adapter connections, list/show outputs, log messages, and state modifications) within the \dbt-telemetry\ crate. These schemas implement \ArrowSerializableTelemetryEvent\ to enable efficient Arrow-based serialization and deserialization, including backward compatibility fallbacks for legacy JSON payloads. Additionally, sensitive data in compiled SQL and show data outputs is automatically redacted when cloned for non-sensitive contexts, ensuring user privacy in telemetry records.

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

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.

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

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

The \dbt-test-utils\ crate now includes a comprehensive set of new task types to streamline test assertions and golden file management. These include \ArtifactComparisonTask\ for generic JSON artifact comparison with path-based field exclusion, \CheckCompiledFiles\ for validating compiled SQL against golden files (with optional hook checking), and \CheckPublicationArtifact\ for verifying publication outputs while stripping volatile metadata like timestamps and invocation IDs. Additional utilities provide file and directory existence assertions (\AssertFileExistsTask\, \AssertDirExistsTask\), directory manifest comparison with SHA256 checksums (\CompareDirManifest\), and specific capture tasks for dbt manifests (\CaptureDbtManifest\) and structured JSON logs (\ExecuteAndCaptureLogs\). The suite also supports record/replay workflows via \DbtRecordTask\ and general file operations like \FileWriteTask\ and \CpFromTargetTask\, all integrated into the existing \Task\ trait for use in test sequences.

crates/dbt-test-utils/src/task · high confidence

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

This change introduces a new \impls\ module within the \dbt-telemetry\ crate that provides manual trait implementations and helper constructors for the generated protobuf types. These implementations bridge the gap between the generated code and the runtime tracing library, enabling features such as converting proto severity levels to tracing severities, serializing debug values with precision handling for large integers, and constructing specific telemetry events for dependencies, hooks, logs, and node processing with correct legacy event codes.

crates/dbt-telemetry/src/impls · high confidence

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

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

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

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

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

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

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

The Databricks adapter's relation configuration logic has been restructured into modular components (column\_comments, column\_masks, column\_tags, constraints, liquid\_clustering, metric\_view\_query, partition\_by, query, refresh, relation\_comment, relation\_tags, row\_filter, tbl\_properties) that implement the new config\_v2 interface. This change standardizes how Databricks-specific settings are loaded from local model definitions and compared against remote warehouse state, ensuring consistent diffing and application of changes for features like column tags, masks, constraints, liquid clustering, and metric views.

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

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

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

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

The \catalog\_relation\_v2.rs\ module now handles the construction of \CatalogRelation\ objects using the new \catalogs.yml\ v2 schema. This change introduces support for specific catalog types across adapters, including Databricks Unity and Hive Metastore, Snowflake Horizon and linked catalogs (Glue, Iceberg REST, Unity), BigQuery Biglake Metastore, and DuckDB. It enforces configuration constraints, such as requiring a \catalog\_name\ for Iceberg tables on BigQuery and preventing the use of \catalog\_type\ in model-level configs, while also handling default behaviors for adapters when no catalog is specified.

_crates/dbt-adapter/src/catalog\relation · high confidence

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

Adds the ClickHouseMetadataAdapter implementation in the dbt-adapter crate, enabling catalog and relation metadata retrieval for ClickHouse databases. This change includes specific fixes for the ADBC driver, such as handling the \?\ character in SQL queries to prevent bind-parameter conflicts, correcting default database selection, and adding necessary connection settings. It also introduces logic for parsing materialized view targets, handling refreshable views, and quoting identifiers to ensure correct relation lookups.

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

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

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

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

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

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

The \renderable\ module in \crates/dbt-tasks-sa\ has been restructured to use a new task-based rendering pipeline. A new \RenderTask\ orchestrates the rendering of models, snapshots, tests, seeds, and unit tests, routing them to specific handlers (\default::run\_default\_render\, \run\_seed\_render\, \unit\_test::run\_unit\_test\_render\). This includes a new \AggregatedTestRenderTask\ for handling grouped tests and a \common::handle\_render\_result\ utility for processing and sending render outcomes. Unit test rendering now supports a three-phase pipeline (Discover, Fetch, Render) with schema caching and specific typing support for BigQuery, Databricks, and Snowflake.

crates/dbt-tasks-sa/src/renderable/renderable · high confidence

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

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

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

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

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

The test utilities now provide a \TestEnvGuard\ that isolates tests by clearing external environment variables, preserving only a strict list of allowed variables and prefixes (such as \RUST\\, \CARGO\\, and \DBT\_SKIP\_REMOTE\_LICENSE\) to ensure consistent test execution. Additionally, the utilities standardize how database profiles are loaded and written for tests, automatically applying target-specific schema and database overrides to the loaded configuration.

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

The web server now bundles its own TypeScript protocol buffer definitions in \crates/dbt-docs-server/web/src/proto\ instead of relying on the external \@dbt-labs/proto\ package. This change introduces generated TypeScript files for common telemetry contexts, Vortex options, and event schemas (including agent interactions, Beacon, Canvas, Copilot, and dbt Index events), ensuring the web layer has the necessary type definitions for telemetry and event handling without an external registry dependency.

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

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

The telemetry crate now uses a new generated module at \crates/dbt-telemetry/src/gen\ to define its event structures. This change introduces generated Rust types for Fusion-specific telemetry events, including artifact tracking (e.g., \ArtifactWritten\ with types like Manifest, Catalog, and Freshness), asset parsing (\AssetParsed\), dependency operations (\DepsAddPackage\, \DepsPackageInstalled\), and generic operations (\GenericOpExecuted\). The migration also includes updated serialization/deserialization logic for these events and a new \SeverityNumber\ enum for log severity, replacing the previous event definition approach.

crates/dbt-telemetry/src/gen · high confidence

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.

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

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

The frontend now uses a structured error system that attaches precise source locations (line, column, byte offset) to errors and exposes a comprehensive set of linting and semantic error codes (e.g., DBT02–DBT05, syntax, and schema errors). This improves error messages with actionable location details and specific rule identifiers, helping users quickly identify and fix issues in their SQL and dbt projects.

crates/dbt-frontend-common/src/error · high confidence

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

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

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

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

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

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

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

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

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

The SQL parsing layer now recognizes the LakeCompute adapter, mapping it to the DuckDB dialect for tokenization and statement splitting. This change, implemented in the new \dialect.rs\ module, also ensures that other adapters like Spark, Fabric, and various generic engines (Trino, Athena, etc.) are correctly mapped to their closest sqlparser equivalents (Hive, MSSQL, or Generic), improving compatibility for these data sources.

crates/dbt-tasks-sa/src/sql · high confidence

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

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

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

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

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

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

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

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

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

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

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

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

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

Corrected an off-by-one error in the microbatch incremental strategy where a lookback value of N would only yield N batches instead of the expected N+1. This fix ensures that when a checkpoint sits exactly on a batch boundary, the system correctly includes the current batch in the reprocessing window, aligning the behavior with the intended dbt-core pattern for batch window calculation.

crates/dbt-tasks-sa/src/microbatch · high confidence

Added MetricFlow test suite and test infrastructure; Added Snowflake timeout reproduction test project; Added golden tests for compile and parse commands; Added hello\_world test fixture for dbt integration tests; Added integration tests for ADBC driver backends; Added integration tests for dbt-sa-cli commands; Added macro integration tests for dbt-loader; 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 snapshot tests for DuckDB catalog ATTACH generation; 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 tests for dbt-test-utils task assertions; Added unit tests for the tracing subsystem; Updated snapshot tests for Jinja environment builder.

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

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

lib · high confidence

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

• CAI 70 → 65 (-5.0)
• Rubric changed (rubric-2026.09.8 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 78 → 78 (-0.0)
• Architecture 98 → 94 (-4.4)
• Maturity 78 → 78 (-0.1)
• Readiness 67 → 57 (-10.7)
• Security 68 → 71 (+3.5)
• Domain Modelling 100 → 100 (+0.4)
• Event-Driven 80 → 80 (+0.0)
• Event Sourcing 100 → 100 (+0.0)
• Accessibility 70 → 70 (+0.0)
• Performance 70 (new)

• Change coupling: legacy.rs ↔ codes.rs (crates/dbt-common/src/warn_error_options/legacy.rs)
• ClassTooLong: Environment (crates/dbt-jinja/minijinja-py/src/environment.rs)
• Documentation: no installation or build instructions (crates/dbt-ci/README.md)
• Documentation: no installation or build instructions (crates/dbt-jinja/fuzz/README.md)
• Duplicated block (10 lines × 2) (crates/dbt-dist/src/python.rs)
• Duplicated block (11 lines × 3) (crates/dbt-parser/src/resolve/resolve_models.rs)
• Duplicated block (11–14 lines × 2) (crates/dbt-deps/src/steps/load_package_lock.rs)
• Duplicated block (11–14 lines × 4) (crates/dbt-adapter/src/metadata/bigquery/mod.rs)
• Duplicated block (12 lines × 2) (crates/dbt-parser/src/resolve/resolve_analyses.rs)
• Duplicated block (12–14 lines × 2) (crates/dbt-index-core/src/parquet.rs)
• Duplicated block (13 lines × 2) (crates/dbt-adapter/src/metadata/databricks/mod.rs)
• Duplicated block (13–14 lines × 2) (crates/dbt-jinja-utils/src/phases/run/run_node_context.rs)
• Duplicated block (13–14 lines × 2) (crates/dbt-parser/src/resolve/resolve_analyses.rs)
• Duplicated block (13–14 lines × 6) (crates/dbt-parser/src/resolve/resolve_exposures.rs)
• Duplicated block (13–15 lines × 2) (crates/dbt-metadata/src/partial_parse.rs)
• Duplicated block (13–28 lines × 2) (crates/dbt-parser/src/resolve/resolve_models.rs)
• Duplicated block (14 lines × 4) (crates/dbt-parser/src/resolve/resolve_groups.rs)
• Duplicated block (15 lines × 2) (crates/dbt-jinja/minijinja/src/compiler/parser.rs)
• Duplicated block (15 lines × 3) (crates/dbt-jinja/minijinja/src/compiler/parser.rs)
• Duplicated block (15 lines × 6) (crates/dbt-schemas/src/schemas/manifest/manifest_nodes.rs)
• …and 142 more

• BigqueryMetadataAdapter::list_relations_schemas_inner (cognitive 16) (crates/dbt-adapter/src/metadata/bigquery/mod.rs)
• CatalogRegistry::validate_semantic (cyclomatic 16) (crates/dbt-schemas/src/schemas/dbt_catalogs_v2.rs)
• CatalogRegistry::validate_structural (cognitive 21) (crates/dbt-schemas/src/schemas/dbt_catalogs_v2.rs)
• Change coupling: tests.rs ↔ sql_types.rs (crates/dbt-adapter-sql/src/types/tests.rs)
• Dependency hygiene PARTLY measured — Cargo dependencies read, no committed lock to grade for currency
• Documentation: no installation or build instructions (README.md)
• Documentation: no installation or build instructions (crates/dbt-jinja/minijinja-embed/README.md)
• Duplicated block (10 lines × 2) (crates/dbt-schemas/src/schemas/project/configs/common.rs)
• Duplicated block (10–12 lines × 2) (crates/dbt-metadata/src/partial_parse.rs)
• Duplicated block (10–12 lines × 2) (crates/dbt-parser/src/resolve/resolve_models.rs)
• Duplicated block (11 lines × 2) (crates/dbt-adapter/src/relation/databricks/config/components/column_tags.rs)
• Duplicated block (11 lines × 5) (crates/dbt-adapter/src/metadata/bigquery/mod.rs)
• Duplicated block (11 lines × 6) (crates/dbt-schemas/src/schemas/manifest/manifest_nodes.rs)
• Duplicated block (12 lines × 4) (crates/dbt-jinja/minijinja/src/compiler/parser.rs)
• Duplicated block (12 lines × 4) (crates/dbt-schemas/src/schemas/manifest/manifest_nodes.rs)
• Duplicated block (12 lines × 5) (crates/dbt-schemas/src/schemas/manifest/manifest_nodes.rs)
• Duplicated block (12–13 lines × 2) (crates/dbt-jinja-utils/src/phases/run/run_node_context.rs)
• Duplicated block (12–14 lines × 4) (crates/dbt-adapter/src/metadata/bigquery/mod.rs)
• Duplicated block (13 lines × 2) (crates/dbt-jinja/minijinja/src/compiler/parser.rs)
• Duplicated block (13 lines × 2) (crates/dbt-jinja/minijinja/src/compiler/parser.rs)
• …and 146 more

• 110 commits — 63 feature/other, 47 fixes

• (root) — 21 commits
• crates/dbt-adapter — 17 commits
• .changes/unreleased — 12 commits
• crates/dbt-parser — 8 commits
• crates/dbt-adbc — 5 commits
• crates/dbt-loader — 4 commits
• crates/dbt-state — 4 commits
• crates/dbt-common — 3 commits
• crates/dbt-schemas — 3 commits
• crates/dbt-tasks-core — 3 commits
• crates/dbt-adapter-engine — 2 commits
• crates/dbt-deps — 2 commits
• crates/dbt-docs-server — 2 commits
• crates/dbt-index-core — 2 commits
• crates/dbt-main — 2 commits
• crates/proto-rust — 2 commits
• .github/workflows — 1 commit
• crates/adbc-record-replay — 1 commit
• crates/dbt-adapter-sql — 1 commit
• crates/dbt-ci — 1 commit

• fix: Fix README logo again
• fix: Fix broken embedded images
• fix: Revert "feat(state): enable compare_unrendered_code by default"
• fix: Sidecar: Fixed interpolated values for getting relation info
• fix: [dbt-adapter] Fix relations download progress bar stuck at 0/N
• fix: fix
• fix: fix(adapter): handle BigQuery partition field mismatches
• fix: fix(adapters/bigquery): stop erroring on duplicate compute_region when dataproc_region is also set
• fix: fix(bigquery): apply connection priority and maximum_bytes_billed to query jobs
• fix: fix(bigquery): render STRUCT and ARRAY types in snapshot ALTER ADD COLUMN
• fix: fix(databricks): add unit test coverage for column tags
• fix: fix(databricks): emit only changed keys in relation-tag SET TAGS diffs
• fix: fix(databricks): harden redact_credentials
• fix: fix(dbt-adapter): catalogs-v2 bare-string dispatch panic + lakecompute test-node reachability gap
• fix: fix(dbt-compute): stop skipping the debug propagation check when no CLD is declared
• fix: fix(dbt-index): commit a rebuilt index only once every table is written
• fix: fix(dbt-parser): avoid duplicate AST parse in parse_unrendered_config
• fix: fix(dbt-parser): avoid duplicate AST parse in static source() discovery
• fix: fix(dbt-parser): set tags on operation nodes so v1 can discover hooks via --use-v2-parser
• fix: fix(dbt-state): send Redshift case-sensitive dialect setting to server
• …and 90 more

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

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.