sqlbuild 0.65.2__tar.gz → 0.65.4__tar.gz

{sqlbuild-0.65.2 → sqlbuild-0.65.4}/Cargo.lock

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

{sqlbuild-0.65.2 → sqlbuild-0.65.4}/PKG-INFO

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

{sqlbuild-0.65.2 → sqlbuild-0.65.4}/crates/sqlbuild-kata-native/Cargo.toml

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

{sqlbuild-0.65.2 → sqlbuild-0.65.4}/pyproject.toml

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

{sqlbuild-0.65.2 → sqlbuild-0.65.4}/src/sqlbuild/cli/commands/_helpers/clone/execution.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import time
 from typing import TextIO
 
+from sqlbuild.adapter.contract.classes.base_adapter import BaseAdapter
 from sqlbuild.cli.commands._helpers.clone.output import render_clone_item_line
 from sqlbuild.cli.commands.models import (
     CloneCommandRequest,
@@ -13,6 +14,14 @@ from sqlbuild.cli.commands.models import (
     CloneInvocation,
     CloneRunOutcome,
 )
+from sqlbuild.compiler.compile.models import CompiledObjectKey, CompiledRelationLocation
+from sqlbuild.compiler.compile.types import CompiledResourceType
+from sqlbuild.compiler.planner.models import (
+    CloneSourcePlanEntry,
+    FunctionPlanEntry,
+    ModelPlanEntry,
+    SeedPlanEntry,
+)
 from sqlbuild.executor.clone.main.execute import execute_clone
 from sqlbuild.executor.clone.main.fingerprinting import copy_clone_fingerprints
 from sqlbuild.executor.clone.models import (
@@ -22,6 +31,7 @@ from sqlbuild.executor.clone.models import (
     CloneSourceEntries,
 )
 from sqlbuild.executor.clone.types import CloneItemCallback
+from sqlbuild.spec.contracts.models import SourceEntry
 
 
 def execute_clone_plan(
@@ -55,6 +65,11 @@ def execute_clone_plan(
             hard_copy=request.hard_copy,
             run_id=preparation.pipeline_result.destination_project.run_id,
             query_change_tracking=preparation.pipeline_result.destination_project.settings.query_change_tracking,
+            upstream_deps=preparation.pipeline_result.clone_plan.upstream_deps,
+            dependency_locations=_clone_dependency_locations(
+                preparation=preparation,
+                adapter=invocation.adapter,
+            ),
             on_item=on_item,
         )
     )
@@ -72,6 +87,44 @@ def execute_clone_plan(
     return CloneRunOutcome(result=result, elapsed=time.monotonic() - clone_start)
 
 
+def _clone_dependency_locations(
+    *, preparation: CloneExecutionPreparation, adapter: BaseAdapter
+) -> dict[CompiledObjectKey, CompiledRelationLocation]:
+    entries: tuple[
+        CloneSourcePlanEntry | ModelPlanEntry | SeedPlanEntry | FunctionPlanEntry, ...
+    ] = (
+        *preparation.pipeline_result.destination_source_entries,
+        *preparation.pipeline_result.destination_model_entries,
+        *preparation.pipeline_result.destination_seed_entries,
+        *preparation.pipeline_result.destination_function_entries,
+    )
+    locations: dict[CompiledObjectKey, CompiledRelationLocation] = {
+        entry.key: entry.destination for entry in entries
+    }
+    source_map: dict[str, SourceEntry] = (
+        preparation.pipeline_result.clone_plan.source_read_map
+        or preparation.pipeline_result.clone_plan.source_map
+    )
+    for name, source in source_map.items():
+        if source.table is None:
+            continue
+        key: CompiledObjectKey = CompiledObjectKey(CompiledResourceType.SOURCE, name)
+        locations[key] = CompiledRelationLocation(
+            database=source.database,
+            schema=source.schema,
+            name=source.table,
+            qualified_name=(
+                adapter.render_qualified_name(
+                    database=source.database,
+                    schema=source.schema,
+                    name=source.table,
+                )
+                or source.table
+            ),
+        )
+    return locations
+
+
 def _build_on_clone_item(*, stream: TextIO, use_color: bool) -> CloneItemCallback:
     def _on_clone_item(*, index: int, total: int, item: CloneItemResult) -> None:
         stream.write(

{sqlbuild-0.65.2 → sqlbuild-0.65.4}/src/sqlbuild/cli/commands/_helpers/clone/output.py

@@ -118,4 +118,4 @@ def render_clone_output(
 
 
 def is_clone_success(result: CloneExecutionResult) -> bool:
-    return all(item.status == CloneStatus.SUCCESS for item in result.item_results)
+    return all(item.status != CloneStatus.FAILED for item in result.item_results)

{sqlbuild-0.65.2 → sqlbuild-0.65.4}/src/sqlbuild/cli/commands/_helpers/clone/outputs.py

@@ -13,6 +13,14 @@ from sqlbuild.cli.commands.models import (
     CloneInvocation,
     CloneRunOutcome,
 )
+from sqlbuild.cli.output.main._clone_execution_json import format_clone_execution_json
+from sqlbuild.cli.output.main._write_execution_json_output import write_execution_json_output
+from sqlbuild.compiler.planner.models import (
+    CloneSourcePlanEntry,
+    FunctionPlanEntry,
+    ModelPlanEntry,
+    SeedPlanEntry,
+)
 
 
 def write_clone_execution_header(
@@ -51,6 +59,35 @@ def write_clone_completion_output(*, invocation: CloneInvocation, outcome: Clone
     )
 
 
+def write_clone_execution_json_output(
+    *,
+    request: CloneCommandRequest,
+    preparation: CloneExecutionPreparation,
+    outcome: CloneRunOutcome,
+) -> None:
+    """Write structured direct clone outcomes when requested."""
+
+    entries: tuple[
+        CloneSourcePlanEntry | ModelPlanEntry | SeedPlanEntry | FunctionPlanEntry, ...
+    ] = (
+        *preparation.pipeline_result.destination_source_entries,
+        *preparation.pipeline_result.destination_model_entries,
+        *preparation.pipeline_result.destination_seed_entries,
+        *preparation.pipeline_result.destination_function_entries,
+    )
+    resource_types_by_name: dict[str, str] = {
+        entry.name: str(entry.key.resource_type) for entry in entries
+    }
+    write_execution_json_output(
+        payload=format_clone_execution_json(
+            result=outcome.result,
+            resource_types_by_name=resource_types_by_name,
+        ),
+        json_output=False,
+        json_output_path=request.json_output_path,
+    )
+
+
 def resolve_clone_exit_code(outcome: CloneRunOutcome) -> int:
     """Return the shell exit code for a direct clone outcome."""
 

{sqlbuild-0.65.2 → sqlbuild-0.65.4}/src/sqlbuild/cli/commands/_helpers/clone/virtual.py

@@ -15,6 +15,10 @@ from sqlbuild.cli.commands._helpers.runtime.connection import (
     resolve_target_connection_config,
 )
 from sqlbuild.cli.commands.models import CloneCommandRequest, CloneInvocation
+from sqlbuild.cli.output.main._virtual_clone_execution_json import (
+    format_virtual_clone_execution_json,
+)
+from sqlbuild.cli.output.main._write_execution_json_output import write_execution_json_output
 from sqlbuild.cli.progress.classes.planning_progress_reporter import PlanningProgressReporter
 from sqlbuild.virtual.executor.main.clone import run_virtual_clone
 from sqlbuild.virtual.executor.models import CloneOptions, VirtualCloneResult
@@ -61,4 +65,9 @@ def execute_virtual_clone(*, request: CloneCommandRequest, invocation: CloneInvo
         use_color=invocation.use_color,
         verbose=request.verbose,
     )
+    write_execution_json_output(
+        payload=format_virtual_clone_execution_json(result=result),
+        json_output=False,
+        json_output_path=request.json_output_path,
+    )
     return 0 if is_virtual_clone_success(result) else 1

{sqlbuild-0.65.2 → sqlbuild-0.65.4}/src/sqlbuild/cli/commands/_helpers/entry/dispatch.py

@@ -316,6 +316,7 @@ def dispatch_cli_command(*, args: CliNamespace, handlers: CliEntrypointHandlers)
                 exclude=tuple(args.exclude),
                 verbose=args.verbose,
                 cli_vars=args.vars,
+                json_output_path=args.json_output,
             )
         )
     if args.command == CliCommand.DIFF:

{sqlbuild-0.65.2 → sqlbuild-0.65.4}/src/sqlbuild/cli/commands/_helpers/entry/parser.py

@@ -267,6 +267,7 @@ def _add_data_parsers(
     _ = add_select_args(clone_parser)
     _ = add_vars_args(clone_parser)
     _ = add_dbt_config_args(parser=clone_parser)
+    _ = add_execution_json_output_arg(clone_parser)
 
     diff_parser: argparse.ArgumentParser = subparsers.add_parser(CliCommand.DIFF)
     diff_parser.add_argument("target_range", metavar="FROM:TO")

{sqlbuild-0.65.2 → sqlbuild-0.65.4}/src/sqlbuild/cli/commands/main/inspection/_clone.py

@@ -12,6 +12,7 @@ from sqlbuild.cli.commands._helpers.clone.outputs import (
     resolve_clone_exit_code,
     write_clone_completion_output,
     write_clone_execution_header,
+    write_clone_execution_json_output,
 )
 from sqlbuild.cli.commands._helpers.clone.planning import prepare_clone_execution
 from sqlbuild.cli.commands._helpers.clone.virtual import execute_virtual_clone
@@ -54,4 +55,9 @@ def run_clone(request: CloneCommandRequest) -> int:
     finally:
         _ = close_clone_targets(invocation=invocation, connection_context=connection_context)
     write_clone_completion_output(invocation=invocation, outcome=outcome)
+    write_clone_execution_json_output(
+        request=request,
+        preparation=preparation,
+        outcome=outcome,
+    )
     return resolve_clone_exit_code(outcome)

{sqlbuild-0.65.2 → sqlbuild-0.65.4}/src/sqlbuild/cli/commands/models.py

@@ -389,6 +389,7 @@ class CloneCommandRequest:
     exclude: tuple[str, ...] = ()
     verbose: bool = False
     cli_vars: dict[str, object] | None = None
+    json_output_path: Path | None = None
 
 
 @dataclass(frozen=True)

{sqlbuild-0.65.2 → sqlbuild-0.65.4}/src/sqlbuild/cli/output/_helpers/execution_protocol_v1.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import json
 import sys
+from collections.abc import Mapping
 from pathlib import Path
 from typing import cast
 
@@ -20,6 +21,8 @@ from sqlbuild.executor.build.models import (
     SeedExecutionResult,
 )
 from sqlbuild.executor.build.types import BuildStatus, ExecutionStatus
+from sqlbuild.executor.clone.models import CloneExecutionResult
+from sqlbuild.executor.clone.types import CloneStatus
 from sqlbuild.executor.load.models import LoadExecutionResult
 from sqlbuild.executor.python_nodes.models import (
     PythonCheckExecutionResult,
@@ -38,6 +41,12 @@ from sqlbuild.executor.testing.models import SqlTestExecutionResult, StepResult
 from sqlbuild.executor.testing.types import SqlTestOutcome
 from sqlbuild.sql_values.models import SqlValue
 from sqlbuild.sql_values.types import SqlValueKind
+from sqlbuild.virtual.executor.constants import (
+    VIRTUAL_CLONE_FOUND_ACTIONS,
+    VIRTUAL_CLONE_MISSING_ACTION,
+    VIRTUAL_CLONE_SKIPPED_LOCKED_ACTION,
+)
+from sqlbuild.virtual.executor.models import VirtualCloneResult
 
 _JSON_VERSION: int = 1
 
@@ -202,6 +211,88 @@ def format_load_execution_json(*, results: tuple[LoadExecutionResult, ...]) -> s
     )
 
 
+def format_clone_execution_json(
+    *, result: CloneExecutionResult, resource_types_by_name: Mapping[str, str]
+) -> str:
+    """Format direct clone command execution results as JSON."""
+
+    failure_count: int = sum(1 for item in result.item_results if item.status == CloneStatus.FAILED)
+    warning_count: int = sum(
+        1 for item in result.item_results if item.status == CloneStatus.WARNING
+    )
+    return _format_execution_json(
+        command="clone",
+        status=(BuildStatus.SUCCESS.value if failure_count == 0 else BuildStatus.FAILED.value),
+        assets=tuple(
+            _drop_none(
+                {
+                    "kind": resource_types_by_name[item.name],
+                    "name": item.name,
+                    "status": item.status.value,
+                    "action": item.action.value,
+                    "duration_ms": (
+                        round(item.duration_seconds * 1000)
+                        if item.duration_seconds is not None
+                        else None
+                    ),
+                    "origin_relation": item.origin_relation,
+                    "target": item.destination_relation,
+                    "message": item.message,
+                }
+            )
+            for item in result.item_results
+        ),
+        checks=(),
+        summary={
+            "success_count": len(result.item_results) - failure_count - warning_count,
+            "failure_count": failure_count,
+            "warning_count": warning_count,
+            "total_count": len(result.item_results),
+        },
+    )
+
+
+def format_virtual_clone_execution_json(*, result: VirtualCloneResult) -> str:
+    """Format virtual clone command execution results as JSON."""
+
+    return _format_execution_json(
+        command="clone",
+        status=(
+            BuildStatus.SUCCESS.value if result.missing_count == 0 else BuildStatus.FAILED.value
+        ),
+        assets=tuple(
+            _drop_none(
+                {
+                    "kind": item.artifact_type.value,
+                    "name": item.artifact_name,
+                    "status": _virtual_clone_item_status(action=item.action),
+                    "action": item.action,
+                    "version_hash": item.version_hash,
+                    "message": item.message,
+                }
+            )
+            for item in result.item_results
+        ),
+        checks=(),
+        summary={
+            "success_count": result.found_count,
+            "failure_count": result.missing_count,
+            "skipped_count": result.skipped_locked_count,
+            "total_count": result.selected_count,
+        },
+    )
+
+
+def _virtual_clone_item_status(*, action: str) -> str:
+    if action in VIRTUAL_CLONE_FOUND_ACTIONS:
+        return "success"
+    if action == VIRTUAL_CLONE_SKIPPED_LOCKED_ACTION:
+        return "skipped"
+    if action == VIRTUAL_CLONE_MISSING_ACTION:
+        return "warning"
+    return "failed"
+
+
 def format_test_execution_json(*, results: tuple[SqlTestExecutionResult, ...]) -> str:
     """Format test command execution results as JSON."""
 

sqlbuild-0.65.4/src/sqlbuild/cli/output/main/_clone_execution_json.py

@@ -0,0 +1,21 @@
+"""Public clone execution JSON formatting entrypoint."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+
+from sqlbuild.cli.output._helpers.execution_protocol_v1 import (
+    format_clone_execution_json as _format_clone_execution_json,
+)
+from sqlbuild.executor.clone.models import CloneExecutionResult
+
+
+def format_clone_execution_json(
+    *, result: CloneExecutionResult, resource_types_by_name: Mapping[str, str]
+) -> str:
+    """Format clone command execution results as JSON."""
+
+    return _format_clone_execution_json(
+        result=result,
+        resource_types_by_name=resource_types_by_name,
+    )

sqlbuild-0.65.4/src/sqlbuild/cli/output/main/_virtual_clone_execution_json.py

@@ -0,0 +1,14 @@
+"""Public virtual clone execution JSON formatting entrypoint."""
+
+from __future__ import annotations
+
+from sqlbuild.cli.output._helpers.execution_protocol_v1 import (
+    format_virtual_clone_execution_json as _format_virtual_clone_execution_json,
+)
+from sqlbuild.virtual.executor.models import VirtualCloneResult
+
+
+def format_virtual_clone_execution_json(*, result: VirtualCloneResult) -> str:
+    """Format virtual clone command execution results as JSON."""
+
+    return _format_virtual_clone_execution_json(result=result)

sqlbuild-0.65.4/src/sqlbuild/executor/clone/_helpers/execution_items.py

@@ -0,0 +1,148 @@
+"""Per-item clone execution decisions."""
+
+from __future__ import annotations
+
+import time
+
+from sqlbuild.adapter.contract.classes.statement_recorder import StatementRecorder
+from sqlbuild.adapter.contract.models import RelationLookup
+from sqlbuild.compiler.compile.models import CompiledObjectKey
+from sqlbuild.compiler.planner.models import (
+    CloneSourcePlanEntry,
+    FunctionPlanEntry,
+    ModelPlanEntry,
+    SeedPlanEntry,
+)
+from sqlbuild.compiler.planner.types import MaterializationType
+from sqlbuild.executor.build.models import FunctionExecutionResult
+from sqlbuild.executor.clone._helpers.operations import clone_relation, recreate_view
+from sqlbuild.executor.clone.models import CloneExecutionInput, CloneItemResult
+from sqlbuild.executor.clone.types import CloneAction, CloneStatus
+from sqlbuild.executor.functions.main._execute import execute_function
+from sqlbuild.executor.scheduling.types import ExecutionStatus
+
+
+def execute_clone_function_item(
+    *,
+    destination_entry: FunctionPlanEntry,
+    inputs: CloneExecutionInput,
+    available_keys: set[CompiledObjectKey],
+) -> CloneItemResult:
+    """Recreate one function and normalize its clone outcome."""
+
+    missing_dependencies: tuple[CompiledObjectKey, ...] = _missing_destination_dependencies(
+        key=destination_entry.key,
+        inputs=inputs,
+        available_keys=available_keys,
+    )
+    if missing_dependencies:
+        return _missing_dependency_result(
+            name=destination_entry.name,
+            destination_relation=destination_entry.destination.qualified_name,
+            missing_dependencies=missing_dependencies,
+            inputs=inputs,
+        )
+    start: float = time.monotonic()
+    recorder: StatementRecorder = StatementRecorder()
+    function_result: FunctionExecutionResult = execute_function(
+        function_entry=destination_entry,
+        adapter=inputs.adapter,
+        connection=inputs.destination_connection,
+        statement_recorder=recorder,
+        run_id=inputs.run_id,
+        query_change_tracking=inputs.query_change_tracking,
+    )
+    succeeded: bool = function_result.status == ExecutionStatus.SUCCESS
+    return CloneItemResult(
+        name=destination_entry.name,
+        action=CloneAction.RECREATED_FUNCTION if succeeded else CloneAction.FAILED,
+        status=CloneStatus.SUCCESS if succeeded else CloneStatus.FAILED,
+        message=(
+            "; ".join(function_result.warning_messages)
+            if succeeded and function_result.warning_messages
+            else function_result.error_message
+        ),
+        destination_relation=destination_entry.destination.qualified_name,
+        duration_seconds=time.monotonic() - start,
+        executed_statements=function_result.lifecycle_events,
+    )
+
+
+def execute_clone_relation_item(
+    *,
+    destination_entry: CloneSourcePlanEntry | SeedPlanEntry | ModelPlanEntry,
+    origin_entry: CloneSourcePlanEntry | SeedPlanEntry | ModelPlanEntry,
+    inputs: CloneExecutionInput,
+    relation_lookup: RelationLookup,
+    available_keys: set[CompiledObjectKey],
+) -> CloneItemResult:
+    """Clone a physical relation or conditionally recreate one view."""
+
+    if (
+        not isinstance(destination_entry, ModelPlanEntry)
+        or not isinstance(origin_entry, ModelPlanEntry)
+        or destination_entry.materialization_type != MaterializationType.VIEW
+    ):
+        return clone_relation(
+            destination_entry=destination_entry,
+            origin_entry=origin_entry,
+            adapter=inputs.adapter,
+            destination_connection=inputs.destination_connection,
+            hard_copy=inputs.hard_copy,
+            origin_lookup=relation_lookup,
+        )
+    missing_dependencies: tuple[CompiledObjectKey, ...] = _missing_destination_dependencies(
+        key=destination_entry.key,
+        inputs=inputs,
+        available_keys=available_keys,
+    )
+    if missing_dependencies:
+        return _missing_dependency_result(
+            name=destination_entry.name,
+            origin_relation=origin_entry.destination.qualified_name,
+            destination_relation=destination_entry.destination.qualified_name,
+            missing_dependencies=missing_dependencies,
+            inputs=inputs,
+        )
+    return recreate_view(
+        destination_entry=destination_entry,
+        origin_entry=origin_entry,
+        adapter=inputs.adapter,
+        destination_connection=inputs.destination_connection,
+    )
+
+
+def _missing_destination_dependencies(
+    *,
+    key: CompiledObjectKey,
+    inputs: CloneExecutionInput,
+    available_keys: set[CompiledObjectKey],
+) -> tuple[CompiledObjectKey, ...]:
+    return tuple(
+        dependency
+        for dependency in inputs.upstream_deps.get(key, ())
+        if dependency in inputs.dependency_locations and dependency not in available_keys
+    )
+
+
+def _missing_dependency_result(
+    *,
+    name: str,
+    destination_relation: str | None,
+    missing_dependencies: tuple[CompiledObjectKey, ...],
+    inputs: CloneExecutionInput,
+    origin_relation: str | None = None,
+) -> CloneItemResult:
+    return CloneItemResult(
+        name=name,
+        action=CloneAction.SKIPPED_MISSING_DEPENDENCY,
+        status=CloneStatus.WARNING,
+        message="missing destination dependencies: "
+        + ", ".join(
+            inputs.dependency_locations[dependency].qualified_name
+            or inputs.dependency_locations[dependency].name
+            for dependency in missing_dependencies
+        ),
+        origin_relation=origin_relation,
+        destination_relation=destination_relation,
+    )

{sqlbuild-0.65.2 → sqlbuild-0.65.4}/src/sqlbuild/executor/clone/_helpers/operations.py

@@ -50,18 +50,12 @@ def recreate_view(
     origin_entry: SeedPlanEntry | ModelPlanEntry,
     adapter: BaseAdapter,
     destination_connection: Any,
-    origin_lookup: RelationLookup,
 ) -> CloneItemResult:
     return recreate_view_by_names(
         name=destination_entry.name,
         origin_relation=qualified_name(adapter=adapter, entry=origin_entry),
         destination_relation=qualified_name(adapter=adapter, entry=destination_entry),
         view_sql=destination_entry.resolved_sql,
-        origin_exists=origin_lookup.exists(
-            database=origin_entry.destination.database,
-            schema=origin_entry.destination.schema,
-            name=origin_entry.destination.name,
-        ),
         adapter=adapter,
         connection=destination_connection,
     )

{sqlbuild-0.65.2 → sqlbuild-0.65.4}/src/sqlbuild/executor/clone/main/_recreate_view_operation.py

@@ -17,21 +17,11 @@ def recreate_view_by_names(
     origin_relation: str,
     destination_relation: str,
     view_sql: str,
-    origin_exists: bool,
     adapter: BaseAdapter,
     connection: Any,
 ) -> CloneItemResult:
     """Recreate the destination view from SQL, returning a timed item result."""
 
-    if not origin_exists:
-        return CloneItemResult(
-            name=name,
-            action=CloneAction.WARNING_MISSING_SOURCE,
-            status=CloneStatus.WARNING,
-            message="missing in origin environment",
-            origin_relation=origin_relation,
-            destination_relation=destination_relation,
-        )
     recorder: StatementRecorder = StatementRecorder()
     start: float = time.monotonic()
     try: