sqlbuild 0.66.4__tar.gz → 0.66.6__tar.gz

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

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

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

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

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

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

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

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

{sqlbuild-0.66.4 → sqlbuild-0.66.6}/src/sqlbuild/adapters/snowflake/classes/snowflake_cursor.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import json
 import logging
+import time
 from collections.abc import Callable, Iterator
 from datetime import UTC, datetime
 from types import TracebackType
@@ -13,7 +14,7 @@ from uuid import uuid4
 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
+from sqlbuild.cost.models import CostResourceContext, StatementExecutionTelemetry
 
 _LOGGER: logging.Logger = logging.getLogger("sqlbuild.cost")
 _QUERY_TAG_PARAMETER: str = "QUERY_TAG"
@@ -77,6 +78,7 @@ class _SnowflakeCursor:
         query_tag_injected: bool,
     ) -> Any:
         started_at: datetime = datetime.now(UTC)
+        started_monotonic: float = time.monotonic()
         previous_query_id: str | None = _current_query_id(cursor=self.raw_cursor)
         try:
             result: Any = operation(sql, *args, **kwargs)
@@ -103,6 +105,7 @@ class _SnowflakeCursor:
                         context=context,
                         sql=sql,
                         started_at=started_at,
+                        started_monotonic=started_monotonic,
                         error=retry_error,
                         previous_query_id=previous_query_id,
                         statement_id=statement_id,
@@ -112,6 +115,7 @@ class _SnowflakeCursor:
                     context=context,
                     sql=sql,
                     started_at=started_at,
+                    started_monotonic=started_monotonic,
                     previous_query_id=previous_query_id,
                     statement_id=statement_id,
                 )
@@ -121,6 +125,7 @@ class _SnowflakeCursor:
                     context=context,
                     sql=sql,
                     started_at=started_at,
+                    started_monotonic=started_monotonic,
                     error=error,
                     previous_query_id=previous_query_id,
                     statement_id=statement_id,
@@ -131,6 +136,7 @@ class _SnowflakeCursor:
                 context=context,
                 sql=sql,
                 started_at=started_at,
+                started_monotonic=started_monotonic,
                 previous_query_id=previous_query_id,
                 statement_id=statement_id,
             )
@@ -157,22 +163,32 @@ class _SnowflakeCursor:
         context: CostResourceContext,
         sql: str,
         started_at: datetime,
+        started_monotonic: float,
         error: Exception,
         previous_query_id: str | None,
         statement_id: str,
     ) -> None:
+        completed_at: datetime = datetime.now(UTC)
+        elapsed_seconds: float = time.monotonic() - started_monotonic
+        query_id: str | None = _submitted_query_id(
+            cursor=self.raw_cursor, previous_query_id=previous_query_id
+        )
         StatementLedger.record(
             context=context,
             statement_id=statement_id,
             sql=sql,
-            query_id=_submitted_query_id(
-                cursor=self.raw_cursor, previous_query_id=previous_query_id
-            ),
+            query_id=query_id,
             status="failed",
             started_at=started_at,
-            completed_at=datetime.now(UTC),
+            completed_at=completed_at,
             error=error,
         )
+        _notify_statement_complete(
+            context=context,
+            query_id=query_id,
+            status="failed",
+            elapsed_seconds=elapsed_seconds,
+        )
 
     def _record_success(
         self,
@@ -180,19 +196,29 @@ class _SnowflakeCursor:
         context: CostResourceContext,
         sql: str,
         started_at: datetime,
+        started_monotonic: float,
         previous_query_id: str | None,
         statement_id: str,
     ) -> None:
