sqlbuild 0.44.4__tar.gz → 0.45.0__tar.gz

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

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

{sqlbuild-0.44.4 → sqlbuild-0.45.0}/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.45.0](https://github.com/chio-labs/sqlbuild/compare/v0.44.4...v0.45.0) (2026-06-28)
+
+
+### Features
+
+* configure defer clone from project config ([6242def](https://github.com/chio-labs/sqlbuild/commit/6242def3f72b6d14bae98bd680143793ce71aa94))
+
+
+### Performance Improvements
+
+* optimize source freshness metadata planning ([ac737bf](https://github.com/chio-labs/sqlbuild/commit/ac737bf3f9135668260107d4819172643031c8f0))
+
 ## [0.44.4](https://github.com/chio-labs/sqlbuild/compare/v0.44.3...v0.44.4) (2026-06-28)
 
 

{sqlbuild-0.44.4 → sqlbuild-0.45.0}/PKG-INFO

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

{sqlbuild-0.44.4 → sqlbuild-0.45.0}/pyproject.toml

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

{sqlbuild-0.44.4 → sqlbuild-0.45.0}/src/sqlbuild/adapters/snowflake/client.py

@@ -74,6 +74,38 @@ class SnowflakeAdapter(BaseAdapter):
         {"source", "profile", "target", "project_dir", "profiles_dir"}
     )
 
+    @staticmethod
+    def _information_schema_identifier(value: str) -> str:
+        return value.upper()
+
+    @staticmethod
+    def _freshness_request_key(
+        *, database: str | None, schema: str | None, name: str
+    ) -> tuple[str | None, str | None, str]:
+        return (
+            None if database is None else database.upper(),
+            None if schema is None else schema.upper(),
+            name.upper(),
+        )
+
+    @staticmethod
+    def _find_freshness_request_for_row(
+        *,
+        requests_by_key: dict[tuple[str | None, str | None, str], TableFreshnessRequest],
+        database: object | None,
+        schema: object | None,
+        name: object,
+    ) -> TableFreshnessRequest | None:
+        row_database: str | None = None if database is None else str(database).upper()
+        row_schema: str | None = None if schema is None else str(schema).upper()
+        row_name: str = str(name).upper()
+        return (
+            requests_by_key.get((row_database, row_schema, row_name))
+            or requests_by_key.get((None, row_schema, row_name))
+            or requests_by_key.get((row_database, None, row_name))
+            or requests_by_key.get((None, None, row_name))
+        )
+
     def render_read_latest_fingerprints_sql(
         self,
         *,
@@ -229,14 +261,14 @@ class SnowflakeAdapter(BaseAdapter):
         schema: str | None,
         name: str,
     ) -> TableFreshnessMetadata:
-        clauses: list[str] = ["UPPER(table_name) = UPPER(%s)"]
-        params: list[str] = [name]
+        clauses: list[str] = ["table_name = %s"]
+        params: list[str] = [self._information_schema_identifier(name)]
         if schema is not None:
-            clauses.append("UPPER(table_schema) = UPPER(%s)")
-            params.append(schema)
+            clauses.append("table_schema = %s")
+            params.append(self._information_schema_identifier(schema))
         if database is not None:
-            clauses.append("UPPER(table_catalog) = UPPER(%s)")
-            params.append(database)
+            clauses.append("table_catalog = %s")
+            params.append(self._information_schema_identifier(database))
         cursor: Any = connection.cursor()
         try:
             cursor.execute(
@@ -273,68 +305,79 @@ class SnowflakeAdapter(BaseAdapter):
     ) -> dict[TableFreshnessRequest, TableFreshnessMetadata]:
         if not requests:
             return {}
-        clauses: list[str] = []
-        params: list[str] = []
+        results: dict[TableFreshnessRequest, TableFreshnessMetadata] = {}
+        requests_by_key: dict[tuple[str | None, str | None, str], TableFreshnessRequest] = {
+            self._freshness_request_key(
+                database=request.database,
+                schema=request.schema,
+                name=request.name,
+            ): request
+            for request in requests
+        }
+        requests_by_scope: dict[tuple[str | None, str | None], list[TableFreshnessRequest]] = {}
         request: TableFreshnessRequest
         for request in requests:
-            request_clauses: list[str] = ["UPPER(table_name) = UPPER(%s)"]
-            params.append(request.name)
-            if request.schema is not None:
-                request_clauses.append("UPPER(table_schema) = UPPER(%s)")
-                params.append(request.schema)
-            if request.database is not None:
-                request_clauses.append("UPPER(table_catalog) = UPPER(%s)")
-                params.append(request.database)
-            clauses.append("(" + " AND ".join(request_clauses) + ")")
-        cursor: Any = connection.cursor()
-        try:
-            cursor.execute(
-                "SELECT table_catalog, table_schema, table_name, table_type, last_altered "
-                "FROM information_schema.tables WHERE " + " OR ".join(clauses),
-                tuple(params),
+            scope: tuple[str | None, str | None] = (
+                None
+                if request.database is None
+                else self._information_schema_identifier(request.database),
+                None
+                if request.schema is None
+                else self._information_schema_identifier(request.schema),
             )
-            rows: list[tuple[Any, ...]] = list(cursor.fetchall())
-        finally:
-            cursor.close()
-
-        results: dict[TableFreshnessRequest, TableFreshnessMetadata] = {}
-        row: tuple[Any, ...]
-        for row in rows:
-            row_database: str | None = str(row[0]) if row[0] is not None else None
-            row_schema: str | None = str(row[1]) if row[1] is not None else None
-            row_name: str = str(row[2])
-            matched_request: TableFreshnessRequest | None = next(
-                (
-                    request
-                    for request in requests
-                    if request not in results
-                    and self._freshness_request_matches(
-                        request=request,
-                        database=row_database,
-                        schema=row_schema,
-                        name=row_name,
-                    )
-                ),
-                None,
+            requests_by_scope.setdefault(scope, []).append(request)
+        for (database, schema), scoped_requests in requests_by_scope.items():
+            clauses: list[str] = []
+            params: list[str] = []
+            if database is not None:
+                clauses.append("table_catalog = %s")
+                params.append(database)
+            if schema is not None:
+                clauses.append("table_schema = %s")
+                params.append(schema)
+            placeholders: str = ", ".join(["%s"] * len(scoped_requests))
+            clauses.append(f"table_name IN ({placeholders})")
+            params.extend(
+                self._information_schema_identifier(request.name) for request in scoped_requests
             )
-            if matched_request is None:
-                continue
-            table_type: str = str(row[3]).upper()
-            if table_type != "BASE TABLE":
-                raise AdapterUserError(
-                    "Snowflake table freshness metadata only supports physical tables; "
-                    f"found {table_type}"
+            cursor: Any = connection.cursor()
+            try:
+                cursor.execute(
+                    "SELECT table_catalog, table_schema, table_name, table_type, last_altered "
+                    "FROM information_schema.tables WHERE " + " AND ".join(clauses),
+                    tuple(params),
                 )
-            if row[4] is None:
-                raise AdapterUserError(
-                    "Snowflake table freshness metadata is missing LAST_ALTERED "
-                    f"for {matched_request.name}"
+                rows: list[tuple[Any, ...]] = list(cursor.fetchall())
+            finally:
+                cursor.close()
+            row: tuple[Any, ...]
+            for row in rows:
+                matched_request: TableFreshnessRequest | None = (
+                    self._find_freshness_request_for_row(
+                        requests_by_key=requests_by_key,
+                        database=row[0],
+                        schema=row[1],
+                        name=row[2],
+                    )
+                )
+                if matched_request is None:
+                    continue
+                table_type: str = str(row[3]).upper()
+                if table_type != "BASE TABLE":
+                    raise AdapterUserError(
+                        "Snowflake table freshness metadata only supports physical tables; "
+                        f"found {table_type}"
+                    )
+                if row[4] is None:
+                    raise AdapterUserError(
+                        "Snowflake table freshness metadata is missing LAST_ALTERED "
+                        f"for {matched_request.name}"
+                    )
+                results[matched_request] = TableFreshnessMetadata(
+                    data_version=row[4],
+                    value_kind="timestamp",
+                    observed_at=row[4] if isinstance(row[4], datetime) else None,
                 )
-            results[matched_request] = TableFreshnessMetadata(
-                data_version=row[4],
-                value_kind="timestamp",
-                observed_at=row[4] if isinstance(row[4], datetime) else None,
-            )
         missing_requests: list[TableFreshnessRequest] = [
             request for request in requests if request not in results
         ]
@@ -345,26 +388,6 @@ class SnowflakeAdapter(BaseAdapter):
             )
         return results
 
-    @staticmethod
-    def _freshness_request_matches(
-        *,
-        request: TableFreshnessRequest,
-        database: str | None,
-        schema: str | None,
-        name: str,
-    ) -> bool:
-        if request.name.upper() != name.upper():
-            return False
-        if request.schema is not None and (
-            schema is None or request.schema.upper() != schema.upper()
-        ):
-            return False
-        if request.database is not None and (
-            database is None or request.database.upper() != database.upper()
-        ):
-            return False
-        return True
-
     def persists_python_functions(self) -> bool:
         return True
 
@@ -1394,14 +1417,14 @@ class SnowflakeAdapter(BaseAdapter):
         schema: str | None,
         name: str,
     ) -> bool:
-        clauses: list[str] = ["UPPER(table_name) = UPPER(%s)"]
-        params: list[str] = [name]
+        clauses: list[str] = ["table_name = %s"]
+        params: list[str] = [self._information_schema_identifier(name)]
         if schema is not None:
-            clauses.append("UPPER(table_schema) = UPPER(%s)")
-            params.append(schema)
+            clauses.append("table_schema = %s")
+            params.append(self._information_schema_identifier(schema))
         if database is not None:
-            clauses.append("UPPER(table_catalog) = UPPER(%s)")
-            params.append(database)
+            clauses.append("table_catalog = %s")
+            params.append(self._information_schema_identifier(database))
         cursor: Any = connection.cursor()
         try:
             cursor.execute(
@@ -1427,15 +1450,15 @@ class SnowflakeAdapter(BaseAdapter):
         params: list[str] = []
         if schemas:
             placeholders: str = ", ".join(["%s"] * len(schemas))
-            query += f" AND UPPER(table_schema) IN ({placeholders})"
-            params.extend(schema.upper() for schema in schemas)
+            query += f" AND table_schema IN ({placeholders})"
+            params.extend(self._information_schema_identifier(schema) for schema in schemas)
         if names:
             placeholders = ", ".join(["%s"] * len(names))
-            query += f" AND UPPER(table_name) IN ({placeholders})"
-            params.extend(name.upper() for name in names)
+            query += f" AND table_name IN ({placeholders})"
+            params.extend(self._information_schema_identifier(name) for name in names)
         if database is not None:
-            query += " AND UPPER(table_catalog) = UPPER(%s)"
-            params.append(database)
+            query += " AND table_catalog = %s"
+            params.append(self._information_schema_identifier(database))
         cursor: Any = connection.cursor()
         try:
             cursor.execute(query, tuple(params))
@@ -1506,15 +1529,15 @@ class SnowflakeAdapter(BaseAdapter):
         query: str = (
             "SELECT column_name, data_type, numeric_precision, numeric_scale, "
             "character_maximum_length FROM information_schema.columns "
-            "WHERE UPPER(table_name) = UPPER(%s)"
+            "WHERE table_name = %s"
         )
-        params: list[str] = [name]
+        params: list[str] = [self._information_schema_identifier(name)]
         if schema is not None:
-            query += " AND UPPER(table_schema) = UPPER(%s)"
-            params.append(schema)
+            query += " AND table_schema = %s"
+            params.append(self._information_schema_identifier(schema))
         if database is not None:
-            query += " AND UPPER(table_catalog) = UPPER(%s)"
-            params.append(database)
+            query += " AND table_catalog = %s"
+            params.append(self._information_schema_identifier(database))
         query += " ORDER BY ordinal_position"
         cursor: Any = connection.cursor()
         try:
@@ -1550,15 +1573,15 @@ class SnowflakeAdapter(BaseAdapter):
         params: list[str] = []
         if schemas:
             placeholders: str = ", ".join(["%s"] * len(schemas))
-            query += f" AND UPPER(table_schema) IN ({placeholders})"
-            params.extend(schema.upper() for schema in schemas)
+            query += f" AND table_schema IN ({placeholders})"
+            params.extend(self._information_schema_identifier(schema) for schema in schemas)
         if names:
             placeholders = ", ".join(["%s"] * len(names))
-            query += f" AND UPPER(table_name) IN ({placeholders})"
-            params.extend(name.upper() for name in names)
+            query += f" AND table_name IN ({placeholders})"
+            params.extend(self._information_schema_identifier(name) for name in names)
         if database is not None:
-            query += " AND UPPER(table_catalog) = UPPER(%s)"
-            params.append(database)
+            query += " AND table_catalog = %s"
+            params.append(self._information_schema_identifier(database))
         query += " ORDER BY table_name, ordinal_position"
         cursor: Any = connection.cursor()
         try:

{sqlbuild-0.44.4 → sqlbuild-0.45.0}/src/sqlbuild/cli/commands/main/build.py

@@ -87,8 +87,12 @@ from sqlbuild.executor.python_nodes.models import (
 )
 from sqlbuild.provider.main.session import build_provider_session
 from sqlbuild.shared.helpers.colors import supports_color
-from sqlbuild.spec.models.project import resolve_effective_adapter_name
-from sqlbuild.spec.models.targets import resolve_effective_force
+from sqlbuild.spec.models.project import TargetConfig, resolve_effective_adapter_name
+from sqlbuild.spec.models.targets import (
+    resolve_effective_force,
+    resolve_target_config,
+    resolve_target_name,
+)
 
 
 def run_build(
@@ -127,11 +131,16 @@ def run_build(
     discovered_inputs: DiscoveredProjectInputs = discover_project_inputs(
         project_dir=effective_project_dir
     )
-    if defer_to is not None and defer_clone_from is not None:
+    effective_defer_clone_from: str | None = _resolve_defer_clone_from(
+        discovered_inputs=discovered_inputs,
+        selected_target=selected_target,
+        cli_defer_clone_from=defer_clone_from,
+    )
+    if defer_to is not None and effective_defer_clone_from is not None:
         raise CliUserError("--defer-clone-from cannot be used with --defer-to", code="C408")
     if (
         discovered_inputs.project_config.settings.virtual_environments
-        and defer_clone_from is not None
+        and effective_defer_clone_from is not None
     ):
         raise CliUserError(
             "build does not support --defer-clone-from when virtual_environments = true",
@@ -215,7 +224,7 @@ def run_build(
                 progress_stream=progress_stream,
                 providers=provider_session.providers,
             )
-        if defer_clone_from is not None:
+        if effective_defer_clone_from is not None:
             cloned_project: CompiledProject
             boundary_selectors: tuple[str, ...]
             view_chain_selectors: tuple[str, ...]
@@ -235,7 +244,7 @@ def run_build(
             run_defer_clone_prephase(
                 discovered_inputs=discovered_inputs,
                 adapter=adapter,
-                origin_target_name=defer_clone_from,
+                origin_target_name=effective_defer_clone_from,
                 destination_target_name=cloned_project.effective_target_name,
                 no_sql_validation=no_sql_validation,
                 select=boundary_selectors,
@@ -495,3 +504,26 @@ def run_build(
         )
     finally:
         provider_session.close()
+
+
+def _resolve_defer_clone_from(
+    *,
+    discovered_inputs: DiscoveredProjectInputs,
+    selected_target: str | None,
+    cli_defer_clone_from: str | None,
+) -> str | None:
+    if cli_defer_clone_from is not None:
+        return cli_defer_clone_from
+    target_name: str | None = resolve_target_name(
+        project_config=discovered_inputs.project_config,
+        local_config=discovered_inputs.local_config,
+        selected_target=selected_target,
+    )
+    if target_name is None:
+        return None
+    target_config: TargetConfig = resolve_target_config(
+        project_config=discovered_inputs.project_config,
+        local_config=discovered_inputs.local_config,
+        target_name=target_name,
+    )
+    return target_config.defer_clone_from

{sqlbuild-0.44.4 → sqlbuild-0.45.0}/src/sqlbuild/compiler/discovery/helpers/yml/project.py

@@ -448,6 +448,7 @@ def _load_targets(*, payload: object, file_path: Path) -> dict[str, TargetConfig
             database=_optional_str(payload=target_mapping, key="database"),
             schema=_optional_str(payload=target_mapping, key="schema"),
             defer_sources_to=_optional_str(payload=target_mapping, key="defer_sources_to"),
+            defer_clone_from=_optional_str(payload=target_mapping, key="defer_clone_from"),
             reuse_from=_optional_str(payload=target_mapping, key="reuse_from"),
             force=_optional_nullable_bool(mapping=target_mapping, key="force"),
             reuse_hard_copy=_optional_bool(
@@ -514,6 +515,7 @@ def _load_local_targets(*, payload: object, file_path: Path) -> dict[str, LocalT
             database=_optional_str(payload=target_mapping, key="database"),
             schema=_optional_str(payload=target_mapping, key="schema"),
             defer_sources_to=_optional_str(payload=target_mapping, key="defer_sources_to"),
+            defer_clone_from=_optional_str(payload=target_mapping, key="defer_clone_from"),
             reuse_from=_optional_str(payload=target_mapping, key="reuse_from"),
             force=_optional_nullable_bool(mapping=target_mapping, key="force"),
             reuse_hard_copy=_optional_nullable_bool(
@@ -683,6 +685,7 @@ def _load_dbt(*, payload: object, file_path: Path) -> DbtConfig:
                 "target_path",
                 "vars",
                 "replay_on_change",
+                "defer_clone_from",
                 "production_ref",
             }
         ),
@@ -696,6 +699,11 @@ def _load_dbt(*, payload: object, file_path: Path) -> DbtConfig:
         target_path=_optional_str(payload=mapping, key="target_path"),
         vars=_load_object_mapping(payload=mapping.get("vars"), file_path=file_path),
         replay_on_change=_optional_str(payload=mapping, key="replay_on_change"),
+        defer_clone_from=_optional_bool(
+            mapping=mapping,
+            key="defer_clone_from",
+            default=False,
+        ),
         production_ref=_load_dbt_production_ref(
             payload=mapping.get("production_ref"),
             file_path=file_path,
@@ -709,13 +717,14 @@ def _load_local_dbt(*, payload: object, file_path: Path) -> LocalDbtConfig:
     mapping: dict[str, object] = _coerce_mapping(payload=payload, label="dbt", file_path=file_path)
     _validate_allowed_keys(
         mapping=mapping,
-        allowed_keys=frozenset({"target", "vars"}),
+        allowed_keys=frozenset({"target", "vars", "defer_clone_from"}),
         label="dbt",
         file_path=file_path,
     )
     return LocalDbtConfig(
         target=_optional_str(payload=mapping, key="target"),
         vars=_load_object_mapping(payload=mapping.get("vars"), file_path=file_path),
+        defer_clone_from=_optional_nullable_bool(mapping=mapping, key="defer_clone_from"),
     )
 
 

{sqlbuild-0.44.4 → sqlbuild-0.45.0}/src/sqlbuild/compiler/planner/helpers/warehouse/source_deferral.py

@@ -172,6 +172,11 @@ def _resolve_target_config(
             if local_target.defer_sources_to is not None
             else project_target.defer_sources_to
         ),
+        defer_clone_from=(
+            local_target.defer_clone_from
+            if local_target.defer_clone_from is not None
+            else project_target.defer_clone_from
+        ),
         clone=ClonePolicy(
             allow_as_clone_origin=(
                 local_target.clone.allow_as_clone_origin

{sqlbuild-0.44.4 → sqlbuild-0.45.0}/src/sqlbuild/integrations/dbt/helpers/cli/arg_parser.py

@@ -30,7 +30,7 @@ def add_dbt_execution_args(parser: argparse.ArgumentParser) -> None:
     parser.add_argument("--indirect-selection", default=None)
     parser.add_argument("--defer", action="store_true", default=False)
     parser.add_argument("--defer-to", default=None)
-    parser.add_argument("--defer-clone-from", action="store_true", default=False)
+    parser.add_argument("--defer-clone-from", action="store_true", default=None)
     parser.add_argument("--start-cursor-ts", default=None)
     parser.add_argument("--end-cursor-ts", default=None)
     parser.add_argument("--start-cursor-int", default=None)

{sqlbuild-0.44.4 → sqlbuild-0.45.0}/src/sqlbuild/integrations/dbt/helpers/planning/model_planning.py

@@ -58,6 +58,7 @@ from sqlbuild.integrations.dbt.manifest.models import (
     DbtManifestIndex,
     DbtManifestModel,
     DbtManifestSeed,
+    DbtManifestSource,
 )
 from sqlbuild.integrations.dbt.models import (
     DbtCombinedGraph,
@@ -117,7 +118,9 @@ def build_dbt_model_planning_result(
     )
     source_freshness: StandardSourceFreshnessPlanningResult = _source_freshness_result(
         manifest=manifest,
+        candidate_unique_ids=expanded_candidate_unique_ids,
         project=project,
+        graph=graph,
         adapter=adapter,
         connection=connection,
         relation_lookup=relation_lookup,
@@ -378,13 +381,24 @@ def _changed_seed_unique_ids(
 def _source_freshness_result(
     *,
     manifest: DbtManifestIndex,
+    candidate_unique_ids: Sequence[str],
     project: CompiledProject,
+    graph: DbtCombinedGraph | None,
     adapter: BaseAdapter,
     connection: Any,
     relation_lookup: RelationLookup,
 ) -> StandardSourceFreshnessPlanningResult:
+    sources_by_unique_id: dict[str, DbtManifestSource] = _freshness_sources_by_unique_id(
+        manifest=manifest,
+        candidate_unique_ids=candidate_unique_ids,
+        graph=graph,
+    )
+    scoped_manifest: DbtManifestIndex = replace(
+        manifest,
+        sources_by_unique_id=sources_by_unique_id,
+    )
     sources: tuple[SourceEntry, ...] = translate_manifest_sources_to_sqlbuild_sources(
-        manifest=manifest
+        manifest=scoped_manifest
     )
     if not sources:
         return StandardSourceFreshnessPlanningResult()
@@ -410,6 +424,32 @@ def _source_freshness_result(
     )
 
 
+def _freshness_sources_by_unique_id(
+    *,
+    manifest: DbtManifestIndex,
+    candidate_unique_ids: Sequence[str],
+    graph: DbtCombinedGraph | None,
+) -> dict[str, DbtManifestSource]:
+    if graph is None:
+        return manifest.sources_by_unique_id
+    source_unique_ids: set[str] = set()
+    unique_id: str
+    for unique_id in candidate_unique_ids:
+        key: DbtCombinedGraphKey
+        for key in expand_combined_upstream(dbt_model_graph_key(unique_id), graph.upstream_deps):
+            if (
+                key.owner == DbtCombinedGraphOwner.DBT
+                and key.resource_type == DbtCombinedGraphResourceType.SOURCE
+                and key.name in manifest.sources_by_unique_id
+            ):
+                source_unique_ids.add(key.name)
+    return {
+        unique_id: source
+        for unique_id, source in manifest.sources_by_unique_id.items()
+        if unique_id in source_unique_ids
+    }
+
+
 def _apply_graph_propagation(
     *,
     entries_by_unique_id: dict[str, DbtModelPlanEntry],

{sqlbuild-0.44.4 → sqlbuild-0.45.0}/src/sqlbuild/integrations/dbt/helpers/runtime/event_stream.py

@@ -118,6 +118,9 @@ def execute_dbt_json_event_stream(
                     if start_result is not None and start_result.unique_id not in started_indexes:
                         display_index += 1
                         started_indexes[start_result.unique_id] = display_index
+                        if status is not None:
+                            status.close()
+                            status = None
                         render_dbt_node_result(
                             stream=stream,
                             style=style,

{sqlbuild-0.44.4 → sqlbuild-0.45.0}/src/sqlbuild/integrations/dbt/models.py

@@ -470,7 +470,7 @@ class DbtInteropParsedArgs:
     state: str | None = None
     indirect_selection: str | None = None
     defer: bool = False
-    defer_clone_from: bool = False
+    defer_clone_from: bool | None = None
     start_cursor_ts: str | None = None
     end_cursor_ts: str | None = None
     start_cursor_int: str | None = None
@@ -491,7 +491,7 @@ class DbtInteropRoutedArgs:
     exclude: tuple[str, ...] = field(default_factory=tuple)
     dbt_args: tuple[str, ...] = field(default_factory=tuple)
     sqlbuild_args: tuple[str, ...] = field(default_factory=tuple)
-    defer_clone_from: bool = False
+    defer_clone_from: bool | None = None
 
 
 @dataclass(frozen=True)

{sqlbuild-0.44.4 → sqlbuild-0.45.0}/src/sqlbuild/integrations/dbt/pipeline/helpers/defer_clone.py

@@ -55,6 +55,21 @@ from sqlbuild.shared.helpers.graph_algorithms import (
 from sqlbuild.spec.models.project import DbtProductionRefConfig
 
 
+def resolve_dbt_defer_clone_from(
+    *,
+    cli_defer_clone_from: bool | None,
+    project_defer_clone_from: bool,
+    local_defer_clone_from: bool | None,
+) -> bool:
+    """Resolve dbt defer-clone enablement from CLI, local config, and project config."""
+
+    if cli_defer_clone_from is not None:
+        return cli_defer_clone_from
+    if local_defer_clone_from is not None:
+        return local_defer_clone_from
+    return project_defer_clone_from
+
+
 def run_dbt_defer_clone_prephase(
     *,
     project_dir: Path,