sqlbuild 0.83.0__tar.gz → 0.83.2__tar.gz

{sqlbuild-0.83.0 → sqlbuild-0.83.2}/Cargo.lock

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

{sqlbuild-0.83.0 → sqlbuild-0.83.2}/PKG-INFO

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

{sqlbuild-0.83.0 → sqlbuild-0.83.2}/crates/sqlbuild-kata-native/Cargo.toml

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

{sqlbuild-0.83.0 → sqlbuild-0.83.2}/pyproject.toml

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

sqlbuild-0.83.2/src/sqlbuild/cli/commands/_helpers/compile/sql_test_artifact_cache.py

@@ -0,0 +1,287 @@
+"""Persistent identities for unchanged compiled SQL test artifacts."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import platform
+from importlib.metadata import PackageNotFoundError, version
+from pathlib import Path
+from typing import cast
+
+from sqlbuild.adapter.contract.classes.base_adapter import BaseAdapter
+from sqlbuild.cli.commands.models import (
+    SqlTestArtifactCacheRecord,
+    SqlTestArtifactIdentityContext,
+)
+from sqlbuild.compiler.compile.models import (
+    CompiledDirectLogicSqlTestPayload,
+    CompiledModel,
+    CompiledModelSqlTestPayload,
+    CompiledProject,
+    CompiledSqlTest,
+    CompileSqlTestCte,
+)
+
+_CACHE_VERSION: int = 1
+_ALGORITHM_FINGERPRINT: str = "sql-test-artifact-v1"
+_CACHE_FILE_NAME: str = "sql-test-artifacts.json"
+_MAX_CACHE_BYTES: int = 10_000_000
+_MAX_CACHE_RECORDS: int = 100_000
+_PARENT_PATH_COMPONENT: str = ".."
+_SQL_FILE_SUFFIX: str = ".sql"
+
+
+def build_sql_test_artifact_identity_context(
+    *, project: CompiledProject, adapter: BaseAdapter
+) -> SqlTestArtifactIdentityContext:
+    """Hash adapter and model inputs once for all test artifact identities."""
+
+    common_identity: str = _payload_digest(
+        {
+            "algorithm": _ALGORITHM_FINGERPRINT,
+            "sqlbuild_version": _package_version("sqlbuild"),
+            "polyglot_version": _package_version("polyglot-sql"),
+            "python_version": platform.python_version_tuple()[:2],
+            "adapter_class": f"{type(adapter).__module__}.{type(adapter).__qualname__}",
+            "set_difference_operator": adapter.render_set_difference_operator(),
+            "sql_analysis_dialect": adapter.sql_analysis_dialect(),
+            "requires_derived_table_aliases": adapter.requires_derived_table_aliases(),
+            "sql_analysis_enabled": project.settings.sql_analysis,
+            "effective_target_name": project.effective_target_name,
+            "effective_target_database": project.effective_target_database,
+            "effective_target_schema": project.effective_target_schema,
+            "function_locations": sorted(
+                (function.name, function.destination.qualified_name)
+                for function in project.functions
+            ),
+        }
+    )
+    return SqlTestArtifactIdentityContext(
+        common_identity=common_identity,
+        model_identities={model.name: _model_identity(model=model) for model in project.models},
+    )
+
+
+def sql_test_artifact_identity(
+    *,
+    test: CompiledSqlTest,
+    model_chain_names: tuple[str, ...],
+    context: SqlTestArtifactIdentityContext,
+) -> str:
+    """Return the complete identity of one rendered comparison artifact."""
+
+    return _payload_digest(
+        {
+            "common_identity": context.common_identity,
+            "test": _test_payload(test=test),
+            "model_chain": [
+                (name, context.model_identities.get(name)) for name in model_chain_names
+            ],
+        }
+    )
+
+
+def sql_test_artifact_record_key(*, test: CompiledSqlTest) -> str:
+    """Return the stable cache slot for one source test case."""
+
+    return _payload_digest(
+        {
+            "source_path": None if test.source_path is None else test.source_path.as_posix(),
+            "block_index": test.block_index,
+            "name": test.name,
+            "parent_name": test.parent_name,
+            "case_name": test.case_name,
+            "case_index": test.case_index,
+        }
+    )
+
+
+def read_sql_test_artifact_cache(
+    *, cache_dir: Path | None
+) -> dict[str, SqlTestArtifactCacheRecord]:
+    """Read valid cache records; cache failures never fail compilation."""
+
+    if cache_dir is None:
+        return {}
+    cache_path: Path = cache_dir / _CACHE_FILE_NAME
+    try:
+        if not cache_path.is_file() or cache_path.stat().st_size > _MAX_CACHE_BYTES:
+            return {}
+        payload: object = json.loads(cache_path.read_text(encoding="utf-8"))
+        if not isinstance(payload, dict) or payload.get("version") != _CACHE_VERSION:
+            return {}
+        raw_records: object = payload.get("records")
+        if not isinstance(raw_records, dict) or len(raw_records) > _MAX_CACHE_RECORDS:
+            return {}
+        records: dict[str, SqlTestArtifactCacheRecord] = {}
+        for key, value in raw_records.items():
+            record: SqlTestArtifactCacheRecord | None = _record_from_payload(value)
+            if isinstance(key, str) and record is not None:
+                records[key] = record
+        return records
+    except (OSError, ValueError, TypeError, json.JSONDecodeError):
+        return {}
+
+
+def write_sql_test_artifact_cache(
+    *, cache_dir: Path | None, records: dict[str, SqlTestArtifactCacheRecord]
+) -> None:
+    """Atomically replace the cache snapshot; cache failures are non-fatal."""
+
+    if cache_dir is None:
+        return
+    payload: dict[str, object] = {
+        "version": _CACHE_VERSION,
+        "records": {
+            key: {
+                "identity": record.identity,
+                "relative_path": record.relative_path.as_posix(),
+                "size": record.size,
+                "mtime_ns": record.mtime_ns,
+            }
+            for key, record in records.items()
+        },
+    }
+    try:
+        cache_dir.mkdir(parents=True, exist_ok=True)
+        cache_path: Path = cache_dir / _CACHE_FILE_NAME
+        temporary_path: Path = cache_dir / f".{_CACHE_FILE_NAME}.{os.getpid()}.tmp"
+        temporary_path.write_text(
+            json.dumps(payload, ensure_ascii=True, separators=(",", ":"), sort_keys=True),
+            encoding="utf-8",
+        )
+        temporary_path.replace(cache_path)
+    except OSError:
+        return
+
+
+def artifact_matches_cache_record(
+    *, tests_root: Path, record: SqlTestArtifactCacheRecord, identity: str
+) -> Path | None:
+    """Return the safe existing artifact path when identity and stat metadata match."""
+
+    if record.identity != identity or not _is_safe_relative_sql_path(record.relative_path):
+        return None
+    artifact_path: Path = tests_root / record.relative_path
+    try:
+        stat: os.stat_result = artifact_path.stat()
+    except OSError:
+        return None
+    if (
+        not artifact_path.is_file()
+        or stat.st_size != record.size
+        or stat.st_mtime_ns != record.mtime_ns
+    ):
+        return None
+    return artifact_path
+
+
+def build_sql_test_artifact_cache_record(
+    *, tests_root: Path, artifact_path: Path, identity: str
+) -> SqlTestArtifactCacheRecord | None:
+    """Capture the metadata needed to reuse one newly written artifact."""
+
+    try:
+        relative_path: Path = artifact_path.relative_to(tests_root)
+        stat: os.stat_result = artifact_path.stat()
+    except (OSError, ValueError):
+        return None
+    if not _is_safe_relative_sql_path(relative_path):
+        return None
+    return SqlTestArtifactCacheRecord(
+        identity=identity,
+        relative_path=relative_path,
+        size=stat.st_size,
+        mtime_ns=stat.st_mtime_ns,
+    )
+
+
+def _model_identity(*, model: CompiledModel) -> str:
+    return _payload_digest(
+        {
+            "name": model.name,
+            "query_sql": model.query_sql,
+            "deps": sorted((str(dep.resource_type), dep.name) for dep in model.deps),
+        }
+    )
+
+
+def _test_payload(*, test: CompiledSqlTest) -> dict[str, object]:
+    payload: dict[str, object] = {
+        "case_fingerprint": test.case_fingerprint,
+        "mode": test.mode.value,
+        "sql_body": test.sql_body,
+        "scope_deps": sorted((str(dep.resource_type), dep.name) for dep in test.scope_deps),
+    }
+    if isinstance(test.payload, CompiledModelSqlTestPayload):
+        payload["model"] = {
+            "authored_ctes": _cte_payload(test.payload.authored_ctes),
+            "macro_mocks": sorted(test.payload.macro_mocks.items()),
+            "model_query_overrides": sorted(test.payload.model_query_overrides.items()),
+            "expected_model_names": test.payload.expected_model_names,
+            "assertion_ctes": _cte_payload(test.payload.assertion_ctes),
+        }
+    elif isinstance(test.payload, CompiledDirectLogicSqlTestPayload):
+        payload["direct"] = {
+            "helper_ctes": _cte_payload(test.payload.helper_ctes),
+            "actual_cte": _cte_payload((test.payload.actual_cte,)),
+            "expected_cte": _cte_payload((test.payload.expected_cte,)),
+            "tested_resource_names": test.payload.tested_resource_names,
+        }
+    return payload
+
+
+def _cte_payload(ctes: tuple[CompileSqlTestCte, ...]) -> list[tuple[str, str]]:
+    return [(cte.name, cte.sql_body) for cte in ctes]
+
+
+def _record_from_payload(payload: object) -> SqlTestArtifactCacheRecord | None:
+    if not isinstance(payload, dict):
+        return None
+    values: dict[str, object] = cast(dict[str, object], payload)
+    identity: object = values.get("identity")
+    relative_path: object = values.get("relative_path")
+    size: object = values.get("size")
+    mtime_ns: object = values.get("mtime_ns")
+    if (
+        not isinstance(identity, str)
+        or not isinstance(relative_path, str)
+        or not isinstance(size, int)
+        or isinstance(size, bool)
+        or size < 0
+        or not isinstance(mtime_ns, int)
+        or isinstance(mtime_ns, bool)
+        or mtime_ns < 0
+    ):
+        return None
+    path: Path = Path(relative_path)
+    if not _is_safe_relative_sql_path(path):
+        return None
+    return SqlTestArtifactCacheRecord(
+        identity=identity,
+        relative_path=path,
+        size=size,
+        mtime_ns=mtime_ns,
+    )
+
+
+def _is_safe_relative_sql_path(path: Path) -> bool:
+    return (
+        not path.is_absolute()
+        and _PARENT_PATH_COMPONENT not in path.parts
+        and path.suffix == _SQL_FILE_SUFFIX
+    )
+
+
+def _payload_digest(payload: object) -> str:
+    encoded: str = json.dumps(payload, ensure_ascii=True, separators=(",", ":"), sort_keys=True)
+    return hashlib.sha256(encoded.encode("utf-8")).hexdigest()
+
+
+def _package_version(package_name: str) -> str:
+    try:
+        return version(package_name)
+    except PackageNotFoundError:
+        return "unknown"

{sqlbuild-0.83.0 → sqlbuild-0.83.2}/src/sqlbuild/cli/commands/_helpers/compile/target_writer.py

@@ -6,11 +6,27 @@ import json
 from pathlib import Path
 
 from sqlbuild.adapter.contract.classes.base_adapter import BaseAdapter
-from sqlbuild.cli.commands.models import WrittenTarget
+from sqlbuild.cli.commands._helpers.compile.sql_test_artifact_cache import (
+    artifact_matches_cache_record,
+    build_sql_test_artifact_cache_record,
+    build_sql_test_artifact_identity_context,
+    read_sql_test_artifact_cache,
+    sql_test_artifact_identity,
+    sql_test_artifact_record_key,
+    write_sql_test_artifact_cache,
+)
+from sqlbuild.cli.commands.models import (
+    SqlTestArtifactCacheRecord,
+    SqlTestArtifactIdentityContext,
+    WrittenTarget,
+)
 from sqlbuild.cli.paths.main._sql_test_output_path import sql_test_output_path
 from sqlbuild.compiler.compile.models import CompiledProject
 from sqlbuild.compiler.compile.types import FunctionLanguage
-from sqlbuild.compiler.planner.main.execution.sql_test_assembly import build_sql_test_plan_entry
+from sqlbuild.compiler.planner.main.execution.sql_test_assembly import (
+    _sql_test_model_chain_names,
+    build_sql_test_plan_entry,
+)
 from sqlbuild.compiler.planner.models import AuditPlanEntry, PlanOutput
 from sqlbuild.executor.testing.main.comparison_sql import build_sql_test_comparison_sql
 
@@ -245,14 +261,44 @@ def _write_static_tests(
     """Write offline SQL-native test SQL."""
 
     managed_paths: set[Path] = set()
+    tests_root: Path = target_dir / _COMPILED_DIR / _TESTS_DIR
+    cached_records: dict[str, SqlTestArtifactCacheRecord] = read_sql_test_artifact_cache(
+        cache_dir=project.compile_cache_dir
+    )
+    current_records: dict[str, SqlTestArtifactCacheRecord] = {}
+    identity_context: SqlTestArtifactIdentityContext | None = (
+        build_sql_test_artifact_identity_context(project=project, adapter=adapter)
+        if project.compile_cache_dir is not None
+        else None
+    )
     for test in project.sql_tests:
+        record_key: str | None = None
+        artifact_identity: str | None = None
+        if identity_context is not None:
+            record_key = sql_test_artifact_record_key(test=test)
+            artifact_identity = sql_test_artifact_identity(
+                test=test,
+                model_chain_names=_sql_test_model_chain_names(test=test, project=project),
+                context=identity_context,
+            )
+            cached_record: SqlTestArtifactCacheRecord | None = cached_records.get(record_key)
+            if cached_record is not None:
+                cached_path: Path | None = artifact_matches_cache_record(
+                    tests_root=tests_root,
+                    record=cached_record,
+                    identity=artifact_identity,
+                )
+                if cached_path is not None:
+                    managed_paths.add(cached_path)
+                    current_records[record_key] = cached_record
+                    continue
         entry, _warnings = build_sql_test_plan_entry(
             test=test,
             project=project,
             adapter=adapter,
             sql_analysis_enabled=project.settings.sql_analysis,
         )
-        test_path: Path = target_dir / _COMPILED_DIR / _TESTS_DIR / sql_test_output_path(entry)
+        test_path: Path = tests_root / sql_test_output_path(entry)
         _write_sql(
             path=test_path,
             sql=build_sql_test_comparison_sql(
@@ -262,6 +308,18 @@ def _write_static_tests(
             ),
         )
         managed_paths.add(test_path)
+        if record_key is not None and artifact_identity is not None:
+            record: SqlTestArtifactCacheRecord | None = build_sql_test_artifact_cache_record(
+                tests_root=tests_root,
+                artifact_path=test_path,
+                identity=artifact_identity,
+            )
+            if record is not None:
+                current_records[record_key] = record
+    write_sql_test_artifact_cache(
+        cache_dir=project.compile_cache_dir,
+        records=current_records,
+    )
     return managed_paths
 
 

{sqlbuild-0.83.0 → sqlbuild-0.83.2}/src/sqlbuild/cli/commands/models.py

@@ -545,6 +545,24 @@ class CompileWriteResult:
     write_ms: int
 
 
+@dataclass(frozen=True)
+class SqlTestArtifactCacheRecord:
+    """Validated metadata for one previously written SQL test artifact."""
+
+    identity: str
+    relative_path: Path
+    size: int
+    mtime_ns: int
+
+
+@dataclass(frozen=True)
+class SqlTestArtifactIdentityContext:
+    """Project-wide identity fragments shared by every SQL test."""
+
+    common_identity: str
+    model_identities: dict[str, str]
+
+
 @dataclass(frozen=True)
 class WrittenTarget:
     """Result of writing compiled output to target/."""

{sqlbuild-0.83.0 → sqlbuild-0.83.2}/src/sqlbuild/cli/output/_helpers/execution_result_document.py

@@ -974,6 +974,8 @@ def _format_audit_checks(
             {
                 "kind": "audit",
                 "name": result.audit_name,
+                "audit_definition_name": result.audit_definition_name,
+                "audit_description": result.audit_description,
                 "check_id": _audit_check_id(result),
                 "passed": result.outcome in {AuditOutcome.PASS, AuditOutcome.INSUFFICIENT},
                 "status": result.outcome.value,

{sqlbuild-0.83.0 → sqlbuild-0.83.2}/src/sqlbuild/cli/output/_helpers/integration_result.py

@@ -388,6 +388,8 @@ def _audit_result(result: AuditExecutionResult) -> IntegrationCheckResult:
             if result.evaluation_mode == AuditEvaluationMode.MEASUREMENT
             else None
         ),
+        audit_definition_name=result.audit_definition_name,
+        audit_description=result.audit_description,
     )
 
 

{sqlbuild-0.83.0 → sqlbuild-0.83.2}/src/sqlbuild/cli/output/constants.py

@@ -11,6 +11,7 @@ INTEGRATION_CHECK_NON_FAIL_STATUSES: frozenset[str] = frozenset({"insufficient",
 INTEGRATION_FAILED_STATUS: str = "failed"
 INTEGRATION_SKIPPED_STATUS: str = "skipped"
 INTEGRATION_LOADER_KIND: str = "loader"
+INTEGRATION_AUDIT_KIND: str = "audit"
 MAX_INTEGRATION_RECORD_BYTES: int = 65_536
 MAX_INTEGRATION_STRING_CHARS: int = 2_048
 MAX_INTEGRATION_IDENTIFIER_CHARS: int = 512
@@ -33,7 +34,9 @@ INTEGRATION_ASSET_KINDS: frozenset[str] = frozenset(
         "view",
     }
 )
-INTEGRATION_CHECK_KINDS: frozenset[str] = frozenset({"audit", "python_check", "sql_test"})
+INTEGRATION_CHECK_KINDS: frozenset[str] = frozenset(
+    {INTEGRATION_AUDIT_KIND, "python_check", "sql_test"}
+)
 INTEGRATION_RESOURCE_KINDS: frozenset[str] = INTEGRATION_ASSET_KINDS | frozenset(
     {"audit", "check", "test"}
 )

{sqlbuild-0.83.0 → sqlbuild-0.83.2}/src/sqlbuild/cli/output/models.py

@@ -20,6 +20,7 @@ from sqlbuild.cli.output._helpers.integration_validation import (
 from sqlbuild.cli.output.constants import (
     INTEGRATION_ASSET_KINDS,
     INTEGRATION_ASSET_STATUSES,
+    INTEGRATION_AUDIT_KIND,
     INTEGRATION_CHECK_ATTACHMENT_KINDS,
     INTEGRATION_CHECK_KINDS,
     INTEGRATION_CHECK_NON_FAIL_STATUSES,
@@ -202,6 +203,8 @@ class IntegrationCheckResult:
     thresholds: Mapping[str, object] | None = None
     evidence_count: int | None = None
     evidence_truncated: bool | None = None
+    audit_definition_name: str | None = None
+    audit_description: str | None = None
 
     def __post_init__(self) -> None:
         for field_name, value in (
@@ -213,6 +216,10 @@ class IntegrationCheckResult:
         validate_optional_identifier(value=self.dag_check_id, field_name="dag_check_id")
         if self.kind not in INTEGRATION_CHECK_KINDS:
             raise ObservabilityValidationError("integration check kind is unsupported")
+        if self.kind == INTEGRATION_AUDIT_KIND and self.audit_definition_name is None:
+            raise ObservabilityValidationError(
+                "integration audit check requires audit_definition_name"
+            )
         if self.status not in INTEGRATION_CHECK_STATUSES:
             raise ObservabilityValidationError("integration check status is unsupported")
         if type(self.passed) is not bool:
@@ -237,6 +244,7 @@ class IntegrationCheckResult:
             ("attached_column_name", self.attached_column_name),
             ("attached_target_name", self.attached_target_name),
             ("run_scope_phase", self.run_scope_phase),
+            ("audit_definition_name", self.audit_definition_name),
         ):
             validate_optional_identifier(value=value, field_name=field_name)
         if self.row_count is not None and (type(self.row_count) is not int or self.row_count < 0):
@@ -265,6 +273,12 @@ class IntegrationCheckResult:
             raise ObservabilityValidationError(
                 "integration check evidence_truncated must be boolean"
             )
+        if self.audit_description is not None and (
+            not isinstance(self.audit_description, str) or not self.audit_description.strip()
+        ):
+            raise ObservabilityValidationError(
+                "integration check audit_description must be a non-empty string"
+            )
         if self.thresholds is not None:
             self._validate_measurement_thresholds()
 

{sqlbuild-0.83.0 → sqlbuild-0.83.2}/src/sqlbuild/compiler/compile/_helpers/analysis/cache.py

@@ -1,4 +1,4 @@
-"""Versioned project-local cache for successful model SQL analysis facts."""
+"""Versioned project-local cache for deterministic model SQL analysis facts."""
 
 from __future__ import annotations
 
@@ -31,8 +31,8 @@ from sqlbuild.compiler.lineage.types import (
 )
 from sqlbuild.compiler.references.types import SqlReferenceKind
 
-_ANALYSIS_CACHE_VERSION: int = 4
-_ANALYSIS_ALGORITHM_FINGERPRINT: str = "model-sql-analysis-v4"
+_ANALYSIS_CACHE_VERSION: int = 5
+_ANALYSIS_ALGORITHM_FINGERPRINT: str = "model-sql-analysis-v5"
 _MAX_CACHE_ENTRY_BYTES: int = 10_000_000
 _SHA256_HEX_LENGTH: int = 64
 _CACHE_ENTRY_SEPARATOR: str = "\n"
@@ -229,12 +229,10 @@ def write_model_analyses(
     latest_analyses_by_model: dict[str, PolyglotAnalysisResult] | None = None,
     dependency_signatures_by_key: dict[str, dict[str, str]] | None = None,
 ) -> None:
-    """Transactionally persist successful analyses; cache failures never fail compilation."""
+    """Transactionally persist deterministic analyses; cache failures never fail compilation."""
 
     rows: list[tuple[str, str]] = []
     for cache_key, analysis in analyses_by_key.items():
-        if not analysis.analysis_succeeded:
-            continue
         contents: str = _analysis_contents(cache_key=cache_key, analysis=analysis)
         if len(contents.encode()) <= _MAX_CACHE_ENTRY_BYTES:
             rows.append((cache_key, contents))
@@ -246,12 +244,11 @@ def write_model_analyses(
             model_analysis_output_signature(analysis),
         )
         for model_name, analysis in (latest_analyses_by_model or {}).items()
-        if analysis.analysis_succeeded
     ]
     dependency_rows: list[tuple[str, str, str, str]] = []
     for cache_key, dependencies in (dependency_signatures_by_key or {}).items():
         analysis: PolyglotAnalysisResult | None = analyses_by_key.get(cache_key)
-        if analysis is None or not analysis.analysis_succeeded:
+        if analysis is None:
             continue
         dependency_rows.extend(
             (context.signature_namespace, cache_key, upstream_name, output_signature)
@@ -436,6 +433,7 @@ def _analysis_payload(*, cache_key: str, analysis: PolyglotAnalysisResult) -> di
     return {
         "v": _ANALYSIS_CACHE_VERSION,
         "k": cache_key,
+        "a": analysis.analysis_succeeded,
         "s": model_analysis_output_signature(analysis),
         "c": (
             None
@@ -476,6 +474,9 @@ def _analysis_from_payload(
         raise AnalysisCacheEntryError("analysis cache version mismatch")
     if values["k"] != expected_cache_key:
         raise AnalysisCacheEntryError("analysis cache key mismatch")
+    analysis_succeeded: object = values["a"]
+    if not isinstance(analysis_succeeded, bool):
+        raise AnalysisCacheEntryError("analysis cache success flag must be a boolean")
     output_signature: object = values["s"]
     if not (
         isinstance(output_signature, str)
@@ -497,7 +498,7 @@ def _analysis_from_payload(
         raise AnalysisCacheEntryError("analysis cache has_star must be a boolean")
     return (
         PolyglotAnalysisResult(
-            analysis_succeeded=True,
+            analysis_succeeded=analysis_succeeded,
             columns=columns,
             lineage_columns=lineage_columns,
             has_star=has_star,

{sqlbuild-0.83.0 → sqlbuild-0.83.2}/src/sqlbuild/compiler/compile/_helpers/assembly/project.py

@@ -115,7 +115,7 @@ from sqlbuild.spec.contracts.models import (
     TargetConfig,
 )
 
-_POLYGLOT_ANALYSIS_WORKERS: int = 2
+_POLYGLOT_ANALYSIS_WORKERS: int = 4
 _POLYGLOT_PARALLEL_ANALYSIS_MIN_MODELS: int = 32
 _POLYGLOT_PARALLEL_REANALYSIS_MIN_MODELS: int = 2
 
@@ -202,6 +202,7 @@ def assemble_compiled_project(
             (inputs.effective_target.schema if inputs.effective_target is not None else None)
             or _str_or_none(inputs.effective_connection.get("schema"))
         ),
+        compile_cache_dir=inputs.compile_cache_dir,
         settings=inputs.effective_settings,
         scenario=resolve_effective_scenario_config(
             project_config=inputs.project_config,
@@ -464,9 +465,16 @@ def _analyze_model_sql_in_parallel(
         if request.cache_key is None or request.cache_key not in cached_analyses
     }
     changed_signature_names: set[str] = {
-        model_name
-        for model_name, output_signature in current_signatures_by_name.items()
-        if previous_signatures.get(model_name) != output_signature
+        _model_name(request.model_input)
+        for request, analysis in zip(requests, analyses, strict=True)
+        if (
+            previous_signatures.get(_model_name(request.model_input))
+            != current_signatures_by_name[_model_name(request.model_input)]
+            or (
+                not analysis.polyglot_analysis.analysis_succeeded
+                and request.cache_key not in cached_analyses
+            )
+        )
     }
     analyses_to_record_by_name.update(
         {model_name: current_analyses_by_name[model_name] for model_name in changed_signature_names}
@@ -934,6 +942,7 @@ def _assemble_compiled_audit(audit_input: CompileAuditInput) -> CompiledAudit:
             attached_target_name=audit_input.attached_target_name,
         ),
         name=audit_name,
+        definition_name=(audit_input.audit_block.name or audit_input.audit_file.file_path.stem),
         audit_file=audit_input.audit_file,
         audit_block=audit_input.audit_block,
         sql_body=audit_input.sql_body,
@@ -951,6 +960,7 @@ def _assemble_compiled_audit(audit_input: CompileAuditInput) -> CompiledAudit:
         severity=audit_input.severity,
         run_scope=audit_input.run_scope,
         always_run=audit_input.always_run,
+        description=audit_input.description,
     )
 
 

{sqlbuild-0.83.0 → sqlbuild-0.83.2}/src/sqlbuild/compiler/compile/_helpers/attachment/audits.py

@@ -536,6 +536,7 @@ def build_attached_audit_input(
         evidence_sql=expanded_evidence_sql,
         evidence_limit=audit_instance.evidence_limit,
         name=audit_instance.name,
+        description=audit_instance.description,
         references=references,
         attached_target_kind=attached_target_kind,
         attached_target_name=attached_target_name,