+        completed_at: datetime = datetime.now(UTC)
+        elapsed_seconds: float = time.monotonic() - started_monotonic
+        query_id: str | None = _submitted_query_id(
+            cursor=self.raw_cursor, previous_query_id=previous_query_id
+        )
         StatementLedger.record(
             context=context,
             statement_id=statement_id,
             sql=sql,
-            query_id=_submitted_query_id(
-                cursor=self.raw_cursor, previous_query_id=previous_query_id
-            ),
+            query_id=query_id,
             status="success",
             started_at=started_at,
-            completed_at=datetime.now(UTC),
+            completed_at=completed_at,
+        )
+        _notify_statement_complete(
+            context=context,
+            query_id=query_id,
+            status="success",
+            elapsed_seconds=elapsed_seconds,
         )
 
     def __getattr__(self, name: str) -> Any:
@@ -264,3 +290,28 @@ def _submitted_query_id(*, cursor: Any, previous_query_id: str | None) -> str |
 def _current_query_id(*, cursor: Any) -> str | None:
     query_id: object = getattr(cursor, "sfqid", None)
     return query_id if isinstance(query_id, str) and query_id else None
+
+
+def _notify_statement_complete(
+    *,
+    context: CostResourceContext,
+    query_id: str | None,
+    status: str,
+    elapsed_seconds: float,
+) -> None:
+    callback: Callable[[StatementExecutionTelemetry], None] | None = context.on_statement_complete
+    if callback is None:
+        return
+    try:
+        callback(
+            StatementExecutionTelemetry(
+                query_id=query_id,
+                status=status,
+                elapsed_seconds=elapsed_seconds,
+                resource_type=context.resource_type,
+                resource_name=context.resource_name,
+                phase=context.phase,
+            )
+        )
+    except BaseException:
+        _LOGGER.exception("Snowflake statement completion diagnostics failed")

sqlbuild-0.66.6/src/sqlbuild/cli/commands/_helpers/build_execution/completion.py

@@ -0,0 +1,106 @@
+"""Successful direct-build completion phase."""
+
+from __future__ import annotations
+
+import time
+from datetime import UTC, datetime
+
+from sqlbuild.cli.commands._helpers.build_execution.outputs import (
+    resolve_build_exit_code,
+    write_build_completion_output,
+    write_build_runtime_targets,
+)
+from sqlbuild.cli.commands._helpers.build_execution.phase_timings import (
+    finish_cost_collection_timing,
+    write_build_phase_timings,
+)
+from sqlbuild.cli.commands._helpers.cost.collection import finalize_build_cost, render_build_cost
+from sqlbuild.cli.commands.models import (
+    BuildCommandRequest,
+    BuildCostFinalization,
+    BuildExecutionPreparation,
+    BuildInvocation,
+    BuildPhaseTimings,
+    BuildRunOutcome,
+)
+from sqlbuild.compiler.pipeline.models import CompilePipelineResult
+from sqlbuild.cost.models import CostRunRecord
+from sqlbuild.executor.python_nodes.models import PythonCheckExecutionResult
+
+
+def complete_direct_build(
+    *,
+    request: BuildCommandRequest,
+    invocation: BuildInvocation,
+    pipeline_result: CompilePipelineResult,
+    preparation: BuildExecutionPreparation,
+    outcome: BuildRunOutcome,
+    check_results: tuple[PythonCheckExecutionResult, ...],
+    build_started_at: datetime,
+    command_started_at: float,
+) -> int:
+    """Persist and render a completed direct build."""
+
+    build_completed_at: datetime = datetime.now(UTC)
+    exit_code: int = resolve_build_exit_code(outcome=outcome, check_results=check_results)
+    write_build_runtime_targets(
+        invocation=invocation,
+        pipeline_result=pipeline_result,
+        outcome=outcome,
+        check_results=check_results,
+    )
+    cost_started_at: float = time.monotonic()
+    try:
+        cost_record: CostRunRecord | None = finalize_build_cost(
+            BuildCostFinalization(
+                project_dir=invocation.effective_project_dir,
+                adapter_name=invocation.adapter_name,
+                adapter=invocation.adapter,
+                connection_config=invocation.connection_config,
+                target_name=pipeline_result.project.effective_target_name,
+                target_database=pipeline_result.project.effective_target_database,
+                run_id=pipeline_result.project.run_id,
+                build_status="success" if exit_code == 0 else "failed",
+                started_at=build_started_at,
+                completed_at=build_completed_at,
+                config=invocation.discovered_inputs.project_config.cost,
+                output_stream=invocation.progress_stream,
+                use_color=invocation.use_color,
+                render=False,
+            )
+        )
+    finally:
+        cost_collection_seconds: float | None = finish_cost_collection_timing(
+            started_at=cost_started_at
+        )
+    write_build_completion_output(
+        request=request,
+        invocation=invocation,
+        pipeline_result=pipeline_result,
+        preparation=preparation,
+        outcome=outcome,
+        check_results=check_results,
+        cost_record=cost_record,
+    )
+    _ = render_build_cost(
+        record=cost_record,
+        output_stream=invocation.progress_stream,
+        use_color=invocation.use_color,
+    )
+    if request.verbose or request.debug:
+        write_build_phase_timings(
+            stream=invocation.progress_stream,
+            timings=BuildPhaseTimings(
+                compile_seconds=pipeline_result.compile_seconds,
+                planning_seconds=pipeline_result.planning_seconds,
+                connection_preparation_seconds=(
+                    outcome.result.timings.connection_preparation_seconds
+                ),
+                schema_preparation_seconds=outcome.result.timings.schema_preparation_seconds,
+                execution_seconds=outcome.result.timings.execution_seconds,
+                cost_collection_seconds=cost_collection_seconds,
+                total_seconds=time.monotonic() - command_started_at,
+            ),
+            use_color=invocation.use_color,
+        )
+    return exit_code

sqlbuild-0.66.6/src/sqlbuild/cli/commands/_helpers/build_execution/exceptional_cost.py

@@ -0,0 +1,46 @@
+"""Exceptional direct-build cost finalization."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+
+from sqlbuild.cli.commands._helpers.cost.collection import finalize_build_cost
+from sqlbuild.cli.commands.models import BuildCostFinalization, BuildInvocation
+from sqlbuild.compiler.pipeline.models import CompilePipelineResult
+from sqlbuild.cost.types import CostStatus
+
+
+def finalize_exceptional_direct_cost(
+    *,
+    invocation: BuildInvocation,
+    pipeline_result: CompilePipelineResult,
+    build_started_at: datetime,
+    error: BaseException,
+) -> None:
+    """Persist failed/interrupted cost state without masking the active error."""
+
+    interrupted: bool = isinstance(error, KeyboardInterrupt)
+    try:
+        _ = finalize_build_cost(
+            BuildCostFinalization(
+                project_dir=invocation.effective_project_dir,
+                adapter_name=invocation.adapter_name,
+                adapter=invocation.adapter,
+                connection_config=invocation.connection_config,
+                target_name=pipeline_result.project.effective_target_name,
+                target_database=pipeline_result.project.effective_target_database,
+                run_id=pipeline_result.project.run_id,
+                build_status="interrupted" if interrupted else "failed",
+                started_at=build_started_at,
+                completed_at=datetime.now(UTC),
+                config=invocation.discovered_inputs.project_config.cost,
+                output_stream=invocation.progress_stream,
+                use_color=invocation.use_color,
+                collect=not interrupted,
+                render=False,
+                cost_status=CostStatus.PARTIAL,
+                cost_message="Build was interrupted before cost collection completed.",
+            )
+        )
+    except BaseException:
+        return

{sqlbuild-0.66.4 → sqlbuild-0.66.6}/src/sqlbuild/cli/commands/_helpers/build_execution/execution.py

@@ -182,6 +182,16 @@ def execute_build_plan(
                     connection_count=connection_count, elapsed_seconds=elapsed_seconds
                 )
             ),
+            on_scheduler_state=(
+                preparation.callbacks.on_scheduler_state
+                if request.verbose or request.debug
+                else None
+            ),
+            on_statement_complete=(
+                preparation.callbacks.on_statement_complete
+                if request.verbose or request.debug
+                else None
+            ),
         ),
         customizations=BuildCustomizations(
             custom_materializations=pipeline_result.custom_materializations,

sqlbuild-0.66.6/src/sqlbuild/cli/commands/_helpers/build_execution/phase_timings.py

@@ -0,0 +1,199 @@
+"""Verbose final build phase timing output."""
+
+from __future__ import annotations
+
+import time
+from datetime import datetime
+from typing import TextIO
+
+from sqlbuild.cli.commands._helpers.build_execution.exceptional_cost import (
+    finalize_exceptional_direct_cost,
+)
+from sqlbuild.cli.commands._helpers.build_execution.no_work import (
+    finalize_no_work_build_if_needed,
+)
+from sqlbuild.cli.commands.models import (
+    BuildCommandRequest,
+    BuildInvocation,
+    BuildPhaseTimings,
+    VirtualBuildCliRequest,
+    VirtualBuildExecution,
+)
+from sqlbuild.compiler.pipeline.models import CompilePipelineResult
+from sqlbuild.diagnostics.classes.build_phase_timing_tracker import BuildPhaseTimingTracker
+from sqlbuild.diagnostics.models import PartialBuildPhaseTimings
+from sqlbuild.presentation.classes.cli_document import CliDocument
+from sqlbuild.presentation.classes.cli_style import CliStyle
+from sqlbuild.virtual.executor.models import VirtualBuildPipelineResult
+
+
+def write_build_phase_timings(
+    *, stream: TextIO, timings: BuildPhaseTimings, use_color: bool
+) -> None:
+    """Write available monotonic build phase durations."""
+
+    document: CliDocument = CliDocument(CliStyle(use_color=use_color))
+    document.blank()
+    document.header(text="Phase timings")
+    document.fields(rows=_timing_rows(timings), label_width=24)
+    stream.write(document.render())
+    stream.flush()
+
+
+def write_partial_build_phase_timings(
+    *, stream: TextIO, timings: PartialBuildPhaseTimings, use_color: bool
+) -> None:
+    """Write available exceptional build phase durations."""
+
+    write_build_phase_timings(
+        stream=stream,
+        timings=BuildPhaseTimings(
+            compile_seconds=timings.compile_seconds,
+            planning_seconds=timings.planning_seconds,
+            connection_preparation_seconds=timings.connection_preparation_seconds,
+            schema_preparation_seconds=timings.schema_preparation_seconds,
+            execution_seconds=timings.execution_seconds,
+            cost_collection_seconds=timings.cost_collection_seconds,
+            total_seconds=timings.total_seconds,
+        ),
+        use_color=use_color,
+    )
+
+
+def finish_cost_collection_timing(*, started_at: float) -> float | None:
+    """Retain cost collection elapsed time without affecting the active outcome."""
+
+    try:
+        elapsed_seconds: float = time.monotonic() - started_at
+        timing_tracker: BuildPhaseTimingTracker | None = BuildPhaseTimingTracker.current()
+        if timing_tracker is not None:
+            timing_tracker.cost_collection_seconds = elapsed_seconds
+        return elapsed_seconds
+    except BaseException:
+        return None
+
+
+def finalize_no_work_with_timings(
+    *,
+    request: BuildCommandRequest,
+    invocation: BuildInvocation,
+    pipeline_result: CompilePipelineResult,
+    command_started_at: float,
+) -> bool:
+    """Finalize no-work output and append verbose phase timings when complete."""
+
+    cost_started_at: float = time.monotonic()
+    try:
+        finalized: bool = finalize_no_work_build_if_needed(
+            request=request,
+            invocation=invocation,
+            pipeline_result=pipeline_result,
+        )
+    finally:
+        cost_collection_seconds: float | None = finish_cost_collection_timing(
+            started_at=cost_started_at
+        )
+    if finalized and (request.verbose or request.debug):
+        write_build_phase_timings(
+            stream=invocation.progress_stream,
+            timings=BuildPhaseTimings(
+                compile_seconds=pipeline_result.compile_seconds,
+                planning_seconds=pipeline_result.planning_seconds,
+                cost_collection_seconds=cost_collection_seconds,
+                total_seconds=time.monotonic() - command_started_at,
+            ),
+            use_color=invocation.use_color,
+        )
+    return finalized
+
+
+def finalize_exceptional_with_timings(
+    *,
+    request: BuildCommandRequest,
+    invocation: BuildInvocation,
+    pipeline_result: CompilePipelineResult,
+    build_started_at: datetime,
+    command_started_at: float,
+    error: BaseException,
+) -> None:
+    """Finalize exceptional cost state and available verbose phase timings."""
+
+    cost_started_at: float = time.monotonic()
+    try:
+        finalize_exceptional_direct_cost(
+            invocation=invocation,
+            pipeline_result=pipeline_result,
+            build_started_at=build_started_at,
+            error=error,
+        )
+    finally:
+        _ = finish_cost_collection_timing(started_at=cost_started_at)
+
+
+def write_virtual_build_phase_timings(
+    *,
+    stream: TextIO,
+    request: VirtualBuildCliRequest,
+    execution: VirtualBuildExecution,
+    result: VirtualBuildPipelineResult,
+    cost_collection_seconds: float,
+) -> None:
+    """Write completed virtual-build timings from typed pipeline results."""
+
+    if not request.verbose and not request.debug:
+        return
+    total_seconds: float = (
+        time.monotonic() - request.command_started_at
+        if request.command_started_at is not None
+        else execution.elapsed
+    )
+    write_build_phase_timings(
+        stream=stream,
+        timings=BuildPhaseTimings(
+            compile_seconds=result.compile_seconds,
+            planning_seconds=result.planning_seconds,
+            connection_preparation_seconds=(
+                result.execution_result.timings.connection_preparation_seconds
+            ),
+            schema_preparation_seconds=result.execution_result.timings.schema_preparation_seconds,
+            execution_seconds=result.execution_result.timings.execution_seconds,
+            cost_collection_seconds=cost_collection_seconds,
+            total_seconds=total_seconds,
+        ),
+        use_color=request.use_color,
+    )
+
+
+def record_and_write_virtual_build_phase_timings(
+    *,
+    stream: TextIO,
+    request: VirtualBuildCliRequest,
+    execution: VirtualBuildExecution,
+    result: VirtualBuildPipelineResult,
+    cost_collection_seconds: float,
+) -> None:
+    """Record and write completed virtual-build timing diagnostics."""
+
+    timing_tracker: BuildPhaseTimingTracker | None = BuildPhaseTimingTracker.current()
+    if timing_tracker is not None:
+        timing_tracker.cost_collection_seconds = cost_collection_seconds
+    write_virtual_build_phase_timings(
+        stream=stream,
+        request=request,
+        execution=execution,
+        result=result,
+        cost_collection_seconds=cost_collection_seconds,
+    )
+
+
+def _timing_rows(timings: BuildPhaseTimings) -> tuple[tuple[str, str], ...]:
+    values: tuple[tuple[str, float | None], ...] = (
+        ("compile", timings.compile_seconds),
+        ("planning", timings.planning_seconds),
+        ("connection preparation", timings.connection_preparation_seconds),
+        ("schema preparation", timings.schema_preparation_seconds),
+        ("execution", timings.execution_seconds),
+        ("cost collection", timings.cost_collection_seconds),
+        ("total", timings.total_seconds),
+    )
+    return tuple((label, f"{seconds:.2f}s") for label, seconds in values if seconds is not None)

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

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