sqlbuild 0.72.2__tar.gz → 0.73.0__tar.gz

{sqlbuild-0.72.2 → sqlbuild-0.73.0}/Cargo.lock

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

{sqlbuild-0.72.2 → sqlbuild-0.73.0}/PKG-INFO

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

{sqlbuild-0.72.2 → sqlbuild-0.73.0}/crates/sqlbuild-kata-native/Cargo.toml

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

{sqlbuild-0.72.2 → sqlbuild-0.73.0}/pyproject.toml

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

{sqlbuild-0.72.2 → sqlbuild-0.73.0}/src/sqlbuild/cli/commands/_helpers/build_planning/planning.py

@@ -48,6 +48,7 @@ def compile_build_plan(
                 discovered_inputs=invocation.discovered_inputs,
             ),
             resolve_python_run_selectors=(request.include_python or invocation.should_load_sources),
+            max_microbatches=request.max_microbatches,
         ),
         hooks=ConnectionHooks(
             on_progress=invocation.planning_progress.on_progress,

{sqlbuild-0.72.2 → sqlbuild-0.73.0}/src/sqlbuild/cli/commands/_helpers/build_virtual/virtual_execution.py

@@ -133,6 +133,7 @@ def execute_virtual_build(
                     no_cache=request.no_cache,
                     defer_sources_to=request.defer_sources_to,
                     cursor_overrides=request.cursor_overrides,
+                    max_microbatches=request.max_microbatches,
                     full_refresh=request.full_refresh,
                     virtual_environment_name=request.virtual_environment_name,
                     include_stale_upstreams=request.include_stale_upstreams,

{sqlbuild-0.72.2 → sqlbuild-0.73.0}/src/sqlbuild/cli/commands/_helpers/entry/dispatch.py

@@ -143,6 +143,7 @@ def dispatch_cli_command(*, args: CliNamespace, handlers: CliEntrypointHandlers)
                 cli_vars=args.vars,
                 include_stale_upstreams=args.include_stale_upstreams,
                 changes_only=args.changes_only,
+                max_microbatches=args.max_microbatches,
             )
         )
     if args.command == CliCommand.DBT:
@@ -193,6 +194,7 @@ def dispatch_cli_command(*, args: CliNamespace, handlers: CliEntrypointHandlers)
                 json_output=args.json,
                 json_output_path=args.json_output,
                 event_output_path=args.event_output,
+                max_microbatches=args.max_microbatches,
             )
         )
     if args.command == CliCommand.FRESHNESS:

{sqlbuild-0.72.2 → sqlbuild-0.73.0}/src/sqlbuild/cli/commands/_helpers/entry/parser.py

