sqlbuild 0.72.2__tar.gz → 0.74.0__tar.gz

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.72.2
+Version: 0.74.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.74.0}/crates/sqlbuild-kata-native/Cargo.toml

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

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

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

{sqlbuild-0.72.2 → sqlbuild-0.74.0}/src/sqlbuild/adapter/contract/classes/base_adapter.py

@@ -209,6 +209,28 @@ class BaseAdapter(RetentionAdapterMixin, StrictAdapter):
             return None
         return row[0]
 
+    def render_max_cursor_at_or_before(
+        self,
+        *,
+        relation: str,
+        cursor_column: str,
+        maximum_allowed: str,
+        cursor_type: str | None,
+        is_date: bool,
+    ) -> str:
+        """Render a portable eligible-cursor MAX query."""
+
+        quoted_cursor: str = self.render_identifier(cursor_column)
+        maximum_literal: str = (
+            f"CAST('{maximum_allowed}' AS DATE)"
+            if is_date
+            else self.render_cursor_bound_literal(value=maximum_allowed, cursor_type=cursor_type)
+        )
+        return (
+            f"SELECT MAX({quoted_cursor}) FROM {relation} "
+            f"WHERE {quoted_cursor} <= {maximum_literal}"
+        )
+
     def build_cursor_filter(
         self,
         *,

{sqlbuild-0.72.2 → sqlbuild-0.74.0}/src/sqlbuild/adapter/contract/classes/duckdb_backed_adapter.py

@@ -1171,6 +1171,26 @@ class DuckDbBackedAdapter(BaseAdapter):
             return None
         return row[0]
 
+    def render_max_cursor_at_or_before(
+        self,
+        *,
+        relation: str,
+        cursor_column: str,
+        maximum_allowed: str,
+        cursor_type: str | None,
+        is_date: bool,
+    ) -> str:
+        quoted_cursor: str = self.render_identifier(cursor_column)
+        maximum_literal: str = (
+            f"CAST('{maximum_allowed}' AS DATE)"
+            if is_date
+            else self.render_cursor_bound_literal(value=maximum_allowed, cursor_type=cursor_type)
+        )
+        return (
+            f"SELECT MAX({quoted_cursor}) FROM {relation} "
+            f"WHERE {quoted_cursor} <= {maximum_literal}"
+        )
+
     def build_cursor_filter(
         self,
         *,

{sqlbuild-0.72.2 → sqlbuild-0.74.0}/src/sqlbuild/adapter/contract/classes/strict_adapter.py

@@ -169,6 +169,19 @@ class StrictAdapter(
         """Return the maximum cursor value currently present in a relation."""
         ...
 
+    @abstractmethod
+    def render_max_cursor_at_or_before(
+        self,
+        *,
+        relation: str,
+        cursor_column: str,
+        maximum_allowed: str,
+        cursor_type: str | None,
+        is_date: bool,
+    ) -> str:
+        """Render an eligible-cursor MAX query."""
+        ...
+
     @abstractmethod
     def build_cursor_filter(
         self,

{sqlbuild-0.72.2 → sqlbuild-0.74.0}/src/sqlbuild/adapters/bigquery/classes/bigquery_adapter.py

@@ -2072,6 +2072,26 @@ class BigQueryAdapter(MicrobatchMixin, BaseAdapter):
             return None
         return row[0]
 
+    def render_max_cursor_at_or_before(
+        self,
+        *,
+        relation: str,
+        cursor_column: str,
+        maximum_allowed: str,
+        cursor_type: str | None,
+        is_date: bool,
+    ) -> str:
+        quoted_cursor: str = self.render_identifier(cursor_column)
+        maximum_literal: str = (
+            f"CAST('{maximum_allowed}' AS DATE)"
+            if is_date
+            else self.render_cursor_bound_literal(value=maximum_allowed, cursor_type=cursor_type)
+        )
+        return (
+            f"SELECT MAX({quoted_cursor}) FROM {relation} "
+            f"WHERE {quoted_cursor} <= {maximum_literal}"
+        )
+
     def build_cursor_filter(
         self,
         *,

{sqlbuild-0.72.2 → sqlbuild-0.74.0}/src/sqlbuild/adapters/databricks/classes/databricks_adapter.py

@@ -2294,6 +2294,26 @@ class DatabricksAdapter(MicrobatchMixin, BaseAdapter):
         finally:
             cursor.close()
 
+    def render_max_cursor_at_or_before(
+        self,
+        *,
+        relation: str,
+        cursor_column: str,
+        maximum_allowed: str,
+        cursor_type: str | None,
+        is_date: bool,
+    ) -> str:
+        quoted_cursor: str = self.render_identifier(cursor_column)
+        maximum_literal: str = (
+            f"CAST('{maximum_allowed}' AS DATE)"
+            if is_date
+            else self.render_cursor_bound_literal(value=maximum_allowed, cursor_type=cursor_type)
+        )
+        return (
+            f"SELECT MAX({quoted_cursor}) FROM {relation} "
+            f"WHERE {quoted_cursor} <= {maximum_literal}"
+        )
+
     def add_columns(
         self,
         *,

{sqlbuild-0.72.2 → sqlbuild-0.74.0}/src/sqlbuild/adapters/postgres/classes/postgres_adapter.py

@@ -187,6 +187,26 @@ class PostgresAdapter(MicrobatchMixin, BaseAdapter):
             return None
         return row[0]
 
+    def render_max_cursor_at_or_before(
+        self,
+        *,
+        relation: str,
+        cursor_column: str,
+        maximum_allowed: str,
+        cursor_type: str | None,
+        is_date: bool,
+    ) -> str:
+        quoted_cursor: str = self.render_identifier(cursor_column)
+        maximum_literal: str = (
+            f"CAST('{maximum_allowed}' AS DATE)"
+            if is_date
+            else self.render_cursor_bound_literal(value=maximum_allowed, cursor_type=cursor_type)
+        )
+        return (
+            f"SELECT MAX({quoted_cursor}) FROM {relation} "
+            f"WHERE {quoted_cursor} <= {maximum_literal}"
+        )
+
     def build_cursor_filter(
         self,
         *,

{sqlbuild-0.72.2 → sqlbuild-0.74.0}/src/sqlbuild/adapters/snowflake/classes/snowflake_adapter.py

@@ -2427,6 +2427,26 @@ class SnowflakeAdapter(MicrobatchMixin, BaseAdapter):
         finally:
             cursor.close()
 
+    def render_max_cursor_at_or_before(
+        self,
+        *,
+        relation: str,
+        cursor_column: str,
+        maximum_allowed: str,
+        cursor_type: str | None,
+        is_date: bool,
+    ) -> str:
+        quoted_cursor: str = self.render_identifier(cursor_column)
+        maximum_literal: str = (
+            f"CAST('{maximum_allowed}' AS DATE)"
+            if is_date
+            else self.render_cursor_bound_literal(value=maximum_allowed, cursor_type=cursor_type)
+        )
+        return (
+            f"SELECT MAX({quoted_cursor}) FROM {relation} "
+            f"WHERE {quoted_cursor} <= {maximum_literal}"
+        )
+
     def add_columns(
         self,
         *,

{sqlbuild-0.72.2 → sqlbuild-0.74.0}/src/sqlbuild/adapters/sqlserver/classes/sqlserver_adapter.py

@@ -407,6 +407,26 @@ class SqlServerAdapter(MicrobatchMixin, BaseAdapter):
             return None
         return row[0]
 
+    def render_max_cursor_at_or_before(
+        self,
+        *,
+        relation: str,
+        cursor_column: str,
+        maximum_allowed: str,
+        cursor_type: str | None,
+        is_date: bool,
+    ) -> str:
+        quoted_cursor: str = self.render_identifier(cursor_column)
+        maximum_literal: str = (
+            f"CAST('{maximum_allowed}' AS DATE)"
+            if is_date
+            else self.render_cursor_bound_literal(value=maximum_allowed, cursor_type=cursor_type)
+        )
+        return (
+            f"SELECT MAX({quoted_cursor}) FROM {relation} "
+            f"WHERE {quoted_cursor} <= {maximum_literal}"
+        )
+
     def query(self, *, connection: Any, sql: str, limit: int | None) -> QueryResult:
         if limit is not None:
             column_names: tuple[str, ...] = self.query_column_names(connection=connection, sql=sql)

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

@@ -48,6 +48,8 @@ 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,
+            selection_diagnostics=request.selection_diagnostics,
         ),
         hooks=ConnectionHooks(
             on_progress=invocation.planning_progress.on_progress,

{sqlbuild-0.72.2 → sqlbuild-0.74.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.74.0}/src/sqlbuild/cli/commands/_helpers/entry/dispatch.py

@@ -143,6 +143,8 @@ 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,
+                selection_diagnostics=args.selection_diagnostics,
             )
         )
     if args.command == CliCommand.DBT:
@@ -193,6 +195,8 @@ 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,
+                selection_diagnostics=args.selection_diagnostics,
             )
         )
     if args.command == CliCommand.FRESHNESS:

{sqlbuild-0.72.2 → sqlbuild-0.74.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,
@@ -139,6 +140,12 @@ def _add_plan_and_build_parsers(
         default=False,
         help="Only include resources that require execution.",
     )
+    plan_parser.add_argument(
+        "--selection-diagnostics",
+        action="store_true",
+        default=False,
+        help="Include direct-mode stale-out-of-selection diagnostics.",
+    )
     plan_parser.add_argument(
         "--no-python", dest="include_python", action="store_false", default=True
     )
@@ -147,6 +154,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)
@@ -172,6 +180,12 @@ def _add_plan_and_build_parsers(
         default=False,
         help="Only include resources that require execution.",
     )
+    build_parser.add_argument(
+        "--selection-diagnostics",
+        action="store_true",
+        default=False,
+        help="Include direct-mode stale-out-of-selection diagnostics.",
+    )
     build_parser.add_argument(
         "--no-python", dest="include_python", action="store_false", default=True
     )
@@ -181,6 +195,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.74.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.74.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,8 @@ 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,
+            selection_diagnostics=request.selection_diagnostics,
         ),
         hooks=ConnectionHooks(
             on_progress=invocation.planning_progress.on_progress,

{sqlbuild-0.72.2 → sqlbuild-0.74.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
@@ -195,6 +197,7 @@ class CliNamespace:
     skip_locked: bool
     include_stale_upstreams: bool
     changes_only: bool
+    selection_diagnostics: bool
     include_python: bool
     load_sources: bool | None
     reload: bool

{sqlbuild-0.72.2 → sqlbuild-0.74.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.74.0}/src/sqlbuild/cli/commands/models.py

@@ -220,6 +220,8 @@ class BuildCommandRequest:
     json_output_path: Path | None = None
     event_output_path: Path | None = None
     no_cache: bool = False
+    max_microbatches: int | None = None
+    selection_diagnostics: bool = False
     selector_files: tuple[SelectorFileSummary, ...] = ()
 
 
@@ -377,6 +379,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 +1018,8 @@ class PlanCommandRequest:
     include_stale_upstreams: bool = False
     changes_only: bool = False
     no_cache: bool = False
+    max_microbatches: int | None = None
+    selection_diagnostics: bool = False
 
 
 @dataclass(frozen=True)

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

@@ -9,6 +9,7 @@ from pathlib import Path
 from typing import cast
 
 from sqlbuild.cli.output._helpers.future_cursor_safety import serialize_future_cursor_safety
+from sqlbuild.cli.output._helpers.maximum_start_safety import serialize_maximum_start_safety
 from sqlbuild.compiler.auditing.types import AuditOutcome
 from sqlbuild.compiler.compile.types import CompiledResourceType
 from sqlbuild.compiler.planner.models import (
@@ -500,6 +501,7 @@ def _format_model_assets(
                 "error_message": result.error_message,
                 "warnings": result.warning_messages,
                 "future_cursor_safety": serialize_future_cursor_safety(result.future_cursor_safety),
+                "maximum_start_safety": serialize_maximum_start_safety(result.maximum_start_safety),
                 "microbatch": _format_microbatch_result(result),
             }
         )
@@ -510,7 +512,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 +543,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.74.0/src/sqlbuild/cli/output/_helpers/maximum_start_safety.py

@@ -0,0 +1,27 @@
+"""Structured maximum automatic-start safety output."""
+
+from __future__ import annotations
+
+from sqlbuild.compiler.planner.models import MaximumStartSafetyEvidence
+
+
+def serialize_maximum_start_safety(
+    evidence: MaximumStartSafetyEvidence | None,
+) -> dict[str, object] | None:
+    """Serialize automatic-start policy and physical eligibility evidence."""
+
+    if evidence is None:
+        return None
+    return {
+        "action": evidence.action.value,
+        "max_ahead": evidence.max_ahead,
+        "invocation_time": evidence.invocation_time,
+        "physical_target_max": evidence.physical_target_max,
+        "highest_eligible_target_max": evidence.highest_eligible_target_max,
+        "effective_start": evidence.effective_start,
+        "maximum_allowed_start": evidence.maximum_allowed_start,
+        "input": {
+            "relation": evidence.target_relation,
+            "cursor_column": evidence.cursor_column,
+        },
+    }

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

@@ -8,12 +8,14 @@ from typing import cast
 
 from sqlbuild.cli.output._helpers.cursor_plan import build_cursor_plan_details
 from sqlbuild.cli.output._helpers.future_cursor_safety import serialize_future_cursor_safety
+from sqlbuild.cli.output._helpers.maximum_start_safety import serialize_maximum_start_safety
 from sqlbuild.cli.output.models import CursorPlanDetails
 from sqlbuild.compiler.pipeline.models import PythonPlanEntry
 from sqlbuild.compiler.planner.models import (
     CascadeResult,
     FunctionPlanEntry,
     FutureCursorSafetyEvidence,
+    MaximumStartSafetyEvidence,
     ModelPlanEntry,
     PlanOutput,
     PlanProviderUsage,
@@ -123,12 +125,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:
@@ -148,6 +164,17 @@ def _serialize_model_entry(entry: ModelPlanEntry) -> dict[str, object]:
     )
     if serialized_future_safety is not None:
         model["future_cursor_safety"] = serialized_future_safety
+    maximum_start_safety: MaximumStartSafetyEvidence | None = (
+        entry.microbatch_range.maximum_start_safety
+        if entry.microbatch_range is not None
+        and entry.microbatch_range.maximum_start_safety is not None
+        else (entry.cursor_bounds.maximum_start_safety if entry.cursor_bounds is not None else None)
+    )
+    serialized_maximum_start: dict[str, object] | None = serialize_maximum_start_safety(
+        maximum_start_safety
+    )
+    if serialized_maximum_start is not None:
+        model["maximum_start_safety"] = serialized_maximum_start
     cursor_details: CursorPlanDetails | None = build_cursor_plan_details(entry=entry)
     if cursor_details is not None:
         model["cursor"] = _serialize_cursor_details(details=cursor_details)

{sqlbuild-0.72.2 → sqlbuild-0.74.0}/src/sqlbuild/cli/output/_helpers/plan_text.py

@@ -9,6 +9,7 @@ from collections.abc import Callable, Sequence
 from typing import cast
 
 from sqlbuild.cli.output._helpers.cursor_plan import build_cursor_plan_details
+from sqlbuild.cli.output._helpers.selection_diagnostics import direct_selection_diagnostics_enabled
 from sqlbuild.cli.output.models import CursorPlanDetails
 from sqlbuild.cli.output.types import CursorBoundsOwner, CursorResolutionStatus, PlanRowKind
 from sqlbuild.compiler.pipeline.models import PythonPlanEntry
@@ -1444,12 +1445,18 @@ def _format_warnings(
 ) -> list[str]:
     """Append the warnings section."""
 
+    selection_diagnostics: bool | None = direct_selection_diagnostics_enabled(plan)
+    include_stale_input_warnings: bool = (
+        selection_diagnostics
+        if selection_diagnostics is not None
+        else include_direct_freshness_diagnostics
+    )
     warning_entries: list[PlanWarning] = [
         warning
         for warning in plan.warnings
         if warning.severity != WarningSeverity.INFO
         and (
-            include_direct_freshness_diagnostics
+            include_stale_input_warnings
             or not warning.message.startswith(_STALE_INPUT_WARNING_TITLE)
         )
     ]
@@ -1769,6 +1776,8 @@ def _format_direct_remaining_stale_metadata(
     section_header_style: Callable[[str], str],
     display_options: DisplayOptions,
 ) -> list[str]:
+    if direct_selection_diagnostics_enabled(plan) is False:
+        return lines
     remaining_stale_model_names: tuple[str, ...] = _metadata_string_tuple(
         plan.metadata.get("direct_remaining_stale_model_names")
     )

sqlbuild-0.74.0/src/sqlbuild/cli/output/_helpers/selection_diagnostics.py

@@ -0,0 +1,18 @@
+"""Selection diagnostics output policy."""
+
+from __future__ import annotations
+
+from typing import cast
+
+from sqlbuild.compiler.planner.models import PlanOutput
+
+
+def direct_selection_diagnostics_enabled(plan: PlanOutput) -> bool | None:
+    """Return the explicit direct diagnostics policy, if present."""
+
+    raw_diagnostics: object | None = plan.metadata.get("selection_diagnostics")
+    if not isinstance(raw_diagnostics, dict):
+        return None
+    diagnostics: dict[str, object] = cast(dict[str, object], raw_diagnostics)
+    enabled: object | None = diagnostics.get("enabled")
+    return enabled if isinstance(enabled, bool) else None

{sqlbuild-0.72.2 → sqlbuild-0.74.0}/src/sqlbuild/compiler/compile/_helpers/attachment/core.py

@@ -1843,6 +1843,14 @@ def project_defaults_to_mapping(defaults: DefaultsConfig) -> dict[str, object]:
         values["append_cursor_inclusive"] = defaults.append_cursor_inclusive
     if defaults.cursor_start is not None:
         values["cursor_start"] = defaults.cursor_start
+    if defaults.cursor_start_max_ahead is not None:
+        values["cursor_start_max_ahead"] = defaults.cursor_start_max_ahead
+    if defaults.cursor_start_max_action is not None:
+        values["cursor_start_max_action"] = defaults.cursor_start_max_action
+    if defaults.cursor_future_max_distance is not None:
+        values["cursor_future_max_distance"] = defaults.cursor_future_max_distance
+    if defaults.cursor_future_action is not None:
+        values["cursor_future_action"] = defaults.cursor_future_action
     if defaults.lookback is not None:
         values["lookback"] = defaults.lookback
     if defaults.batch_size is not None: