sqlbuild 0.76.0__tar.gz → 0.76.2__tar.gz

{sqlbuild-0.76.0 → sqlbuild-0.76.2}/Cargo.lock

@@ -572,7 +572,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sqlbuild-kata-native"
-version = "0.76.0"
+version = "0.76.2"
 dependencies = [
  "fensu-policy",
  "globset",

{sqlbuild-0.76.0 → sqlbuild-0.76.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.76.0
+Version: 0.76.2
 Requires-Dist: duckdb>=1.3.2
 Requires-Dist: filelock>=3.20.3
 Requires-Dist: polyglot-sql>=0.9.2

{sqlbuild-0.76.0 → sqlbuild-0.76.2}/crates/sqlbuild-kata-native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlbuild-kata-native"
-version = "0.76.0"
+version = "0.76.2"
 edition.workspace = true
 license.workspace = true
 publish.workspace = true

{sqlbuild-0.76.0 → sqlbuild-0.76.2}/pyproject.toml

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

{sqlbuild-0.76.0 → sqlbuild-0.76.2}/src/sqlbuild/cli/commands/_helpers/audit/execution.py

@@ -140,6 +140,7 @@ def _build_on_complete(
             canonical_resource_id=audit_resource_id(
                 audit_name=result.audit_name,
                 attachment_kind=result.attachment_kind,
+                attached_target_kind=result.attached_target_kind,
                 attached_target_name=result.attached_target_name,
                 attached_column_name=result.attached_column_name,
             ),

{sqlbuild-0.76.0 → sqlbuild-0.76.2}/src/sqlbuild/cli/commands/_helpers/clone/execution.py

@@ -6,7 +6,10 @@ import time
 from typing import TextIO
 
 from sqlbuild.adapter.contract.classes.base_adapter import BaseAdapter
-from sqlbuild.cli.commands._helpers.clone.output import render_clone_item_line
+from sqlbuild.cli.commands._helpers.clone.output import (
+    clone_relation_flow_text,
+    render_clone_item_line,
+)
 from sqlbuild.cli.commands.models import (
     CloneCommandRequest,
     CloneConnectionContext,
@@ -52,11 +55,13 @@ def execute_clone_plan(
     clone_start: float = time.monotonic()
     resource_types_by_name: dict[str, str] = _clone_resource_types_by_name(preparation=preparation)
     event_writer: ExecutionEventWriter = ExecutionEventWriter(path=request.event_output_path)
+    relation_width: int = _clone_relation_width(preparation=preparation)
     on_item: CloneItemCallback = _build_on_clone_item(
         stream=invocation.progress_stream,
         use_color=invocation.use_color,
         event_writer=event_writer,
         resource_types_by_name=resource_types_by_name,
+        relation_width=relation_width,
     )
     try:
         result: CloneExecutionResult = execute_clone(
@@ -170,10 +175,18 @@ def _build_on_clone_item(
     use_color: bool,
     event_writer: ExecutionEventWriter,
     resource_types_by_name: dict[str, str],
+    relation_width: int,
 ) -> CloneItemCallback:
     def _on_clone_item(*, index: int, total: int, item: CloneItemResult) -> None:
         stream.write(
-            render_clone_item_line(index=index, total=total, item=item, use_color=use_color) + "\n"
+            render_clone_item_line(
+                index=index,
+                total=total,
+                item=item,
+                use_color=use_color,
+                relation_width=relation_width,
+            )
+            + "\n"
         )
         stream.flush()
         event_writer.write_clone_result(
@@ -182,3 +195,32 @@ def _build_on_clone_item(
         )
 
     return _on_clone_item
+
+
+def _clone_relation_width(*, preparation: CloneExecutionPreparation) -> int:
+    origin_entries: tuple[CloneSourcePlanEntry | ModelPlanEntry | SeedPlanEntry, ...] = (
+        *preparation.pipeline_result.origin_source_entries,
+        *preparation.pipeline_result.origin_model_entries,
+        *preparation.pipeline_result.origin_seed_entries,
+    )
+    origin_relations: dict[str, str | None] = {
+        entry.name: entry.destination.qualified_name or entry.destination.name
+        for entry in origin_entries
+    }
+    destination_entries: tuple[
+        CloneSourcePlanEntry | ModelPlanEntry | SeedPlanEntry | FunctionPlanEntry, ...
+    ] = (
+        *preparation.pipeline_result.destination_source_entries,
+        *preparation.pipeline_result.destination_model_entries,
+        *preparation.pipeline_result.destination_seed_entries,
+        *preparation.pipeline_result.destination_function_entries,
+    )
+    flows: tuple[str, ...] = tuple(
+        clone_relation_flow_text(
+            name=entry.name,
+            origin_relation=origin_relations.get(entry.name),
+            destination_relation=entry.destination.qualified_name or entry.destination.name,
+        )
+        for entry in destination_entries
+    )
+    return max((len(flow) for flow in flows), default=0)

{sqlbuild-0.76.0 → sqlbuild-0.76.2}/src/sqlbuild/cli/commands/_helpers/clone/output.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import re
+
 from sqlbuild.executor.clone.models import CloneExecutionResult, CloneItemResult
 from sqlbuild.executor.clone.types import CloneAction, CloneStatus
 from sqlbuild.presentation.classes.cli_style import CliStyle
@@ -9,6 +11,10 @@ from sqlbuild.presentation.main.completion_line import format_completion_line
 from sqlbuild.presentation.main.summary_footer import format_summary_footer
 from sqlbuild.presentation.types import CompletionState
 
+_QUOTED_IDENTIFIER_PATTERN: re.Pattern[str] = re.compile(
+    r'("(?:[^"]|"")*"|`(?:[^`]|``)*`|\[(?:[^\]]|\]\])*\])'
+)
+
 
 def render_clone_header(
     *, origin_target_name: str, destination_target_name: str, total: int, use_color: bool
@@ -32,27 +38,66 @@ def _clone_status_text(status: CloneStatus) -> str:
     return "OK"
 
 
+def clone_relation_flow_text(
+    *, name: str, origin_relation: str | None, destination_relation: str | None
+) -> str:
+    """Return the normalized plain-text relation flow used for clone progress."""
+
+    if origin_relation is None or destination_relation is None:
+        return name.lower()
+    return (
+        f"{clone_relation_display_name(origin_relation)} -> "
+        f"{clone_relation_display_name(destination_relation)}"
+    )
+
+
+def clone_relation_display_name(relation: str) -> str:
+    """Normalize ordinary identifiers while preserving quoted identifier case."""
+
+    parts: list[str] = _QUOTED_IDENTIFIER_PATTERN.split(relation)
+    return "".join(
+        part if _QUOTED_IDENTIFIER_PATTERN.fullmatch(part) else part.lower() for part in parts
+    )
+
+
 def render_clone_item_line(
-    *, index: int, total: int, item: CloneItemResult, use_color: bool
+    *,
+    index: int,
+    total: int,
+    item: CloneItemResult,
+    use_color: bool,
+    relation_width: int | None = None,
 ) -> str:
     """Render one streamed clone line: position, action, origin to destination, and status."""
 
     style: CliStyle = CliStyle(use_color=use_color)
     position: str = f"{index:>{len(str(total))}}/{total}"
-    relation_flow: str = item.name
+    plain_relation_flow: str = clone_relation_flow_text(
+        name=item.name,
+        origin_relation=item.origin_relation,
+        destination_relation=item.destination_relation,
+    )
+    relation_flow: str = style.object_name(plain_relation_flow)
     if item.origin_relation is not None and item.destination_relation is not None:
         relation_flow = (
-            f"{style.object_name(item.origin_relation)} "
-            f"{style.muted('->')} {style.object_name(item.destination_relation)}"
+            f"{style.object_name(clone_relation_display_name(item.origin_relation))} "
+            f"{style.muted('->')} "
+            f"{style.object_name(clone_relation_display_name(item.destination_relation))}"
         )
+    effective_relation_width: int = max(len(plain_relation_flow), relation_width or 0)
+    relation_padding: str = " " * (effective_relation_width - len(plain_relation_flow))
+    action: str = item.action.value
+    action_width: int = max(len(value.value) for value in CloneAction)
+    action_padding: str = " " * (action_width - len(action))
     duration: str = (
         f"  {style.muted(f'{item.duration_seconds:.2f}s')}"
         if item.duration_seconds is not None
         else ""
     )
     return (
-        f"  {style.muted(position)}  {style.accent(item.action.value):<18} "
-        f"{relation_flow}  {style.status(status=_clone_status_text(status=item.status))}{duration}"
+        f"  {style.muted(position)}  {style.accent(action)}{action_padding}  "
+        f"{relation_flow}{relation_padding}  "
+        f"{style.status(status=_clone_status_text(status=item.status))}{duration}"
     )
 
 

{sqlbuild-0.76.0 → sqlbuild-0.76.2}/src/sqlbuild/cli/output/_helpers/execution_protocol_v1.py

@@ -906,6 +906,11 @@ def _format_audit_checks(
                 "severity": result.severity.value,
                 "row_count": result.row_count,
                 "attachment_kind": result.attachment_kind.value,
+                "attached_target_kind": (
+                    result.attached_target_kind.value
+                    if result.attached_target_kind is not None
+                    else None
+                ),
                 "asset_name": result.attached_target_name,
                 "attached_column_name": result.attached_column_name,
                 "run_scope_phase": result.run_scope_phase.value,
@@ -921,6 +926,7 @@ def _audit_check_id(result: AuditExecutionResult) -> str:
     return audit_resource_id(
         audit_name=result.audit_name,
         attachment_kind=result.attachment_kind,
+        attached_target_kind=result.attached_target_kind,
         attached_target_name=result.attached_target_name,
         attached_column_name=result.attached_column_name,
     )

{sqlbuild-0.76.0 → sqlbuild-0.76.2}/src/sqlbuild/cli/output/_helpers/integration_result.py

@@ -300,6 +300,7 @@ def _audit_check_id(result: AuditExecutionResult) -> str:
     return audit_resource_id(
         audit_name=result.audit_name,
         attachment_kind=result.attachment_kind,
+        attached_target_kind=result.attached_target_kind,
         attached_target_name=result.attached_target_name,
         attached_column_name=result.attached_column_name,
     )

{sqlbuild-0.76.0 → sqlbuild-0.76.2}/src/sqlbuild/compiler/planner/_helpers/graph/core.py

@@ -3,13 +3,11 @@
 from __future__ import annotations
 
 from sqlbuild.compiler.compile.models import (
-    CompiledAudit,
     CompiledObjectKey,
     CompiledProject,
     CompiledSqlTest,
 )
 from sqlbuild.compiler.compile.types import (
-    AttachedAuditTargetKind,
     CompiledResourceType,
     SqlTestMode,
 )
@@ -26,7 +24,7 @@ def _key_sort_key(key: CompiledObjectKey) -> tuple[str, str]:
 def build_execution_upstream_deps(
     project: CompiledProject,
 ) -> dict[CompiledObjectKey, tuple[CompiledObjectKey, ...]]:
-    """Return EXECUTION-order edges: lineage plus audit scope-deps and woven SQL test nodes."""
+    """Return execution-order edges from lineage and woven SQL test nodes."""
 
     upstream: dict[CompiledObjectKey, list[CompiledObjectKey]] = {}
     upstream.update({model.key: list(model.deps) for model in project.models})
@@ -34,17 +32,6 @@ def build_execution_upstream_deps(
     upstream.update({seed.key: list(seed.deps) for seed in project.seeds})
     upstream.update({function.key: list(function.deps) for function in project.functions})
 
-    audit: CompiledAudit
-    for audit in project.audits:
-        target_key: CompiledObjectKey | None = _attached_audit_target_key(audit=audit)
-        if target_key is None or target_key not in upstream:
-            continue
-        dep_key: CompiledObjectKey
-        for dep_key in audit.scope_deps:
-            if dep_key == target_key or dep_key in upstream[target_key]:
-                continue
-            upstream[target_key].append(dep_key)
-
     test: CompiledSqlTest
     for test in project.sql_tests:
         if test.mode == SqlTestMode.TABLE_FN:
@@ -64,18 +51,6 @@ def build_execution_edge_origins(
     """Return human-readable origins for execution edges injected beyond pure lineage."""
 
     origins: dict[tuple[CompiledObjectKey, CompiledObjectKey], str] = {}
-    audit: CompiledAudit
-    for audit in project.audits:
-        target_key: CompiledObjectKey | None = _attached_audit_target_key(audit=audit)
-        if target_key is None:
-            continue
-        dep_key: CompiledObjectKey
-        for dep_key in audit.scope_deps:
-            if dep_key == target_key:
-                continue
-            origins[(target_key, dep_key)] = (
-                f"audit '{audit.name}' on '{target_key.name}' reads '{dep_key.name}'"
-            )
     test: CompiledSqlTest
     for test in project.sql_tests:
         for target_key in test.scope_deps:
@@ -85,23 +60,6 @@ def build_execution_edge_origins(
     return origins
 
 
-def _attached_audit_target_key(*, audit: CompiledAudit) -> CompiledObjectKey | None:
-    if audit.attached_target_kind is None or audit.attached_target_name is None:
-        return None
-    target_kind: AttachedAuditTargetKind = AttachedAuditTargetKind(audit.attached_target_kind)
-    if target_kind == AttachedAuditTargetKind.MODEL:
-        return CompiledObjectKey(
-            resource_type=CompiledResourceType.MODEL,
-            name=audit.attached_target_name,
-        )
-    if target_kind == AttachedAuditTargetKind.SOURCE:
-        return CompiledObjectKey(
-            resource_type=CompiledResourceType.SOURCE,
-            name=audit.attached_target_name,
-        )
-    return None
-
-
 def _function_scope_deps_for_test(*, test: CompiledSqlTest) -> tuple[CompiledObjectKey, ...]:
     return tuple(
         scope_dep

{sqlbuild-0.76.0 → sqlbuild-0.76.2}/src/sqlbuild/compiler/planner/_helpers/output/audit_entry.py

@@ -14,6 +14,7 @@ from sqlbuild.compiler.compile.models import (
     CompiledObjectKey,
     CompiledRelationLocation,
 )
+from sqlbuild.compiler.compile.types import AttachedAuditTargetKind
 from sqlbuild.compiler.planner._helpers.output.audit_scheduling import (
     resolve_attachment_kind,
     resolve_effective_run_scope,
@@ -73,6 +74,11 @@ def plan_audit(
         requested_run_scope=requested_run_scope,
         attached_model_materialization=attached_materialization,
     )
+    attached_target_kind: AttachedAuditTargetKind | None = audit.attached_target_kind
+    if attached_target_kind is None and attachment_kind == AuditAttachmentKind.MODEL:
+        attached_target_kind = AttachedAuditTargetKind.MODEL
+    elif attached_target_kind is None and attachment_kind == AuditAttachmentKind.SOURCE:
+        attached_target_kind = AttachedAuditTargetKind.SOURCE
 
     return AuditPlanEntry(
         key=audit.key,
@@ -84,6 +90,7 @@ def plan_audit(
         requested_run_scope=requested_run_scope,
         effective_run_scope=effective_run_scope,
         scope_deps=audit.scope_deps,
+        attached_target_kind=attached_target_kind,
         attached_target_name=attached_target_name,
         attached_column_name=audit.attached_column_name,
         always_run=audit.always_run,

{sqlbuild-0.76.0 → sqlbuild-0.76.2}/src/sqlbuild/compiler/planner/_helpers/output/audit_scheduling.py

@@ -31,14 +31,17 @@ def resolve_attachment_kind(
 
     if audit.attached_target_kind == AttachedAuditTargetKind.SOURCE:
         _validate_source_attached_audit(audit=audit)
-        return AuditAttachmentKind.SOURCE, audit.attached_target_name
+        if _source_lifecycle_attachment_is_safe(audit=audit):
+            return AuditAttachmentKind.SOURCE, audit.attached_target_name
+        return AuditAttachmentKind.END, audit.attached_target_name
 
     if audit.attached_target_kind == AttachedAuditTargetKind.MODEL:
-        _validate_model_attached_audit(
+        if _model_lifecycle_attachment_is_safe(
             audit=audit,
             upstream_deps=upstream_deps,
-        )
-        return AuditAttachmentKind.MODEL, audit.attached_target_name
+        ):
+            return AuditAttachmentKind.MODEL, audit.attached_target_name
+        return AuditAttachmentKind.END, audit.attached_target_name
 
     return _infer_singular_attachment(
         audit=audit,
@@ -79,12 +82,26 @@ def _validate_source_attached_audit(*, audit: CompiledAudit) -> None:
             )
 
 
-def _validate_model_attached_audit(
+def _source_lifecycle_attachment_is_safe(*, audit: CompiledAudit) -> bool:
+    """Return whether an attached audit only depends on its target source."""
+
+    if audit.attached_target_name is None:
+        raise PlannerInputError(
+            f"audit '{audit.name}': source-attached audit is missing an attached source name"
+        )
+    attached_key: CompiledObjectKey = CompiledObjectKey(
+        resource_type=CompiledResourceType.SOURCE,
+        name=audit.attached_target_name,
+    )
+    return all(dep_key == attached_key for dep_key in audit.scope_deps)
+
+
+def _model_lifecycle_attachment_is_safe(
     *,
     audit: CompiledAudit,
     upstream_deps: dict[CompiledObjectKey, tuple[CompiledObjectKey, ...]],
-) -> None:
-    """Validate that all model refs in a model-attached audit are upstream of the attached model."""
+) -> bool:
+    """Return whether an attached audit can run inside the target model lifecycle."""
 
     if audit.attached_target_name is None:
         raise PlannerInputError(
@@ -97,24 +114,11 @@ def _validate_model_attached_audit(
         key=attached_key, upstream_deps=upstream_deps
     )
 
-    ref: CompileSqlReference
-    for ref in audit.references:
-        if ref.ref_kind != SqlReferenceKind.REF:
-            continue
-        if ref.ref_name == audit.attached_target_name:
-            continue
-        ref_key: CompiledObjectKey = CompiledObjectKey(
-            resource_type=CompiledResourceType.MODEL, name=ref.ref_name
-        )
-        seed_key: CompiledObjectKey = CompiledObjectKey(
-            resource_type=CompiledResourceType.SEED, name=ref.ref_name
-        )
-        if ref_key not in attached_upstream and seed_key not in attached_upstream:
-            raise PlannerInputError(
-                f"audit '{audit.name}': model-attached audit on '{audit.attached_target_name}' "
-                f"references '{ref.ref_name}' which is not upstream of "
-                f"'{audit.attached_target_name}'"
-            )
+    dep_key: CompiledObjectKey
+    for dep_key in audit.scope_deps:
+        if dep_key != attached_key and dep_key not in attached_upstream:
+            return False
+    return True
 
 
 def _infer_singular_attachment(

{sqlbuild-0.76.0 → sqlbuild-0.76.2}/src/sqlbuild/compiler/planner/_helpers/output/plan_entry.py

@@ -11,6 +11,7 @@ from sqlbuild.adapter.contract.models import ColumnInfo, RelationInfo
 from sqlbuild.compiler.compile.exceptions import CompileInputError
 from sqlbuild.compiler.compile.main._cursor_roles import resolve_cursor_input_roles
 from sqlbuild.compiler.compile.models import (
+    CompiledAudit,
     CompiledModel,
     CompiledObjectKey,
     CompiledProject,
@@ -19,7 +20,7 @@ from sqlbuild.compiler.compile.models import (
     CompileSqlReference,
     CursorInputRoles,
 )
-from sqlbuild.compiler.compile.types import CompiledResourceType
+from sqlbuild.compiler.compile.types import AttachedAuditTargetKind, CompiledResourceType
 from sqlbuild.compiler.fingerprints.models import Fingerprint
 from sqlbuild.compiler.planner._helpers.graph.source_load_nodes import build_source_load_map
 from sqlbuild.compiler.planner._helpers.output.cursor_type_check import (
@@ -147,9 +148,13 @@ def build_planner_relations_context(
             deferred_locations=effective_deferral.deferred_locations,
             selected_keys=scope.selected_keys,
         )
-    source_map: dict[str, SourceEntry] = build_source_load_map(
+    audit_relation_keys: frozenset[CompiledObjectKey] = _selected_audit_relation_keys(
         project=project,
         selected_keys=scope.selected_keys,
+    )
+    source_map: dict[str, SourceEntry] = build_source_load_map(
+        project=project,
+        selected_keys=scope.selected_keys | audit_relation_keys,
         upstream_deps=scope.upstream_deps if scope.all_keys else None,
     )
     source_read_map: dict[str, SourceEntry] = (
@@ -1530,6 +1535,42 @@ def scope_overlaps(
     return False
 
 
+def audit_is_selected(
+    *,
+    audit: CompiledAudit,
+    selected_keys: frozenset[CompiledObjectKey],
+) -> bool:
+    """Return whether an audit belongs to the selected logical target scope."""
+
+    if audit.attached_target_kind is not None and audit.attached_target_name is not None:
+        resource_type: CompiledResourceType = (
+            CompiledResourceType.SOURCE
+            if audit.attached_target_kind == AttachedAuditTargetKind.SOURCE
+            else CompiledResourceType.MODEL
+        )
+        target_key: CompiledObjectKey = CompiledObjectKey(
+            resource_type=resource_type,
+            name=audit.attached_target_name,
+        )
+        return target_key in selected_keys
+    return scope_overlaps(scope_deps=audit.scope_deps, selected_keys=selected_keys)
+
+
+def _selected_audit_relation_keys(
+    *,
+    project: CompiledProject,
+    selected_keys: frozenset[CompiledObjectKey],
+) -> frozenset[CompiledObjectKey]:
+    """Return relation keys needed to render selected audits without selecting those relations."""
+
+    relation_keys: set[CompiledObjectKey] = set()
+    audit: CompiledAudit
+    for audit in project.audits:
+        if audit_is_selected(audit=audit, selected_keys=selected_keys):
+            relation_keys.update(audit.scope_deps)
+    return frozenset(relation_keys)
+
+
 def build_model_materializations(
     model_entries: tuple[ModelPlanEntry, ...],
 ) -> dict[str, str]:

{sqlbuild-0.76.0 → sqlbuild-0.76.2}/src/sqlbuild/compiler/planner/_helpers/output/plan_output.py

@@ -22,6 +22,7 @@ from sqlbuild.compiler.planner._helpers.graph.loader_dag import upstream_loader_
 from sqlbuild.compiler.planner._helpers.graph.source_load_nodes import build_source_load_entries
 from sqlbuild.compiler.planner._helpers.output.audit_entry import plan_audit
 from sqlbuild.compiler.planner._helpers.output.plan_entry import (
+    audit_is_selected,
     build_model_materializations,
     extract_seed_columns,
     scope_overlaps,
@@ -384,7 +385,7 @@ def _build_audit_entries(
     entries: list[AuditPlanEntry] = []
     audit: CompiledAudit
     for audit in project.audits:
-        if not scope_overlaps(scope_deps=audit.scope_deps, selected_keys=scope.selected_keys):
+        if not audit_is_selected(audit=audit, selected_keys=scope.selected_keys):
             continue
         entries.append(
             plan_audit(

{sqlbuild-0.76.0 → sqlbuild-0.76.2}/src/sqlbuild/compiler/planner/models.py

@@ -26,7 +26,7 @@ from sqlbuild.compiler.compile.models import (
     CompiledRelationLocation,
     FunctionReturnColumn,
 )
-from sqlbuild.compiler.compile.types import FunctionLanguage
+from sqlbuild.compiler.compile.types import AttachedAuditTargetKind, FunctionLanguage
 from sqlbuild.compiler.discovery.models import DiscoveredHookFunction, SqlTestParameterDeclaration
 from sqlbuild.compiler.fingerprints.models import Fingerprint
 from sqlbuild.compiler.planner.exceptions import PlannerInputError
@@ -901,6 +901,7 @@ class AuditPlanEntry:
     requested_run_scope: AuditRunScope
     effective_run_scope: AuditRunScope
     scope_deps: tuple[CompiledObjectKey, ...] = field(default_factory=tuple)
+    attached_target_kind: AttachedAuditTargetKind | None = None
     attached_target_name: str | None = None
     attached_column_name: str | None = None
     always_run: bool = False

{sqlbuild-0.76.0 → sqlbuild-0.76.2}/src/sqlbuild/executor/auditing/main/_execute.py

@@ -100,6 +100,7 @@ def execute_audit(
         row_count=row_count,
         executed_sql=executed_sql,
         run_scope_phase=run_scope_phase,
+        attached_target_kind=audit.attached_target_kind,
         attached_target_name=audit.attached_target_name,
         attached_column_name=audit.attached_column_name,
     )

{sqlbuild-0.76.0 → sqlbuild-0.76.2}/src/sqlbuild/executor/auditing/main/resource_id.py

@@ -1,21 +1,27 @@
 """Canonical resource identity for an attached audit execution."""
 
 from sqlbuild.compiler.auditing.types import AuditAttachmentKind
+from sqlbuild.compiler.compile.types import AttachedAuditTargetKind
 
 
 def audit_resource_id(
     *,
     audit_name: str,
     attachment_kind: AuditAttachmentKind,
+    attached_target_kind: AttachedAuditTargetKind | None = None,
     attached_target_name: str | None,
     attached_column_name: str | None,
 ) -> str:
     """Format the stable execution-protocol identity of one attached audit."""
 
+    identity_kind: str = (
+        attached_target_kind.value if attached_target_kind is not None else attachment_kind.value
+    )
+
     parts: tuple[str | None, ...] = (
         "audit",
         audit_name,
-        attachment_kind.value,
+        identity_kind,
         attached_target_name,
         attached_column_name,
     )

{sqlbuild-0.76.0 → sqlbuild-0.76.2}/src/sqlbuild/executor/auditing/models.py

@@ -10,6 +10,7 @@ from sqlbuild.compiler.auditing.types import (
     AuditRunScope,
     AuditSeverity,
 )
+from sqlbuild.compiler.compile.types import AttachedAuditTargetKind
 
 
 @dataclass(frozen=True)
@@ -23,6 +24,7 @@ class AuditExecutionResult:
     row_count: int
     executed_sql: str
     run_scope_phase: AuditRunScope = AuditRunScope.FINAL
+    attached_target_kind: AttachedAuditTargetKind | None = None
     attached_target_name: str | None = None
     attached_column_name: str | None = None
     reused: bool = False

{sqlbuild-0.76.0 → sqlbuild-0.76.2}/src/sqlbuild/executor/build/_helpers/end_audits.py

@@ -36,6 +36,7 @@ def run_end_audits(
             resource_id=audit_resource_id(
                 audit_name=audit.name,
                 attachment_kind=audit.attachment_kind,
+                attached_target_kind=audit.attached_target_kind,
                 attached_target_name=audit.attached_target_name,
                 attached_column_name=audit.attached_column_name,
             ),

{sqlbuild-0.76.0 → sqlbuild-0.76.2}/src/sqlbuild/executor/build/_helpers/source_audits.py

@@ -57,6 +57,7 @@ def run_pending_source_audits(
                 resource_id=audit_resource_id(
                     audit_name=audit.name,
                     attachment_kind=audit.attachment_kind,
+                    attached_target_kind=audit.attached_target_kind,
                     attached_target_name=audit.attached_target_name,
                     attached_column_name=audit.attached_column_name,
                 ),

{sqlbuild-0.76.0 → sqlbuild-0.76.2}/src/sqlbuild/executor/pipeline/_helpers/auditing.py

@@ -54,6 +54,7 @@ def run_audit_pipeline(
                 resource_id=audit_resource_id(
                     audit_name=entry.name,
                     attachment_kind=entry.attachment_kind,
+                    attached_target_kind=entry.attached_target_kind,
                     attached_target_name=entry.attached_target_name,
                     attached_column_name=entry.attached_column_name,
                 ),

{sqlbuild-0.76.0 → sqlbuild-0.76.2}/src/sqlbuild/executor/run/_helpers/reuse/audit.py

@@ -46,6 +46,7 @@ def reused_final_audit_results_by_binding_key(
             row_count=0,
             executed_sql=audit.resolved_sql,
             run_scope_phase=AuditRunScope.FINAL,
+            attached_target_kind=audit.attached_target_kind,
             attached_target_name=audit.attached_target_name,
             attached_column_name=audit.attached_column_name,
             reused=True,