sqlbuild 0.97.2__tar.gz → 0.98.0__tar.gz

{sqlbuild-0.97.2 → sqlbuild-0.98.0}/Cargo.lock

@@ -529,7 +529,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sqlbuild-rules-native"
-version = "0.97.2"
+version = "0.98.0"
 dependencies = [
  "fensu-policy",
  "globset",

{sqlbuild-0.97.2 → sqlbuild-0.98.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.97.2
+Version: 0.98.0
 Requires-Dist: duckdb>=1.3.2
 Requires-Dist: filelock>=3.20.3
 Requires-Dist: orjson>=3.10.0
@@ -123,6 +123,13 @@ __expected__fact_orders AS (
 SELECT 1
 ```
 
+Relation fixtures can omit a column when the compiled test or scenario closure requires it and
+SQLBuild knows both its adapter type and that it is nullable. SQLBuild completes that test-only
+fixture column with a typed null such as `CAST(NULL AS VARCHAR)`; it never changes model SQL or
+warehouse defaults. Required non-nullable columns and columns with unknown type or nullability must
+be supplied explicitly. When the relation's complete column set is authoritative, misspelled or
+unknown supplied fixture columns are rejected.
+
 See the [documentation](https://docs.sqlbuild.com) for incremental models, scenarios, loaders, and more.
 
 ### Python project layout

{sqlbuild-0.97.2 → sqlbuild-0.98.0}/README.md

@@ -87,6 +87,13 @@ __expected__fact_orders AS (
 SELECT 1
 ```
 
+Relation fixtures can omit a column when the compiled test or scenario closure requires it and
+SQLBuild knows both its adapter type and that it is nullable. SQLBuild completes that test-only
+fixture column with a typed null such as `CAST(NULL AS VARCHAR)`; it never changes model SQL or
+warehouse defaults. Required non-nullable columns and columns with unknown type or nullability must
+be supplied explicitly. When the relation's complete column set is authoritative, misspelled or
+unknown supplied fixture columns are rejected.
+
 See the [documentation](https://docs.sqlbuild.com) for incremental models, scenarios, loaders, and more.
 
 ### Python project layout

{sqlbuild-0.97.2 → sqlbuild-0.98.0}/crates/sqlbuild-rules-native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlbuild-rules-native"
-version = "0.97.2"
+version = "0.98.0"
 edition.workspace = true
 license.workspace = true
 publish.workspace = true

{sqlbuild-0.97.2 → sqlbuild-0.98.0}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "maturin"
 
 [project]
 name = "sqlbuild"
-version = "0.97.2"
+version = "0.98.0"
 description = "Typed, test-first SQL pipelines with local E2E testing"
 readme = "README.md"
 requires-python = ">=3.12"

sqlbuild-0.98.0/src/sqlbuild/compiler/planner/_helpers/fixtures/completion.py

@@ -0,0 +1,466 @@
+"""Schema-aware completion for test-only relation fixtures."""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from sqlbuild.adapter.contract.classes.base_adapter import BaseAdapter
+from sqlbuild.compiler.compile.main._infer_fixture_columns import infer_fixture_columns
+from sqlbuild.compiler.compile.models import CompiledModel, CompiledProject, InferredColumn
+from sqlbuild.compiler.compile.types import CompiledResourceType
+from sqlbuild.compiler.lineage.types import ColumnTransformKind, InferredNullability
+from sqlbuild.compiler.planner.models import (
+    FixtureColumnMetadata,
+    FixtureRelationMetadata,
+    RelationFixtureCompletion,
+    RelationFixtureDiagnostic,
+)
+from sqlbuild.compiler.planner.types import ContractPolicy, FixtureGroups, FixtureKey
+from sqlbuild.compiler.references.constants import REF_PATTERN, SEED_PATTERN, SOURCE_PATTERN
+from sqlbuild.compiler.sql_analysis.main.import_polyglot_sql import import_polyglot_sql
+
+_PARTIAL_FIXTURE_ALIAS: str = "__sqlbuild_partial_fixture"
+_DBT_REF_PATTERN: re.Pattern[str] = re.compile(r'__dbt_ref\("([^"]+)",\s*"([^"]+)"\)')
+
+
+def build_relation_fixture_completion(
+    *,
+    project: CompiledProject,
+    adapter: BaseAdapter,
+    ordered_model_names: tuple[str, ...],
+    fixture_groups: FixtureGroups,
+) -> RelationFixtureCompletion:
+    """Complete only required omitted columns with authoritative nullable typed nulls."""
+
+    model_map: dict[str, CompiledModel] = {model.name: model for model in project.models}
+    fixture_sql_by_key: dict[FixtureKey, str] = {}
+    inferred_by_fixture: dict[FixtureKey, tuple[InferredColumn, ...]] = {}
+    for resource_type, fixtures in fixture_groups:
+        for name, sql in fixtures.items():
+            key: FixtureKey = (resource_type, name)
+            fixture_sql_by_key[key] = sql
+            inferred: tuple[InferredColumn, ...] | None = infer_fixture_columns(
+                query_sql=sql,
+                inference_profile=adapter.expression_inference_profile(),
+            )
+            if inferred is not None:
+                inferred_by_fixture[key] = inferred
+
+    relations: dict[FixtureKey, FixtureRelationMetadata] = _fixture_relation_metadata(
+        project=project,
+        model_map=model_map,
+    )
+    required: dict[FixtureKey, dict[str, set[str]]]
+    star_fixture_keys: frozenset[FixtureKey]
+    required, star_fixture_keys = _required_fixture_columns(
+        ordered_model_names=ordered_model_names,
+        model_map=model_map,
+        fixture_keys=frozenset(fixture_sql_by_key),
+        relations=relations,
+        adapter=adapter,
+    )
+    expected_types: dict[FixtureKey, dict[str, str]] = _expected_fixture_types(
+        relations=relations,
+        ordered_model_names=ordered_model_names,
+        model_map=model_map,
+    )
+    diagnostics: list[RelationFixtureDiagnostic] = list(
+        _unknown_fixture_column_diagnostics(
+            inferred_by_fixture=inferred_by_fixture,
+            relations=relations,
+        )
+    )
+
+    for key, required_columns in required.items():
+        inferred: tuple[InferredColumn, ...] | None = inferred_by_fixture.get(key)
+        if inferred is None:
+            continue
+        available_names: set[str] = {column.name.casefold() for column in inferred}
+        missing: tuple[str, ...] = tuple(
+            sorted(name for name in required_columns if name.casefold() not in available_names)
+        )
+        if not missing:
+            continue
+        relation: FixtureRelationMetadata | None = relations.get(key)
+        metadata: tuple[FixtureColumnMetadata, ...] = (
+            relation.columns if relation is not None else ()
+        )
+        metadata_by_name: dict[str, FixtureColumnMetadata] = {
+            column.name.casefold(): column for column in metadata
+        }
+        nullable_columns: list[FixtureColumnMetadata] = []
+        unknown: list[str] = []
+        non_nullable: list[str] = []
+        for name in missing:
+            column: FixtureColumnMetadata | None = metadata_by_name.get(name.casefold())
+            if column is None or column.type is None or column.nullable is None:
+                unknown.append(name)
+            elif column.nullable:
+                nullable_columns.append(column)
+            else:
+                non_nullable.append(name)
+        if unknown:
+            read_by: tuple[str, ...] = _models_reading_columns(
+                column_names=tuple(unknown),
+                required_columns=required_columns,
+            )
+            diagnostics.append(
+                RelationFixtureDiagnostic(
+                    key=key,
+                    message=(
+                        f"mock {key[0].value} '{key[1]}' is missing required columns: "
+                        f"{', '.join(unknown)}; provide explicit values because their types or "
+                        f"nullability are not authoritative (read by: {', '.join(read_by)})"
+                    ),
+                )
+            )
+        if non_nullable:
+            diagnostics.append(
+                RelationFixtureDiagnostic(
+                    key=key,
+                    message=(
+                        f"mock {key[0].value} '{key[1]}' must provide required non-nullable "
+                        f"columns: {', '.join(non_nullable)}"
+                    ),
+                )
+            )
+        if unknown or non_nullable:
+            continue
+        if key in star_fixture_keys and not _supplied_columns_form_schema_prefix(
+            inferred=inferred,
+            metadata=metadata,
+        ):
+            diagnostics.append(
+                RelationFixtureDiagnostic(
+                    key=key,
+                    message=(
+                        f"mock {key[0].value} '{key[1]}' supplies columns out of authoritative "
+                        "order for a SELECT * closure; provide the leading relation columns in "
+                        "schema order"
+                    ),
+                )
+            )
+            continue
+        metadata_order: dict[str, int] = {
+            column.name.casefold(): index for index, column in enumerate(metadata)
+        }
+        nullable_columns.sort(key=lambda column: metadata_order[column.name.casefold()])
+        fixture_sql_by_key[key] = _completed_fixture_sql(
+            sql=fixture_sql_by_key[key],
+            completed=tuple(nullable_columns),
+            adapter=adapter,
+        )
+
+    return RelationFixtureCompletion(
+        fixture_sql_by_key=fixture_sql_by_key,
+        inferred_by_fixture=inferred_by_fixture,
+        expected_types=expected_types,
+        diagnostics=tuple(diagnostics),
+    )
+
+
+def _required_fixture_columns(
+    *,
+    ordered_model_names: tuple[str, ...],
+    model_map: dict[str, CompiledModel],
+    fixture_keys: frozenset[FixtureKey],
+    relations: dict[FixtureKey, FixtureRelationMetadata],
+    adapter: BaseAdapter,
+) -> tuple[dict[FixtureKey, dict[str, set[str]]], frozenset[FixtureKey]]:
+    required: dict[FixtureKey, dict[str, set[str]]] = {}
+    star_fixture_keys: set[FixtureKey] = set()
+    for model_name in ordered_model_names:
+        model: CompiledModel | None = model_map.get(model_name)
+        if model is None:
+            continue
+        for lineage_column in model.fast_lineage_columns or ():
+            for upstream in lineage_column.upstream_columns:
+                key: FixtureKey = (
+                    CompiledResourceType(upstream.resource_type),
+                    upstream.resource_name,
+                )
+                if key not in fixture_keys:
+                    continue
+                required.setdefault(key, {}).setdefault(upstream.column_name, set()).add(model_name)
+        if model.fast_lineage_has_star:
+            model_star_fixture_keys: frozenset[FixtureKey] = _star_fixture_keys(
+                model=model,
+                fixture_keys=fixture_keys,
+                relations=relations,
+                adapter=adapter,
+            )
+            star_fixture_keys.update(model_star_fixture_keys)
+            for key in model_star_fixture_keys:
+                relation: FixtureRelationMetadata | None = relations.get(key)
+                if relation is None or not relation.authoritative_names:
+                    continue
+                for column in relation.columns:
+                    required.setdefault(key, {}).setdefault(column.name, set()).add(model_name)
+    return required, frozenset(star_fixture_keys)
+
+
+def _star_fixture_keys(
+    *,
+    model: CompiledModel,
+    fixture_keys: frozenset[FixtureKey],
+    relations: dict[FixtureKey, FixtureRelationMetadata],
+    adapter: BaseAdapter,
+) -> frozenset[FixtureKey]:
+    dependency_keys: frozenset[FixtureKey] = frozenset(
+        (CompiledResourceType(dependency.resource_type), dependency.name)
+        for dependency in model.deps
+        if (CompiledResourceType(dependency.resource_type), dependency.name) in fixture_keys
+    )
+    schema_tables: list[dict[str, object]] = []
+    for key in dependency_keys:
+        relation: FixtureRelationMetadata | None = relations.get(key)
+        if relation is None or not relation.columns:
+            continue
+        schema_tables.append(
+            {
+                "name": key[1],
+                "columns": [
+                    {"name": column.name, "type": column.type or "UNKNOWN"}
+                    for column in relation.columns
+                ],
+            }
+        )
+    if not schema_tables:
+        return frozenset()
+    polyglot_module: Any = import_polyglot_sql()
+    try:
+        analysis: object = polyglot_module.analyze_query(
+            _replace_relation_markers_with_stubs(model.query_sql),
+            {
+                "dialect": adapter.expression_inference_profile().sql_analysis_dialect or "generic",
+                "schema": {"tables": schema_tables},
+            },
+        )
+    except polyglot_module.PolyglotError:
+        return frozenset()
+    if not isinstance(analysis, dict):
+        return frozenset()
+    star_projections: object = analysis.get("starProjections")
+    query_relations: object = analysis.get("relations")
+    if not isinstance(star_projections, list) or not isinstance(query_relations, list):
+        return frozenset()
+    relation_names_by_alias: dict[str, str] = {}
+    for query_relation in query_relations:
+        if not isinstance(query_relation, dict):
+            continue
+        name: object = query_relation.get("name")
+        alias: object = query_relation.get("alias")
+        if not isinstance(name, str):
+            continue
+        relation_names_by_alias[name.casefold()] = name.casefold()
+        if isinstance(alias, str):
+            relation_names_by_alias[alias.casefold()] = name.casefold()
+    star_relation_names: set[str] = set()
+    for projection in star_projections:
+        if not isinstance(projection, dict):
+            continue
+        table: object = projection.get("table")
+        if table is None:
+            expanded_columns: object = projection.get("expandedColumns")
+            if not isinstance(expanded_columns, list):
+                continue
+            expanded_names: set[str] = {
+                column.casefold() for column in expanded_columns if isinstance(column, str)
+            }
+            for key in dependency_keys:
+                relation: FixtureRelationMetadata | None = relations.get(key)
+                if relation is not None and any(
+                    column.name.casefold() in expanded_names for column in relation.columns
+                ):
+                    star_relation_names.add(key[1].casefold())
+        elif isinstance(table, str):
+            relation_name: str | None = relation_names_by_alias.get(table.casefold())
+            if relation_name is not None:
+                star_relation_names.add(relation_name)
+    return frozenset(key for key in dependency_keys if key[1].casefold() in star_relation_names)
+
+
+def _replace_relation_markers_with_stubs(query_sql: str) -> str:
+    result: str = REF_PATTERN.sub(r"\1", query_sql)
+    result = SEED_PATTERN.sub(r"\1", result)
+    result = SOURCE_PATTERN.sub(r"\1", result)
+    return _DBT_REF_PATTERN.sub(r"\2", result)
+
+
+def _fixture_relation_metadata(
+    *, project: CompiledProject, model_map: dict[str, CompiledModel]
+) -> dict[FixtureKey, FixtureRelationMetadata]:
+    relations: dict[FixtureKey, FixtureRelationMetadata] = {}
+    for model_name, model in model_map.items():
+        relations[(CompiledResourceType.MODEL, model_name)] = _model_fixture_metadata(model=model)
+    for source in project.sources:
+        relations[(CompiledResourceType.SOURCE, source.name)] = FixtureRelationMetadata(
+            columns=tuple(
+                FixtureColumnMetadata(
+                    name=column.name,
+                    type=column.type,
+                    nullable=column.nullable,
+                )
+                for column in source.source_entry.columns
+            ),
+            authoritative_names=source.source_entry.contract == ContractPolicy.ENFORCED,
+        )
+    for seed in project.seeds:
+        seed_columns: tuple[FixtureColumnMetadata, ...] = tuple(
+            FixtureColumnMetadata(
+                name=column.name,
+                type=column.type,
+                nullable=column.nullable,
+            )
+            for column in seed.schema_entry.columns
+        )
+        relations[(CompiledResourceType.SEED, seed.name)] = FixtureRelationMetadata(
+            columns=seed_columns,
+            authoritative_names=bool(seed_columns),
+        )
+    return relations
+
+
+def _model_fixture_metadata(*, model: CompiledModel) -> FixtureRelationMetadata:
+    columns_by_name: dict[str, FixtureColumnMetadata] = {}
+    order: list[str] = []
+    for column in model.inferred_columns or ():
+        key: str = column.name.casefold()
+        order.append(key)
+        columns_by_name[key] = FixtureColumnMetadata(
+            name=column.name,
+            type=column.type,
+            nullable=_inferred_nullable(column.nullability),
+        )
+    for column in model.schema_entry.columns if model.schema_entry is not None else ():
+        key = column.name.casefold()
+        if key not in columns_by_name:
+            order.append(key)
+        inferred: FixtureColumnMetadata | None = columns_by_name.get(key)
+        columns_by_name[key] = FixtureColumnMetadata(
+            name=column.name,
+            type=column.type or (inferred.type if inferred is not None else None),
+            nullable=(
+                column.nullable
+                if column.nullable is not None
+                else (inferred.nullable if inferred is not None else None)
+            ),
+        )
+    return FixtureRelationMetadata(
+        columns=tuple(columns_by_name[key] for key in order),
+        authoritative_names=(
+            model.config.values.get("contract") == ContractPolicy.ENFORCED
+            or (model.inferred_columns is not None and not model.fast_lineage_has_star)
+        ),
+    )
+
+
+def _expected_fixture_types(
+    *,
+    relations: dict[FixtureKey, FixtureRelationMetadata],
+    ordered_model_names: tuple[str, ...],
+    model_map: dict[str, CompiledModel],
+) -> dict[FixtureKey, dict[str, str]]:
+    expected_types: dict[FixtureKey, dict[str, str]] = {}
+    for key, relation in relations.items():
+        column_types: dict[str, str] = {}
+        for column in relation.columns:
+            if column.type is not None:
+                column_types[column.name.casefold()] = column.type
+        expected_types[key] = column_types
+    for model_name in ordered_model_names:
+        model: CompiledModel | None = model_map.get(model_name)
+        if model is None:
+            continue
+        model_types: dict[str, str] = expected_types[(CompiledResourceType.MODEL, model_name)]
+        for lineage_column in model.fast_lineage_columns or ():
+            if lineage_column.transform_kind != ColumnTransformKind.DIRECT:
+                continue
+            upstream_types: set[str] = set()
+            for upstream in lineage_column.upstream_columns:
+                upstream_type: str | None = expected_types.get(
+                    (CompiledResourceType(upstream.resource_type), upstream.resource_name), {}
+                ).get(upstream.column_name.casefold())
+                if upstream_type is not None:
+                    upstream_types.add(upstream_type)
+            if len(upstream_types) == 1:
+                model_types.setdefault(
+                    lineage_column.output_column.casefold(), upstream_types.pop()
+                )
+    return expected_types
+
+
+def _unknown_fixture_column_diagnostics(
+    *,
+    inferred_by_fixture: dict[FixtureKey, tuple[InferredColumn, ...]],
+    relations: dict[FixtureKey, FixtureRelationMetadata],
+) -> tuple[RelationFixtureDiagnostic, ...]:
+    diagnostics: list[RelationFixtureDiagnostic] = []
+    for key, inferred in inferred_by_fixture.items():
+        relation: FixtureRelationMetadata | None = relations.get(key)
+        if relation is None or not relation.authoritative_names:
+            continue
+        expected_names: set[str] = {column.name.casefold() for column in relation.columns}
+        unknown: tuple[str, ...] = tuple(
+            sorted(
+                column.name for column in inferred if column.name.casefold() not in expected_names
+            )
+        )
+        if unknown:
+            diagnostics.append(
+                RelationFixtureDiagnostic(
+                    key=key,
+                    message=(
+                        f"mock {key[0].value} '{key[1]}' supplies unknown columns: "
+                        f"{', '.join(unknown)}"
+                    ),
+                )
+            )
+    return tuple(diagnostics)
+
+
+def _inferred_nullable(value: InferredNullability) -> bool | None:
+    if value == InferredNullability.NULLABLE:
+        return True
+    if value == InferredNullability.NON_NULL:
+        return False
+    return None
+
+
+def _models_reading_columns(
+    *, column_names: tuple[str, ...], required_columns: dict[str, set[str]]
+) -> tuple[str, ...]:
+    model_names: set[str] = set()
+    for name in column_names:
+        model_names.update(required_columns[name])
+    return tuple(sorted(model_names))
+
+
+def _supplied_columns_form_schema_prefix(
+    *,
+    inferred: tuple[InferredColumn, ...],
+    metadata: tuple[FixtureColumnMetadata, ...],
+) -> bool:
+    supplied_names: tuple[str, ...] = tuple(column.name.casefold() for column in inferred)
+    schema_prefix: tuple[str, ...] = tuple(
+        column.name.casefold() for column in metadata[: len(supplied_names)]
+    )
+    return supplied_names == schema_prefix
+
+
+def _completed_fixture_sql(
+    *,
+    sql: str,
+    completed: tuple[FixtureColumnMetadata, ...],
+    adapter: BaseAdapter,
+) -> str:
+    alias: str = adapter.render_identifier(_PARTIAL_FIXTURE_ALIAS)
+    projections: list[str] = [f"{alias}.*"]
+    for completed_column in completed:
+        projections.append(
+            f"CAST(NULL AS {completed_column.type}) AS "
+            f"{adapter.render_identifier(completed_column.name)}"
+        )
+    projection_sql: str = ",\n  ".join(projections)
+    return f"SELECT\n  {projection_sql}\nFROM (\n{sql}\n) AS {alias}"

{sqlbuild-0.97.2 → sqlbuild-0.98.0}/src/sqlbuild/compiler/planner/_helpers/scenario/relations.py

@@ -28,6 +28,9 @@ from sqlbuild.compiler.compile.models import (
     CompileSqlScenarioCte,
 )
 from sqlbuild.compiler.compile.types import CompiledResourceType
+from sqlbuild.compiler.planner._helpers.fixtures.completion import (
+    build_relation_fixture_completion,
+)
 from sqlbuild.compiler.planner._helpers.graph.core import (
     build_execution_upstream_deps,
     topologically_order_keys,
@@ -41,6 +44,7 @@ from sqlbuild.compiler.planner._helpers.resolve.resolve import resolve_function_
 from sqlbuild.compiler.planner.constants import (
     POLYGLOT_ALIAS_VALUE_KEY,
     SCENARIO_PLAN_INTERNAL,
+    SCENARIO_PLAN_INVALID_FIXTURE,
     SCENARIO_PLAN_MISSING_FIXTURE_SQL,
     SCENARIO_PLAN_MISSING_RELATION_TARGET,
     SCENARIO_PLAN_SQLGLOT_PARSE,
@@ -53,6 +57,7 @@ from sqlbuild.compiler.planner.models import (
     ModelPlanContext,
     ModelPlanEntry,
     PlanWarning,
+    RelationFixtureCompletion,
     ScenarioArtifactIdentity,
     ScenarioAssertionExpectationPlan,
     ScenarioExecutionPlan,
@@ -64,7 +69,11 @@ from sqlbuild.compiler.planner.models import (
     SeedPlanEntry,
     WarehouseSnapshot,
 )
-from sqlbuild.compiler.planner.types import RelationMarkerTargetResolver, ScenarioArtifactKind
+from sqlbuild.compiler.planner.types import (
+    FixtureKey,
+    RelationMarkerTargetResolver,
+    ScenarioArtifactKind,
+)
 from sqlbuild.compiler.references.main._render_source_relation import render_source_relation
 from sqlbuild.compiler.references.main.reference_call_prefix_pattern_text import (
     reference_call_prefix_pattern_text,
@@ -297,6 +306,39 @@ def build_scenario_execution_plan(
         for key in topologically_order_keys(upstream=upstream_deps)
         if key.resource_type == CompiledResourceType.MODEL and key.name in scenario_model_names
     )
+    scenario_fixture_groups: tuple[tuple[CompiledResourceType, dict[str, str]], ...] = (
+        (
+            CompiledResourceType.SOURCE,
+            _extract_fixture_ctes(scenario=scenario, prefix=SOURCE_TEST_CTE_PREFIX),
+        ),
+        (
+            CompiledResourceType.MODEL,
+            _extract_fixture_ctes(scenario=scenario, prefix=REF_TEST_CTE_PREFIX),
+        ),
+        (
+            CompiledResourceType.SEED,
+            _extract_fixture_ctes(scenario=scenario, prefix=SEED_TEST_CTE_PREFIX),
+        ),
+    )
+    fixture_sql_overrides: dict[FixtureKey, str] | None = None
+    if sql_analysis_enabled:
+        fixture_completion: RelationFixtureCompletion = build_relation_fixture_completion(
+            project=project,
+            adapter=adapter,
+            ordered_model_names=tuple(key.name for key in ordered_model_keys),
+            fixture_groups=scenario_fixture_groups,
+        )
+        if fixture_completion.diagnostics:
+            source_path: str = str(scenario.source_path or scenario.name)
+            details: str = "\n".join(
+                f"- {diagnostic.message}" for diagnostic in fixture_completion.diagnostics
+            )
+            raise PlannerInputError(
+                f"Scenario '{scenario.name}' has invalid relation fixtures in "
+                f"{source_path}:\n{details}",
+                code=SCENARIO_PLAN_INVALID_FIXTURE,
+            )
+        fixture_sql_overrides = fixture_completion.fixture_sql_by_key
     fixture_plans: tuple[ScenarioFixturePlan, ...] = build_scenario_fixture_plans(
         scenario=scenario,
         graph_plan=graph_plan,
@@ -304,6 +346,7 @@ def build_scenario_execution_plan(
         adapter=adapter,
         sql_analysis_enabled=sql_analysis_enabled,
         sql_analysis_dialect=sql_analysis_dialect,
+        fixture_sql_overrides=fixture_sql_overrides,
     )
     seed_entries: tuple[SeedPlanEntry, ...] = build_scenario_seed_entries(
         project=project,
@@ -446,6 +489,7 @@ def build_scenario_fixture_plans(
     adapter: BaseAdapter,
     sql_analysis_enabled: bool = True,
     sql_analysis_dialect: str | None = None,
+    fixture_sql_overrides: dict[FixtureKey, str] | None = None,
 ) -> tuple[ScenarioFixturePlan, ...]:
     """Build self-contained fixture SQL plans, including shared helper CTEs."""
 
@@ -479,6 +523,22 @@ def build_scenario_fixture_plans(
         scenario=scenario,
         prefix=DBT_REF_TEST_CTE_PREFIX,
     )
+    overrides: dict[FixtureKey, str] = fixture_sql_overrides or {}
+    source_ctes = _apply_fixture_overrides(
+        resource_type=CompiledResourceType.SOURCE,
+        fixture_sql=source_ctes,
+        overrides=overrides,
+    )
+    ref_ctes = _apply_fixture_overrides(
+        resource_type=CompiledResourceType.MODEL,
+        fixture_sql=ref_ctes,
+        overrides=overrides,
+    )
+    seed_ctes = _apply_fixture_overrides(
+        resource_type=CompiledResourceType.SEED,
+        fixture_sql=seed_ctes,
+        overrides=overrides,
+    )
 
     plans: list[ScenarioFixturePlan] = []
     source_name: str
@@ -590,6 +650,15 @@ def build_scenario_fixture_plans(
     return tuple(plans)
 
 
+def _apply_fixture_overrides(
+    *,
+    resource_type: CompiledResourceType,
+    fixture_sql: dict[str, str],
+    overrides: dict[FixtureKey, str],
+) -> dict[str, str]:
+    return {name: overrides.get((resource_type, name), sql) for name, sql in fixture_sql.items()}
+
+
 def build_scenario_seed_entries(
     *,
     project: CompiledProject,

{sqlbuild-0.97.2 → sqlbuild-0.98.0}/src/sqlbuild/compiler/planner/_helpers/sql_tests/assembly.py

@@ -37,7 +37,9 @@ from sqlbuild.compiler.planner._helpers.sql_tests.comments import (
     uncommented_matches_by_pattern,
     uncommented_pattern_matches,
 )
-from sqlbuild.compiler.planner._helpers.sql_tests.fixture_validation import validate_test_fixtures
+from sqlbuild.compiler.planner._helpers.sql_tests.fixture_validation import (
+    build_validated_test_fixtures,
+)
 from sqlbuild.compiler.planner.exceptions import PlannerInputError
 from sqlbuild.compiler.planner.models import (
     ChainStep,
@@ -177,7 +179,7 @@ def plan_test(
         mock_ref_names=frozenset(mock_refs),
     )
     if sql_analysis_enabled and validate_fixtures:
-        validate_test_fixtures(
+        mock_refs, mock_sources, mock_seeds = build_validated_test_fixtures(
             test=test,
             project=project,
             adapter=adapter,