sqlbuild 0.109.0__tar.gz → 0.110.1__tar.gz

{sqlbuild-0.109.0 → sqlbuild-0.110.1}/Cargo.lock

@@ -529,7 +529,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sqlbuild-rules-native"
-version = "0.109.0"
+version = "0.110.1"
 dependencies = [
  "fensu-policy",
  "globset",

{sqlbuild-0.109.0 → sqlbuild-0.110.1}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.109.0
+Version: 0.110.1
 Requires-Dist: duckdb>=1.3.2
 Requires-Dist: filelock>=3.20.3
 Requires-Dist: orjson>=3.10.0
-Requires-Dist: polyglot-sql==0.11.0
+Requires-Dist: polyglot-sql==0.12.0
 Requires-Dist: pydantic-settings>=2,<3
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: rich>=15.0.0
@@ -60,7 +60,7 @@ All state is persisted as append-only tables in the warehouse alongside your dat
 - **Cursor-based incremental processing.** Automatic gap detection and resume, with microbatch mode for large ranges. No external checkpoint to maintain.
 - **Ingestion and Python nodes.** Load external data with Python `@loader` functions, and run `@task`, `@asset`, and `@check` nodes as first-class members of the same DAG as your SQL models.
 
-See the [documentation](https://docs.sqlbuild.com) for the full feature set, including providers, lifecycle hooks, Python macros, UDFs, custom materializations, data diffs, zero-copy cloning, and virtual environments. This repository also includes a focused guide to [model and raw-query diffs](docs/query-diffs.md). To coordinate dbt and SQLBuild projects, see the [dbt compatibility guide](https://docs.sqlbuild.com/concepts/dbt-compatibility/overview).
+See the [documentation](https://docs.sqlbuild.com) for the full feature set, including providers, lifecycle hooks, Python macros, UDFs, custom materializations, data diffs, zero-copy cloning, and virtual environments. This repository also includes focused guides to [target execution limits](docs/execution-limits.md) and [model and raw-query diffs](docs/query-diffs.md). To coordinate dbt and SQLBuild projects, see the [dbt compatibility guide](https://docs.sqlbuild.com/concepts/dbt-compatibility/overview).
 
 ## Quick start
 

{sqlbuild-0.109.0 → sqlbuild-0.110.1}/README.md

@@ -24,7 +24,7 @@ All state is persisted as append-only tables in the warehouse alongside your dat
 - **Cursor-based incremental processing.** Automatic gap detection and resume, with microbatch mode for large ranges. No external checkpoint to maintain.
 - **Ingestion and Python nodes.** Load external data with Python `@loader` functions, and run `@task`, `@asset`, and `@check` nodes as first-class members of the same DAG as your SQL models.
 
-See the [documentation](https://docs.sqlbuild.com) for the full feature set, including providers, lifecycle hooks, Python macros, UDFs, custom materializations, data diffs, zero-copy cloning, and virtual environments. This repository also includes a focused guide to [model and raw-query diffs](docs/query-diffs.md). To coordinate dbt and SQLBuild projects, see the [dbt compatibility guide](https://docs.sqlbuild.com/concepts/dbt-compatibility/overview).
+See the [documentation](https://docs.sqlbuild.com) for the full feature set, including providers, lifecycle hooks, Python macros, UDFs, custom materializations, data diffs, zero-copy cloning, and virtual environments. This repository also includes focused guides to [target execution limits](docs/execution-limits.md) and [model and raw-query diffs](docs/query-diffs.md). To coordinate dbt and SQLBuild projects, see the [dbt compatibility guide](https://docs.sqlbuild.com/concepts/dbt-compatibility/overview).
 
 ## Quick start
 

{sqlbuild-0.109.0 → sqlbuild-0.110.1}/crates/sqlbuild-rules-native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlbuild-rules-native"
-version = "0.109.0"
+version = "0.110.1"
 edition.workspace = true
 license.workspace = true
 publish.workspace = true

{sqlbuild-0.109.0 → sqlbuild-0.110.1}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "maturin"
 
 [project]
 name = "sqlbuild"
-version = "0.109.0"
+version = "0.110.1"
 description = "Typed, test-first SQL pipelines with local E2E testing"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -15,7 +15,7 @@ dependencies = [
   "duckdb>=1.3.2",
   "filelock>=3.20.3",
   "orjson>=3.10.0",
-  "polyglot-sql==0.11.0",
+  "polyglot-sql==0.12.0",
   "pydantic-settings>=2,<3",
   "PyYAML>=6.0.2",
   "rich>=15.0.0",

{sqlbuild-0.109.0 → sqlbuild-0.110.1}/src/sqlbuild/adapter/contract/classes/base_adapter.py

@@ -85,6 +85,7 @@ class BaseAdapter(RetentionAdapterMixin, StrictAdapter):
     max_identifier_length: ClassVar[int] = 63
     state_tables_transient: ClassVar[bool] = False
     allows_implicit_managed_write_schema: ClassVar[bool] = False
+    execution_duration_limit_seconds: ClassVar[int | None] = None
 
     def supports_zero_copy_clone(self) -> bool:
         return False

{sqlbuild-0.109.0 → sqlbuild-0.110.1}/src/sqlbuild/adapter/contract/classes/connection.py

@@ -9,6 +9,10 @@ from typing import Any, ClassVar
 
 from sqlbuild.adapter.contract.main._attribute_failed_sql import attribute_failed_sql
 from sqlbuild.adapter.contract.models import QueryResult
+from sqlbuild.runtime.execution_limits.exceptions import ExecutionDurationLimitError
+from sqlbuild.runtime.execution_limits.main.enforce_execution_deadline import (
+    enforce_execution_deadline,
+)
 from sqlbuild.runtime.observability.classes.statement_lifecycle import StatementLifecycle
 
 
@@ -27,8 +31,13 @@ class ConnectionMixin(ABC):
 
         with StatementLifecycle(adapter=self.adapter_name, sql=sql, intent="execute") as lifecycle:
             try:
+                enforce_execution_deadline()
                 result: Any = self._execute(connection=connection, sql=sql)
             except Exception as error:
+                try:
+                    enforce_execution_deadline()
+                except ExecutionDurationLimitError as deadline_error:
+                    raise deadline_error from error
                 attributed_error: Exception = attribute_failed_sql(error=error, sql=sql)
                 if attributed_error is error:
                     raise

{sqlbuild-0.109.0 → sqlbuild-0.110.1}/src/sqlbuild/adapters/snowflake/classes/snowflake_adapter.py

@@ -70,6 +70,7 @@ from sqlbuild.adapters.snowflake.classes.snowflake_connection import _SnowflakeC
 from sqlbuild.adapters.snowflake.constants import (
     BASE_TABLE_METADATA_TYPE,
     EXTERNAL_BROWSER_AUTHENTICATOR,
+    MAX_STATEMENT_TIMEOUT_SECONDS,
     MFA_AUTHENTICATOR,
     NUMBER_TYPE_NAME,
     OAUTH_AUTHORIZATION_CODE_AUTHENTICATOR,
@@ -102,6 +103,8 @@ class SnowflakeAdapter(MicrobatchMixin, UnkeyedDiffMixin, BaseAdapter):
 
     adapter_name: ClassVar[str] = BuiltinAdapter.SNOWFLAKE.value
     sql_analysis_dialect_name: ClassVar[str | None] = "snowflake"
+    execution_duration_limit_seconds: ClassVar[int | None] = MAX_STATEMENT_TIMEOUT_SECONDS
+
     max_identifier_length: ClassVar[int] = 255
     state_tables_transient: ClassVar[bool] = True
     connection_routing_keys: ClassVar[frozenset[str]] = frozenset(

{sqlbuild-0.109.0 → sqlbuild-0.110.1}/src/sqlbuild/adapters/snowflake/classes/snowflake_cursor.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import json
 import logging
+import math
 import time
 from collections.abc import Callable, Iterator
 from datetime import UTC, datetime
@@ -15,6 +16,10 @@ from sqlbuild.cost.classes.cost_context import CostContext
 from sqlbuild.cost.classes.statement_ledger import StatementLedger
 from sqlbuild.cost.constants import SQLBUILD_QUERY_TAG_APP
 from sqlbuild.cost.models import CostResourceContext, StatementExecutionTelemetry
+from sqlbuild.runtime.execution_limits.main.current_execution_deadline import (
+    current_execution_deadline,
+)
+from sqlbuild.runtime.execution_limits.models import ExecutionDeadline
 from sqlbuild.runtime.observability.classes.statement_lifecycle import StatementLifecycle
 from sqlbuild.runtime.observability.main.current_execution_identity import (
     current_execution_identity,
@@ -23,6 +28,7 @@ from sqlbuild.runtime.observability.models import ExecutionIdentity
 
 _LOGGER: logging.Logger = logging.getLogger("sqlbuild.cost")
 _QUERY_TAG_PARAMETER: str = "QUERY_TAG"
+_STATEMENT_TIMEOUT_PARAMETER: str = "STATEMENT_TIMEOUT_IN_SECONDS"
 _STATEMENT_PARAMETER_ERROR_FRAGMENT: str = "STATEMENT PARAMETER"
 _RAW_CURSOR_ATTRIBUTE: str = "raw_cursor"
 _EXECUTEMANY_INTENT: str = "executemany"
@@ -50,8 +56,9 @@ class _SnowflakeCursor:
     def execute(self, sql: str, *args: Any, **kwargs: Any) -> Any:
         context: CostResourceContext | None = CostContext.current()
         statement_id: str = _statement_id()
+        deadline_kwargs: dict[str, Any] = _with_execution_deadline(kwargs=kwargs)
         tagged_kwargs, query_tag_injected = _with_query_tag(
-            kwargs=kwargs, context=context, statement_id=statement_id
+            kwargs=deadline_kwargs, context=context, statement_id=statement_id
         )
         return self._execute_with_telemetry(
             operation=self.raw_cursor.execute,
@@ -67,8 +74,9 @@ class _SnowflakeCursor:
     def executemany(self, sql: str, *args: Any, **kwargs: Any) -> Any:
         context: CostResourceContext | None = CostContext.current()
         statement_id: str = _statement_id()
+        deadline_kwargs: dict[str, Any] = _with_execution_deadline(kwargs=kwargs)
         tagged_kwargs, query_tag_injected = _with_query_tag(
-            kwargs=kwargs, context=context, statement_id=statement_id
+            kwargs=deadline_kwargs, context=context, statement_id=statement_id
         )
         return self._execute_with_telemetry(
             operation=self.raw_cursor.executemany,
@@ -120,7 +128,9 @@ class _SnowflakeCursor:
                         "Snowflake query tagging was rejected before submission; "
                         "continuing without a query tag"
                     )
-                    retry_kwargs: dict[str, Any] = _without_query_tag(kwargs=kwargs)
+                    retry_kwargs: dict[str, Any] = _with_execution_deadline(
+                        kwargs=_without_query_tag(kwargs=kwargs)
+                    )
                     try:
                         result = operation(sql, *args, **retry_kwargs)
                     except Exception as retry_error:
@@ -284,6 +294,20 @@ def _with_query_tag(
     return tagged_kwargs, True
 
 
+def _with_execution_deadline(*, kwargs: dict[str, Any]) -> dict[str, Any]:
+    deadline: ExecutionDeadline | None = current_execution_deadline()
+    if deadline is None:
+        return dict(kwargs)
+    deadline.enforce()
+    statement_params: dict[str, str] = dict(kwargs.get("_statement_params") or {})
+    statement_params[_STATEMENT_TIMEOUT_PARAMETER] = str(
+        max(1, math.ceil(deadline.remaining_seconds))
+    )
+    deadline_kwargs: dict[str, Any] = dict(kwargs)
+    deadline_kwargs["_statement_params"] = statement_params
+    return deadline_kwargs
+
+
 def _without_query_tag(*, kwargs: dict[str, Any]) -> dict[str, Any]:
     retry_kwargs: dict[str, Any] = dict(kwargs)
     statement_params: dict[str, str] = dict(retry_kwargs.get("_statement_params") or {})

{sqlbuild-0.109.0 → sqlbuild-0.110.1}/src/sqlbuild/adapters/snowflake/constants.py

@@ -1,5 +1,7 @@
 """Snowflake adapter constants."""
 
+MAX_STATEMENT_TIMEOUT_SECONDS: int = 604_800
+
 BASE_TABLE_METADATA_TYPE: str = "BASE TABLE"
 VIEW_RELATION_TYPE_TOKEN: str = "view"
 EXTERNAL_BROWSER_AUTHENTICATOR: str = "externalbrowser"

{sqlbuild-0.109.0 → sqlbuild-0.110.1}/src/sqlbuild/cli/commands/_helpers/build_planning/defer_clone.py

@@ -7,6 +7,9 @@ from pathlib import Path
 from typing import Any
 
 from sqlbuild.adapter.contract.classes.base_adapter import BaseAdapter
+from sqlbuild.cli.commands._helpers.build_planning.execution_limits import (
+    enforce_model_execution_limit,
+)
 from sqlbuild.cli.commands._helpers.planning.external_refs import (
     resolve_external_sql_reference_resolver,
 )
@@ -69,7 +72,7 @@ def build_defer_clone_boundary_selectors(
     cli_vars: dict[str, object] | None,
     project_dir: Path,
     auto_load_sources: bool,
-) -> tuple[CompiledProject, tuple[str, ...], tuple[str, ...]]:
+) -> tuple[CompiledProject, tuple[str, ...], tuple[str, ...], int]:
     """Resolve out-of-selection clone boundaries and the view chain to rebuild over them."""
 
     project: CompiledProject = build_compiled_project(
@@ -94,6 +97,7 @@ def build_defer_clone_boundary_selectors(
         project,
         defer_clone_boundary_selectors(scope=scope),
         defer_clone_view_chain_selectors(scope=scope),
+        selected_executable_model_count(scope=scope),
     )
 
 
@@ -142,6 +146,20 @@ def defer_clone_view_chain_selectors(*, scope: PlannerScope) -> tuple[str, ...]:
     return tuple(sorted(key.name for key in view_keys))
 
 
+def selected_executable_model_count(*, scope: PlannerScope) -> int:
+    """Count selected models except those explicitly disabled."""
+
+    count: int = 0
+    for key in scope.selected_keys:
+        if key.resource_type != CompiledResourceType.MODEL:
+            continue
+        model: CompiledModel | None = scope.models_by_name.get(key.name)
+        if model is not None and model.config.values.get("enabled") is False:
+            continue
+        count += 1
+    return count
+
+
 def run_defer_clone_boundary_prephase(
     *,
     request: BuildCommandRequest,
@@ -153,7 +171,12 @@ def run_defer_clone_boundary_prephase(
     cloned_project: CompiledProject
     boundary_selectors: tuple[str, ...]
     view_chain_selectors: tuple[str, ...]
-    cloned_project, boundary_selectors, view_chain_selectors = build_defer_clone_boundary_selectors(
+    (
+        cloned_project,
+        boundary_selectors,
+        view_chain_selectors,
+        selected_model_count,
+    ) = build_defer_clone_boundary_selectors(
         discovered_inputs=invocation.discovered_inputs,
         adapter=invocation.adapter,
         selected_target=request.selected_target,
@@ -165,6 +188,11 @@ def run_defer_clone_boundary_prephase(
         project_dir=invocation.effective_project_dir,
         auto_load_sources=invocation.should_load_sources,
     )
+    enforce_model_execution_limit(
+        model_count=selected_model_count,
+        target_name=invocation.effective_target_name,
+        limits=invocation.execution_limits,
+    )
     run_defer_clone_prephase(
         inputs=DeferClonePrephaseInputs(
             discovered_inputs=invocation.discovered_inputs,

sqlbuild-0.110.1/src/sqlbuild/cli/commands/_helpers/build_planning/execution_limits.py

@@ -0,0 +1,39 @@
+"""Target-scoped build execution-limit enforcement."""
+
+from __future__ import annotations
+
+from sqlbuild.cli.commands.exceptions import CliUserError
+from sqlbuild.compiler.planner.models import PlanOutput
+from sqlbuild.compiler.planner.types import PlanAction
+from sqlbuild.spec.contracts.models import ExecutionLimitsConfig
+
+
+def executable_model_count(*, plan: PlanOutput) -> int:
+    """Return the number of model entries that would execute."""
+
+    return sum(entry.action != PlanAction.SKIP for entry in plan.model_entries)
+
+
+def enforce_model_execution_limit(
+    *,
+    model_count: int,
+    target_name: str | None,
+    limits: ExecutionLimitsConfig,
+) -> None:
+    """Reject a build whose expanded model count exceeds its target policy."""
+
+    maximum: int | None = limits.max_models
+    if maximum is None or model_count <= maximum:
+        return
+    target_label: str = target_name or "default"
+    raise CliUserError(
+        "Build plan exceeds the configured model limit\n\n"
+        f"Target:          {target_label}\n"
+        f"Selected models: {model_count}\n"
+        f"Maximum models:  {maximum}\n"
+        "Configuration:   "
+        f"targets.{target_label}.execution_limits.max_models\n\n"
+        "No warehouse changes were made.",
+        code="C413",
+        help=limits.remediation,
+    )

{sqlbuild-0.109.0 → sqlbuild-0.110.1}/src/sqlbuild/cli/commands/_helpers/build_planning/invocation.py

@@ -32,7 +32,7 @@ from sqlbuild.spec.contracts.main.resolve_effective_changes_only import (
 )
 from sqlbuild.spec.contracts.main.resolve_target_config import resolve_target_config
 from sqlbuild.spec.contracts.main.resolve_target_name import resolve_target_name
-from sqlbuild.spec.contracts.models import TargetConfig
+from sqlbuild.spec.contracts.models import ExecutionLimitsConfig, TargetConfig
 
 
 def resolve_build_invocation(*, request: BuildCommandRequest) -> BuildInvocation:
@@ -101,6 +101,44 @@ def resolve_build_invocation(*, request: BuildCommandRequest) -> BuildInvocation
         if request.load_sources is not None
         else build_effective_settings_config(discovered_inputs=discovered_inputs).auto_load_sources
     )
+    effective_target_name: str | None = resolve_target_name(
+        project_config=discovered_inputs.project_config,
+        local_config=discovered_inputs.local_config,
+        selected_target=request.selected_target,
+    )
+    execution_limits: ExecutionLimitsConfig = (
+        resolve_target_config(
+            project_config=discovered_inputs.project_config,
+            local_config=discovered_inputs.local_config,
+            target_name=effective_target_name,
+        ).execution_limits
+        if effective_target_name is not None
+        else ExecutionLimitsConfig()
+    )
+    if (
+        execution_limits.max_duration is not None
+        and adapter_context.adapter.execution_duration_limit_seconds is None
+    ):
+        target_label: str = effective_target_name or "default"
+        raise CliUserError(
+            f"Target '{target_label}' configures max_duration, but adapter "
+            f"'{adapter_context.adapter_name}' cannot cancel active statements safely",
+            code="C415",
+            help=execution_limits.remediation,
+        )
+    maximum_duration_seconds: int | None = adapter_context.adapter.execution_duration_limit_seconds
+    if (
+        execution_limits.max_duration_seconds is not None
+        and maximum_duration_seconds is not None
+        and execution_limits.max_duration_seconds > maximum_duration_seconds
+    ):
+        target_label = effective_target_name or "default"
+        raise CliUserError(
+            f"Target '{target_label}' max_duration exceeds the largest duration supported by "
+            f"adapter '{adapter_context.adapter_name}' ({maximum_duration_seconds} seconds)",
+            code="C416",
+            help=execution_limits.remediation,
+        )
     return BuildInvocation(
         effective_project_dir=effective_project_dir,
         discovered_inputs=discovered_inputs,
@@ -115,6 +153,8 @@ def resolve_build_invocation(*, request: BuildCommandRequest) -> BuildInvocation
         planning_progress=reporters.planning,
         should_load_sources=should_load_sources,
         virtual_mode=bool(discovered_inputs.project_config.settings.virtual_environments),
+        effective_target_name=effective_target_name,
+        execution_limits=execution_limits,
     )
 
 

{sqlbuild-0.109.0 → sqlbuild-0.110.1}/src/sqlbuild/cli/commands/_helpers/build_virtual/virtual_execution.py

@@ -30,6 +30,7 @@ from sqlbuild.compiler.pipeline.models import PythonPlanEntry
 from sqlbuild.compiler.planner.models import CursorOverrides, PlanOutput
 from sqlbuild.spec.contracts.main.resolve_target_config import resolve_target_config
 from sqlbuild.spec.contracts.main.resolve_target_name import resolve_target_name
+from sqlbuild.spec.contracts.models import ExecutionLimitsConfig, TargetConfig
 from sqlbuild.virtual.executor.main.build import run_virtual_build as run_virtual_build_pipeline
 from sqlbuild.virtual.executor.models import (
     VirtualBuildExecutionHooks,
@@ -72,15 +73,20 @@ def execute_virtual_build(
         local_config=discovered_inputs.local_config,
         selected_target=request.selected_target,
     )
-    unsuffixed_virtual_environment_name: str | None = (
+    physical_target_config: TargetConfig | None = (
         resolve_target_config(
             project_config=discovered_inputs.project_config,
             local_config=discovered_inputs.local_config,
             target_name=physical_target_name,
-        ).state.unsuffixed_virtual_env
+        )
         if physical_target_name is not None
         else None
     )
+    unsuffixed_virtual_environment_name: str | None = (
+        physical_target_config.state.unsuffixed_virtual_env
+        if physical_target_config is not None
+        else None
+    )
     plan_hook: VirtualBuildPlanHook = VirtualBuildPlanHook(
         stream=stream,
         project_dir=project_dir,
@@ -102,6 +108,12 @@ def execute_virtual_build(
                 request.virtual_environment_name or physical_target_name or "default"
             ),
             unsuffixed_virtual_environment_name=unsuffixed_virtual_environment_name,
+            effective_target_name=physical_target_name,
+            execution_limits=(
+                physical_target_config.execution_limits
+                if physical_target_config is not None
+                else ExecutionLimitsConfig()
+            ),
         ),
     )
     cursor_overrides: CursorOverrides = request.cursor_overrides or CursorOverrides()

{sqlbuild-0.109.0 → sqlbuild-0.110.1}/src/sqlbuild/cli/commands/_helpers/entry/dispatch_errors.py

@@ -21,6 +21,7 @@ from sqlbuild.compiler.discovery.exceptions import DiscoveryError
 from sqlbuild.executor.pipeline.exceptions import AuditExecutionError
 from sqlbuild.lint.exceptions import LintError
 from sqlbuild.rule_engine.exceptions import RulesError
+from sqlbuild.runtime.execution_limits.exceptions import ExecutionDurationLimitError
 from sqlbuild.spec.contracts.exceptions import SpecConfigError
 from sqlbuild.virtual.state.exceptions import StateBackendError
 
@@ -68,6 +69,7 @@ def dispatch_and_handle_errors(
     except (
         AuditExecutionError,
         DiscoveryError,
+        ExecutionDurationLimitError,
         SpecConfigError,
         StateBackendError,
         ValueError,

{sqlbuild-0.109.0 → sqlbuild-0.110.1}/src/sqlbuild/cli/commands/classes/virtual_build_plan_hook.py

@@ -10,6 +10,10 @@ from sqlbuild.adapter.contract.classes.base_adapter import BaseAdapter
 from sqlbuild.cli.commands._helpers.build_execution.run_context import (
     write_build_run_context,
 )
+from sqlbuild.cli.commands._helpers.build_planning.execution_limits import (
+    enforce_model_execution_limit,
+    executable_model_count,
+)
 from sqlbuild.cli.commands._helpers.build_planning.full_refresh import (
     enforce_snapshot_full_refresh_policy,
 )
@@ -58,6 +62,8 @@ class VirtualBuildPlanHook:
         self._selector_files = config.selector_files
         self._virtual_environment_name = config.virtual_environment_name or "default"
         self._unsuffixed_virtual_environment_name = config.unsuffixed_virtual_environment_name
+        self._effective_target_name = config.effective_target_name
+        self._execution_limits = config.execution_limits
         self.callbacks: BuildProgressCallbacks | None = None
         self._closed: bool = False
 
@@ -85,6 +91,11 @@ class VirtualBuildPlanHook:
         )
         self._stream.write("\n" + plan_text + "\n\n")
         self._stream.flush()
+        enforce_model_execution_limit(
+            model_count=executable_model_count(plan=plan_output),
+            target_name=self._effective_target_name,
+            limits=self._execution_limits,
+        )
         enforce_snapshot_full_refresh_policy(
             plan=plan_output,
             snapshots_config=self._discovered_inputs.project_config.snapshots,

{sqlbuild-0.109.0 → sqlbuild-0.110.1}/src/sqlbuild/cli/commands/main/execution/_build.py

@@ -25,6 +25,10 @@ from sqlbuild.cli.commands._helpers.build_planning.compile_target import write_b
 from sqlbuild.cli.commands._helpers.build_planning.defer_clone import (
     run_defer_clone_boundary_prephase,
 )
+from sqlbuild.cli.commands._helpers.build_planning.execution_limits import (
+    enforce_model_execution_limit,
+    executable_model_count,
+)
 from sqlbuild.cli.commands._helpers.build_planning.full_refresh import (
     enforce_snapshot_full_refresh_policy,
 )
@@ -52,6 +56,10 @@ from sqlbuild.diagnostics.classes.build_phase_timing_tracker import BuildPhaseTi
 from sqlbuild.diagnostics.main.process_resource_reporting import process_resource_reporting
 from sqlbuild.executor.python_nodes.models import PythonCheckExecutionResult
 from sqlbuild.provider.main.session import build_provider_session
+from sqlbuild.runtime.execution_limits.main.execution_deadline_scope import (
+    execution_deadline_scope,
+)
+from sqlbuild.spec.contracts.models import ExecutionLimitsConfig
 
 
 def run_build(request: BuildCommandRequest) -> int:
@@ -60,7 +68,20 @@ def run_build(request: BuildCommandRequest) -> int:
     timing_tracker: BuildPhaseTimingTracker = BuildPhaseTimingTracker()
     with process_resource_reporting(enabled=request.debug), timing_tracker.scope():
         try:
-            return _run_build(request=request)
+            command_started_at: float = time.monotonic()
+            invocation: BuildInvocation = resolve_build_invocation(request=request)
+            limits: ExecutionLimitsConfig = invocation.execution_limits
+            with execution_deadline_scope(
+                max_duration_seconds=limits.max_duration_seconds,
+                max_duration=limits.max_duration,
+                target_name=invocation.effective_target_name,
+                remediation=limits.remediation,
+            ):
+                return _run_build(
+                    request=request,
+                    invocation=invocation,
+                    command_started_at=command_started_at,
+                )
         except BaseException:
             if request.verbose or request.debug:
                 try:
@@ -74,9 +95,9 @@ def run_build(request: BuildCommandRequest) -> int:
             raise
 
 
-def _run_build(*, request: BuildCommandRequest) -> int:
-    command_started_at: float = time.monotonic()
-    invocation: BuildInvocation = resolve_build_invocation(request=request)
+def _run_build(
+    *, request: BuildCommandRequest, invocation: BuildInvocation, command_started_at: float
+) -> int:
     provider_session: Any = build_provider_session(
         discovered_providers=invocation.discovered_inputs.providers
     )
@@ -138,6 +159,11 @@ def _run_build(*, request: BuildCommandRequest) -> int:
             invocation=invocation,
             pipeline_result=pipeline_result,
         )
+        enforce_model_execution_limit(
+            model_count=executable_model_count(plan=pipeline_result.plan_output),
+            target_name=invocation.effective_target_name,
+            limits=invocation.execution_limits,
+        )
         enforce_snapshot_full_refresh_policy(
             plan=pipeline_result.plan_output,
             snapshots_config=invocation.discovered_inputs.project_config.snapshots,

{sqlbuild-0.109.0 → sqlbuild-0.110.1}/src/sqlbuild/cli/commands/models.py

@@ -73,7 +73,7 @@ from sqlbuild.presentation.classes.transient_status_reporter import TransientSta
 from sqlbuild.provider.main.runtime import ProviderContainer
 from sqlbuild.python_nodes.models import SqlResourceRef
 from sqlbuild.runtime.contracts.types import NodeStartCallback
-from sqlbuild.spec.contracts.models import CostConfig, SourceEntry
+from sqlbuild.spec.contracts.models import CostConfig, ExecutionLimitsConfig, SourceEntry
 from sqlbuild.virtual.executor.models import VirtualBuildPipelineResult
 from sqlbuild.virtual.state.models import (
     CheckpointRetentionInspection,
@@ -255,6 +255,8 @@ class BuildInvocation:
     planning_progress: PlanningProgressReporter
     should_load_sources: bool
     virtual_mode: bool
+    effective_target_name: str | None = None
+    execution_limits: ExecutionLimitsConfig = field(default_factory=ExecutionLimitsConfig)
 
 
 @dataclass(frozen=True)
@@ -344,6 +346,8 @@ class VirtualBuildPlanHookConfig:
     selector_files: tuple[SelectorFileSummary, ...] = ()
     virtual_environment_name: str | None = None
     unsuffixed_virtual_environment_name: str | None = None
+    effective_target_name: str | None = None
+    execution_limits: ExecutionLimitsConfig = field(default_factory=ExecutionLimitsConfig)
 
 
 @dataclass(frozen=True)

{sqlbuild-0.109.0 → sqlbuild-0.110.1}/src/sqlbuild/compiler/compile/_helpers/analysis/dynamic_pivot.py

@@ -140,6 +140,7 @@ def _analyze_passthrough(
             DynamicColumnFamilyProof(name=family.name, inferred_type=family.type)
             for family in families
         ),
+        input_relations=(name,),
     )
 
 
@@ -174,6 +175,13 @@ def _analyze_pivot(
     )
     if source_columns is None:
         return _failure("dynamic pivot input does not have an authoritative, explicit schema")
+    input_relation: str | None = _external_relation_name(
+        node=source_node,
+        ctes=ctes,
+        seen=frozenset(),
+    )
+    if input_relation is None:
+        return _failure("dynamic pivot input relation could not be resolved")
     pivot_column: str = pivot_columns[0]
     matched_aggregate_indices: set[int] = set()
     family_proofs: list[DynamicColumnFamilyProof] = []
@@ -238,6 +246,7 @@ def _analyze_pivot(
             for name in fixed_names
         ),
         families=tuple(family_proofs),
+        input_relations=(input_relation,),
         bare_dynamic_pivot=bare_dynamic_pivot,
     )
 
@@ -393,6 +402,46 @@ def _relation_schema(
     )
 
 
+def _external_relation_name(
+    *,
+    node: object,
+    ctes: _CteMap,
+    seen: frozenset[str],
+) -> str | None:
+    key: str = _node_key(node)
+    payload: object = cast(dict[str, object], node).get(key) if isinstance(node, dict) else None
+    if key in _QUERY_AST_KINDS and isinstance(payload, dict):
+        return _external_relation_name(
+            node=cast(dict[str, object], payload).get("this"),
+            ctes=ctes,
+            seen=seen,
+        )
+    if key == _SELECT_AST_KIND and isinstance(payload, dict):
+        payload_dict: dict[str, object] = cast(dict[str, object], payload)
+        if payload_dict.get("joins"):
+            return None
+        relations: tuple[dict[str, object], ...] = _nested_dict_list(
+            node=payload_dict.get("from"), key="expressions"
+        )
+        if len(relations) != 1:
+            return None
+        return _external_relation_name(node=relations[0], ctes=ctes, seen=seen)
+    relation_name: str | None = _relation_name(node)
+    if relation_name is None:
+        return None
+    normalized_name: str = relation_name.casefold()
+    if normalized_name not in ctes:
+        return relation_name
+    cte: dict[str, object] | None = ctes[normalized_name]
+    if cte is None or normalized_name in seen:
+        return None
+    return _external_relation_name(
+        node=cte,
+        ctes=ctes,
+        seen=seen | {normalized_name},
+    )
+
+
 def _select_schema(
     *,
     node: object,

{sqlbuild-0.109.0 → sqlbuild-0.110.1}/src/sqlbuild/compiler/compile/models.py

@@ -159,6 +159,7 @@ class DynamicColumnContractProof:
     output_proven: bool
     fixed_columns: tuple[InferredColumn, ...] = field(default_factory=tuple)
     families: tuple[DynamicColumnFamilyProof, ...] = field(default_factory=tuple)
+    input_relations: tuple[str, ...] = field(default_factory=tuple)
     failure_reason: str | None = None
     bare_dynamic_pivot: bool = False