sqlbuild 0.41.0__tar.gz → 0.41.1__tar.gz

sqlbuild-0.41.1/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.41.1"
+}

{sqlbuild-0.41.0 → sqlbuild-0.41.1}/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.41.1](https://github.com/chio-labs/sqlbuild/compare/v0.41.0...v0.41.1) (2026-06-26)
+
+
+### Bug Fixes
+
+* **planner:** memoize write-identity hashes to avoid exponential hang ([df812df](https://github.com/chio-labs/sqlbuild/commit/df812df5762a45bf07d3cdec68ff9c23d5076cdb))
+* **planner:** memoize write-identity hashes to avoid exponential hang ([c98f865](https://github.com/chio-labs/sqlbuild/commit/c98f8658df26080c9dc9ee274b165210f922086a))
+
 ## [0.41.0](https://github.com/chio-labs/sqlbuild/compare/v0.40.1...v0.41.0) (2026-06-26)
 
 

{sqlbuild-0.41.0 → sqlbuild-0.41.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.41.0
+Version: 0.41.1
 Summary: Typed, test-first SQL pipelines with local E2E testing
 License-File: LICENSE
 Requires-Python: >=3.12

{sqlbuild-0.41.0 → sqlbuild-0.41.1}/pyproject.toml

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

{sqlbuild-0.41.0 → sqlbuild-0.41.1}/src/sqlbuild/compiler/planner/helpers/identity/graph.py

@@ -49,17 +49,17 @@ def build_graph_write_identity_hashes(
     compose_identity: Callable[[str, tuple[tuple[GraphNodeKey, str], ...]], str],
 ) -> dict[GraphNodeKey, str]:
     hashes: dict[GraphNodeKey, str] = dict(base_identity_hashes)
+    resolved_selected: dict[GraphNodeKey, str] = {}
 
     def resolve(key: GraphNodeKey, visiting: frozenset[GraphNodeKey]) -> str | None:
-        if key in hashes and key not in selected_keys:
-            return hashes[key]
+        if key not in selected_keys:
+            return hashes.get(key)
+        if key in resolved_selected:
+            return resolved_selected[key]
         node: GraphIdentityNode | None = nodes.get(key)
         if node is None or node.local_hash is None:
             return hashes.get(key)
-        if key not in selected_keys:
-            return hashes.get(key)
         if key in visiting:
-            hashes[key] = node.local_hash
             return node.local_hash
         upstream_hashes: list[tuple[GraphNodeKey, str]] = []
         upstream_key: GraphNodeKey
@@ -67,8 +67,10 @@ def build_graph_write_identity_hashes(
             upstream_hash: str | None = resolve(upstream_key, visiting | {key})
             if upstream_hash is not None:
                 upstream_hashes.append((upstream_key, upstream_hash))
-        hashes[key] = compose_identity(node.local_hash, tuple(upstream_hashes))
-        return hashes[key]
+        composed: str = compose_identity(node.local_hash, tuple(upstream_hashes))
+        resolved_selected[key] = composed
+        hashes[key] = composed
+        return composed
 
     key: GraphNodeKey
     for key in execution_order:

{sqlbuild-0.41.0 → sqlbuild-0.41.1}/tests/unit/src/sqlbuild/compiler/planner/helpers/_test_types.py

@@ -200,6 +200,13 @@ class GraphIdentityWriteHashesTestCase:
     expected_hashes: dict[GraphNodeKey, str]
 
 
+@dataclass(frozen=True)
+class GraphIdentityWritePerfTestCase:
+    description: str
+    layer_count: int
+    expected_max_seconds: float
+
+
 @dataclass(frozen=True)
 class GraphChangesOnlyPropagationTestCase:
     description: str

{sqlbuild-0.41.0 → sqlbuild-0.41.1}/tests/unit/src/sqlbuild/compiler/planner/helpers/helpers.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import base64
+import hashlib
 from dataclasses import replace
 from datetime import UTC, datetime
 from pathlib import Path
@@ -59,6 +60,7 @@ from sqlbuild.compiler.planner.models import (
     BackfillResult,
     CascadeResult,
     ChangeDetectionResult,
+    GraphIdentityNode,
     GraphNodeKey,
     PlannerChangeResults,
     PlannerScope,
@@ -71,7 +73,7 @@ from sqlbuild.compiler.planner.models import (
     WarehouseFingerprints,
     WarehouseSnapshot,
 )
-from sqlbuild.compiler.planner.types import BackfillAction, ChangeKind
+from sqlbuild.compiler.planner.types import BackfillAction, ChangeKind, GraphResourceKind
 from sqlbuild.compiler.source_freshness.models import (
     SourceFreshnessIdentity,
     SourceFreshnessRecord,
@@ -137,6 +139,46 @@ def compose_readable_identity(
     return f"{local_hash}|{rendered}"
 
 
+def compose_hashed_identity(
+    local_hash: str, upstream_hashes: tuple[tuple[GraphNodeKey, str], ...]
+) -> str:
+    if not upstream_hashes:
+        return local_hash
+    payload: str = (
+        local_hash + "|" + ",".join(upstream_hash for _, upstream_hash in upstream_hashes)
+    )
+    return hashlib.sha256(payload.encode()).hexdigest()
+
+
+def build_diamond_ladder_identity_nodes(
+    *, layer_count: int
+) -> tuple[dict[GraphNodeKey, GraphIdentityNode], tuple[GraphNodeKey, ...]]:
+    """Build a dense ladder where each layer depends on both nodes of the prior layer."""
+
+    def node_key(name: str) -> GraphNodeKey:
+        return GraphNodeKey(node_type="model", node_name=name)
+
+    nodes: dict[GraphNodeKey, GraphIdentityNode] = {}
+    order: list[GraphNodeKey] = []
+    previous: tuple[GraphNodeKey, ...] = ()
+    layer_index: int
+    for layer_index in range(layer_count):
+        current: list[GraphNodeKey] = []
+        suffix: str
+        for suffix in ("a", "b"):
+            key: GraphNodeKey = node_key(f"L{layer_index}_{suffix}")
+            nodes[key] = GraphIdentityNode(
+                key=key,
+                resource_kind=GraphResourceKind.MODEL,
+                upstream_keys=previous,
+                local_hash=f"local_{key.node_name}",
+            )
+            order.append(key)
+            current.append(key)
+        previous = tuple(current)
+    return nodes, tuple(order)
+
+
 class StandardReuseFromTargetTestAdapter(PlannerTestAdapter):
     """Adapter test double for standard reuse_from snapshot tests."""
 

sqlbuild-0.41.1/tests/unit/src/sqlbuild/compiler/planner/helpers/test_graph_identity.py

@@ -0,0 +1,193 @@
+from __future__ import annotations
+
+import time
+
+import pytest
+
+from sqlbuild.compiler.planner.main.graph_identity import (
+    build_expected_graph_identity_hashes,
+)
+from sqlbuild.compiler.planner.main.graph_write_identity import build_graph_write_identity_hashes
+from sqlbuild.compiler.planner.models import GraphIdentityNode, GraphNodeKey
+from sqlbuild.compiler.planner.types import GraphResourceKind
+from tests.unit.src.sqlbuild.compiler.planner.helpers._test_types import (
+    GraphIdentityExpectedHashesTestCase,
+    GraphIdentityWriteHashesTestCase,
+    GraphIdentityWritePerfTestCase,
+)
+from tests.unit.src.sqlbuild.compiler.planner.helpers.helpers import (
+    build_diamond_ladder_identity_nodes,
+    compose_hashed_identity,
+    compose_readable_identity,
+)
+
+MODEL_A: GraphNodeKey = GraphNodeKey(node_type="model", node_name="a")
+MODEL_B: GraphNodeKey = GraphNodeKey(node_type="model", node_name="b")
+MODEL_C: GraphNodeKey = GraphNodeKey(node_type="model", node_name="c")
+MODEL_D: GraphNodeKey = GraphNodeKey(node_type="model", node_name="d")
+
+
+@pytest.mark.parametrize(
+    "test_case",
+    [
+        GraphIdentityExpectedHashesTestCase(
+            description=(
+                "uses dependency order and named upstream keys while preserving missing nodes"
+            ),
+            nodes={
+                MODEL_A: GraphIdentityNode(
+                    key=MODEL_A,
+                    resource_kind=GraphResourceKind.MODEL,
+                    upstream_keys=(MODEL_B, MODEL_C),
+                    local_hash="local_a",
+                ),
+                MODEL_B: GraphIdentityNode(
+                    key=MODEL_B,
+                    resource_kind=GraphResourceKind.MODEL,
+                    upstream_keys=(),
+                    local_hash="local_b",
+                ),
+                MODEL_C: GraphIdentityNode(
+                    key=MODEL_C,
+                    resource_kind=GraphResourceKind.MODEL,
+                    upstream_keys=(),
+                    local_hash=None,
+                ),
+            },
+            execution_order=(MODEL_B, MODEL_C, MODEL_A),
+            expected_hashes={
+                MODEL_A: "local_a|model:b=local_b",
+                MODEL_B: "local_b",
+                MODEL_C: None,
+            },
+        )
+    ],
+    ids=["uses dependency order and named upstream keys while preserving missing nodes"],
+)
+def test_given_identity_graph_when_building_expected_hashes_then_resolves_from_upstreams(
+    test_case: GraphIdentityExpectedHashesTestCase,
+) -> None:
+    result: dict[GraphNodeKey, str | None] = build_expected_graph_identity_hashes(
+        nodes=test_case.nodes,
+        execution_order=test_case.execution_order,
+        compose_identity=compose_readable_identity,
+    )
+
+    assert result == test_case.expected_hashes
+
+
+WRITE_HASHES_TEST_CASES: list[GraphIdentityWriteHashesTestCase] = [
+    GraphIdentityWriteHashesTestCase(
+        description="recomputes selected child from caller supplied parent write hash",
+        nodes={
+            MODEL_A: GraphIdentityNode(
+                key=MODEL_A,
+                resource_kind=GraphResourceKind.MODEL,
+                upstream_keys=(MODEL_B,),
+                local_hash="local_a",
+            ),
+            MODEL_B: GraphIdentityNode(
+                key=MODEL_B,
+                resource_kind=GraphResourceKind.MODEL,
+                upstream_keys=(),
+                local_hash="local_b",
+            ),
+        },
+        execution_order=(MODEL_B, MODEL_A),
+        selected_keys=frozenset({MODEL_A}),
+        base_identity_hashes={MODEL_B: "honest_b"},
+        expected_hashes={
+            MODEL_A: "local_a|model:b=honest_b",
+            MODEL_B: "honest_b",
+        },
+    ),
+    GraphIdentityWriteHashesTestCase(
+        description="composes a fully selected diamond from the shared root once",
+        nodes={
+            MODEL_A: GraphIdentityNode(
+                key=MODEL_A,
+                resource_kind=GraphResourceKind.MODEL,
+                upstream_keys=(),
+                local_hash="local_a",
+            ),
+            MODEL_B: GraphIdentityNode(
+                key=MODEL_B,
+                resource_kind=GraphResourceKind.MODEL,
+                upstream_keys=(MODEL_A,),
+                local_hash="local_b",
+            ),
+            MODEL_C: GraphIdentityNode(
+                key=MODEL_C,
+                resource_kind=GraphResourceKind.MODEL,
+                upstream_keys=(MODEL_A,),
+                local_hash="local_c",
+            ),
+            MODEL_D: GraphIdentityNode(
+                key=MODEL_D,
+                resource_kind=GraphResourceKind.MODEL,
+                upstream_keys=(MODEL_B, MODEL_C),
+                local_hash="local_d",
+            ),
+        },
+        execution_order=(MODEL_A, MODEL_B, MODEL_C, MODEL_D),
+        selected_keys=frozenset({MODEL_A, MODEL_B, MODEL_C, MODEL_D}),
+        base_identity_hashes={},
+        expected_hashes={
+            MODEL_A: "local_a",
+            MODEL_B: "local_b|model:a=local_a",
+            MODEL_C: "local_c|model:a=local_a",
+            MODEL_D: "local_d|model:b=local_b|model:a=local_a,model:c=local_c|model:a=local_a",
+        },
+    ),
+]
+
+
+@pytest.mark.parametrize(
+    "test_case",
+    WRITE_HASHES_TEST_CASES,
+    ids=[case.description for case in WRITE_HASHES_TEST_CASES],
+)
+def test_given_available_hashes_when_building_write_hashes_then_uses_caller_supplied_upstreams(
+    test_case: GraphIdentityWriteHashesTestCase,
+) -> None:
+    result: dict[GraphNodeKey, str] = build_graph_write_identity_hashes(
+        nodes=test_case.nodes,
+        execution_order=test_case.execution_order,
+        selected_keys=test_case.selected_keys,
+        base_identity_hashes=test_case.base_identity_hashes,
+        compose_identity=compose_readable_identity,
+    )
+
+    assert result == test_case.expected_hashes
+
+
+@pytest.mark.parametrize(
+    "test_case",
+    [
+        GraphIdentityWritePerfTestCase(
+            description="fully selected densely connected graph resolves without path blowup",
+            layer_count=400,
+            expected_max_seconds=5.0,
+        )
+    ],
+    ids=["fully selected densely connected graph resolves without path blowup"],
+)
+def test_given_fully_selected_dense_graph_when_building_write_hashes_then_stays_linear(
+    test_case: GraphIdentityWritePerfTestCase,
+) -> None:
+    nodes: dict[GraphNodeKey, GraphIdentityNode]
+    execution_order: tuple[GraphNodeKey, ...]
+    nodes, execution_order = build_diamond_ladder_identity_nodes(layer_count=test_case.layer_count)
+
+    start: float = time.monotonic()
+    result: dict[GraphNodeKey, str] = build_graph_write_identity_hashes(
+        nodes=nodes,
+        execution_order=execution_order,
+        selected_keys=frozenset(nodes.keys()),
+        base_identity_hashes={},
+        compose_identity=compose_hashed_identity,
+    )
+    elapsed: float = time.monotonic() - start
+
+    assert len(result) == len(nodes)
+    assert elapsed < test_case.expected_max_seconds

{sqlbuild-0.41.0 → sqlbuild-0.41.1}/uv.lock

@@ -4098,7 +4098,7 @@ wheels = [
 
 [[package]]
 name = "sqlbuild"
-version = "0.38.0"
+version = "0.40.1"
 source = { editable = "." }
 dependencies = [
     { name = "duckdb" },

sqlbuild-0.41.0/.release-please-manifest.json

@@ -1,3 +0,0 @@
-{
-  ".": "0.41.0"
-}

sqlbuild-0.41.0/tests/unit/src/sqlbuild/compiler/planner/helpers/test_graph_identity.py

@@ -1,112 +0,0 @@
-from __future__ import annotations
-
-import pytest
-
-from sqlbuild.compiler.planner.main.graph_identity import (
-    build_expected_graph_identity_hashes,
-)
-from sqlbuild.compiler.planner.main.graph_write_identity import build_graph_write_identity_hashes
-from sqlbuild.compiler.planner.models import GraphIdentityNode, GraphNodeKey
-from sqlbuild.compiler.planner.types import GraphResourceKind
-from tests.unit.src.sqlbuild.compiler.planner.helpers._test_types import (
-    GraphIdentityExpectedHashesTestCase,
-    GraphIdentityWriteHashesTestCase,
-)
-from tests.unit.src.sqlbuild.compiler.planner.helpers.helpers import compose_readable_identity
-
-MODEL_A: GraphNodeKey = GraphNodeKey(node_type="model", node_name="a")
-MODEL_B: GraphNodeKey = GraphNodeKey(node_type="model", node_name="b")
-MODEL_C: GraphNodeKey = GraphNodeKey(node_type="model", node_name="c")
-
-
-@pytest.mark.parametrize(
-    "test_case",
-    [
-        GraphIdentityExpectedHashesTestCase(
-            description=(
-                "uses dependency order and named upstream keys while preserving missing nodes"
-            ),
-            nodes={
-                MODEL_A: GraphIdentityNode(
-                    key=MODEL_A,
-                    resource_kind=GraphResourceKind.MODEL,
-                    upstream_keys=(MODEL_B, MODEL_C),
-                    local_hash="local_a",
-                ),
-                MODEL_B: GraphIdentityNode(
-                    key=MODEL_B,
-                    resource_kind=GraphResourceKind.MODEL,
-                    upstream_keys=(),
-                    local_hash="local_b",
-                ),
-                MODEL_C: GraphIdentityNode(
-                    key=MODEL_C,
-                    resource_kind=GraphResourceKind.MODEL,
-                    upstream_keys=(),
-                    local_hash=None,
-                ),
-            },
-            execution_order=(MODEL_B, MODEL_C, MODEL_A),
-            expected_hashes={
-                MODEL_A: "local_a|model:b=local_b",
-                MODEL_B: "local_b",
-                MODEL_C: None,
-            },
-        )
-    ],
-    ids=["uses dependency order and named upstream keys while preserving missing nodes"],
-)
-def test_given_identity_graph_when_building_expected_hashes_then_resolves_from_upstreams(
-    test_case: GraphIdentityExpectedHashesTestCase,
-) -> None:
-    result: dict[GraphNodeKey, str | None] = build_expected_graph_identity_hashes(
-        nodes=test_case.nodes,
-        execution_order=test_case.execution_order,
-        compose_identity=compose_readable_identity,
-    )
-
-    assert result == test_case.expected_hashes
-
-
-@pytest.mark.parametrize(
-    "test_case",
-    [
-        GraphIdentityWriteHashesTestCase(
-            description="recomputes selected child from caller supplied parent write hash",
-            nodes={
-                MODEL_A: GraphIdentityNode(
-                    key=MODEL_A,
-                    resource_kind=GraphResourceKind.MODEL,
-                    upstream_keys=(MODEL_B,),
-                    local_hash="local_a",
-                ),
-                MODEL_B: GraphIdentityNode(
-                    key=MODEL_B,
-                    resource_kind=GraphResourceKind.MODEL,
-                    upstream_keys=(),
-                    local_hash="local_b",
-                ),
-            },
-            execution_order=(MODEL_B, MODEL_A),
-            selected_keys=frozenset({MODEL_A}),
-            base_identity_hashes={MODEL_B: "honest_b"},
-            expected_hashes={
-                MODEL_A: "local_a|model:b=honest_b",
-                MODEL_B: "honest_b",
-            },
-        )
-    ],
-    ids=["recomputes selected child from caller supplied parent write hash"],
-)
-def test_given_available_hashes_when_building_write_hashes_then_uses_caller_supplied_upstreams(
-    test_case: GraphIdentityWriteHashesTestCase,
-) -> None:
-    result: dict[GraphNodeKey, str] = build_graph_write_identity_hashes(
-        nodes=test_case.nodes,
-        execution_order=test_case.execution_order,
-        selected_keys=test_case.selected_keys,
-        base_identity_hashes=test_case.base_identity_hashes,
-        compose_identity=compose_readable_identity,
-    )
-
-    assert result == test_case.expected_hashes