sqlbuild 0.55.2__tar.gz → 0.55.4__tar.gz

{sqlbuild-0.55.2 → sqlbuild-0.55.4}/Cargo.lock

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

{sqlbuild-0.55.2 → sqlbuild-0.55.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.55.2
+Version: 0.55.4
 Requires-Dist: duckdb>=1.3.2
 Requires-Dist: polyglot-sql>=0.5.10
 Requires-Dist: pydantic-settings>=2,<3

{sqlbuild-0.55.2 → sqlbuild-0.55.4}/crates/sqlbuild-kata-native/Cargo.toml

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

{sqlbuild-0.55.2 → sqlbuild-0.55.4}/pyproject.toml

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

{sqlbuild-0.55.2 → sqlbuild-0.55.4}/src/sqlbuild/cli/commands/_helpers/build_planning/defer_clone.py

@@ -22,15 +22,16 @@ from sqlbuild.cli.commands.models import (
     DeferClonePrephaseOutputContext,
 )
 from sqlbuild.compiler.compile.models import (
+    CompileAnalysisSelection,
     CompiledModel,
     CompiledObjectKey,
     CompiledProject,
 )
 from sqlbuild.compiler.compile.types import CompiledResourceType
 from sqlbuild.compiler.discovery.models import DiscoveredProjectInputs
-from sqlbuild.compiler.pipeline.main.clone import run_clone_pipeline
+from sqlbuild.compiler.pipeline.main.clone_with_options import run_clone_pipeline_with_options
 from sqlbuild.compiler.pipeline.main.compiled_project import build_compiled_project
-from sqlbuild.compiler.pipeline.models import ClonePipelineResult
+from sqlbuild.compiler.pipeline.models import ClonePipelineOptions, ClonePipelineResult
 from sqlbuild.compiler.planner.main.clone.resolve_clone_boundary import (
     resolve_clone_boundary,
 )
@@ -53,6 +54,7 @@ def build_defer_clone_boundary_selectors(
     adapter: BaseAdapter,
     selected_target: str | None,
     no_sql_validation: bool,
+    no_cache: bool,
     select: tuple[str, ...],
     exclude: tuple[str, ...],
     cli_vars: dict[str, object] | None,
@@ -66,6 +68,7 @@ def build_defer_clone_boundary_selectors(
         adapter=adapter,
         selected_target=selected_target,
         no_sql_validation=no_sql_validation,
+        analysis_selection=CompileAnalysisSelection(no_cache=no_cache),
         cli_vars=cli_vars,
         external_sql_reference_resolver=resolve_external_sql_reference_resolver(
             project_dir=project_dir,
@@ -139,6 +142,7 @@ def run_defer_clone_boundary_prephase(
         adapter=invocation.adapter,
         selected_target=request.selected_target,
         no_sql_validation=request.no_sql_validation,
+        no_cache=request.no_cache,
         select=request.select,
         exclude=request.exclude,
         cli_vars=request.cli_vars,
@@ -152,6 +156,7 @@ def run_defer_clone_boundary_prephase(
             origin_target_name=origin_target_name,
             destination_target_name=cloned_project.effective_target_name,
             no_sql_validation=request.no_sql_validation,
+            no_cache=request.no_cache,
             select=(*boundary_selectors, *view_chain_selectors),
             caused_by_names=request.select,
             cli_vars=request.cli_vars,
@@ -210,16 +215,18 @@ def run_defer_clone_prephase(
     )
     destination_connection: Any = adapter.connect(inputs.connection_config)
     try:
-        clone_pipeline: ClonePipelineResult = run_clone_pipeline(
+        clone_pipeline: ClonePipelineResult = run_clone_pipeline_with_options(
             discovered_inputs=discovered_inputs,
             adapter=adapter,
             origin_target_name=origin_target_name,
             destination_target_name=destination_target_name,
-            no_sql_validation=inputs.no_sql_validation,
-            select=inputs.select,
-            exclude=(),
-            cli_vars=cli_vars,
             destination_connection=destination_connection,
+            options=ClonePipelineOptions(
+                no_sql_validation=inputs.no_sql_validation,
+                no_cache=inputs.no_cache,
+                select=inputs.select,
+                cli_vars=cli_vars,
+            ),
             external_sql_reference_resolver=resolve_external_sql_reference_resolver(
                 project_dir=project_dir,
                 discovered_inputs=discovered_inputs,

{sqlbuild-0.55.2 → sqlbuild-0.55.4}/src/sqlbuild/cli/commands/_helpers/build_planning/planning.py

@@ -31,6 +31,7 @@ def compile_build_plan(
         adapter=invocation.adapter,
         options=CompilePipelineOptions(
             no_sql_validation=request.no_sql_validation,
+            no_cache=request.no_cache,
             selected_target=request.selected_target,
             defer_to=request.defer_to,
             defer_sources_to=request.defer_sources_to,

{sqlbuild-0.55.2 → sqlbuild-0.55.4}/src/sqlbuild/cli/commands/_helpers/build_virtual/virtual_execution.py

@@ -106,6 +106,7 @@ def execute_virtual_build(
             planning=VirtualPlanOptions(
                 selected_target=request.selected_target,
                 no_sql_validation=request.no_sql_validation,
+                no_cache=request.no_cache,
                 defer_sources_to=request.defer_sources_to,
                 cursor_overrides=request.cursor_overrides,
                 full_refresh=request.full_refresh,

{sqlbuild-0.55.2 → sqlbuild-0.55.4}/src/sqlbuild/cli/commands/_helpers/compile/pipeline.py

@@ -48,6 +48,7 @@ def analyze_compile_project(
     *,
     project_dir: Path,
     no_sql_validation: bool,
+    no_cache: bool,
     selected_target: str | None,
     lineage_mode: CompileLineageMode,
     cli_vars: dict[str, object] | None,
@@ -86,6 +87,7 @@ def analyze_compile_project(
         skip_column_inference=profile_flags.skip_column_inference,
         column_lineage_mode=compile_analysis_lineage_mode(lineage_mode),
         cli_vars=cli_vars,
+        no_cache=no_cache,
     )
     graph_ms: int = elapsed_ms(graph_start)
     _ = complete_compile_phase(

{sqlbuild-0.55.2 → sqlbuild-0.55.4}/src/sqlbuild/cli/commands/_helpers/entry/dispatch.py

@@ -65,6 +65,7 @@ def dispatch_cli_command(*, args: CliNamespace, handlers: CliEntrypointHandlers)
             CompileCommandRequest(
                 project_dir=project_dir,
                 no_sql_validation=args.no_sql_validation,
+                no_cache=args.no_cache,
                 defer_to=args.defer_to,
                 selected_target=args.target,
                 json_output=args.json,
@@ -93,6 +94,7 @@ def dispatch_cli_command(*, args: CliNamespace, handlers: CliEntrypointHandlers)
             PlanCommandRequest(
                 project_dir=project_dir,
                 no_sql_validation=args.no_sql_validation,
+                no_cache=args.no_cache,
                 defer_to=args.defer_to,
                 defer_sources_to=args.defer_sources_to,
                 selected_target=args.target,
@@ -128,6 +130,7 @@ def dispatch_cli_command(*, args: CliNamespace, handlers: CliEntrypointHandlers)
             BuildCommandRequest(
                 project_dir=project_dir,
                 no_sql_validation=args.no_sql_validation,
+                no_cache=args.no_cache,
                 defer_to=args.defer_to,
                 defer_clone_from=args.defer_clone_from,
                 defer_sources_to=args.defer_sources_to,

{sqlbuild-0.55.2 → sqlbuild-0.55.4}/src/sqlbuild/cli/commands/_helpers/entry/parser.py

@@ -57,6 +57,12 @@ def _add_compile_and_dag_parsers(
 ) -> None:
     compile_parser: argparse.ArgumentParser = subparsers.add_parser(CliCommand.COMPILE)
     compile_parser.add_argument("--no-sql-validation", action="store_true", default=False)
+    compile_parser.add_argument(
+        "--no-cache",
+        action="store_true",
+        default=False,
+        help="Bypass the compile analysis cache for this invocation",
+    )
     compile_parser.add_argument("--defer-to", default=None)
     compile_parser.add_argument("--target", default=None)
     compile_parser.add_argument("--json", action="store_true", default=False)
@@ -108,6 +114,12 @@ def _add_plan_and_build_parsers(
 ) -> None:
     plan_parser: argparse.ArgumentParser = subparsers.add_parser(CliCommand.PLAN)
     plan_parser.add_argument("--no-sql-validation", action="store_true", default=False)
+    plan_parser.add_argument(
+        "--no-cache",
+        action="store_true",
+        default=False,
+        help="Bypass the compile analysis cache for this invocation",
+    )
     plan_parser.add_argument("--defer-to", default=None)
     plan_parser.add_argument("--defer-sources-to", default=None)
     plan_parser.add_argument("--target", default=None)
@@ -135,6 +147,12 @@ def _add_plan_and_build_parsers(
 
     build_parser: argparse.ArgumentParser = subparsers.add_parser(CliCommand.BUILD)
     build_parser.add_argument("--no-sql-validation", action="store_true", default=False)
+    build_parser.add_argument(
+        "--no-cache",
+        action="store_true",
+        default=False,
+        help="Bypass the compile analysis cache for this invocation",
+    )
     build_parser.add_argument("--defer-to", default=None)
     build_parser.add_argument("--defer-clone-from", default=None)
     build_parser.add_argument("--defer-sources-to", default=None)

{sqlbuild-0.55.2 → sqlbuild-0.55.4}/src/sqlbuild/cli/commands/_helpers/plan/planning.py

@@ -42,6 +42,7 @@ def compile_plan_pipeline(
             options=VirtualPlanOptions(
                 selected_target=request.selected_target,
                 no_sql_validation=request.no_sql_validation,
+                no_cache=request.no_cache,
                 defer_sources_to=request.defer_sources_to,
                 cursor_overrides=request.cursor_overrides,
                 full_refresh=request.full_refresh,
@@ -84,6 +85,7 @@ def compile_plan_pipeline(
         options=CompilePipelineOptions(
             selected_target=request.selected_target,
             no_sql_validation=request.no_sql_validation,
+            no_cache=request.no_cache,
             defer_to=request.defer_to,
             defer_sources_to=request.defer_sources_to,
             cursor_overrides=request.cursor_overrides,

{sqlbuild-0.55.2 → sqlbuild-0.55.4}/src/sqlbuild/cli/commands/classes/cli_namespace.py

@@ -20,6 +20,7 @@ _DEFAULT_VALUES: dict[str, object] = {
     "overwrite": False,
     "skip_dbt_debug": False,
     "no_sql_validation": False,
+    "no_cache": False,
     "defer_to": None,
     "defer_clone_from": None,
     "defer_sources_to": None,
@@ -145,6 +146,7 @@ class CliNamespace:
     overwrite: bool
     skip_dbt_debug: bool
     no_sql_validation: bool
+    no_cache: bool
     defer_to: str | None
     defer_clone_from: str | None
     defer_sources_to: str | None

{sqlbuild-0.55.2 → sqlbuild-0.55.4}/src/sqlbuild/cli/commands/main/execution/_build.py

@@ -69,6 +69,7 @@ def run_build(request: BuildCommandRequest) -> int:
                 request=VirtualBuildCliRequest(
                     selected_target=request.selected_target,
                     no_sql_validation=request.no_sql_validation,
+                    no_cache=request.no_cache,
                     defer_sources_to=request.defer_sources_to,
                     cursor_overrides=request.cursor_overrides,
                     full_refresh=request.full_refresh,

{sqlbuild-0.55.2 → sqlbuild-0.55.4}/src/sqlbuild/cli/commands/main/project/_compile.py

@@ -65,6 +65,7 @@ def _run_compile_with_status(
     analysis: CompileAnalysis = analyze_compile_project(
         project_dir=project_dir,
         no_sql_validation=request.no_sql_validation,
+        no_cache=request.no_cache,
         selected_target=request.selected_target,
         lineage_mode=lineage_mode,
         cli_vars=request.cli_vars,

{sqlbuild-0.55.2 → sqlbuild-0.55.4}/src/sqlbuild/cli/commands/models.py

@@ -182,6 +182,7 @@ class BuildCommandRequest:
     manifest: bool = False
     json_output: bool = False
     json_output_path: Path | None = None
+    no_cache: bool = False
 
 
 @dataclass(frozen=True)
@@ -236,6 +237,7 @@ class DeferClonePrephaseInputs:
     cli_vars: dict[str, object] | None
     connection_config: dict[str, object]
     project_dir: Path
+    no_cache: bool = False
 
 
 @dataclass(frozen=True)
@@ -316,6 +318,7 @@ class VirtualBuildCliRequest:
     use_color: bool = False
     external_sql_reference_resolver: ExternalSqlReferenceResolver | None = None
     providers: ProviderContainer | None = None
+    no_cache: bool = False
 
 
 @dataclass(frozen=True)
@@ -450,6 +453,7 @@ class CompileCommandRequest:
     lineage_mode: CompileLineageMode = CompileLineageMode.FAST
     cli_vars: dict[str, object] | None = None
     profile_flags: CompileProfileFlags = CompileProfileFlags()
+    no_cache: bool = False
 
 
 @dataclass(frozen=True)
@@ -951,6 +955,7 @@ class PlanCommandRequest:
     cli_vars: dict[str, object] | None = None
     include_stale_upstreams: bool = False
     changes_only: bool = False
+    no_cache: bool = False
 
 
 @dataclass(frozen=True)

{sqlbuild-0.55.2 → sqlbuild-0.55.4}/src/sqlbuild/compiler/compile/_helpers/analysis/cache.py

@@ -12,6 +12,7 @@ from pathlib import Path
 from typing import Any, cast
 
 from sqlbuild.adapter.contract.models import ExpressionInferenceProfile
+from sqlbuild.compiler.compile._helpers.analysis.columns import table_function_analysis_name
 from sqlbuild.compiler.compile.exceptions import AnalysisCacheEntryError
 from sqlbuild.compiler.compile.models import (
     AnalysisCacheContext,
@@ -26,9 +27,10 @@ from sqlbuild.compiler.lineage.types import (
     ColumnTransformKind,
     InferredNullability,
 )
+from sqlbuild.compiler.references.types import SqlReferenceKind
 
-_ANALYSIS_CACHE_VERSION: int = 1
-_ANALYSIS_ALGORITHM_FINGERPRINT: str = "model-sql-analysis-v1"
+_ANALYSIS_CACHE_VERSION: int = 2
+_ANALYSIS_ALGORITHM_FINGERPRINT: str = "model-sql-analysis-v2"
 _MAX_CACHE_ENTRY_BYTES: int = 10_000_000
 _LOCAL_QUALNAME_MARKER: str = "<locals>"
 _SQLITE_QUERY_CHUNK_SIZE: int = 500
@@ -40,15 +42,32 @@ CREATE TABLE IF NOT EXISTS model_analysis (
     payload TEXT NOT NULL
 )
 """
+_CREATE_SIGNATURE_TABLE_SQL: str = """
+CREATE TABLE IF NOT EXISTS model_analysis_signature (
+    shared_fingerprint TEXT NOT NULL,
+    signature_namespace TEXT NOT NULL,
+    model_name TEXT NOT NULL,
+    output_signature TEXT NOT NULL,
+    PRIMARY KEY (shared_fingerprint, signature_namespace, model_name)
+)
+"""
+_CREATE_DEPENDENCY_TABLE_SQL: str = """
+CREATE TABLE IF NOT EXISTS model_analysis_dependency (
+    signature_namespace TEXT NOT NULL,
+    cache_key TEXT NOT NULL,
+    upstream_model_name TEXT NOT NULL,
+    output_signature TEXT NOT NULL,
+    PRIMARY KEY (signature_namespace, cache_key, upstream_model_name)
+)
+"""
 
 
 def build_analysis_cache_context(
     *,
     root: Path | None,
     inference_profile: ExpressionInferenceProfile,
-    column_nullability_by_table: dict[str, dict[str, InferredNullability]],
-    column_types_by_table: dict[str, dict[str, str]],
     allow_compact_analysis: bool,
+    signature_namespace: object = None,
 ) -> AnalysisCacheContext | None:
     """Build a reusable cache context, or bypass when profile identity is unstable."""
 
@@ -65,16 +84,15 @@ def build_analysis_cache_context(
         "python_version": platform.python_version_tuple()[:2],
         "allow_compact_analysis": allow_compact_analysis,
         "inference_profile": profile_payload,
-        "column_nullability_by_table": _nullability_payload(column_nullability_by_table),
-        "column_types_by_table": {
-            table: dict(sorted(columns.items()))
-            for table, columns in sorted(column_types_by_table.items())
-        },
     }
-    return AnalysisCacheContext(
-        root=root,
-        shared_fingerprint=_payload_digest(shared_payload),
-    )
+    try:
+        return AnalysisCacheContext(
+            root=root,
+            shared_fingerprint=_payload_digest(shared_payload),
+            signature_namespace=_payload_digest(signature_namespace),
+        )
+    except (TypeError, ValueError):
+        return None
 
 
 def model_analysis_cache_key(
@@ -83,6 +101,8 @@ def model_analysis_cache_key(
     query_sql: str,
     references: tuple[CompileSqlReference, ...],
     placeholders: dict[str, str] | None,
+    column_nullability_by_table: dict[str, dict[str, InferredNullability]],
+    column_types_by_table: dict[str, dict[str, str]],
 ) -> str:
     """Return the exact analysis identity for one expanded model query."""
 
@@ -100,6 +120,14 @@ def model_analysis_cache_key(
                 for reference in references
             ],
             "placeholders": dict(sorted((placeholders or {}).items())),
+            "referenced_column_nullability": _referenced_nullability_payload(
+                references=references,
+                column_nullability_by_table=column_nullability_by_table,
+            ),
+            "referenced_column_types": _referenced_types_payload(
+                references=references,
+                column_types_by_table=column_types_by_table,
+            ),
         }
     )
 
@@ -108,13 +136,16 @@ def read_model_analyses(
     *,
     context: AnalysisCacheContext,
     cache_keys: tuple[str, ...],
-) -> dict[str, PolyglotAnalysisResult]:
-    """Read cached analyses in batches, treating invalid entries or storage as misses."""
+    model_names: tuple[str, ...],
+    upstream_model_names_by_key: dict[str, tuple[str, ...]],
+) -> tuple[dict[str, PolyglotAnalysisResult], dict[str, str]]:
+    """Read one consistent snapshot of analyses, dependencies, and output signatures."""
 
     database_path: Path = _cache_database_path(context=context)
     if not database_path.is_file() or not cache_keys:
-        return {}
+        return {}, {}
     analyses: dict[str, PolyglotAnalysisResult] = {}
+    signatures: dict[str, str] = {}
     try:
         connection_uri: str = f"file:{database_path}?mode=ro"
         with sqlite3.connect(
@@ -122,6 +153,28 @@ def read_model_analyses(
             uri=True,
             timeout=_SQLITE_TIMEOUT_SECONDS,
         ) as connection:
+            _ = connection.execute("BEGIN")
+            signature_model_name_set: set[str] = set(model_names)
+            upstream_names: tuple[str, ...]
+            for upstream_names in upstream_model_names_by_key.values():
+                signature_model_name_set.update(upstream_names)
+            signature_model_names: tuple[str, ...] = tuple(sorted(signature_model_name_set))
+            for start in range(0, len(signature_model_names), _SQLITE_QUERY_CHUNK_SIZE):
+                model_chunk: tuple[str, ...] = signature_model_names[
+                    start : start + _SQLITE_QUERY_CHUNK_SIZE
+                ]
+                model_placeholders: str = ",".join("?" for _ in model_chunk)
+                signature_rows: list[tuple[str, str]] = connection.execute(
+                    f"SELECT model_name, output_signature FROM model_analysis_signature "
+                    f"WHERE shared_fingerprint = ? AND signature_namespace = ? "
+                    f"AND model_name IN ({model_placeholders})",
+                    (
+                        context.shared_fingerprint,
+                        context.signature_namespace,
+                        *model_chunk,
+                    ),
+                ).fetchall()
+                signatures.update(signature_rows)
             for start in range(0, len(cache_keys), _SQLITE_QUERY_CHUNK_SIZE):
                 chunk: tuple[str, ...] = cache_keys[start : start + _SQLITE_QUERY_CHUNK_SIZE]
                 placeholders: str = ",".join("?" for _ in chunk)
@@ -130,7 +183,25 @@ def read_model_analyses(
                     f"WHERE cache_key IN ({placeholders})",
                     chunk,
                 ).fetchall()
+                dependency_rows: list[tuple[str, str, str]] = connection.execute(
+                    f"SELECT cache_key, upstream_model_name, output_signature "
+                    f"FROM model_analysis_dependency WHERE signature_namespace = ? "
+                    f"AND cache_key IN ({placeholders})",
+                    (context.signature_namespace, *chunk),
+                ).fetchall()
+                dependencies_by_key: dict[str, dict[str, str]] = {}
+                for cache_key, upstream_name, output_signature in dependency_rows:
+                    dependencies_by_key.setdefault(cache_key, {})[upstream_name] = output_signature
                 for cache_key, contents in rows:
+                    expected_dependencies: dict[str, str] | None = _expected_dependencies(
+                        upstream_model_names=upstream_model_names_by_key.get(cache_key, ()),
+                        signatures=signatures,
+                    )
+                    if (
+                        expected_dependencies is None
+                        or dependencies_by_key.get(cache_key, {}) != expected_dependencies
+                    ):
+                        continue
                     analysis: PolyglotAnalysisResult | None = _analysis_from_contents(
                         contents=contents,
                         expected_cache_key=cache_key,
@@ -138,14 +209,16 @@ def read_model_analyses(
                     if analysis is not None:
                         analyses[cache_key] = analysis
     except (OSError, sqlite3.DatabaseError):
-        return {}
-    return analyses
+        return {}, {}
+    return analyses, signatures
 
 
 def write_model_analyses(
     *,
     context: AnalysisCacheContext,
     analyses_by_key: dict[str, PolyglotAnalysisResult],
+    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."""
 
@@ -162,21 +235,97 @@ def write_model_analyses(
         for cache_key, analysis in analyses_by_key.items()
         if analysis.analysis_succeeded
     ]
-    if not rows:
+    signature_rows: list[tuple[str, str, str, str]] = [
+        (
+            context.shared_fingerprint,
+            context.signature_namespace,
+            model_name,
+            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:
+            continue
+        dependency_rows.extend(
+            (context.signature_namespace, cache_key, upstream_name, output_signature)
+            for upstream_name, output_signature in dependencies.items()
+        )
+    if not rows and not signature_rows:
         return
     try:
         database_path: Path = _cache_database_path(context=context)
         database_path.parent.mkdir(parents=True, exist_ok=True)
         with sqlite3.connect(database_path, timeout=_SQLITE_TIMEOUT_SECONDS) as connection:
             _ = connection.execute(_CREATE_CACHE_TABLE_SQL)
+            _ = connection.execute(_CREATE_SIGNATURE_TABLE_SQL)
+            _ = connection.execute(_CREATE_DEPENDENCY_TABLE_SQL)
             _ = connection.executemany(
                 "INSERT OR REPLACE INTO model_analysis (cache_key, payload) VALUES (?, ?)",
                 rows,
             )
+            written_cache_keys: tuple[str, ...] = tuple(cache_key for cache_key, _ in rows)
+            for start in range(0, len(written_cache_keys), _SQLITE_QUERY_CHUNK_SIZE):
+                chunk: tuple[str, ...] = written_cache_keys[
+                    start : start + _SQLITE_QUERY_CHUNK_SIZE
+                ]
+                placeholders: str = ",".join("?" for _ in chunk)
+                _ = connection.execute(
+                    f"DELETE FROM model_analysis_dependency "
+                    f"WHERE signature_namespace = ? AND cache_key IN ({placeholders})",
+                    (context.signature_namespace, *chunk),
+                )
+            _ = connection.executemany(
+                "INSERT INTO model_analysis_dependency "
+                "(signature_namespace, cache_key, upstream_model_name, output_signature) "
+                "VALUES (?, ?, ?, ?)",
+                dependency_rows,
+            )
+            _ = connection.executemany(
+                "INSERT OR REPLACE INTO model_analysis_signature "
+                "(shared_fingerprint, signature_namespace, model_name, output_signature) "
+                "VALUES (?, ?, ?, ?)",
+                signature_rows,
+            )
     except (OSError, sqlite3.DatabaseError):
         return
 
 
+def _expected_dependencies(
+    *,
+    upstream_model_names: tuple[str, ...],
+    signatures: dict[str, str],
+) -> dict[str, str] | None:
+    if any(name not in signatures for name in upstream_model_names):
+        return None
+    return {name: signatures[name] for name in upstream_model_names}
+
+
+def model_analysis_output_signature(analysis: PolyglotAnalysisResult) -> str:
+    """Return the exported column signature relevant to downstream analysis."""
+
+    return _payload_digest(
+        {
+            "columns": (
+                None
+                if analysis.columns is None
+                else [
+                    {
+                        "name": column.name,
+                        "type": column.type,
+                        "nullability": column.nullability.value,
+                    }
+                    for column in analysis.columns
+                ]
+            ),
+            "has_star": analysis.has_star,
+        }
+    )
+
+
 def _analysis_from_contents(
     *, contents: str, expected_cache_key: str
 ) -> PolyglotAnalysisResult | None:
@@ -224,17 +373,50 @@ def _inference_profile_payload(
     }
 
 
-def _nullability_payload(
+def _referenced_nullability_payload(
+    *,
+    references: tuple[CompileSqlReference, ...],
     column_nullability_by_table: dict[str, dict[str, InferredNullability]],
 ) -> dict[str, dict[str, str]]:
     payload: dict[str, dict[str, str]] = {}
-    for table, columns in sorted(column_nullability_by_table.items()):
+    table: str
+    for table in _referenced_analysis_tables(references):
+        columns: dict[str, InferredNullability] | None = column_nullability_by_table.get(table)
+        if columns is None:
+            continue
         payload[table] = {
             column: nullability.value for column, nullability in sorted(columns.items())
         }
     return payload
 
 
+def _referenced_types_payload(
+    *,
+    references: tuple[CompileSqlReference, ...],
+    column_types_by_table: dict[str, dict[str, str]],
+) -> dict[str, dict[str, str]]:
+    payload: dict[str, dict[str, str]] = {}
+    table: str
+    for table in _referenced_analysis_tables(references):
+        columns: dict[str, str] | None = column_types_by_table.get(table)
+        if columns is not None:
+            payload[table] = dict(sorted(columns.items()))
+    return payload
+
+
+def _referenced_analysis_tables(
+    references: tuple[CompileSqlReference, ...],
+) -> tuple[str, ...]:
+    names: set[str] = set()
+    for reference in references:
+        names.add(
+            table_function_analysis_name(reference.ref_name)
+            if reference.ref_kind == SqlReferenceKind.TABLE_FUNCTION
+            else reference.ref_name
+        )
+    return tuple(sorted(names))
+
+
 def _analysis_payload(*, cache_key: str, analysis: PolyglotAnalysisResult) -> dict[str, object]:
     analysis_payload: dict[str, object] = {
         "columns": (