sqlbuild 0.45.1__tar.gz → 0.45.2__tar.gz

sqlbuild-0.45.2/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.45.2"
+}

{sqlbuild-0.45.1 → sqlbuild-0.45.2}/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.45.2](https://github.com/chio-labs/sqlbuild/compare/v0.45.1...v0.45.2) (2026-06-28)
+
+
+### Bug Fixes
+
+* **dbt:** isolate defer clone prephase output ([9806c24](https://github.com/chio-labs/sqlbuild/commit/9806c24e4dfac3362b78e42dffc5af61248a8912))
+* **dbt:** isolate defer clone prephase output ([4a6e9ff](https://github.com/chio-labs/sqlbuild/commit/4a6e9ff60393de9904b62bef5c6fae3880216456))
+
 ## [0.45.1](https://github.com/chio-labs/sqlbuild/compare/v0.45.0...v0.45.1) (2026-06-28)
 
 

{sqlbuild-0.45.1 → sqlbuild-0.45.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.45.1
+Version: 0.45.2
 Summary: Typed, test-first SQL pipelines with local E2E testing
 License-File: LICENSE
 Requires-Python: >=3.12

{sqlbuild-0.45.1 → sqlbuild-0.45.2}/pyproject.toml

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

{sqlbuild-0.45.1 → sqlbuild-0.45.2}/scripts/structure/structure_conventions/checker.py

@@ -45,6 +45,7 @@ from scripts.structure.structure_conventions.rules import (
     check_no_raw_runtime_diagnostics,
     check_no_relative_imports,
     check_no_sibling_package_imports,
+    check_no_singular_source_freshness_writer,
     check_no_standalone_comments,
     check_no_swallowed_exception_probes,
     check_private_definition_ordering,
@@ -104,6 +105,7 @@ def check_paths(paths: list[Path], repo_root: Path | None = None) -> list[Violat
         violations.extend(check_target_reuse_terminology(file_path))
         violations.extend(check_no_swallowed_exception_probes(file_path, module))
         violations.extend(check_no_metadata_calls_in_loops(file_path, module))
+        violations.extend(check_no_singular_source_freshness_writer(file_path, module))
         violations.extend(check_no_ad_hoc_dbt_ref_scans(file_path, module))
         violations.extend(check_no_ad_hoc_dbt_graph_projection(file_path, module))
         violations.extend(check_no_ad_hoc_selector_plus_parsing(file_path, module))

{sqlbuild-0.45.1 → sqlbuild-0.45.2}/scripts/structure/structure_conventions/rules.py

@@ -105,6 +105,7 @@ _DOCSTRING_BEARING_NODE_TYPES: tuple[type[ast.AST], ...] = (
     ast.AsyncFunctionDef,
     ast.ClassDef,
 )
+_SOURCE_FRESHNESS_SINGULAR_WRITER_NAME: str = "write_source_freshness_record"
 
 
 def parse_python_module(file_path: Path) -> ast.Module:
@@ -216,6 +217,54 @@ def check_no_raw_color_helper_imports(file_path: Path, module: ast.Module) -> li
     return violations
 
 
+def check_no_singular_source_freshness_writer(
+    file_path: Path, module: ast.Module
+) -> list[Violation]:
+    """Reject per-record source freshness writer imports and calls."""
+
+    violations: list[Violation] = []
+    for node in ast.walk(module):
+        if isinstance(node, ast.ImportFrom):
+            alias: ast.alias
+            for alias in node.names:
+                if alias.name == _SOURCE_FRESHNESS_SINGULAR_WRITER_NAME:
+                    violations.append(
+                        Violation(
+                            code="SC057",
+                            path=file_path,
+                            line=node.lineno,
+                            message=(
+                                "source freshness state writes must use "
+                                "write_source_freshness_records() batch writes"
+                            ),
+                        )
+                    )
+        if (
+            isinstance(node, ast.Call)
+            and _call_name(node) == _SOURCE_FRESHNESS_SINGULAR_WRITER_NAME
+        ):
+            violations.append(
+                Violation(
+                    code="SC057",
+                    path=file_path,
+                    line=node.lineno,
+                    message=(
+                        "source freshness state writes must use "
+                        "write_source_freshness_records() batch writes"
+                    ),
+                )
+            )
+    return violations
+
+
+def _call_name(node: ast.Call) -> str | None:
+    if isinstance(node.func, ast.Name):
+        return node.func.id
+    if isinstance(node.func, ast.Attribute):
+        return node.func.attr
+    return None
+
+
 def check_no_internal_reexport_modules(
     repo_root: Path, file_path: Path, module: ast.Module
 ) -> list[Violation]:

{sqlbuild-0.45.1 → sqlbuild-0.45.2}/src/sqlbuild/cli/commands/main/build.py

@@ -247,13 +247,15 @@ def run_build(
                 origin_target_name=effective_defer_clone_from,
                 destination_target_name=cloned_project.effective_target_name,
                 no_sql_validation=no_sql_validation,
-                select=boundary_selectors,
+                select=(*boundary_selectors, *view_chain_selectors),
+                caused_by_names=select,
                 cli_vars=cli_vars,
                 connection_config=connection_config,
                 project_dir=effective_project_dir,
                 on_progress=planning_progress.on_progress,
+                progress_stream=progress_stream,
+                use_color=use_color,
             )
-            select = (*select, *view_chain_selectors)
 
         progress_stream.write("\n")
         progress_stream.flush()

{sqlbuild-0.45.1 → sqlbuild-0.45.2}/src/sqlbuild/cli/commands/main/helpers/build_defer_clone.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import time
 from pathlib import Path
-from typing import Any
+from typing import Any, TextIO
 
 from sqlbuild.adapter.base.base_adapter import BaseAdapter
 from sqlbuild.cli.commands.main.shared.exceptions import CliUserError
@@ -28,12 +28,14 @@ from sqlbuild.compiler.planner.main.scope import build_planner_scope
 from sqlbuild.compiler.planner.models import PlannerScope
 from sqlbuild.executor.clone.main.execute import execute_clone
 from sqlbuild.executor.clone.main.fingerprinting import copy_clone_fingerprints
-from sqlbuild.executor.clone.models import CloneExecutionResult
-from sqlbuild.executor.clone.types import CloneStatus
+from sqlbuild.executor.clone.models import CloneExecutionResult, CloneItemResult
+from sqlbuild.executor.clone.types import CloneAction, CloneStatus
 from sqlbuild.shared.helpers.graph_algorithms import (
     resolve_clone_boundary,
     resolve_skipped_view_chain,
 )
+from sqlbuild.shared.helpers.prephase_progress import write_prephase_header, write_prephase_rows
+from sqlbuild.shared.models import PrephaseProgressRow
 
 
 def build_defer_clone_boundary_selectors(
@@ -117,10 +119,13 @@ def run_defer_clone_prephase(
     destination_target_name: str | None,
     no_sql_validation: bool,
     select: tuple[str, ...],
+    caused_by_names: tuple[str, ...],
     cli_vars: dict[str, object] | None,
     connection_config: dict[str, object],
     project_dir: Path,
     on_progress: Any,
+    progress_stream: TextIO | None = None,
+    use_color: bool = False,
 ) -> None:
     """Clone selected boundary relations from origin before build planning."""
 
@@ -202,6 +207,47 @@ def run_defer_clone_prephase(
             on_progress(
                 f"Cloned deferred boundary relations. ({time.monotonic() - clone_start:.2f}s)"
             )
+        if progress_stream is not None:
+            write_prephase_header(stream=progress_stream, title="defer clone", use_color=use_color)
+            write_prephase_rows(
+                stream=progress_stream,
+                rows=_prephase_rows_from_clone_result(
+                    result=result,
+                    caused_by_names=caused_by_names,
+                ),
+                use_color=use_color,
+            )
     finally:
         adapter.close(origin_connection)
         adapter.close(destination_connection)
+
+
+def _prephase_rows_from_clone_result(
+    *, result: CloneExecutionResult, caused_by_names: tuple[str, ...]
+) -> tuple[PrephaseProgressRow, ...]:
+    return tuple(
+        PrephaseProgressRow(
+            label=_clone_item_label(item),
+            name=item.name,
+            status=_clone_item_status(item),
+            duration_seconds=item.duration_seconds,
+            caused_by_names=caused_by_names,
+        )
+        for item in result.item_results
+    )
+
+
+def _clone_item_label(item: CloneItemResult) -> str:
+    if item.action == CloneAction.RECREATED_VIEW:
+        return "view"
+    if item.action == CloneAction.COPIED:
+        return "copy"
+    return "clone"
+
+
+def _clone_item_status(item: CloneItemResult) -> str:
+    if item.status == CloneStatus.SUCCESS:
+        return "OK"
+    if item.status == CloneStatus.WARNING:
+        return "WARN"
+    return "FAIL"

{sqlbuild-0.45.1 → sqlbuild-0.45.2}/src/sqlbuild/cli/commands/main/helpers/source_freshness.py

@@ -7,7 +7,7 @@ from typing import Any
 
 from sqlbuild.adapter.base.base_adapter import BaseAdapter
 from sqlbuild.compiler.planner.models import ModelPlanEntry, PlanOutput
-from sqlbuild.compiler.source_freshness.main.write import write_source_freshness_record
+from sqlbuild.compiler.source_freshness.main.write import write_source_freshness_records
 from sqlbuild.compiler.source_freshness.models import (
     SourceFreshnessIdentity,
     SourceFreshnessRecord,
@@ -46,6 +46,7 @@ def append_eligible_standard_source_freshness_records(
 
     connection: Any = adapter.connect(connection_config)
     try:
+        records_by_location: dict[tuple[str | None, str], list[SourceFreshnessRecord]] = {}
         identity: SourceFreshnessIdentity
         affected_model_names: frozenset[str]
         for (
@@ -62,41 +63,57 @@ def append_eligible_standard_source_freshness_records(
             record: SourceFreshnessRecord | None = observed_records_by_identity.get(identity)
             if record is None:
                 continue
-            _append_record_to_affected_model_schemas(
-                adapter=adapter,
-                connection=connection,
+            _collect_record_for_affected_model_schemas(
+                records_by_location=records_by_location,
                 record=replace(record, run_id=run_id),
                 affected_model_names=affected_selected_model_names,
                 entries_by_name=entries_by_name,
             )
+        _append_records_by_location(
+            adapter=adapter,
+            connection=connection,
+            records_by_location=records_by_location,
+        )
     finally:
         adapter.close(connection)
 
 
-def _append_record_to_affected_model_schemas(
+def _collect_record_for_affected_model_schemas(
     *,
-    adapter: BaseAdapter,
-    connection: Any,
+    records_by_location: dict[tuple[str | None, str], list[SourceFreshnessRecord]],
     record: SourceFreshnessRecord,
     affected_model_names: frozenset[str],
     entries_by_name: dict[str, ModelPlanEntry],
 ) -> None:
-    written_locations: set[tuple[str | None, str]] = set()
+    recorded_locations: set[tuple[str | None, str]] = set()
     model_name: str
     for model_name in sorted(affected_model_names):
         entry: ModelPlanEntry | None = entries_by_name.get(model_name)
         if entry is None or entry.destination.schema is None:
             continue
         location: tuple[str | None, str] = (entry.destination.database, entry.destination.schema)
-        if location in written_locations:
+        if location in recorded_locations:
             continue
-        written_locations.add(location)
-        write_source_freshness_record(
+        recorded_locations.add(location)
+        records_by_location.setdefault(location, []).append(record)
+
+
+def _append_records_by_location(
+    *,
+    adapter: BaseAdapter,
+    connection: Any,
+    records_by_location: dict[tuple[str | None, str], list[SourceFreshnessRecord]],
+) -> None:
+    location: tuple[str | None, str]
+    records: list[SourceFreshnessRecord]
+    for location, records in records_by_location.items():
+        database, schema = location
+        write_source_freshness_records(
             connection=connection,
             execute=adapter.execute,
-            database=entry.destination.database,
-            schema=entry.destination.schema,
-            record=record,
+            database=database,
+            schema=schema,
+            records=tuple(records),
             render_qualified_name=adapter.render_qualified_name,
             render_framework_type=adapter.render_framework_type,
             render_create_index_sqls=adapter.render_create_source_freshness_index_sqls,

{sqlbuild-0.45.1 → sqlbuild-0.45.2}/src/sqlbuild/compiler/source_freshness/main/write.py

@@ -13,21 +13,23 @@ from sqlbuild.compiler.source_freshness.main.shared.helpers.sql import (
 from sqlbuild.compiler.source_freshness.models import SourceFreshnessRecord
 
 
-def write_source_freshness_record(
+def write_source_freshness_records(
     *,
     connection: Any,
     execute: Any,
     database: str | None,
     schema: str,
-    record: SourceFreshnessRecord,
+    records: tuple[SourceFreshnessRecord, ...],
     render_qualified_name: Callable[..., str | None],
     render_framework_type: Callable[[FrameworkType], str],
     render_create_table_sql: Callable[..., str] | None = None,
     render_create_index_sqls: Callable[..., tuple[str, ...]] | None = None,
     transient: bool = False,
 ) -> None:
-    """Append one source freshness row, creating the table if needed."""
+    """Append source freshness rows, creating the table once if needed."""
 
+    if not records:
+        return
     create_sql: str = (
         render_create_table_sql(database=database, schema=schema)
         if render_create_table_sql is not None
@@ -44,19 +46,21 @@ def write_source_freshness_record(
         index_sql: str
         for index_sql in render_create_index_sqls(database=database, schema=schema):
             execute(connection, index_sql)
-    insert_sql: str = build_insert_sql(
-        database=database,
-        schema=schema,
-        source_name=record.source_name,
-        target_database=record.target_database,
-        target_schema=record.target_schema,
-        target_name=record.target_name,
-        run_id=record.run_id,
-        strategy=record.strategy,
-        value_kind=record.value_kind,
-        data_version=record.data_version,
-        data_version_hash=record.data_version_hash,
-        observed_at=record.observed_at.isoformat(),
-        render_qualified_name=render_qualified_name,
-    )
-    execute(connection, insert_sql)
+    record: SourceFreshnessRecord
+    for record in records:
+        insert_sql: str = build_insert_sql(
+            database=database,
+            schema=schema,
+            source_name=record.source_name,
+            target_database=record.target_database,
+            target_schema=record.target_schema,
+            target_name=record.target_name,
+            run_id=record.run_id,
+            strategy=record.strategy,
+            value_kind=record.value_kind,
+            data_version=record.data_version,
+            data_version_hash=record.data_version_hash,
+            observed_at=record.observed_at.isoformat(),
+            render_qualified_name=render_qualified_name,
+        )
+        execute(connection, insert_sql)

{sqlbuild-0.45.1 → sqlbuild-0.45.2}/src/sqlbuild/integrations/dbt/helpers/runtime/event_stream.py

@@ -65,6 +65,7 @@ def execute_dbt_json_event_stream(
     target_path: Path | None,
     display_total: int | None = None,
     on_node_result: Callable[[DbtNodeExecutionResult], None] | None = None,
+    detail_by_unique_id: dict[str, str] | None = None,
 ) -> tuple[int, tuple[DbtNodeExecutionResult, ...]]:
     """Run dbt and render SQLBuild-styled rows from JSON events."""
 
@@ -129,6 +130,10 @@ def execute_dbt_json_event_stream(
                             result=start_result,
                             display_index=display_index,
                             display_total=display_total,
+                            detail=_node_detail(
+                                unique_id=start_result.unique_id,
+                                detail_by_unique_id=detail_by_unique_id,
+                            ),
                         )
                         active_nodes[start_result.unique_id] = (
                             start_result.node_name,
@@ -167,6 +172,10 @@ def execute_dbt_json_event_stream(
                     result=result,
                     display_index=result_display_index,
                     display_total=display_total,
+                    detail=_node_detail(
+                        unique_id=result.unique_id,
+                        detail_by_unique_id=detail_by_unique_id,
+                    ),
                 )
                 status = _update_active_node_status(
                     status=status,
@@ -362,6 +371,7 @@ def render_dbt_node_result(
     result: DbtNodeExecutionResult,
     display_index: int | None = None,
     display_total: int | None = None,
+    detail: str = "",
 ) -> None:
     ctr: str = (
         f"{display_index}/{display_total}"
@@ -381,7 +391,7 @@ def render_dbt_node_result(
         + format_aligned_name_value(
             plain_name=name,
             styled_name=style.dbt_object_name(name),
-            value=f"{style.status(status)} {duration}".rstrip(),
+            value=f"{style.status(status)} {duration}{detail}".rstrip(),
             name_column_width=30,
             prefix=" ",
         )
@@ -393,6 +403,12 @@ def render_dbt_node_result(
     stream.flush()
 
 
+def _node_detail(*, unique_id: str, detail_by_unique_id: dict[str, str] | None) -> str:
+    if detail_by_unique_id is None:
+        return ""
+    return detail_by_unique_id.get(unique_id, "")
+
+
 def _display_status(status: str) -> str:
     normalized: str = status.lower()
     if normalized in {"ok", "success"}:

{sqlbuild-0.45.1 → sqlbuild-0.45.2}/src/sqlbuild/integrations/dbt/pipeline/helpers/defer_clone.py

@@ -83,10 +83,10 @@ def run_dbt_defer_clone_prephase(
     current_manifest: DbtManifestIndex,
     unique_ids: tuple[str, ...],
     on_progress: Callable[[str], None] | None,
-) -> None:
+) -> CloneExecutionResult | None:
     if not unique_ids:
         _report_progress(on_progress, "defer-clone enabled but no clonable dbt boundary resolved.")
-        return
+        return None
     production_ref: DbtProductionRefConfig = discovered_inputs.project_config.dbt.production_ref
     if production_ref.git_ref is None or production_ref.generate_schema_name_override is None:
         raise DbtInteropConfigError(
@@ -149,6 +149,7 @@ def run_dbt_defer_clone_prephase(
         on_progress,
         f"Cloned deferred dbt boundary relations. ({time.monotonic() - clone_start:.2f}s)",
     )
+    return result
 
 
 def resolve_defer_clone_unique_ids(

sqlbuild-0.45.2/src/sqlbuild/integrations/dbt/pipeline/helpers/defer_clone_progress.py

@@ -0,0 +1,124 @@
+"""dbt defer-clone prephase progress helpers."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TextIO
+
+from sqlbuild.executor.clone.models import CloneExecutionResult, CloneItemResult
+from sqlbuild.executor.clone.types import CloneAction, CloneStatus
+from sqlbuild.integrations.dbt.helpers.cli.runner import build_dbt_command_argv
+from sqlbuild.integrations.dbt.helpers.runtime.event_stream import execute_dbt_json_event_stream
+from sqlbuild.integrations.dbt.manifest.models import DbtManifestIndex, DbtManifestModel
+from sqlbuild.integrations.dbt.models import (
+    DbtCliOptions,
+    DbtCommandExecutionResult,
+    DbtNodeExecutionResult,
+)
+from sqlbuild.shared.helpers.prephase_progress import (
+    format_prephase_cause_annotation,
+    write_prephase_header,
+    write_prephase_rows,
+)
+from sqlbuild.shared.models import PrephaseProgressRow
+
+
+def selected_dbt_defer_clone_cause_names(
+    *,
+    manifest: DbtManifestIndex,
+    selected_sqlbuild_model_names: tuple[str, ...],
+    selected_dbt_unique_ids: tuple[str, ...],
+) -> tuple[str, ...]:
+    """Return selected model names used in prephase cause annotations."""
+
+    names: set[str] = set(selected_sqlbuild_model_names)
+    unique_id: str
+    for unique_id in selected_dbt_unique_ids:
+        model: DbtManifestModel | None = manifest.models_by_unique_id.get(unique_id)
+        names.add(model.name if model is not None else unique_id)
+    return tuple(sorted(names))
+
+
+def write_dbt_defer_clone_prephase_rows(
+    *,
+    stream: TextIO,
+    result: CloneExecutionResult | None,
+    caused_by_names: tuple[str, ...],
+    use_color: bool,
+) -> None:
+    """Write dbt defer-clone clone/copy rows with shared prephase formatting."""
+
+    if result is None or not result.item_results:
+        return
+    write_prephase_header(stream=stream, title="dbt defer clone", use_color=use_color)
+    write_prephase_rows(
+        stream=stream,
+        rows=tuple(
+            PrephaseProgressRow(
+                label=_clone_item_label(item),
+                name=item.name,
+                status=_clone_item_status(item),
+                duration_seconds=item.duration_seconds,
+                caused_by_names=caused_by_names,
+            )
+            for item in result.item_results
+        ),
+        use_color=use_color,
+    )
+
+
+def run_dbt_defer_clone_view_chain_prephase(
+    *,
+    dbt_options: DbtCliOptions,
+    dbt_executable: str,
+    view_chain_terms: tuple[str, ...],
+    view_chain_unique_ids: frozenset[str],
+    caused_by_names: tuple[str, ...],
+    output_stream: TextIO,
+    use_color: bool,
+    on_progress: Callable[[str], None] | None,
+) -> DbtCommandExecutionResult:
+    """Refresh deferred dbt view-chain models with dbt run."""
+
+    if not view_chain_terms:
+        return DbtCommandExecutionResult(returncode=0)
+    if on_progress is not None:
+        on_progress("Refreshing deferred dbt view chain...")
+    write_prephase_header(stream=output_stream, title="dbt defer clone views", use_color=use_color)
+    detail: str = format_prephase_cause_annotation(caused_by_names)
+    returncode: int
+    results: tuple[DbtNodeExecutionResult, ...]
+    argv: tuple[str, ...] = build_dbt_command_argv(
+        dbt_executable=dbt_executable,
+        command="run",
+        options=dbt_options,
+        args=("--select", *view_chain_terms),
+    )
+    returncode, results = execute_dbt_json_event_stream(
+        argv=argv,
+        cwd=dbt_options.project_dir,
+        stream=output_stream,
+        use_color=use_color,
+        target_path=dbt_options.target_path,
+        display_total=len(view_chain_terms),
+        detail_by_unique_id={unique_id: detail for unique_id in view_chain_unique_ids},
+    )
+    if on_progress is not None:
+        on_progress("Refreshed deferred dbt view chain.")
+    return DbtCommandExecutionResult(returncode=returncode, node_results=results)
+
+
+def _clone_item_label(item: CloneItemResult) -> str:
+    if item.action == CloneAction.RECREATED_VIEW:
+        return "view"
+    if item.action == CloneAction.COPIED:
+        return "copy"
+    return "clone"
+
+
+def _clone_item_status(item: CloneItemResult) -> str:
+    if item.status == CloneStatus.SUCCESS:
+        return "OK"
+    if item.status == CloneStatus.WARNING:
+        return "WARN"
+    return "FAIL"

{sqlbuild-0.45.1 → sqlbuild-0.45.2}/src/sqlbuild/integrations/dbt/pipeline/helpers/execute.py

@@ -396,7 +396,6 @@ def build_merged_dbt_execution_argv(
     plan: DbtInteropPlan,
     replay_on_change: str | None = None,
     defer_clone_unique_ids: frozenset[str] = frozenset(),
-    defer_clone_view_chain_terms: tuple[str, ...] = (),
 ) -> tuple[str, ...] | None:
     """Build the single dbt argv used for execution."""
 
@@ -406,7 +405,6 @@ def build_merged_dbt_execution_argv(
         command=command,
         plan=plan,
         defer_clone_unique_ids=defer_clone_unique_ids,
-        defer_clone_view_chain_terms=defer_clone_view_chain_terms,
     )
     if plan.dbt_model_plan is not None:
         if not planned_select_terms:
@@ -662,7 +660,6 @@ def _planned_dbt_select_terms(
     command: DbtInteropCommand,
     plan: DbtInteropPlan,
     defer_clone_unique_ids: frozenset[str] = frozenset(),
-    defer_clone_view_chain_terms: tuple[str, ...] = (),
 ) -> tuple[str, ...]:
     if plan.dbt_model_plan is None:
         return ()
@@ -683,7 +680,7 @@ def _planned_dbt_select_terms(
         for entry in plan.dbt_model_plan.entries
         if entry.action == DbtModelPlanAction.RUN and entry.unique_id in executable_model_unique_ids
     )
-    return tuple(sorted(frozenset((*model_terms, *defer_clone_view_chain_terms, *non_model_terms))))
+    return tuple(sorted(frozenset((*model_terms, *non_model_terms))))
 
 
 def _selected_non_model_unique_ids(

{sqlbuild-0.45.1 → sqlbuild-0.45.2}/src/sqlbuild/integrations/dbt/pipeline/helpers/source_freshness.py

@@ -9,7 +9,7 @@ from typing import Any
 
 from sqlbuild.adapter.base.base_adapter import BaseAdapter
 from sqlbuild.compiler.compile.models.core import CompiledProject
-from sqlbuild.compiler.source_freshness.main.write import write_source_freshness_record
+from sqlbuild.compiler.source_freshness.main.write import write_source_freshness_records
 from sqlbuild.compiler.source_freshness.models import SourceFreshnessRecord
 from sqlbuild.integrations.dbt.models import DbtInteropPlan
 
@@ -40,19 +40,17 @@ def append_dbt_source_freshness_records(
         on_progress("Recording dbt source freshness...")
     connection: Any = adapter.connect(connection_config)
     try:
-        record: SourceFreshnessRecord
-        for record in observed_records:
-            write_source_freshness_record(
-                connection=connection,
-                execute=adapter.execute,
-                database=project.effective_target_database,
-                schema=project.effective_target_schema,
-                record=replace(record, run_id=project.run_id),
-                render_qualified_name=adapter.render_qualified_name,
-                render_framework_type=adapter.render_framework_type,
-                render_create_index_sqls=adapter.render_create_source_freshness_index_sqls,
-                transient=adapter.state_tables_transient,
-            )
+        write_source_freshness_records(
+            connection=connection,
+            execute=adapter.execute,
+            database=project.effective_target_database,
+            schema=project.effective_target_schema,
+            records=tuple(replace(record, run_id=project.run_id) for record in observed_records),
+            render_qualified_name=adapter.render_qualified_name,
+            render_framework_type=adapter.render_framework_type,
+            render_create_index_sqls=adapter.render_create_source_freshness_index_sqls,
+            transient=adapter.state_tables_transient,
+        )
     finally:
         adapter.close(connection)
     if on_progress is not None: