sqlbuild 0.61.0__tar.gz → 0.62.0__tar.gz

{sqlbuild-0.61.0 → sqlbuild-0.62.0}/Cargo.lock

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

{sqlbuild-0.61.0 → sqlbuild-0.62.0}/PKG-INFO

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

{sqlbuild-0.61.0 → sqlbuild-0.62.0}/crates/sqlbuild-kata-native/Cargo.toml

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

{sqlbuild-0.61.0 → sqlbuild-0.62.0}/crates/sqlbuild-kata-native/src/models.rs

@@ -461,6 +461,24 @@ pub(crate) struct TestedResource {
     pub name: String,
 }
 
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub(crate) struct SqlTestParameterFact {
+    pub name: String,
+    #[serde(rename = "type")]
+    pub value_type: String,
+    pub nullable: bool,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+pub(crate) struct SqlTestParameterValueFact {
+    pub name: String,
+    #[serde(rename = "type")]
+    pub value_type: String,
+    pub value: serde_json::Value,
+}
+
 #[derive(Clone, Debug, Deserialize, Serialize)]
 #[serde(deny_unknown_fields)]
 pub(crate) struct SqlTestFact {
@@ -469,6 +487,18 @@ pub(crate) struct SqlTestFact {
     pub block_index: u64,
     pub name: String,
     pub explicit_name: Option<String>,
+    #[serde(default)]
+    pub parent_name: Option<String>,
+    #[serde(default)]
+    pub case_name: Option<String>,
+    #[serde(default)]
+    pub case_index: Option<u64>,
+    #[serde(default)]
+    pub case_fingerprint: Option<String>,
+    #[serde(default)]
+    pub parameter_schema: Vec<SqlTestParameterFact>,
+    #[serde(default)]
+    pub parameters: Vec<SqlTestParameterValueFact>,
     pub mode: SqlTestMode,
     pub expected_model_names: Vec<String>,
     pub assertion_names: Vec<String>,

{sqlbuild-0.61.0 → sqlbuild-0.62.0}/pyproject.toml

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

{sqlbuild-0.61.0 → sqlbuild-0.62.0}/src/sqlbuild/cli/commands/_helpers/compile/output.py

@@ -34,6 +34,7 @@ from sqlbuild.presentation.main.status_cell import format_status_cell
 from sqlbuild.presentation.main.surface_header import format_surface_header
 from sqlbuild.presentation.main.tree_connector import tree_connector
 from sqlbuild.spec.contracts.models import SourceLocation
+from sqlbuild.sql_values.types import SqlValueKind
 
 _HUMAN_MODEL_LIMIT: int = 100
 _MIN_MODEL_NAME_WIDTH: int = 24
@@ -314,11 +315,44 @@ def _test_resource(test: CompiledSqlTest) -> dict[str, object]:
     expected_models: list[str] = []
     if isinstance(test.payload, CompiledModelSqlTestPayload):
         expected_models = list(test.payload.expected_model_names)
-    return {
+    item: dict[str, object] = {
         "name": test.name,
         "relative_path": str(test.test_file.relative_path),
         "expected_models": expected_models,
     }
+    if test.case_name is not None:
+        parameter_types: dict[str, str] = {
+            parameter.name: parameter.value_type.value for parameter in test.parameter_schema
+        }
+        item.update(
+            {
+                "source_path": (test.source_path or test.test_file.relative_path).as_posix(),
+                "block_index": test.block_index,
+                "parent_name": test.parent_name,
+                "case_name": test.case_name,
+                "case_index": test.case_index,
+                "case_fingerprint": test.case_fingerprint,
+                "parameter_schema": [
+                    {
+                        "name": parameter.name,
+                        "type": parameter.value_type.value,
+                        "nullable": parameter.nullable,
+                    }
+                    for parameter in test.parameter_schema
+                ],
+                "parameters": [
+                    {
+                        "name": name,
+                        "type": parameter_types[name],
+                        "value": (
+                            str(value.value) if value.kind == SqlValueKind.DECIMAL else value.value
+                        ),
+                    }
+                    for name, value in test.parameter_values
+                ],
+            }
+        )
+    return item
 
 
 def _lineage_summary(

{sqlbuild-0.61.0 → sqlbuild-0.62.0}/src/sqlbuild/cli/commands/_helpers/compile/target_writer.py

@@ -223,9 +223,7 @@ def _write_tests(
 
     managed_paths: set[Path] = set()
     for entry in plan_output.test_entries:
-        test_path: Path = (
-            target_dir / _COMPILED_DIR / _TESTS_DIR / _test_folder(entry) / f"{entry.name}.sql"
-        )
+        test_path: Path = target_dir / _COMPILED_DIR / _TESTS_DIR / _test_output_path(entry)
         _write_sql(
             path=test_path,
             sql=build_sql_test_comparison_sql(
@@ -254,9 +252,7 @@ def _write_static_tests(
             adapter=adapter,
             sql_analysis_enabled=project.settings.sql_analysis,
         )
-        test_path: Path = (
-            target_dir / _COMPILED_DIR / _TESTS_DIR / _test_folder(entry) / f"{entry.name}.sql"
-        )
+        test_path: Path = target_dir / _COMPILED_DIR / _TESTS_DIR / _test_output_path(entry)
         _write_sql(
             path=test_path,
             sql=build_sql_test_comparison_sql(
@@ -373,3 +369,10 @@ def _test_folder(entry: SqlTestPlanEntry) -> Path:
     if len(unique_names) <= 1:
         return Path(unique_names[0] if unique_names else entry.name)
     return Path(_CHAIN_DIR) / "__".join(unique_names)
+
+
+def _test_output_path(entry: SqlTestPlanEntry) -> Path:
+    if entry.case_name is None or entry.source_path is None:
+        return _test_folder(entry) / f"{entry.name}{_SQL_FILE_SUFFIX}"
+    source_path: Path = entry.source_path.with_suffix("")
+    return source_path / f"block_{entry.block_index}__{entry.case_name}{_SQL_FILE_SUFFIX}"

{sqlbuild-0.61.0 → sqlbuild-0.62.0}/src/sqlbuild/cli/commands/_helpers/test/execution.py

@@ -6,6 +6,7 @@ from collections.abc import Callable
 
 from sqlbuild.cli.commands._helpers.test.sql_progress import (
     build_test_expectation_rows,
+    format_parameterized_test_label,
     resolve_test_name_width,
     test_outcome_status,
 )
@@ -101,7 +102,12 @@ def execute_test_plan(
         on_progress=preparation.preflight_progress.report_preflight_progress,
         on_test_start=lambda entry: preparation.progress.on_item_start(
             group_name=_test_group_name_from_entry(entry),
-            item_name=entry.name,
+            item_name=format_parameterized_test_label(
+                name=entry.name,
+                source_path=entry.source_path,
+                parameter_schema=entry.parameter_schema,
+                parameter_values=entry.parameter_values,
+            ),
         ),
         on_test_complete=on_complete,
     )
@@ -118,7 +124,12 @@ def _build_on_complete(
         status_text: str = test_outcome_status(outcome=result.outcome)
         progress.on_item_complete(
             group_name=group_name,
-            item_name=result.test_name,
+            item_name=format_parameterized_test_label(
+                name=result.test_name,
+                source_path=result.source_path,
+                parameter_schema=result.parameter_schema,
+                parameter_values=result.parameter_values,
+            ),
             status_text=status_text,
             child_rows=build_test_expectation_rows(result),
             error_code=result.error_code,

{sqlbuild-0.61.0 → sqlbuild-0.62.0}/src/sqlbuild/cli/commands/_helpers/test/outputs.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from sqlbuild.cli.commands._helpers.test.sql_progress import format_parameterized_test_label
 from sqlbuild.cli.commands.models import TestCommandRequest, TestInvocation
 from sqlbuild.cli.output.main._sql_test_execution_json import format_test_execution_json
 from sqlbuild.cli.output.main._write_execution_json_output import write_execution_json_output
@@ -67,7 +68,15 @@ def _format_test_failure_details(
     lines: list[str] = [style.error_strong("Failures:"), ""]
     result: SqlTestExecutionResult
     for result in failed_results:
-        lines.append(f"  {result.test_name}")
+        lines.append(
+            "  "
+            + format_parameterized_test_label(
+                name=result.test_name,
+                source_path=result.source_path,
+                parameter_schema=result.parameter_schema,
+                parameter_values=result.parameter_values,
+            )
+        )
         error_message: str = result.error_message or "test failed"
         rendered_error: str = error_message
         if result.error_code is not None:

{sqlbuild-0.61.0 → sqlbuild-0.62.0}/src/sqlbuild/cli/commands/_helpers/test/sql_progress.py

@@ -2,13 +2,19 @@
 
 from __future__ import annotations
 
+import json
+from pathlib import Path
+
 from sqlbuild.cli.progress.main._expectation_detail import format_expectation_detail
 from sqlbuild.cli.progress.main._expectation_name import format_expectation_name
 from sqlbuild.cli.progress.models import NestedProgressChildRow
+from sqlbuild.compiler.discovery.models import SqlTestParameterDeclaration
 from sqlbuild.compiler.planner.models import SqlTestPlanEntry
 from sqlbuild.executor.testing.models import SqlTestExecutionResult, StepResult
 from sqlbuild.executor.testing.types import SqlTestOutcome
 from sqlbuild.presentation.main.resolve_name_column_width import resolve_name_column_width
+from sqlbuild.sql_values.models import SqlValue
+from sqlbuild.sql_values.types import SqlValueKind
 
 
 def resolve_test_name_width(test_entries: tuple[SqlTestPlanEntry, ...]) -> int:
@@ -17,7 +23,14 @@ def resolve_test_name_width(test_entries: tuple[SqlTestPlanEntry, ...]) -> int:
     names: list[str] = []
     entry: SqlTestPlanEntry
     for entry in test_entries:
-        names.append(entry.name)
+        names.append(
+            format_parameterized_test_label(
+                name=entry.name,
+                source_path=entry.source_path,
+                parameter_schema=entry.parameter_schema,
+                parameter_values=entry.parameter_values,
+            )
+        )
         names.extend(f"expected {step.model_name}" for step in entry.chain if step.expected_cte_sql)
         names.extend(f"assertion {assertion.name}" for assertion in entry.assertions)
     return resolve_name_column_width(names=names, min_width=50)
@@ -44,6 +57,32 @@ def build_test_expectation_rows(
     return tuple(rows)
 
 
+def format_parameterized_test_label(
+    *,
+    name: str,
+    source_path: Path | None,
+    parameter_schema: tuple[SqlTestParameterDeclaration, ...],
+    parameter_values: tuple[tuple[str, SqlValue], ...],
+) -> str:
+    """Add source and safe typed values only for parameterized test rows."""
+
+    if source_path is None or not parameter_values:
+        return name
+    schema_by_name: dict[str, SqlTestParameterDeclaration] = {
+        parameter.name: parameter for parameter in parameter_schema
+    }
+    rendered_values: list[str] = []
+    value_name: str
+    value: SqlValue
+    for value_name, value in parameter_values:
+        declaration: SqlTestParameterDeclaration = schema_by_name[value_name]
+        payload: object = str(value.value) if value.kind == SqlValueKind.DECIMAL else value.value
+        rendered: str = json.dumps(payload, ensure_ascii=True, separators=(",", ":"))
+        nullable: str = "?" if declaration.nullable else ""
+        rendered_values.append(f"{value_name}:{declaration.value_type.value}{nullable}={rendered}")
+    return f"{name} ({source_path.as_posix()}; {', '.join(rendered_values)})"
+
+
 def test_outcome_status(*, outcome: SqlTestOutcome) -> str:
     """Preserve the semantic distinction between assertion failures and execution errors."""
 

{sqlbuild-0.61.0 → sqlbuild-0.62.0}/src/sqlbuild/cli/commands/classes/build_progress_callbacks.py

@@ -8,6 +8,7 @@ import time
 
 from sqlbuild.adapter.contract.models import LifeCycleEvent
 from sqlbuild.adapter.contract.types import LifeCycleEventKind
+from sqlbuild.cli.commands._helpers.test.sql_progress import format_parameterized_test_label
 from sqlbuild.cli.progress.main._expectation_detail import format_expectation_detail
 from sqlbuild.cli.progress.main._expectation_name import format_expectation_name
 from sqlbuild.compiler.auditing.types import AuditOutcome, AuditRunScope
@@ -90,7 +91,7 @@ class BuildProgressCallbacks:
         self._model_entry_map: dict[str, ModelPlanEntry] = {
             entry.name: entry for entry in plan.model_entries
         }
-        self._test_results_by_model: dict[str, SqlTestExecutionResult] = {}
+        self._test_results_by_model: dict[str, list[SqlTestExecutionResult]] = {}
         self._total: int = (
             len(plan.model_entries)
             + len(plan.seed_entries)
@@ -264,7 +265,7 @@ class BuildProgressCallbacks:
             step: object
             for step in node_result.step_results:
                 if hasattr(step, "model_name"):
-                    self._test_results_by_model[step.model_name] = node_result
+                    self._test_results_by_model.setdefault(step.model_name, []).append(node_result)
             return
 
         self._stop_spinner_loop()
@@ -403,12 +404,15 @@ class BuildProgressCallbacks:
             label_width=hook_label_width,
         )
 
-        test_result: SqlTestExecutionResult | None = self._test_results_by_model.get(
-            model_result.model_name
-        )
-        if test_result is not None:
+        test_result: SqlTestExecutionResult
+        for test_result in self._test_results_by_model.get(model_result.model_name, []):
             test_status: str = self._style.status(status=_test_outcome_display(test_result.outcome))
-            test_name: str = test_result.test_name
+            test_name: str = format_parameterized_test_label(
+                name=test_result.test_name,
+                source_path=test_result.source_path,
+                parameter_schema=test_result.parameter_schema,
+                parameter_values=test_result.parameter_values,
+            )
             self._stream.write(
                 f"{sub_pad}{self._style.muted(f'{"test":<{_TYPE_WIDTH}}')}"
                 f"{test_name:<{sub_nw}} {test_status}\n"
@@ -479,7 +483,15 @@ class BuildProgressCallbacks:
             self._show_cursor()
         blank_ctr: str = " " * (len(str(self._total)) * 2 + 1)
         test_status: str = self._style.status(status=_test_outcome_display(test_result.outcome))
-        test_name: str = _truncate_name(name=test_result.test_name, width=self._name_width)
+        test_name: str = _truncate_name(
+            name=format_parameterized_test_label(
+                name=test_result.test_name,
+                source_path=test_result.source_path,
+                parameter_schema=test_result.parameter_schema,
+                parameter_values=test_result.parameter_values,
+            ),
+            width=self._name_width,
+        )
         self._stream.write(
             f"  {blank_ctr}  {self._style.muted(f'{"test":<{_TYPE_WIDTH}}')}"
             f"{test_name:<{self._name_width}} {test_status}\n"
@@ -896,7 +908,13 @@ def _format_failure_details(*, result: BuildExecutionResult, style: CliStyle) ->
             lines.append(style.error_strong("Failures:"))
             lines.append("")
             has_failures = True
-        lines.append(f"  {test_r.test_name}  (test)")
+        test_label: str = format_parameterized_test_label(
+            name=test_r.test_name,
+            source_path=test_r.source_path,
+            parameter_schema=test_r.parameter_schema,
+            parameter_values=test_r.parameter_values,
+        )
+        lines.append(f"  {test_label}  (test)")
         if test_r.error_message is not None:
             lines.extend(
                 _format_failure_error_block(

{sqlbuild-0.61.0 → sqlbuild-0.62.0}/src/sqlbuild/cli/output/_helpers/execution_protocol_v1.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 import sys
 from pathlib import Path
+from typing import cast
 
 from sqlbuild.compiler.auditing.types import AuditOutcome
 from sqlbuild.compiler.compile.types import CompiledResourceType
@@ -35,6 +36,8 @@ from sqlbuild.executor.scenario.models import (
 from sqlbuild.executor.scenario.types import ScenarioLocalRunStatus
 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
 
 _JSON_VERSION: int = 1
 
@@ -486,7 +489,8 @@ def _format_sql_test_checks(
                 {
                     "kind": "sql_test",
                     "name": result.test_name,
-                    "check_id": f"sql_test:{result.test_name}",
+                    "check_id": _sql_test_check_id(result),
+                    **_sql_test_case_metadata(result),
                     "passed": result.outcome == SqlTestOutcome.PASS,
                     "status": result.outcome.value,
                     "asset_name": _sql_test_asset_name(result),
@@ -500,6 +504,63 @@ def _format_sql_test_checks(
     return tuple(checks)
 
 
+def _sql_test_check_id(result: SqlTestExecutionResult) -> str:
+    if result.case_name is None or result.source_path is None or result.block_index is None:
+        return f"sql_test:{result.test_name}"
+    return f"sql_test:{result.source_path.as_posix()}:{result.block_index}:{result.case_name}"
+
+
+def _sql_test_case_metadata(result: SqlTestExecutionResult) -> dict[str, object]:
+    if result.case_name is None or result.source_path is None:
+        return {}
+    parameter_types: dict[str, str] = {
+        parameter.name: parameter.value_type.value for parameter in result.parameter_schema
+    }
+    return {
+        "source_path": result.source_path.as_posix(),
+        "block_index": result.block_index,
+        "parent_name": result.parent_name,
+        "case_name": result.case_name,
+        "case_index": result.case_index,
+        "case_fingerprint": result.case_fingerprint,
+        "parameter_schema": tuple(
+            {
+                "name": parameter.name,
+                "type": parameter.value_type.value,
+                "nullable": parameter.nullable,
+            }
+            for parameter in result.parameter_schema
+        ),
+        "parameters": tuple(
+            {
+                "name": name,
+                "type": parameter_types[name],
+                "value": _sql_value_json(value),
+            }
+            for name, value in result.parameter_values
+        ),
+    }
+
+
+def _sql_value_json(value: SqlValue) -> object:
+    if value.kind == SqlValueKind.DECIMAL:
+        return str(value.value)
+    if value.kind in {
+        SqlValueKind.STRING,
+        SqlValueKind.INTEGER,
+        SqlValueKind.BOOLEAN,
+        SqlValueKind.FLOAT,
+        SqlValueKind.NULL,
+    }:
+        return value.value
+    if value.kind in {SqlValueKind.LIST, SqlValueKind.SET}:
+        return [_sql_value_json(item) for item in cast(tuple[SqlValue, ...], value.value)]
+    return {
+        name: _sql_value_json(item)
+        for name, item in cast(tuple[tuple[str, SqlValue], ...], value.value)
+    }
+
+
 def _format_python_check_results(
     *, results: tuple[PythonCheckExecutionResult, ...]
 ) -> tuple[dict[str, object], ...]:

{sqlbuild-0.61.0 → sqlbuild-0.62.0}/src/sqlbuild/cli/target_artifacts/_helpers/runtime.py

@@ -99,12 +99,26 @@ def write_test_runtime_target(
     """Write executed SQL unit-test statements under target/run/tests."""
 
     run_dir: Path = target_dir / _RUN_DIR
-    result_names: frozenset[str] = frozenset(result.test_name for result in results)
+    result_keys: frozenset[tuple[str, str | None, int | None, str | None]] = frozenset(
+        (
+            result.test_name,
+            result.source_path.as_posix() if result.source_path is not None else None,
+            result.block_index,
+            result.case_name,
+        )
+        for result in results
+    )
     entry: SqlTestPlanEntry
     for entry in plan_output.test_entries:
-        if entry.name not in result_names:
+        entry_key: tuple[str, str | None, int | None, str | None] = (
+            entry.name,
+            entry.source_path.as_posix() if entry.source_path is not None else None,
+            entry.block_index,
+            entry.case_name,
+        )
+        if entry_key not in result_keys:
             continue
-        test_run_path: Path = run_dir / _TESTS_DIR / _test_folder(entry) / f"{entry.name}.sql"
+        test_run_path: Path = run_dir / _TESTS_DIR / _test_output_path(entry)
         _write_sql(
             path=test_run_path,
             sql=build_sql_test_comparison_sql(
@@ -169,6 +183,13 @@ def _function_output_path(*, relative_path: Path, language: FunctionLanguage) ->
     return (Path(_FUNCTIONS_DIR) / language_dir / relative_path).with_suffix(_SQL_FILE_SUFFIX)
 
 
+def _test_output_path(entry: SqlTestPlanEntry) -> Path:
+    if entry.case_name is None or entry.source_path is None:
+        return _test_folder(entry) / f"{entry.name}{_SQL_FILE_SUFFIX}"
+    source_path: Path = entry.source_path.with_suffix("")
+    return source_path / f"block_{entry.block_index}__{entry.case_name}{_SQL_FILE_SUFFIX}"
+
+
 def _test_folder(entry: SqlTestPlanEntry) -> Path:
     model_names: list[str] = [step.model_name for step in entry.chain]
     unique_names: list[str] = sorted(set(model_names))

{sqlbuild-0.61.0 → sqlbuild-0.62.0}/src/sqlbuild/compiler/compile/_helpers/assembly/project.py

@@ -43,6 +43,9 @@ from sqlbuild.compiler.compile._helpers.render.macros import (
 )
 from sqlbuild.compiler.compile._helpers.render.templating import expand_template_data
 from sqlbuild.compiler.compile._helpers.sql_tests.core import extract_assertion_target_model_names
+from sqlbuild.compiler.compile._helpers.sql_tests.identity import (
+    build_sql_test_case_fingerprint,
+)
 from sqlbuild.compiler.compile.constants import NOT_NULL_AUDIT_NAME, PRESERVE_TARGET_VALUE
 from sqlbuild.compiler.compile.exceptions import CompileInputError
 from sqlbuild.compiler.compile.main._scope_index_with_compile_usages import (
@@ -984,6 +987,28 @@ def _assemble_compiled_sql_test(
             assertion_ctes=model_payload.assertion_ctes,
             assertion_names=model_payload.assertion_names,
         )
+    tested_resources: tuple[CompiledSqlTestResource, ...] = (
+        tuple(
+            CompiledSqlTestResource(kind=test_input.payload.mode, name=name)
+            for name in test_input.payload.tested_resource_names
+        )
+        if isinstance(test_input.payload, CompileDirectLogicSqlTestInputPayload)
+        else ()
+    )
+    case_fingerprint: str | None = (
+        build_sql_test_case_fingerprint(
+            source_path=test_input.test_file.relative_path,
+            block_index=test_input.test_block.test_index,
+            case_name=test_input.case_name,
+            parameter_schema=test_input.parameter_schema,
+            parameter_values=test_input.parameter_values,
+            expanded_sql=test_input.sql_body,
+            scope_deps=scope_deps,
+            tested_resources=tested_resources,
+        )
+        if test_input.case_name is not None
+        else None
+    )
     return CompiledSqlTest(
         key=CompiledObjectKey(resource_type=CompiledResourceType.SQL_TEST, name=test_name),
         scope_deps=scope_deps,
@@ -997,6 +1022,12 @@ def _assemble_compiled_sql_test(
         ownership_root=test_input.test_file.ownership_root,
         block_index=test_input.test_block.test_index,
         explicit_name=test_input.test_block.name,
+        parent_name=test_input.parent_name,
+        case_name=test_input.case_name,
+        case_index=test_input.case_index,
+        case_fingerprint=case_fingerprint,
+        parameter_schema=test_input.parameter_schema,
+        parameter_values=test_input.parameter_values,
         expected_model_names=(
             test_input.payload.expected_model_names
             if isinstance(test_input.payload, CompileModelSqlTestInputPayload)
@@ -1021,14 +1052,7 @@ def _assemble_compiled_sql_test(
             if isinstance(test_input.payload, CompileModelSqlTestInputPayload)
             else ()
         ),
-        tested_resources=(
-            tuple(
-                CompiledSqlTestResource(kind=test_input.payload.mode, name=name)
-                for name in test_input.payload.tested_resource_names
-            )
-            if isinstance(test_input.payload, CompileDirectLogicSqlTestInputPayload)
-            else ()
-        ),
+        tested_resources=tested_resources,
     )
 
 
@@ -1167,9 +1191,10 @@ def _resolve_audit_name(audit_input: CompileAuditInput) -> str:
 
 
 def _resolve_test_name(test_input: CompileSqlTestInput) -> str:
-    if test_input.test_block.name is not None:
-        return test_input.test_block.name
-    return test_input.test_file.file_path.stem
+    parent_name: str = test_input.test_block.name or test_input.test_file.file_path.stem
+    if test_input.case_name is not None:
+        return f"{parent_name} [{test_input.case_name}]"
+    return parent_name
 
 
 def _build_model_relation_target(