sqlbuild 0.37.1__tar.gz → 0.37.2__tar.gz

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

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

{sqlbuild-0.37.1 → sqlbuild-0.37.2}/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.37.2](https://github.com/chio-labs/sqlbuild/compare/v0.37.1...v0.37.2) (2026-06-22)
+
+
+### Bug Fixes
+
+* **executor:** preflight schemas before concurrent builds ([591401b](https://github.com/chio-labs/sqlbuild/commit/591401b96e40abe7ae838eff458c6ca3046b5123))
+* **executor:** preflight schemas before concurrent builds ([58c5cce](https://github.com/chio-labs/sqlbuild/commit/58c5ccefa55f1686bcbd51241bf2d6b6b3f3ac09))
+
 ## [0.37.1](https://github.com/chio-labs/sqlbuild/compare/v0.37.0...v0.37.1) (2026-06-21)
 
 

{sqlbuild-0.37.1 → sqlbuild-0.37.2}/Makefile

@@ -27,6 +27,13 @@ test-e2e-duckdb:
 	uv run pytest tests/e2e -m "performance and not real_warehouse and not dbt" -vv
 
 
+test-virtual:
+	TESTCONTAINERS_RYUK_DISABLED=true SQLBUILD_CONCURRENCY=$(SQLBUILD_CONCURRENCY) uv run pytest \
+		$(VIRTUAL_TEST_ROOTS) \
+		-k "$(VIRTUAL_TEST_KEYWORD)" \
+		-m "not dbt and not performance" -vv -n auto --dist loadfile
+
+
 skills:
 	uv run sqb skills update --global --target opencode
 	uv run python -m scripts.skills.update_structure_skill
@@ -38,12 +45,21 @@ skills:
 DBT_EXECUTABLE ?= dbt
 export DBT_EXECUTABLE
 
+# Default per-project SQLBuild execution concurrency for verify runs. Override with
+# `make verify SQLBUILD_CONCURRENCY=8` or by exporting SQLBUILD_CONCURRENCY.
+SQLBUILD_CONCURRENCY ?= 8
+
+# Virtual-environment focused test selection. Override roots/keyword to zoom in,
+# e.g. `make test-virtual VIRTUAL_TEST_ROOTS=tests/e2e/src/sqlbuild/cli/commands/main/build`.
+VIRTUAL_TEST_ROOTS ?= tests/e2e/src/sqlbuild/cli/commands/main tests/e2e/src/sqlbuild/integrations/dagster
+VIRTUAL_TEST_KEYWORD ?= virtual or reconcile or diff or janitor or snapshot or dagster
+
 
 test-dbt:
 	@mkdir -p /tmp/opencode
 	@log=/tmp/opencode/test-dbt-$$(date +%Y%m%d-%H%M%S).log; \
 	echo "Logging to $$log (DBT_EXECUTABLE=$(DBT_EXECUTABLE))"; \
-	uv run pytest tests/integration/src/sqlbuild/integrations/dbt tests/e2e/src/sqlbuild/cli/commands/main/dbt -m "dbt and not real_warehouse" -vv --color=yes 2>&1 | tee "$$log"; \
+	uv run pytest tests/integration/src/sqlbuild/integrations/dbt tests/e2e/src/sqlbuild/cli/commands/main/dbt -m "dbt and not real_warehouse" -vv --color=yes -n auto --dist load 2>&1 | tee "$$log"; \
 	status=$${PIPESTATUS[0]}; \
 	echo "Full output saved to $$log"; \
 	exit $$status
@@ -53,31 +69,31 @@ DBT_TEST_PATHS := tests/integration/src/sqlbuild/integrations/dbt tests/e2e/src/
 
 
 test-dbt-real:
-	uv run pytest $(DBT_TEST_PATHS) -m "dbt and real_warehouse" -vv
+	uv run pytest $(DBT_TEST_PATHS) -m "dbt and real_warehouse" -vv -n auto --dist load
 
 
 test-dbt-real-snowflake:
-	uv run pytest $(DBT_TEST_PATHS) -m "dbt and real_warehouse and snowflake" -vv
+	uv run pytest $(DBT_TEST_PATHS) -m "dbt and real_warehouse and snowflake" -vv -n auto --dist load
 
 
 test-dbt-real-bigquery:
-	uv run pytest $(DBT_TEST_PATHS) -m "dbt and real_warehouse and bigquery" -vv
+	uv run pytest $(DBT_TEST_PATHS) -m "dbt and real_warehouse and bigquery" -vv -n auto --dist load
 
 
 test-dbt-real-databricks:
-	uv run pytest $(DBT_TEST_PATHS) -m "dbt and real_warehouse and databricks" -vv
+	uv run pytest $(DBT_TEST_PATHS) -m "dbt and real_warehouse and databricks" -vv -n auto --dist load
 
 
 test-dbt-real-postgres:
-	TESTCONTAINERS_RYUK_DISABLED=true uv run pytest $(DBT_TEST_PATHS) -m "dbt and real_warehouse and postgres" -vv
+	TESTCONTAINERS_RYUK_DISABLED=true uv run pytest $(DBT_TEST_PATHS) -m "dbt and real_warehouse and postgres" -vv -n auto --dist load
 
 
 test-dbt-real-sqlserver:
-	uv run pytest $(DBT_TEST_PATHS) -m "dbt and real_warehouse and sqlserver" -vv
+	uv run pytest $(DBT_TEST_PATHS) -m "dbt and real_warehouse and sqlserver" -vv -n auto --dist load
 
 
 test-dbt-real-motherduck:
-	uv run pytest $(DBT_TEST_PATHS) -m "dbt and real_warehouse and motherduck" -vv
+	uv run pytest $(DBT_TEST_PATHS) -m "dbt and real_warehouse and motherduck" -vv -n auto --dist load
 
 
 waffle-shop:
@@ -104,7 +120,7 @@ test-real-databricks:
 
 
 test-real-postgres:
-	TESTCONTAINERS_RYUK_DISABLED=true uv run pytest tests -m "real_warehouse and postgres" -vv
+	TESTCONTAINERS_RYUK_DISABLED=true uv run pytest tests -m "real_warehouse and postgres" -vv -n auto --dist load
 
 
 test-real-sqlserver:
@@ -169,10 +185,8 @@ verify:
 		run_verify_step "ruff format" uv run ruff format .; \
 		run_verify_step "ruff check" uv run ruff check --fix .; \
 		run_verify_step "type check" uv run ty check src tests; \
-		run_verify_step "e2e tests" env PYTHONUNBUFFERED=1 uv run pytest tests/e2e -m "not real_warehouse and not dbt and not performance" -vv --color=yes -n auto --dist loadfile; \
-		run_verify_step "performance e2e tests" env PYTHONUNBUFFERED=1 uv run pytest tests/e2e -m "performance and not real_warehouse and not dbt" -vv --color=yes; \
-		run_verify_step "integration tests" env PYTHONUNBUFFERED=1 uv run pytest tests/integration -m "not real_warehouse and not dbt" -vv --color=yes; \
-		run_verify_step "unit tests" env PYTHONUNBUFFERED=1 uv run pytest tests/unit -m "not real_warehouse and not dbt" -vv --color=yes; \
+		run_verify_step "tests" env PYTHONUNBUFFERED=1 TESTCONTAINERS_RYUK_DISABLED=true SQLBUILD_CONCURRENCY=$(SQLBUILD_CONCURRENCY) uv run pytest tests/unit tests/integration tests/e2e -m "((not real_warehouse and not dbt) or (dbt and not real_warehouse) or (real_warehouse and postgres)) and not performance" -vv --color=yes -n auto --dist loadfile; \
+		run_verify_step "performance tests" env PYTHONUNBUFFERED=1 SQLBUILD_CONCURRENCY=$(SQLBUILD_CONCURRENCY) uv run pytest tests/e2e -m "performance and not real_warehouse and not dbt" -vv --color=yes; \
 		run_verify_step "test conventions" uv run check-test-conventions tests; \
 		run_verify_step "structure conventions" uv run check-structure-conventions src/sqlbuild scripts; \
 		run_verify_step "type annotation conventions" uv run check-type-annotation-conventions src tests; \

{sqlbuild-0.37.1 → sqlbuild-0.37.2}/PKG-INFO

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

{sqlbuild-0.37.1 → sqlbuild-0.37.2}/pyproject.toml

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

{sqlbuild-0.37.1 → sqlbuild-0.37.2}/src/sqlbuild/cli/commands/main/entry.py

@@ -30,6 +30,7 @@ from sqlbuild.cli.commands.main.shared.helpers.parsers import (
     add_select_args,
     add_vars_args,
     read_selector_files,
+    resolve_env_default_concurrency,
 )
 from sqlbuild.cli.commands.main.shared.types import CliCommand
 from sqlbuild.compiler.discovery.constants import PROJECT_CONFIG_FILENAME
@@ -609,6 +610,11 @@ def _main_with_dependencies(
             args.dbt_args = unknown_args
         elif unknown_args:
             parser.error(f"unrecognized arguments: {' '.join(unknown_args)}")
+        if args.command in {CliCommand.BUILD, CliCommand.LOAD, CliCommand.SEED}:
+            try:
+                args.concurrency = resolve_env_default_concurrency(args.concurrency)
+            except argparse.ArgumentTypeError as error:
+                parser.error(str(error))
     except SystemExit as error:
         if isinstance(error.code, int):
             return error.code

sqlbuild-0.37.2/src/sqlbuild/cli/commands/main/shared/constants.py

@@ -0,0 +1,3 @@
+"""Shared CLI command constants."""
+
+SQLBUILD_CONCURRENCY_ENV_VAR: str = "SQLBUILD_CONCURRENCY"

{sqlbuild-0.37.1 → sqlbuild-0.37.2}/src/sqlbuild/cli/commands/main/shared/helpers/parsers.py

@@ -4,11 +4,14 @@ from __future__ import annotations
 
 import argparse
 import json
+import os
 from datetime import datetime
 from decimal import Decimal
 from pathlib import Path
 from typing import Any
 
+from sqlbuild.cli.commands.main.shared.constants import SQLBUILD_CONCURRENCY_ENV_VAR
+
 
 def parse_cli_vars(value: str) -> dict[str, object]:
     """Parse SQLBuild CLI project vars from a JSON object."""
@@ -29,6 +32,25 @@ def parse_cli_vars(value: str) -> dict[str, object]:
     return result
 
 
+def resolve_env_default_concurrency(explicit_concurrency: int | None) -> int | None:
+    """Return CLI concurrency, falling back to SQLBUILD_CONCURRENCY when unset."""
+
+    if explicit_concurrency is not None:
+        return explicit_concurrency
+    raw_value: str | None = os.environ.get(SQLBUILD_CONCURRENCY_ENV_VAR)
+    if raw_value is None or raw_value == "":
+        return None
+    try:
+        concurrency: int = int(raw_value)
+    except ValueError as error:
+        raise argparse.ArgumentTypeError(
+            f"{SQLBUILD_CONCURRENCY_ENV_VAR} must be an integer"
+        ) from error
+    if concurrency < 1:
+        raise argparse.ArgumentTypeError(f"{SQLBUILD_CONCURRENCY_ENV_VAR} must be >= 1")
+    return concurrency
+
+
 def parse_cursor_timestamp(value: str | None) -> datetime | None:
     if value is None:
         return None

{sqlbuild-0.37.1 → sqlbuild-0.37.2}/src/sqlbuild/executor/pipeline/main/run.py

@@ -10,6 +10,7 @@ from pathlib import Path
 from typing import Any
 
 from sqlbuild.adapter.base.base_adapter import BaseAdapter
+from sqlbuild.adapter.shared.models import StatementRecorder
 from sqlbuild.adapter.shared.types import TablePromotionMode
 from sqlbuild.compiler.compile.models.core import CompiledObjectKey
 from sqlbuild.compiler.discovery.models import DiscoveredLoaderFunction
@@ -47,6 +48,7 @@ from sqlbuild.executor.python_nodes.types import PythonIdentityRecorder
 from sqlbuild.provider.main.runtime import ProviderContainer
 from sqlbuild.shared.types import ExecutionResourceKind
 from sqlbuild.spec.models.project import SettingsConfig, SnapshotsConfig
+from sqlbuild.spec.models.source import SourceEntry
 
 
 def run_build_pipeline(
@@ -119,6 +121,11 @@ def run_build_pipeline(
             providers=providers,
         )
     )
+    _prepare_build_schemas(
+        plan=plan,
+        adapter=adapter,
+        connection_config=connection_config,
+    )
     worker_connections: list[Any] = []
     scheduler_connection: Any | None = None
     if on_connection_start is not None:
@@ -194,3 +201,34 @@ def run_build_pipeline(
         logger.debug("close scheduler connection")
         if scheduler_connection is not None:
             adapter.close(scheduler_connection)
+
+
+def _prepare_build_schemas(
+    *,
+    plan: PlanOutput,
+    adapter: BaseAdapter,
+    connection_config: dict[str, object],
+) -> None:
+    schemas: set[tuple[str | None, str]] = set()
+    for entry in (*plan.model_entries, *plan.seed_entries, *plan.function_entries):
+        if entry.destination.schema is not None:
+            schemas.add((entry.destination.database, entry.destination.schema))
+    for entry in plan.source_load_entries:
+        source_entry: SourceEntry | None = plan.source_map.get(entry.name)
+        if source_entry is not None and source_entry.schema is not None:
+            schemas.add((source_entry.database, source_entry.schema))
+    if not schemas:
+        return
+
+    connection: Any = adapter.connect(connection_config)
+    recorder: StatementRecorder = StatementRecorder()
+    try:
+        for database, schema in sorted(schemas, key=lambda item: (item[0] or "", item[1])):
+            adapter.ensure_schema(
+                connection,
+                database=database,
+                schema=schema,
+                statement_recorder=recorder,
+            )
+    finally:
+        adapter.close(connection)

{sqlbuild-0.37.1 → sqlbuild-0.37.2}/src/sqlbuild/virtual/executor/helpers/build.py

@@ -605,6 +605,11 @@ def run_virtual_build(
             status=BuildStatus.FAILED, load_results=ingress_load_results
         )
     else:
+        _prepare_virtual_physical_schemas(
+            adapter=adapter,
+            connection_config=connection_config,
+            plan_output=executor_plan_output,
+        )
         result = run_build_pipeline(
             plan=executor_plan_output,
             connection_config=connection_config,
@@ -890,6 +895,33 @@ def _load_result_key(*, plan: PlanOutput, result: LoadExecutionResult) -> Compil
     )
 
 
+def _prepare_virtual_physical_schemas(
+    *,
+    adapter: BaseAdapter,
+    connection_config: dict[str, object],
+    plan_output: PlanOutput,
+) -> None:
+    schemas: set[tuple[str | None, str]] = set()
+    for entry in (*plan_output.model_entries, *plan_output.seed_entries):
+        if entry.destination.schema is not None:
+            schemas.add((entry.destination.database, entry.destination.schema))
+    if not schemas:
+        return
+
+    connection: Any = adapter.connect(connection_config)
+    recorder: StatementRecorder = StatementRecorder()
+    try:
+        for database, schema in sorted(schemas, key=lambda item: (item[0] or "", item[1])):
+            adapter.ensure_schema(
+                connection,
+                database=database,
+                schema=schema,
+                statement_recorder=recorder,
+            )
+    finally:
+        adapter.close(connection)
+
+
 def _prepare_custom_virtual_version(
     *,
     adapter: BaseAdapter,

{sqlbuild-0.37.1 → sqlbuild-0.37.2}/tests/e2e/src/sqlbuild/cli/commands/main/bigquery/helpers.py

@@ -115,6 +115,7 @@ def assert_bigquery_seeded_reuse_case(
             f"{relation_name(dataset_name=dev_dataset_name, name='downstream_orders')} "
             "ORDER BY order_id"
         )
+        raw_orders_relation: str = relation_name(dataset_name=dev_dataset_name, name="raw_orders")
         if snapshot:
             assert_dbt_snapshot_seeded_reuse_from_lifecycle(
                 tmp_path=tmp_path,
@@ -123,6 +124,10 @@ def assert_bigquery_seeded_reuse_case(
                 origin_snapshot_schema=prod_dataset_name,
                 destination_snapshot_schema=dev_dataset_name,
                 fetch_rows=lambda sql: fetch_bigquery_rows(dataset_name=dev_dataset_name, sql=sql),
+                execute_sql=lambda sql: execute_bigquery_sql(
+                    dataset_name=dev_dataset_name, sql=sql
+                ),
+                raw_orders_relation=raw_orders_relation,
                 destination_rows_sql=destination_rows_sql,
                 downstream_rows_sql=downstream_rows_sql,
                 expected_rows=expected_rows,
@@ -133,6 +138,10 @@ def assert_bigquery_seeded_reuse_case(
                 profiles_yml=profiles_yml,
                 project_toml=project_toml,
                 fetch_rows=lambda sql: fetch_bigquery_rows(dataset_name=dev_dataset_name, sql=sql),
+                execute_sql=lambda sql: execute_bigquery_sql(
+                    dataset_name=dev_dataset_name, sql=sql
+                ),
+                raw_orders_relation=raw_orders_relation,
                 destination_rows_sql=destination_rows_sql,
                 downstream_rows_sql=downstream_rows_sql,
                 expected_rows=expected_rows,

{sqlbuild-0.37.1 → sqlbuild-0.37.2}/tests/e2e/src/sqlbuild/cli/commands/main/build/_test_types.py

@@ -236,6 +236,16 @@ class VirtualBuildE2ETestCase:
     expected_final_plan_fragments: tuple[str, ...] = field(default_factory=tuple)
 
 
+@dataclass(frozen=True)
+class VirtualConcurrentBuildE2ETestCase:
+    """Test case for concurrent virtual build e2e behavior."""
+
+    description: str
+    concurrency: int
+    expected_model_count: int
+    expected_build_fragments: tuple[str, ...]
+
+
 @dataclass(frozen=True)
 class VirtualSeedBuildE2ETestCase:
     """Test case for virtual seed build state behavior."""

{sqlbuild-0.37.1 → sqlbuild-0.37.2}/tests/e2e/src/sqlbuild/cli/commands/main/build/helpers.py

@@ -64,6 +64,18 @@ def prepare_dependency_baseline_project(
     return project_dir
 
 
+def build_virtual_wide_dag_repo_files(*, model_count: int) -> dict[str, str]:
+    repo_files: dict[str, str] = {
+        "sqlbuild_project.toml": build_virtual_plan_project_toml(),
+    }
+    for index in range(1, model_count + 1):
+        model_name: str = f"model_{index:02d}"
+        repo_files[f"models/{model_name}.sql"] = (
+            f"MODEL (materialized table);\n\nSELECT {index} AS id, '{model_name}' AS model_name\n"
+        )
+    return repo_files
+
+
 def table_upstream_model_sql(*, amount: int = 100) -> str:
     return f"MODEL (materialized table);\n\nSELECT id, {amount} AS amount FROM main.raw_orders\n"
 

{sqlbuild-0.37.1 → sqlbuild-0.37.2}/tests/e2e/src/sqlbuild/cli/commands/main/build/test_lifecycle_commands.py

@@ -46,7 +46,7 @@ from tests.e2e.src.sqlbuild.cli.commands.main.shared.helpers import (
                 "Plan ready (full refresh, 17 selected, 2 sources to load)"
             ),
             expected_plan_ordered_fragments=(
-                "Connecting to duckdb...",
+                "Connecting to duckdb",
                 "Connected to duckdb. (<time>)",
                 "Inspecting warehouse state...",
                 "Generated plan. (<time>)",
@@ -57,16 +57,16 @@ from tests.e2e.src.sqlbuild.cli.commands.main.shared.helpers import (
                 "Seeds (1)",
             ),
             expected_build_ordered_fragments=(
-                "Connecting to duckdb...",
+                "Connecting to duckdb",
                 "Connected to duckdb. (<time>)",
                 "Inspecting warehouse state...",
                 "Generated plan. (<time>)",
                 "Plan ready (17 selected, 2 sources to load)",
                 "Sources to load (2)",
-                "Execution  sqb build  (concurrency: 1)",
+                "Execution  sqb build  (concurrency:",
                 "source    raw_customers",
                 "source    raw_orders",
-                "Connecting to duckdb...",
+                "Connecting to duckdb",
                 "Connected to duckdb. (<time>)",
                 "udf       is_completed_order",
                 "Completed successfully.",

{sqlbuild-0.37.1 → sqlbuild-0.37.2}/tests/e2e/src/sqlbuild/cli/commands/main/build/test_python_hooks.py

@@ -446,6 +446,8 @@ def test_given_python_hooks_lifecycle_matrix_when_building_then_all_materializat
                 CREATE TABLE raw_customers AS
                 SELECT 1 AS customer_id, 'basic' AS plan,
                   TIMESTAMP '2026-01-01 00:00:00' AS updated_at;
+
+                CREATE TABLE hook_log (model_name VARCHAR, phase VARCHAR);
                 """
             ).strip()
             + "\n",
@@ -468,10 +470,6 @@ def test_given_python_hooks_lifecycle_matrix_when_building_then_all_materializat
 
                 @hook
                 def log_hook(ctx):
-                    ctx.execute_sql(
-                        f"CREATE TABLE IF NOT EXISTS {ctx.destination.schema}.hook_log "
-                        "(model_name VARCHAR, phase VARCHAR)"
-                    )
                     ctx.execute_sql(
                         f"INSERT INTO {ctx.destination.schema}.hook_log VALUES "
                         f"('{ctx.model_name}', '{ctx.phase}')"
@@ -620,7 +618,7 @@ def test_given_python_hooks_lifecycle_matrix_when_building_then_all_materializat
     )
 
     result: subprocess.CompletedProcess[str] = run_sqb(
-        command=("--no-color", "build"),
+        command=("--no-color", "build", "--concurrency", "4"),
         project_dir=project_dir,
     )
 

{sqlbuild-0.37.1 → sqlbuild-0.37.2}/tests/e2e/src/sqlbuild/cli/commands/main/build/test_virtual_build.py

@@ -11,6 +11,7 @@ import pytest
 from tests.e2e.src.sqlbuild.cli.commands.main.build._test_types import (
     VirtualBuildE2ETestCase,
     VirtualBuildSelectionGuardE2ETestCase,
+    VirtualConcurrentBuildE2ETestCase,
     VirtualCustomMaterializationE2ETestCase,
     VirtualExplicitCheckpointRollbackE2ETestCase,
     VirtualNodeResultFailureStateE2ETestCase,
@@ -29,6 +30,7 @@ from tests.e2e.src.sqlbuild.cli.commands.main.build._test_types import (
 from tests.e2e.src.sqlbuild.cli.commands.main.build.helpers import (
     build_virtual_multi_seed_lifecycle_repo_files,
     build_virtual_seed_lifecycle_repo_files,
+    build_virtual_wide_dag_repo_files,
     count_virtual_physical_versions,
     initialize_virtual_seeded_project,
     prepare_virtual_cursor_override_without_snapshot_project,
@@ -50,6 +52,60 @@ from tests.e2e.src.sqlbuild.cli.commands.main.shared.helpers import (
 )
 
 
+@pytest.mark.parametrize(
+    "test_case",
+    [
+        VirtualConcurrentBuildE2ETestCase(
+            description="wide virtual DAG builds with concurrent physical schema setup",
+            concurrency=8,
+            expected_model_count=8,
+            expected_build_fragments=("Execution  sqb build  (concurrency: 8)",),
+        )
+    ],
+    ids=["wide virtual DAG builds with concurrent physical schema setup"],
+)
+def test_given_wide_virtual_dag_when_building_concurrently_then_physical_schema_setup_is_safe(
+    test_case: VirtualConcurrentBuildE2ETestCase,
+    tmp_path: Path,
+) -> None:
+    project_dir: Path = prepare_inline_project(
+        tmp_path=tmp_path,
+        project_name="virtual_concurrent_schema_setup",
+        repo_files=build_virtual_wide_dag_repo_files(
+            model_count=test_case.expected_model_count,
+        ),
+    )
+    init_result: subprocess.CompletedProcess[str] = run_sqb(
+        command=("state", "init"),
+        project_dir=project_dir,
+    )
+    assert init_result.returncode == 0, init_result.stderr
+
+    build_result: subprocess.CompletedProcess[str] = run_sqb(
+        command=("--no-color", "build", "--concurrency", str(test_case.concurrency)),
+        project_dir=project_dir,
+    )
+
+    assert build_result.returncode == 0, build_result.stdout + build_result.stderr
+    fragment: str
+    for fragment in test_case.expected_build_fragments:
+        assert fragment in build_result.stdout
+    physical_rows: list[tuple[object, ...]] = query_duckdb(
+        db_path=project_dir / "warehouse.duckdb",
+        sql=(
+            "SELECT table_name FROM information_schema.tables "
+            "WHERE table_schema = 'dev__sqb_physical' AND table_name LIKE '%__v_%' "
+            "ORDER BY table_name"
+        ),
+    )
+    assert len(physical_rows) == test_case.expected_model_count
+    logical_rows: list[tuple[object, ...]] = query_duckdb(
+        db_path=project_dir / "warehouse.duckdb",
+        sql="SELECT id, model_name FROM dev__dev.model_08",
+    )
+    assert logical_rows == [(8, "model_08")]
+
+
 @pytest.mark.parametrize(
     "test_case",
     [

{sqlbuild-0.37.1 → sqlbuild-0.37.2}/tests/e2e/src/sqlbuild/cli/commands/main/databricks/helpers.py

@@ -122,6 +122,7 @@ def assert_databricks_seeded_reuse_case(
             f"{relation_name(schema_name=dev_schema_name, name='downstream_orders')} "
             "ORDER BY order_id"
         )
+        raw_orders_relation: str = relation_name(schema_name=dev_schema_name, name="raw_orders")
         if snapshot:
             assert_dbt_snapshot_seeded_reuse_from_lifecycle(
                 tmp_path=tmp_path,
@@ -130,6 +131,10 @@ def assert_databricks_seeded_reuse_case(
                 origin_snapshot_schema=prod_schema_name,
                 destination_snapshot_schema=dev_schema_name,
                 fetch_rows=lambda sql: fetch_databricks_rows(schema_name=dev_schema_name, sql=sql),
+                execute_sql=lambda sql: execute_databricks_sql(
+                    schema_name=dev_schema_name, sql=sql
+                ),
+                raw_orders_relation=raw_orders_relation,
                 destination_rows_sql=destination_rows_sql,
                 downstream_rows_sql=downstream_rows_sql,
                 expected_rows=expected_rows,
@@ -140,6 +145,10 @@ def assert_databricks_seeded_reuse_case(
                 profiles_yml=profiles_yml,
                 project_toml=project_toml,
                 fetch_rows=lambda sql: fetch_databricks_rows(schema_name=dev_schema_name, sql=sql),
+                execute_sql=lambda sql: execute_databricks_sql(
+                    schema_name=dev_schema_name, sql=sql
+                ),
+                raw_orders_relation=raw_orders_relation,
                 destination_rows_sql=destination_rows_sql,
                 downstream_rows_sql=downstream_rows_sql,
                 expected_rows=expected_rows,

{sqlbuild-0.37.1 → sqlbuild-0.37.2}/tests/e2e/src/sqlbuild/cli/commands/main/postgres/helpers.py

@@ -2,10 +2,14 @@
 
 from __future__ import annotations
 
+import subprocess
+import sys
 import uuid
 from pathlib import Path
 from typing import Any
 
+import pytest
+
 from sqlbuild.adapters.postgres.client import PostgresAdapter
 from tests.e2e.src.sqlbuild.cli.commands.main.shared.helpers import (
     assert_dbt_seeded_reuse_from_lifecycle,
@@ -21,6 +25,40 @@ def build_unique_schema_name(*, prefix: str) -> str:
     return f"{prefix}_{suffix}"
 
 
+def postgres_dbt_core_executable() -> str:
+    """Return a dbt-core executable for Postgres dbt tests, skipping otherwise.
+
+    dbt Fusion does not support the Postgres adapter, so these tests must pin to
+    the dbt-core CLI installed in the project virtual environment rather than
+    honoring any DBT_EXECUTABLE override that may point at Fusion.
+    """
+
+    candidate: Path = Path(sys.prefix) / "bin" / "dbt"
+    if not candidate.exists():
+        pytest.skip("dbt-core CLI is not installed in the project virtual environment")
+    result: subprocess.CompletedProcess[str] = subprocess.run(
+        (str(candidate), "--version"),
+        capture_output=True,
+        check=False,
+        text=True,
+    )
+    output: str = result.stdout + result.stderr
+    if result.returncode != 0:
+        pytest.skip(f"dbt-core CLI is not runnable: {output}")
+    if "fusion" in output.lower():
+        pytest.skip("project virtual environment dbt resolves to Fusion, which lacks Postgres")
+    return str(candidate)
+
+
+def postgres_dbt_env(*, password: str) -> dict[str, str]:
+    """Return the subprocess env for Postgres dbt tests pinned to dbt-core."""
+
+    return {
+        "DBT_POSTGRES_PASSWORD": password,
+        "DBT_EXECUTABLE": postgres_dbt_core_executable(),
+    }
+
+
 def build_postgres_project_toml(
     *,
     project_name: str,
@@ -80,7 +118,7 @@ def assert_postgres_seeded_reuse_case(
     schema_base: str = build_unique_schema_name(prefix=schema_prefix)
     dev_schema_name: str = f"{schema_base}_dev"
     prod_schema_name: str = f"{schema_base}_prod"
-    env: dict[str, str] = {"DBT_POSTGRES_PASSWORD": str(postgres_e2e_config["password"])}
+    env: dict[str, str] = postgres_dbt_env(password=str(postgres_e2e_config["password"]))
     try:
         ensure_postgres_schema_ready(schema_name=dev_schema_name, config=postgres_e2e_config)
         ensure_postgres_schema_ready(schema_name=prod_schema_name, config=postgres_e2e_config)
@@ -105,6 +143,7 @@ def assert_postgres_seeded_reuse_case(
             f"{relation_name(schema_name=dev_schema_name, name='downstream_orders')} "
             "ORDER BY order_id"
         )
+        raw_orders_relation: str = relation_name(schema_name=dev_schema_name, name="raw_orders")
         if snapshot:
             assert_dbt_snapshot_seeded_reuse_from_lifecycle(
                 tmp_path=tmp_path,
@@ -113,6 +152,8 @@ def assert_postgres_seeded_reuse_case(
                 origin_snapshot_schema=prod_schema_name,
                 destination_snapshot_schema=dev_schema_name,
                 fetch_rows=lambda sql: fetch_postgres_rows(config=postgres_e2e_config, sql=sql),
+                execute_sql=lambda sql: execute_postgres_sql(config=postgres_e2e_config, sql=sql),
+                raw_orders_relation=raw_orders_relation,
                 destination_rows_sql=destination_rows_sql,
                 downstream_rows_sql=downstream_rows_sql,
                 expected_rows=expected_rows,
@@ -124,6 +165,8 @@ def assert_postgres_seeded_reuse_case(
                 profiles_yml=profiles_yml,
                 project_toml=project_toml,
                 fetch_rows=lambda sql: fetch_postgres_rows(config=postgres_e2e_config, sql=sql),
+                execute_sql=lambda sql: execute_postgres_sql(config=postgres_e2e_config, sql=sql),
+                raw_orders_relation=raw_orders_relation,
                 destination_rows_sql=destination_rows_sql,
                 downstream_rows_sql=downstream_rows_sql,
                 expected_rows=expected_rows,

{sqlbuild-0.37.1 → sqlbuild-0.37.2}/tests/e2e/src/sqlbuild/cli/commands/main/postgres/test_postgres.py

@@ -38,6 +38,7 @@ from tests.e2e.src.sqlbuild.cli.commands.main.postgres.helpers import (
     ensure_postgres_schema_ready,
     execute_postgres_sql,
     fetch_postgres_rows,
+    postgres_dbt_env,
     prepare_postgres_source_loader_strategies,
     prepare_postgres_waffle_shop,
     relation_name,
@@ -169,7 +170,7 @@ def test_given_postgres_dbt_profile_when_running_dbt_init_then_plain_build_uses_
         ),
     )
     sqlbuild_project_dir: Path = workspace / "sqlbuild_project"
-    env: dict[str, str] = {"DBT_POSTGRES_PASSWORD": str(postgres_e2e_config["password"])}
+    env: dict[str, str] = postgres_dbt_env(password=str(postgres_e2e_config["password"]))
     try:
         init_result: subprocess.CompletedProcess[str] = run_sqb(
             command=(
@@ -307,7 +308,7 @@ def test_given_postgres_dbt_reuse_from_when_plain_build_then_reuses_prod_table(
     schema_base: str = build_unique_schema_name(prefix=test_case.schema_prefix)
     dev_schema_name: str = f"{schema_base}_dev"
     prod_schema_name: str = f"{schema_base}_prod"
-    env: dict[str, str] = {"DBT_POSTGRES_PASSWORD": str(postgres_e2e_config["password"])}
+    env: dict[str, str] = postgres_dbt_env(password=str(postgres_e2e_config["password"]))
     try:
         ensure_postgres_schema_ready(schema_name=dev_schema_name, config=postgres_e2e_config)
         ensure_postgres_schema_ready(schema_name=prod_schema_name, config=postgres_e2e_config)