@@ -11,6 +11,7 @@ from sqlbuild.cli.commands._helpers.entry.parser_arguments import (
     add_dbt_config_args,
     add_execution_args,
     add_execution_json_output_arg,
+    add_microbatch_limit_override_arg,
     add_scenario_snapshot_safety_args,
     add_select_args,
     add_vars_args,
@@ -147,6 +148,7 @@ def _add_plan_and_build_parsers(
     plan_load_group.add_argument("--load", dest="load_sources", action="store_true", default=None)
     plan_load_group.add_argument("--no-load", dest="load_sources", action="store_false")
     _ = add_cursor_override_args(plan_parser)
+    _ = add_microbatch_limit_override_arg(plan_parser)
     _ = add_select_args(plan_parser)
     _ = add_vars_args(plan_parser)
     _ = add_dbt_config_args(parser=plan_parser)
@@ -181,6 +183,7 @@ def _add_plan_and_build_parsers(
     _ = add_execution_json_output_arg(build_parser)
     build_parser.add_argument("--event-output", type=Path, default=None, help=argparse.SUPPRESS)
     _ = add_cursor_override_args(build_parser)
+    _ = add_microbatch_limit_override_arg(build_parser)
     build_load_group: argparse._MutuallyExclusiveGroup = build_parser.add_mutually_exclusive_group()
     build_load_group.add_argument("--load", dest="load_sources", action="store_true", default=None)
     build_load_group.add_argument("--no-load", dest="load_sources", action="store_false")

{sqlbuild-0.72.2 → sqlbuild-0.73.0}/src/sqlbuild/cli/commands/_helpers/entry/parser_arguments.py

@@ -42,6 +42,19 @@ def add_cursor_override_args(parser: argparse.ArgumentParser) -> None:
     parser.add_argument("--end-cursor-int", default=None)
 
 
+def add_microbatch_limit_override_arg(parser: argparse.ArgumentParser) -> None:
+    """Add the intentional per-model microbatch limit override."""
+
+    parser.add_argument("--max-microbatches", type=_positive_integer, default=None)
+
+
+def _positive_integer(value: str) -> int:
+    parsed: int = int(value)
+    if parsed < 1:
+        raise argparse.ArgumentTypeError("value must be a positive integer")
+    return parsed
+
+
 def add_execution_args(parser: argparse.ArgumentParser) -> None:
     """Add execution control flags shared by build and run commands."""
 

{sqlbuild-0.72.2 → sqlbuild-0.73.0}/src/sqlbuild/cli/commands/_helpers/plan/planning.py

@@ -54,6 +54,7 @@ def compile_plan_pipeline(
                 exclude=request.exclude,
                 cli_vars=request.cli_vars,
                 external_sql_reference_resolver=external_sql_reference_resolver,
+                max_microbatches=request.max_microbatches,
             ),
             hooks=ConnectionHooks(
                 on_progress=invocation.planning_progress.on_progress,
@@ -96,6 +97,7 @@ def compile_plan_pipeline(
             cli_vars=request.cli_vars,
             external_sql_reference_resolver=external_sql_reference_resolver,
             resolve_python_run_selectors=request.include_python,
+            max_microbatches=request.max_microbatches,
         ),
         hooks=ConnectionHooks(
             on_progress=invocation.planning_progress.on_progress,

{sqlbuild-0.72.2 → sqlbuild-0.73.0}/src/sqlbuild/cli/commands/classes/cli_namespace.py

@@ -41,6 +41,7 @@ _DEFAULT_VALUES: dict[str, object] = {
     "profile_skip_contracts": False,
     "profile_skip_write": False,
     "start_cursor_ts": None,
+    "max_microbatches": None,
     "end_cursor_ts": None,
     "start_cursor_int": None,
     "end_cursor_int": None,
@@ -185,6 +186,7 @@ class CliNamespace:
     profile_skip_contracts: bool
     profile_skip_write: bool
     start_cursor_ts: str | None
+    max_microbatches: int | None
     end_cursor_ts: str | None
     start_cursor_int: str | None
     end_cursor_int: str | None

{sqlbuild-0.72.2 → sqlbuild-0.73.0}/src/sqlbuild/cli/commands/main/execution/_build.py

@@ -120,6 +120,7 @@ def _run_build(*, request: BuildCommandRequest) -> int:
                     use_color=invocation.use_color,
                     providers=provider_session.providers,
                     command_started_at=command_started_at,
+                    max_microbatches=request.max_microbatches,
                 ),
             )
         if invocation.effective_defer_clone_from is not None:

{sqlbuild-0.72.2 → sqlbuild-0.73.0}/src/sqlbuild/cli/commands/models.py

@@ -220,6 +220,7 @@ class BuildCommandRequest:
     json_output_path: Path | None = None
     event_output_path: Path | None = None
     no_cache: bool = False
+    max_microbatches: int | None = None
     selector_files: tuple[SelectorFileSummary, ...] = ()
 
 
@@ -377,6 +378,7 @@ class VirtualBuildCliRequest:
     providers: ProviderContainer | None = None
     no_cache: bool = False
     selector_files: tuple[SelectorFileSummary, ...] = ()
+    max_microbatches: int | None = None
     command_started_at: float | None = None
 
 
@@ -1015,6 +1017,7 @@ class PlanCommandRequest:
     include_stale_upstreams: bool = False
     changes_only: bool = False
     no_cache: bool = False
+    max_microbatches: int | None = None
 
 
 @dataclass(frozen=True)

{sqlbuild-0.72.2 → sqlbuild-0.73.0}/src/sqlbuild/cli/output/_helpers/execution_protocol_v1.py

@@ -510,7 +510,7 @@ def _format_model_assets(
 def _format_microbatch_result(result: ModelExecutionResult) -> dict[str, object] | None:
     if result.microbatch_run_type is None:
         return None
-    return {
+    microbatch: dict[str, object] = {
         "run_type": result.microbatch_run_type,
         "batch_count": result.batch_count,
         "batch_size": result.batch_size,
@@ -541,6 +541,20 @@ def _format_microbatch_result(result: ModelExecutionResult) -> dict[str, object]
             for interval in result.microbatch_accounting_intervals
         ],
     }
+    if result.microbatch_limit is not None:
+        microbatch.update(
+            {
+                "limit": result.microbatch_limit,
+                "count": result.microbatch_limit_count,
+                "action": (
+                    result.microbatch_limit_action.value
+                    if result.microbatch_limit_action is not None
+                    else None
+                ),
+                "warning": result.microbatch_limit_warning,
+            }
+        )
+    return microbatch
 
 
 def _format_seed_assets(

{sqlbuild-0.72.2 → sqlbuild-0.73.0}/src/sqlbuild/cli/output/_helpers/plan_json.py

@@ -123,12 +123,26 @@ def _serialize_model_entry(entry: ModelPlanEntry) -> dict[str, object]:
     if entry.incremental_mode is not None:
         model["incremental_mode"] = entry.incremental_mode
     if entry.incremental_mode == IncrementalMode.MICROBATCH:
-        model["microbatch_state"] = {
+        microbatch_state: dict[str, object] = {
             "completion_tracking": "universal",
             "batch_concurrency": entry.batch_concurrency,
             "unaccounted_partition_policy": entry.unaccounted_partition_policy,
             "reconciliation": "runtime",
         }
+        if entry.microbatch_limit is not None:
+            microbatch_state.update(
+                {
+                    "limit": entry.microbatch_limit,
+                    "count": entry.microbatch_limit_count,
+                    "action": (
+                        entry.microbatch_limit_action.value
+                        if entry.microbatch_limit_action is not None
+                        else None
+                    ),
+                    "warning": entry.microbatch_limit_warning,
+                }
+            )
+        model["microbatch_state"] = microbatch_state
     if entry.cursor_column is not None:
         model["cursor_column"] = entry.cursor_column
     if entry.cursor_type is not None:

{sqlbuild-0.72.2 → sqlbuild-0.73.0}/src/sqlbuild/compiler/discovery/_helpers/yml/project.py

@@ -49,6 +49,8 @@ from sqlbuild.spec.contracts.models import (
     LocalTargetConfig,
     MaterializationDefaultsConfig,
     MaterializationRetentionDefaults,
+    MicrobatchesConfig,
+    MicrobatchLimitsConfig,
     ProjectConfig,
     ScenarioConfig,
     ScenarioSnapshotLimitsConfig,
@@ -60,6 +62,7 @@ from sqlbuild.spec.contracts.models import (
 )
 from sqlbuild.spec.contracts.types import (
     FutureCursorAction,
+    MicrobatchLimitAction,
     TableType,
     TableTypeDowngradePolicy,
     TableTypeValue,
@@ -78,6 +81,7 @@ _DEFAULT_HISTORICAL_SNAPSHOT_FULL_REFRESH: str = "require_confirmation"
 _DEFAULT_SNAPSHOT_SCHEMA_CHANGE: str = "append_new_columns"
 _DEFAULT_WILDCARD_CHECK_SNAPSHOT_SCHEMA_CHANGE: str = "require_confirmation"
 _BATCH_CONCURRENCY_CONFIG_KEY: str = "batch_concurrency"
+_MAX_BATCHES_CONFIG_KEY: str = "max_batches"
 _CURSOR_DURATION_PATTERN: re.Pattern[str] = re.compile(
     r"^(?=.*[1-9])(?:(\d+)y)?(?:(\d+)mo)?(?:(\d+)d)?(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)s)?$"
 )
@@ -103,6 +107,9 @@ def load_project_config(*, project_dir: Path) -> ProjectConfig:
         payload=payload.get("constants"), file_path=file_path
     )
     cursors: CursorsConfig = _load_cursors(payload=payload.get("cursors"), file_path=file_path)
+    microbatches: MicrobatchesConfig = _load_microbatches(
+        payload=payload.get("microbatches"), file_path=file_path
+    )
     defaults: DefaultsConfig = _load_defaults(payload=payload.get("defaults"), file_path=file_path)
     materialization_defaults: MaterializationDefaultsConfig = _load_materialization_defaults(
         payload=payload.get("materialization_defaults"), file_path=file_path
@@ -141,6 +148,7 @@ def load_project_config(*, project_dir: Path) -> ProjectConfig:
         cost=cost,
         constants=constants,
         cursors=cursors,
+        microbatches=microbatches,
         defaults=defaults,
         materialization_defaults=materialization_defaults,
         path_defaults=path_defaults,
@@ -393,6 +401,40 @@ def _load_cursors(*, payload: object, file_path: Path) -> CursorsConfig:
     return CursorsConfig(future=FutureCursorsConfig(max_distance=max_distance, action=action))
 
 
+def _load_microbatches(*, payload: object, file_path: Path) -> MicrobatchesConfig:
+    mapping: dict[str, object] = _coerce_mapping(
+        payload=payload, label="microbatches", file_path=file_path
+    )
+    _validate_allowed_keys(
+        mapping=mapping,
+        allowed_keys=frozenset({"limits"}),
+        label="microbatches",
+        file_path=file_path,
+    )
+    limits: dict[str, object] = _coerce_mapping(
+        payload=mapping.get("limits"), label="microbatches.limits", file_path=file_path
+    )
+    _validate_allowed_keys(
+        mapping=limits,
+        allowed_keys=frozenset({_MAX_BATCHES_CONFIG_KEY, "action"}),
+        label="microbatches.limits",
+        file_path=file_path,
+    )
+    max_batches: int | None = None
+    if _MAX_BATCHES_CONFIG_KEY in limits:
+        if isinstance(limits[_MAX_BATCHES_CONFIG_KEY], bool):
+            raise ProjectConfigError("microbatches.limits.max_batches must be a positive integer")
+        max_batches = _optional_int(mapping=limits, key=_MAX_BATCHES_CONFIG_KEY, default=0)
+        if max_batches < 1:
+            raise ProjectConfigError("microbatches.limits.max_batches must be a positive integer")
+    raw_action: str = _optional_str(payload=limits, key="action") or MicrobatchLimitAction.ERROR
+    try:
+        action: MicrobatchLimitAction = MicrobatchLimitAction(raw_action)
+    except ValueError:
+        raise ProjectConfigError("microbatches.limits.action must be one of: error, warn") from None
+    return MicrobatchesConfig(limits=MicrobatchLimitsConfig(max_batches=max_batches, action=action))
+
+
 def _load_scopes(*, payload: object, file_path: Path) -> ScopesConfig:
     mapping: dict[str, object] = _coerce_mapping(
         payload=payload, label="scopes", file_path=file_path

{sqlbuild-0.72.2 → sqlbuild-0.73.0}/src/sqlbuild/compiler/pipeline/main/compile.py

@@ -201,6 +201,7 @@ def _build_result(
             cursor_overrides=options.cursor_overrides,
             full_refresh=options.full_refresh,
             reload_sources=options.reload_sources,
+            max_microbatches=options.max_microbatches,
         ),
         deferral=DeferralInputs(
             deferred_locations=deferred_locations,

{sqlbuild-0.72.2 → sqlbuild-0.73.0}/src/sqlbuild/compiler/pipeline/models.py

@@ -47,6 +47,7 @@ class CompilePipelineOptions:
     external_sql_reference_resolver: ExternalSqlReferenceResolver | None = None
     resolve_python_run_selectors: bool = False
     no_cache: bool = False
+    max_microbatches: int | None = None
 
 
 @dataclass(frozen=True)

sqlbuild-0.73.0/src/sqlbuild/compiler/planner/_helpers/output/microbatch_count.py

@@ -0,0 +1,45 @@
+"""Planner-private microbatch count calculation."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from decimal import Decimal, InvalidOperation
+
+from sqlbuild.compiler.planner.models import CursorBounds, Duration
+from sqlbuild.compiler.planner.types import CursorType
+
+
+def count_microbatches(
+    *, bounds: CursorBounds, batch_size: str, cursor_type: str, equal_bounds_are_batch: bool = False
+) -> int:
+    """Count batches for one concrete cursor range."""
+
+    if cursor_type == CursorType.INTEGER:
+        try:
+            start: int = int(Decimal(bounds.start))
+            end: int = int(Decimal(bounds.end))
+            size: int = int(Decimal(batch_size))
+        except (InvalidOperation, ValueError, OverflowError):
+            return 0
+        if equal_bounds_are_batch and start == end:
+            return 1
+        if size <= 0 or start >= end:
+            return 0
+        return (end - start + size - 1) // size
+    if cursor_type != CursorType.TIMESTAMP:
+        return 0
+    duration: Duration | None = Duration.parse(batch_size)
+    if duration is None:
+        return 0
+    try:
+        current: datetime = datetime.fromisoformat(bounds.start)
+        end_at: datetime = datetime.fromisoformat(bounds.end)
+    except (TypeError, ValueError):
+        return 0
+    if equal_bounds_are_batch and current == end_at:
+        return 1
+    count: int = 0
+    while current < end_at:
+        current = min(duration.add_to(current), end_at)
+        count += 1
+    return count

{sqlbuild-0.72.2 → sqlbuild-0.73.0}/src/sqlbuild/compiler/planner/_helpers/output/plan_entry.py

@@ -28,6 +28,7 @@ from sqlbuild.compiler.planner._helpers.output.cursor_type_check import (
 from sqlbuild.compiler.planner._helpers.output.inclusive_cursor_end import (
     resolve_bounded_cursor_override,
 )
+from sqlbuild.compiler.planner._helpers.output.microbatch_count import count_microbatches
 from sqlbuild.compiler.planner._helpers.output.strategy import (
     build_model_warnings,
     get_materialization_type,
@@ -57,6 +58,9 @@ from sqlbuild.compiler.planner.exceptions import PlannerInputError
 from sqlbuild.compiler.planner.main.changes._model_changes import detect_model_changes
 from sqlbuild.compiler.planner.main.execution.future_cursor_safety import apply_future_cursor_safety
 from sqlbuild.compiler.planner.main.execution.future_cursor_warning import future_cursor_cap_warning
+from sqlbuild.compiler.planner.main.execution.microbatch_limit import (
+    microbatch_limit_warning,
+)
 from sqlbuild.compiler.planner.models import (
     BackfillResult,
     ChangeDetectionResult,
@@ -102,7 +106,7 @@ from sqlbuild.spec.contracts.models import (
     SchemaColumn,
     SourceEntry,
 )
-from sqlbuild.spec.contracts.types import TableType
+from sqlbuild.spec.contracts.types import MicrobatchLimitAction, TableType
 
 _MODELS_DIR_PREFIX: str = "models/"
 _IDEMPOTENT_MICROBATCH_STRATEGIES: frozenset[IncrementalStrategy] = frozenset(
@@ -340,6 +344,14 @@ def build_plan_entries(
                     or project.settings.microbatch_unaccounted_partition_policy
                 ),
             )
+            if entry.action != PlanAction.SKIP:
+                entry, limit_warning = _apply_microbatch_limit(
+                    entry=entry,
+                    max_batches=inputs.max_microbatches,
+                    action=inputs.microbatch_limit_action,
+                )
+                if limit_warning is not None:
+                    warnings.append(limit_warning)
         entries.append(entry)
         warnings.extend(entry_warnings)
     configured_concurrent_entries: tuple[ModelPlanEntry, ...] = tuple(
@@ -384,6 +396,52 @@ def build_plan_entries(
     return PlannerModelEntryResults(entries=tuple(entries), warnings=tuple(warnings))
 
 
+def _apply_microbatch_limit(
+    *, entry: ModelPlanEntry, max_batches: int | None, action: MicrobatchLimitAction
+) -> tuple[ModelPlanEntry, PlanWarning | None]:
+    if entry.action == PlanAction.SKIP:
+        return entry, None
+    batch_count: int | None = None
+    if (
+        entry.microbatch_range is not None
+        and entry.batch_size is not None
+        and entry.cursor_type is not None
+    ):
+        batch_count = count_microbatches(
+            bounds=entry.microbatch_range,
+            batch_size=entry.batch_size,
+            cursor_type=entry.cursor_type,
+            equal_bounds_are_batch=entry.action == PlanAction.CREATE_TABLE,
+        )
+    warning: str | None = (
+        None
+        if batch_count is None
+        else microbatch_limit_warning(
+            model_name=entry.name,
+            max_batches=max_batches,
+            batch_count=batch_count,
+            action=action,
+        )
+    )
+    limited_entry: ModelPlanEntry = replace(
+        entry,
+        microbatch_limit=max_batches,
+        microbatch_limit_count=batch_count,
+        microbatch_limit_action=action if max_batches is not None else None,
+        microbatch_limit_warning=warning,
+    )
+    if warning is None:
+        return limited_entry, None
+    if action == MicrobatchLimitAction.ERROR:
+        raise CompileInputError(warning)
+    return limited_entry, PlanWarning(
+        model_name=entry.name,
+        severity=WarningSeverity.WARNING,
+        code="MICROBATCH_LIMIT_EXCEEDED",
+        message=warning,
+    )
+
+
 def plan_model_from_change(
     *,
     model: CompiledModel,

{sqlbuild-0.72.2 → sqlbuild-0.73.0}/src/sqlbuild/compiler/planner/_helpers/planning/entries.py

@@ -70,6 +70,20 @@ def build_planner_entry_results(
                 else None
             ),
             invocation_time=runtime.invocation_time,
+            max_microbatches=(
+                overrides.max_microbatches
+                if overrides.max_microbatches is not None
+                else (
+                    runtime.project_config.microbatches.limits.max_batches
+                    if runtime.project_config is not None
+                    else None
+                )
+            ),
+            microbatch_limit_action=(
+                runtime.project_config.microbatches.limits.action
+                if runtime.project_config is not None
+                else PlanEntryBuildInputs().microbatch_limit_action
+            ),
         ),
     )
     return PlannerEntryResults(

sqlbuild-0.73.0/src/sqlbuild/compiler/planner/main/execution/microbatch_limit.py

@@ -0,0 +1,19 @@
+"""Microbatch planning limit decisions shared by planner and runtime."""
+
+from __future__ import annotations
+
+from sqlbuild.spec.contracts.types import MicrobatchLimitAction
+
+
+def microbatch_limit_warning(
+    *, model_name: str, max_batches: int | None, batch_count: int, action: MicrobatchLimitAction
+) -> str | None:
+    """Return the prominent warning/error message when one model exceeds its limit."""
+
+    if max_batches is None or batch_count <= max_batches:
+        return None
+    return (
+        f"MICROBATCH LIMIT EXCEEDED: model '{model_name}' planned {batch_count} batches, "
+        f"above the per-model limit of {max_batches} (action={action.value}). "
+        "Use --max-microbatches with an intentional invocation-specific value for this backfill."
+    )

{sqlbuild-0.72.2 → sqlbuild-0.73.0}/src/sqlbuild/compiler/planner/main/execution/plan_entry.py

@@ -18,6 +18,7 @@ from sqlbuild.compiler.planner.models import (
     ChangeDetectionResult,
     DeferralInputs,
     ModelChangesPlanInputs,
+    PlanEntryBuildInputs,
     PlannerChangeResults,
     PlannerModelEntryResults,
     PlannerRelationsContext,
@@ -73,6 +74,27 @@ def build_plan_output_from_model_changes_phase(
         resolved_actions=resolved_actions,
         cursor_overrides=resolved.cursor_overrides,
         full_refresh=resolved.full_refresh,
+        build_inputs=PlanEntryBuildInputs(
+            future_cursor_config=(
+                resolved.project_config.cursors.future
+                if resolved.project_config is not None
+                else None
+            ),
+            max_microbatches=(
+                resolved.max_microbatches
+                if resolved.max_microbatches is not None
+                else (
+                    resolved.project_config.microbatches.limits.max_batches
+                    if resolved.project_config is not None
+                    else None
+                )
+            ),
+            microbatch_limit_action=(
+                resolved.project_config.microbatches.limits.action
+                if resolved.project_config is not None
+                else PlanEntryBuildInputs().microbatch_limit_action
+            ),
+        ),
     )
     return build_plan_output(
         project=project,

{sqlbuild-0.72.2 → sqlbuild-0.73.0}/src/sqlbuild/compiler/planner/models.py

@@ -61,7 +61,11 @@ from sqlbuild.spec.contracts.models import (
     SeedCsvSettings,
     SourceEntry,
 )
-from sqlbuild.spec.contracts.types import FutureCursorAction, SourceWriteStrategy
+from sqlbuild.spec.contracts.types import (
+    FutureCursorAction,
+    MicrobatchLimitAction,
+    SourceWriteStrategy,
+)
 from sqlbuild.sql_values.models import SqlValue
 
 
@@ -573,6 +577,7 @@ class ModelChangesPlanInputs:
     seed_version_hashes: dict[str, str] | None = None
     seed_metadata_jsons: dict[str, str] | None = None
     seed_plan_reasons: dict[str, PlanReason] | None = None
+    max_microbatches: int | None = None
 
 
 @dataclass(frozen=True)
@@ -586,6 +591,8 @@ class PlanEntryBuildInputs:
     end_cursor_override: str | None = None
     future_cursor_config: FutureCursorsConfig | None = None
     invocation_time: datetime | None = None
+    max_microbatches: int | None = None
+    microbatch_limit_action: MicrobatchLimitAction = MicrobatchLimitAction.ERROR
 
 
 @dataclass(frozen=True)
@@ -728,6 +735,10 @@ class ModelPlanEntry:
     batch_concurrency: int = 1
     unaccounted_partition_policy: str | None = None
     microbatch_range: CursorBounds | None = None
+    microbatch_limit: int | None = None
+    microbatch_limit_count: int | None = None
+    microbatch_limit_action: MicrobatchLimitAction | None = None
+    microbatch_limit_warning: str | None = None
     start_cursor_override: str | None = None
     end_cursor_override: str | None = None
     future_cursor_config: FutureCursorsConfig | None = None
@@ -1078,6 +1089,7 @@ class PlannerOverrides:
     reload_sources: bool = False
     forced_stale_model_names: tuple[str, ...] = ()
     external_blocked_model_names: tuple[str, ...] = ()
+    max_microbatches: int | None = None
 
 
 @dataclass(frozen=True)

{sqlbuild-0.72.2 → sqlbuild-0.73.0}/src/sqlbuild/executor/run/_helpers/execution/results.py

@@ -67,6 +67,10 @@ def build_failed_result(
         error_help=rendered_help,
         error_message=rendered_error,
         future_cursor_safety=_future_cursor_safety(entry),
+        microbatch_limit=entry.microbatch_limit,
+        microbatch_limit_count=entry.microbatch_limit_count,
+        microbatch_limit_action=entry.microbatch_limit_action,
+        microbatch_limit_warning=entry.microbatch_limit_warning,
     )
 
 
@@ -96,6 +100,10 @@ def build_skipped_result(
         skip_mode=skipped_hook.skip_mode if skipped_hook is not None else None,
         skip_reason=skipped_hook.skip_reason if skipped_hook is not None else None,
         future_cursor_safety=_future_cursor_safety(entry),
+        microbatch_limit=entry.microbatch_limit,
+        microbatch_limit_count=entry.microbatch_limit_count,
+        microbatch_limit_action=entry.microbatch_limit_action,
+        microbatch_limit_warning=entry.microbatch_limit_warning,
     )