sqlbuild 0.66.5__tar.gz → 0.66.6__tar.gz

{sqlbuild-0.66.5 → sqlbuild-0.66.6}/Cargo.lock

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

{sqlbuild-0.66.5 → sqlbuild-0.66.6}/PKG-INFO

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

{sqlbuild-0.66.5 → sqlbuild-0.66.6}/crates/sqlbuild-kata-native/Cargo.toml

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

{sqlbuild-0.66.5 → sqlbuild-0.66.6}/pyproject.toml

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

{sqlbuild-0.66.5 → sqlbuild-0.66.6}/src/sqlbuild/cli/commands/_helpers/build_planning/full_refresh.py

@@ -30,8 +30,6 @@ def enforce_snapshot_full_refresh_policy(
 ) -> None:
     """Fail or confirm before executing protected full-refresh entries."""
 
-    enforce_model_full_refresh_policy(plan=plan)
-
     snapshot_entries: tuple[ModelPlanEntry, ...] = tuple(
         entry
         for entry in plan.model_entries
@@ -80,28 +78,6 @@ def enforce_snapshot_full_refresh_policy(
         raise CliUserError("snapshot full refresh cancelled", code="C240")
 
 
-def enforce_model_full_refresh_policy(*, plan: PlanOutput) -> None:
-    """Reject destructive rebuilds for models that explicitly forbid them."""
-
-    protected_entries: tuple[ModelPlanEntry, ...] = tuple(
-        sorted(
-            (
-                entry
-                for entry in plan.model_entries
-                if entry.reason == PlanReason.FULL_REFRESH and entry.allow_full_refresh is False
-            ),
-            key=lambda entry: entry.name,
-        )
-    )
-    if protected_entries:
-        names: str = _model_names(protected_entries)
-        raise CliUserError(
-            f"full refresh is denied for model {names} by allow_full_refresh=false",
-            code="C265",
-            help="Set allow_full_refresh=true only for models that are safe to fully rebuild.",
-        )
-
-
 def _effective_policy(
     *, entry: ModelPlanEntry, snapshots_config: SnapshotsConfig
 ) -> SnapshotFullRefreshPolicy:

{sqlbuild-0.66.5 → sqlbuild-0.66.6}/src/sqlbuild/cli/commands/_helpers/plan/planning.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 from io import StringIO
 
 from sqlbuild.cli.commands._helpers.build_planning.full_refresh import (
-    enforce_model_full_refresh_policy,
     enforce_snapshot_full_refresh_policy,
 )
 from sqlbuild.cli.commands._helpers.planning.external_refs import (
@@ -113,5 +112,4 @@ def compile_plan_pipeline(
             ),
         ),
     )
-    enforce_model_full_refresh_policy(plan=result.plan_output)
     return result

{sqlbuild-0.66.5 → sqlbuild-0.66.6}/src/sqlbuild/cli/output/_helpers/plan_text.py

@@ -102,7 +102,13 @@ def format_plan(
     style: CliStyle = CliStyle(use_color=True)
     resolved_section_header_style: Callable[[str], str] = section_header_style or style.plan_section
 
-    if full_refresh:
+    active_model_entries: tuple[ModelPlanEntry, ...] = tuple(
+        entry for entry in plan.model_entries if entry.action != PlanAction.SKIP
+    )
+    all_active_models_full_refresh: bool = bool(active_model_entries) and all(
+        entry.reason == PlanReason.FULL_REFRESH for entry in active_model_entries
+    )
+    if all_active_models_full_refresh or (full_refresh and not active_model_entries):
         lines = _format_full_refresh(
             lines=lines,
             plan=plan,

{sqlbuild-0.66.5 → sqlbuild-0.66.6}/src/sqlbuild/compiler/compile/_helpers/attachment/core.py

@@ -61,6 +61,7 @@ from sqlbuild.compiler.compile._helpers.render.templating import (
 from sqlbuild.compiler.compile.constants import (
     MACRO_CALL_PATTERN,
     MODEL_AUDIT_OVERRIDE_KEYS,
+    MODEL_FULL_REFRESH_CONFIG_KEY,
     MODEL_HEADER_METADATA_KEYS,
     PRESERVE_TARGET_VALUE,
 )
@@ -99,6 +100,7 @@ from sqlbuild.compiler.discovery.models import (
     SqlHookEntry,
 )
 from sqlbuild.compiler.path_defaults.main._select import select_path_default
+from sqlbuild.compiler.planner.types import MaterializationType
 from sqlbuild.compiler.references.types import ExternalSqlReferenceResolver
 from sqlbuild.compiler.scopes.models import (
     DeclarationIdentity,
@@ -759,6 +761,11 @@ def build_model_config(
         run_id=run_id,
     )
     target_resolved_values.update(raw_hook_values)
+    if (
+        MODEL_FULL_REFRESH_CONFIG_KEY not in model_header_values
+        and target_resolved_values.get("materialized") != MaterializationType.INCREMENTAL
+    ):
+        target_resolved_values.pop(MODEL_FULL_REFRESH_CONFIG_KEY, None)
     validate_model_config_has_no_macros(values=target_resolved_values)
     return CompileModelConfig(
         values=target_resolved_values,
@@ -1807,8 +1814,8 @@ def project_defaults_to_mapping(defaults: DefaultsConfig) -> dict[str, object]:
         values["incremental_mode"] = defaults.incremental_mode
     if defaults.merge_exclude_columns:
         values["merge_exclude_columns"] = defaults.merge_exclude_columns
-    if defaults.allow_full_refresh is not None:
-        values["allow_full_refresh"] = defaults.allow_full_refresh
+    if defaults.full_refresh is not None:
+        values["full_refresh"] = defaults.full_refresh
     if defaults.append_cursor_inclusive is not None:
         values["append_cursor_inclusive"] = defaults.append_cursor_inclusive
     if defaults.cursor_start is not None:

{sqlbuild-0.66.5 → sqlbuild-0.66.6}/src/sqlbuild/compiler/compile/_helpers/config/model_validation.py

@@ -50,7 +50,7 @@ _INCREMENTAL_ONLY_KEYS: tuple[str, ...] = (
     "replay_on_change",
     "append_cursor_inclusive",
     "merge_exclude_columns",
-    "allow_full_refresh",
+    "full_refresh",
 )
 _SNAPSHOT_DISALLOWED_KEYS: tuple[str, ...] = (
     "incremental_strategy",
@@ -107,7 +107,7 @@ def validate_incremental_config(
     cursor_grain: str | None = _str(config=config, key="cursor_grain")
     replay_on_change: object | None = config.values.get("replay_on_change")
     merge_exclude_columns: object | None = config.values.get("merge_exclude_columns")
-    allow_full_refresh: object | None = config.values.get("allow_full_refresh")
+    full_refresh: object | None = config.values.get("full_refresh")
     if replay_on_change is not None and not isinstance(replay_on_change, str):
         raise CompileInputError(f"model '{model_name}': replay_on_change must be a string")
     if strategy is None:
@@ -178,8 +178,8 @@ def validate_incremental_config(
                 f"model '{model_name}': merge_exclude_columns cannot include unique_key "
                 f"column(s): {', '.join(overlap)}"
             )
-    if allow_full_refresh is not None and not isinstance(allow_full_refresh, bool):
-        raise CompileInputError(f"model '{model_name}': allow_full_refresh must be a boolean")
+    if full_refresh is not None and not isinstance(full_refresh, bool):
+        raise CompileInputError(f"model '{model_name}': full_refresh must be a boolean")
 
     declared_column_names: frozenset[str] | None = _contract_declared_column_names(
         config=config,

{sqlbuild-0.66.5 → sqlbuild-0.66.6}/src/sqlbuild/compiler/compile/constants.py

@@ -13,6 +13,7 @@ AUDIT_DIRECTORY_NAME: str = "audits"
 GENERIC_AUDIT_DIRECTORY_NAME: str = "generic"
 NOT_NULL_AUDIT_NAME: str = "not_null"
 MODEL_AUDIT_OVERRIDE_KEYS: frozenset[str] = frozenset({"by_type", "by_column"})
+MODEL_FULL_REFRESH_CONFIG_KEY: str = "full_refresh"
 MODEL_HEADER_METADATA_KEYS: frozenset[str] = frozenset(
     {"description", "columns", "model_schema", "audits", "enums", "constants"}
 )

{sqlbuild-0.66.5 → sqlbuild-0.66.6}/src/sqlbuild/compiler/discovery/_helpers/yml/project.py

@@ -499,7 +499,7 @@ def _load_defaults(*, payload: object, file_path: Path) -> DefaultsConfig:
         incremental_strategy=_optional_str(payload=mapping, key="incremental_strategy"),
         incremental_mode=_optional_str(payload=mapping, key="incremental_mode"),
         merge_exclude_columns=merge_exclude_columns,
-        allow_full_refresh=_optional_nullable_bool(mapping=mapping, key="allow_full_refresh"),
+        full_refresh=_optional_nullable_bool(mapping=mapping, key="full_refresh"),
         append_cursor_inclusive=_optional_templated_bool(
             mapping=mapping,
             key="append_cursor_inclusive",

{sqlbuild-0.66.5 → sqlbuild-0.66.6}/src/sqlbuild/compiler/manifest/_helpers/shared.py

@@ -99,7 +99,7 @@ def build_config_dict(values: dict[str, object]) -> dict[str, object]:
         "pre-hook": _dbt_sql_hooks(values.get("pre_hooks")),
         "quoting": {},
         "column_types": {},
-        "full_refresh": values.get("allow_full_refresh"),
+        "full_refresh": values.get("full_refresh"),
         "unique_key": values.get("unique_key"),
         "on_schema_change": values.get("on_schema_change", "ignore"),
         "on_configuration_change": "apply",

{sqlbuild-0.66.5 → sqlbuild-0.66.6}/src/sqlbuild/compiler/planner/_helpers/changes/detect.py

@@ -80,7 +80,7 @@ def detect_changes(
             snapshot=snapshot,
             sql_analysis_enabled=project.settings.sql_analysis,
             query_change_tracking=project.settings.query_change_tracking,
-            full_refresh=full_refresh,
+            full_refresh=False,
             function_local_hashes=function_local_hashes,
             hook_version_hashes=hook_version_hashes,
             expected_version_hash=(expected_version_hashes or {}).get(model.name),
@@ -105,6 +105,8 @@ def detect_changes(
             query_change_tracking=project.settings.query_change_tracking,
             full_refresh=full_refresh,
         )
+        if full_refresh:
+            function_backfill = BackfillResult(action=BackfillAction.FORWARD_ONLY)
         function_changes[function.name] = FunctionChangeResult(
             fingerprint_sql=fingerprint_sql,
             reason=function_reason,

{sqlbuild-0.66.5 → sqlbuild-0.66.6}/src/sqlbuild/compiler/planner/_helpers/output/plan_entry.py

@@ -29,6 +29,7 @@ from sqlbuild.compiler.planner._helpers.output.strategy import (
     resolve_model_plan_action,
     resolve_schema_actions,
 )
+from sqlbuild.compiler.planner._helpers.planning.full_refresh import resolve_model_full_refresh
 from sqlbuild.compiler.planner._helpers.resolve.cursor import (
     compute_cursor_bounds,
 )
@@ -260,6 +261,10 @@ def build_plan_entries(
         )
         entry: ModelPlanEntry
         entry_warnings: tuple[PlanWarning, ...]
+        effective_full_refresh: bool = resolve_model_full_refresh(
+            model=model,
+            cli_full_refresh=full_refresh,
+        )
         entry, entry_warnings = plan_model_from_change(
             model=model,
             snapshot=snapshot,
@@ -274,7 +279,7 @@ def build_plan_entries(
                 star_exclude_keyword=relations.star_exclude_keyword,
             ),
             sql_analysis_enabled=project.settings.sql_analysis,
-            full_refresh=full_refresh,
+            full_refresh=effective_full_refresh,
             cursor_overrides=CursorOverridePair(
                 start_cursor_override=resolved_start,
                 end_cursor_override=resolved_end,
@@ -376,7 +381,9 @@ def plan_model_from_change(
     models_by_name: dict[str, CompiledModel] = context.models_by_name
     start_cursor_override: str | None = cursor_overrides.start_cursor_override
     end_cursor_override: str | None = cursor_overrides.end_cursor_override
-    backfill: BackfillResult = change_result.backfill
+    backfill: BackfillResult = (
+        BackfillResult(action=BackfillAction.FULL) if full_refresh else change_result.backfill
+    )
     suppress_runtime_cursor_bounds: bool = (
         backfill_override is not None and backfill_override.action == BackfillAction.FULL
     )
@@ -564,7 +571,6 @@ def plan_model_from_change(
         end_cursor_override=end_cursor_override,
         unique_key=unique_key,
         merge_exclude_columns=_get_config_string_tuple(model=model, key="merge_exclude_columns"),
-        allow_full_refresh=_get_config_optional_bool(model=model, key="allow_full_refresh"),
         snapshot_strategy=snapshot_strategy,
         updated_at_column=updated_at_column,
         check_columns=check_columns,

sqlbuild-0.66.6/src/sqlbuild/compiler/planner/_helpers/planning/full_refresh.py

@@ -0,0 +1,24 @@
+"""Per-model full-refresh resolution."""
+
+from __future__ import annotations
+
+from sqlbuild.compiler.compile.models import CompiledModel, CompiledProject
+
+
+def resolve_model_full_refresh(*, model: CompiledModel, cli_full_refresh: bool) -> bool:
+    """Resolve dbt-compatible nullable model full-refresh semantics."""
+
+    configured: object | None = model.config.values.get("full_refresh")
+    return configured if isinstance(configured, bool) else cli_full_refresh
+
+
+def effectively_full_refreshed_model_names(
+    *, project: CompiledProject, cli_full_refresh: bool
+) -> frozenset[str]:
+    """Return model names that are effectively full refreshed for this invocation."""
+
+    return frozenset(
+        model.name
+        for model in project.models
+        if resolve_model_full_refresh(model=model, cli_full_refresh=cli_full_refresh)
+    )

{sqlbuild-0.66.5 → sqlbuild-0.66.6}/src/sqlbuild/compiler/planner/_helpers/planning/warehouse_state.py

@@ -5,6 +5,9 @@ from __future__ import annotations
 import time
 
 from sqlbuild.compiler.planner._helpers.output.plan_entry import build_planner_relations_context
+from sqlbuild.compiler.planner._helpers.planning.full_refresh import (
+    effectively_full_refreshed_model_names,
+)
 from sqlbuild.compiler.planner._helpers.warehouse.snapshot import gather_warehouse_snapshot
 from sqlbuild.compiler.planner.models import (
     DeferralInputs,
@@ -35,7 +38,10 @@ def gather_planner_warehouse_state(
         connection=runtime.connection,
         execute=runtime.adapter.execute,
         selected_keys=frozenset(scopes.stale_warning_scope.all_keys.values()),
-        full_refresh=overrides.full_refresh,
+        full_refresh_model_names=effectively_full_refreshed_model_names(
+            project=runtime.project,
+            cli_full_refresh=overrides.full_refresh,
+        ),
         on_progress=runtime.on_progress,
         deferred_locations=deferral.deferred_locations,
     )

{sqlbuild-0.66.5 → sqlbuild-0.66.6}/src/sqlbuild/compiler/planner/_helpers/warehouse/snapshot.py

@@ -35,6 +35,9 @@ from sqlbuild.compiler.planner._helpers.graph.core import build_execution_upstre
 from sqlbuild.compiler.planner._helpers.graph.loader_dag import (
     build_upstream_intermediate_source_map,
 )
+from sqlbuild.compiler.planner._helpers.planning.full_refresh import (
+    effectively_full_refreshed_model_names,
+)
 from sqlbuild.compiler.planner.constants import METADATA_NAME_FILTER_LIMIT
 from sqlbuild.compiler.planner.exceptions import PlannerInputError
 from sqlbuild.compiler.planner.models import (
@@ -105,7 +108,10 @@ def build_warehouse_snapshot(
         connection=connection,
         execute=adapter.execute,
         selected_keys=scope.selected_keys,
-        full_refresh=full_refresh,
+        full_refresh_model_names=effectively_full_refreshed_model_names(
+            project=project,
+            cli_full_refresh=full_refresh,
+        ),
         on_progress=on_progress,
         deferred_locations=deferred_locations,
     )
@@ -133,6 +139,7 @@ def gather_warehouse_snapshot(
     execute: AdapterExecute[Any, Any],
     selected_keys: frozenset[CompiledObjectKey] | None = None,
     full_refresh: bool = False,
+    full_refresh_model_names: frozenset[str] | None = None,
     on_progress: Callable[[str], None] | None = None,
     deferred_locations: dict[str, CompiledRelationLocation] | None = None,
 ) -> WarehouseSnapshot:
@@ -178,18 +185,25 @@ def gather_warehouse_snapshot(
         node_names=_selected_node_names(relevant_keys),
     )
 
-    cursor_snapshots: dict[str, ModelCursorSnapshot] = {}
-    if not full_refresh:
-        cursor_snapshots = _gather_cursor_snapshots(
+    effective_full_refresh_names: frozenset[str] = (
+        full_refresh_model_names
+        if full_refresh_model_names is not None
+        else effectively_full_refreshed_model_names(
             project=project,
-            adapter=adapter,
-            connection=connection,
-            execute=execute,
-            existing_relations=relations,
-            selected_keys=selected_keys,
-            on_progress=on_progress,
-            deferred_locations=deferred_locations,
+            cli_full_refresh=full_refresh,
         )
+    )
+    cursor_snapshots: dict[str, ModelCursorSnapshot] = _gather_cursor_snapshots(
+        project=project,
+        adapter=adapter,
+        connection=connection,
+        execute=execute,
+        existing_relations=relations,
+        selected_keys=selected_keys,
+        full_refresh_model_names=effective_full_refresh_names,
+        on_progress=on_progress,
+        deferred_locations=deferred_locations,
+    )
 
     return WarehouseSnapshot(
         existing_relations=relations,
@@ -512,6 +526,7 @@ def _gather_cursor_snapshots(
     execute: AdapterExecute[Any, Any],
     existing_relations: dict[str, RelationInfo],
     selected_keys: frozenset[CompiledObjectKey] | None,
+    full_refresh_model_names: frozenset[str],
     on_progress: Callable[[str], None] | None,
     deferred_locations: dict[str, CompiledRelationLocation] | None = None,
 ) -> dict[str, ModelCursorSnapshot]:
@@ -527,6 +542,7 @@ def _gather_cursor_snapshots(
         source_map=source_map,
         existing_relations=existing_relations,
         selected_keys=selected_keys,
+        full_refresh_model_names=full_refresh_model_names,
         deferred_locations=deferred_locations,
     )
     if not cursor_models:
@@ -557,6 +573,7 @@ def _collect_cursor_models(
     source_map: dict[str, CompiledSource],
     existing_relations: dict[str, RelationInfo],
     selected_keys: frozenset[CompiledObjectKey] | None,
+    full_refresh_model_names: frozenset[str],
     deferred_locations: dict[str, CompiledRelationLocation] | None = None,
 ) -> list[_CursorModelInfo]:
     """Identify selected incremental models and pre-resolve their cursor metadata."""
@@ -567,6 +584,8 @@ def _collect_cursor_models(
     cursor_models: list[_CursorModelInfo] = []
     model: CompiledModel
     for model in project.models:
+        if model.name in full_refresh_model_names:
+            continue
         if selected_keys is not None:
             model_key: CompiledObjectKey = CompiledObjectKey(
                 resource_type=CompiledResourceType.MODEL, name=model.name

{sqlbuild-0.66.5 → sqlbuild-0.66.6}/src/sqlbuild/compiler/planner/main/execution/display_plan.py

@@ -11,6 +11,7 @@ from sqlbuild.compiler.planner._helpers.graph.core import (
     build_execution_upstream_deps,
 )
 from sqlbuild.compiler.planner._helpers.output.strategy import get_materialization_type
+from sqlbuild.compiler.planner._helpers.planning.full_refresh import resolve_model_full_refresh
 from sqlbuild.compiler.planner.models import BackfillResult, ModelPlanEntry, PlanOutput
 from sqlbuild.compiler.planner.types import (
     BackfillAction,
@@ -31,14 +32,23 @@ def build_display_only_sqlbuild_plan(
         if model.name not in selected_names:
             continue
         materialization_type: MaterializationType = get_materialization_type(model)
+        effective_full_refresh: bool = resolve_model_full_refresh(
+            model=model,
+            cli_full_refresh=full_refresh,
+        )
         model_entries.append(
             ModelPlanEntry(
                 key=model.key,
                 name=model.name,
                 relative_path=model.relative_path,
                 materialization_type=materialization_type,
-                action=_display_action(materialization_type),
-                reason=PlanReason.FULL_REFRESH if full_refresh else PlanReason.NO_CHANGE,
+                action=_display_action(
+                    materialization_type=materialization_type,
+                    full_refresh=effective_full_refresh,
+                ),
+                reason=(
+                    PlanReason.FULL_REFRESH if effective_full_refresh else PlanReason.NO_CHANGE
+                ),
                 destination=model.destination,
                 fingerprint_query_sql=model.query_sql,
                 resolved_sql=model.query_sql,
@@ -49,7 +59,13 @@ def build_display_only_sqlbuild_plan(
                 incremental_mode=_as_optional_string(model.config.values.get("incremental_mode")),
                 cursor_column=_as_optional_string(model.config.values.get("cursor_column")),
                 cursor_type=_as_optional_string(model.config.values.get("cursor_type")),
-                backfill=BackfillResult(action=BackfillAction.FORWARD_ONLY),
+                backfill=BackfillResult(
+                    action=(
+                        BackfillAction.FULL
+                        if effective_full_refresh
+                        else BackfillAction.FORWARD_ONLY
+                    )
+                ),
                 custom_materialization_name=(
                     _as_optional_string(model.config.values.get("materialized"))
                     if materialization_type == MaterializationType.CUSTOM
@@ -69,11 +85,13 @@ def build_display_only_sqlbuild_plan(
     )
 
 
-def _display_action(materialization_type: MaterializationType) -> PlanAction:
+def _display_action(
+    *, materialization_type: MaterializationType, full_refresh: bool = False
+) -> PlanAction:
     if materialization_type == MaterializationType.VIEW:
         return PlanAction.CREATE_VIEW
     if materialization_type == MaterializationType.INCREMENTAL:
-        return PlanAction.INCREMENTAL_APPEND
+        return PlanAction.CREATE_TABLE if full_refresh else PlanAction.INCREMENTAL_APPEND
     if materialization_type == MaterializationType.CUSTOM:
         return PlanAction.CUSTOM
     return PlanAction.CREATE_TABLE

{sqlbuild-0.66.5 → sqlbuild-0.66.6}/src/sqlbuild/compiler/planner/main/identity/_version_identity_config.py

@@ -18,7 +18,7 @@ def build_version_identity_config(config_values: dict[str, object]) -> dict[str,
         "incremental_mode",
         "incremental_strategy",
         "merge_exclude_columns",
-        "allow_full_refresh",
+        "full_refresh",
         "initial_valid_from",
         "invalidate_hard_deletes",
         "lookback",

{sqlbuild-0.66.5 → sqlbuild-0.66.6}/src/sqlbuild/compiler/planner/models.py

@@ -634,7 +634,6 @@ class ModelPlanEntry:
     end_cursor_override: str | None = None
     unique_key: tuple[str, ...] = field(default_factory=tuple)
     merge_exclude_columns: tuple[str, ...] = field(default_factory=tuple)
-    allow_full_refresh: bool | None = None
     snapshot_strategy: str | None = None
     updated_at_column: str | None = None
     check_columns: tuple[str, ...] = field(default_factory=tuple)

{sqlbuild-0.66.5 → sqlbuild-0.66.6}/src/sqlbuild/executor/build/_helpers/source_node.py

@@ -34,6 +34,7 @@ def execute_build_source_node(
     connection: Any,
     runtime: BuildRuntimeParams,
     callbacks: BuildCallbacks,
+    schema_prepared: bool = False,
 ) -> LoadExecutionResult:
     """Execute one source-load node from the build scheduler."""
 
@@ -78,6 +79,7 @@ def execute_build_source_node(
             use_color=runtime.use_color,
             providers=runtime.providers,
             result_store=result_store,
+            schema_prepared=schema_prepared,
         ),
         statement_recorder=StatementRecorder(),
         loader_ref_entries=loader_ref_entries,

{sqlbuild-0.66.5 → sqlbuild-0.66.6}/src/sqlbuild/executor/build/classes/build_scheduler.py

@@ -134,6 +134,7 @@ class BuildScheduler:
         callbacks: BuildCallbacks,
         customizations: BuildCustomizations,
         initial_state: BuildInitialState,
+        schema_prepared: bool,
     ) -> None:
         if runtime.promotion_mode is None:
             raise ExecutorInputError("build scheduler requires a resolved promotion mode")
@@ -145,6 +146,7 @@ class BuildScheduler:
         self._connection_config: dict[str, object] = connection_config
         self._connections: tuple[Any, ...] = connections
         self._scheduler_connection: Any = scheduler_connection
+        self._schema_prepared: bool = schema_prepared
         self._promotion_mode: TablePromotionMode = runtime.promotion_mode
         self._run_id: str = runtime.run_id
         self._runtime_dir: Path = runtime.runtime_dir
@@ -747,6 +749,7 @@ class BuildScheduler:
             connection=connection,
             runtime=self._runtime,
             callbacks=self._callbacks,
+            schema_prepared=self._schema_prepared,
         )
 
     def _execute_seed_node(self, *, key: CompiledObjectKey, connection: Any) -> SeedExecutionResult:
@@ -784,6 +787,7 @@ class BuildScheduler:
                 statement_recorder=StatementRecorder(),
                 run_id=self._run_id,
                 query_change_tracking=self._query_change_tracking,
+                schema_prepared=self._schema_prepared,
             )
         duration: int = int((time.monotonic() - start) * 1000)
         completed_result: SeedExecutionResult = dataclasses.replace(result, duration_ms=duration)
@@ -866,6 +870,7 @@ class BuildScheduler:
             statement_recorder=StatementRecorder(),
             run_id=self._run_id,
             query_change_tracking=self._query_change_tracking,
+            schema_prepared=self._schema_prepared,
         )
         duration: int = int((time.monotonic() - start) * 1000)
         return dataclasses.replace(result, duration_ms=duration)
@@ -958,6 +963,7 @@ class BuildScheduler:
                         model_audits=model_audits,
                         run_id=self._run_id,
                         query_change_tracking=self._query_change_tracking,
+                        schema_prepared=self._schema_prepared,
                         hook_functions=self._plan.hook_functions,
                         effective_target_name=self._target,
                         effective_vars=self._effective_vars,

{sqlbuild-0.66.5 → sqlbuild-0.66.6}/src/sqlbuild/executor/build/main/_execute.py

@@ -34,6 +34,7 @@ def execute_build_plan(
     callbacks: BuildCallbacks | None = None,
     customizations: BuildCustomizations | None = None,
     initial_state: BuildInitialState | None = None,
+    schema_prepared: bool = False,
 ) -> BuildExecutionResult:
     """Execute a full build plan using the DAG scheduler."""
 
@@ -54,6 +55,7 @@ def execute_build_plan(
         callbacks=resolved_callbacks,
         customizations=resolved_customizations,
         initial_state=resolved_initial_state,
+        schema_prepared=schema_prepared,
     )
 
     model_results: tuple[ModelExecutionResult, ...]

{sqlbuild-0.66.5 → sqlbuild-0.66.6}/src/sqlbuild/executor/clone/_helpers/execution_items.py

@@ -51,6 +51,7 @@ def execute_clone_function_item(
         statement_recorder=recorder,
         run_id=inputs.run_id,
         query_change_tracking=inputs.query_change_tracking,
+        schema_prepared=True,
     )
     succeeded: bool = function_result.status == ExecutionStatus.SUCCESS
     return CloneItemResult(

{sqlbuild-0.66.5 → sqlbuild-0.66.6}/src/sqlbuild/executor/clone/main/execute.py

@@ -40,6 +40,13 @@ def _ensure_destination_schemas(
     for entry in destination_entries:
         if entry.destination.schema is not None:
             schemas.add((entry.destination.database, entry.destination.schema))
+        if (
+            isinstance(entry, FunctionPlanEntry)
+            and entry.fingerprint_destination.schema is not None
+        ):
+            schemas.add(
+                (entry.fingerprint_destination.database, entry.fingerprint_destination.schema)
+            )
     recorder: StatementRecorder = StatementRecorder()
     for database, schema in sorted(schemas, key=lambda item: (item[0] or "", item[1])):
         adapter.ensure_schema(