sqlbuild 0.108.0__tar.gz → 0.109.0__tar.gz

{sqlbuild-0.108.0 → sqlbuild-0.109.0}/Cargo.lock

@@ -529,7 +529,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sqlbuild-rules-native"
-version = "0.108.0"
+version = "0.109.0"
 dependencies = [
  "fensu-policy",
  "globset",

{sqlbuild-0.108.0 → sqlbuild-0.109.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.108.0
+Version: 0.109.0
 Requires-Dist: duckdb>=1.3.2
 Requires-Dist: filelock>=3.20.3
 Requires-Dist: orjson>=3.10.0

{sqlbuild-0.108.0 → sqlbuild-0.109.0}/crates/sqlbuild-rules-native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlbuild-rules-native"
-version = "0.108.0"
+version = "0.109.0"
 edition.workspace = true
 license.workspace = true
 publish.workspace = true

{sqlbuild-0.108.0 → sqlbuild-0.109.0}/crates/sqlbuild-rules-native/src/sql_lint/_helpers/engine.rs

@@ -515,12 +515,16 @@ fn collect_rule_migration_facts(
             facts.cross_joins.push(tokens[index].span);
         }
         if text.eq_ignore_ascii_case("with") {
-            if depths[index] > 0 {
+            let starts_hierarchy = position.checked_sub(1).is_some_and(|previous| {
+                tokens[significant[previous]].token_type == TokenType::Start
+            });
+            if depths[index] > 0 && !starts_hierarchy {
                 facts.nested_ctes.push(tokens[index].span);
             }
-            if significant
-                .get(position + 1)
-                .is_some_and(|&next| tokens[next].text.eq_ignore_ascii_case("recursive"))
+            if !starts_hierarchy
+                && significant
+                    .get(position + 1)
+                    .is_some_and(|&next| tokens[next].text.eq_ignore_ascii_case("recursive"))
             {
                 facts.recursive_ctes.push(tokens[index].span);
             }

{sqlbuild-0.108.0 → sqlbuild-0.109.0}/crates/sqlbuild-rules-native/src/sql_lint/tests/test_sql_lint.rs

@@ -443,6 +443,12 @@ fn given_plain_sql_rules_when_linting_then_project_context_is_not_required() ->
             rule: "SQBRSQL036",
             expected_count: 1,
         },
+        test_types::PlainSqlLintTestCase {
+            description: "Snowflake hierarchy START WITH is not a nested CTE",
+            sql: "WITH entities AS (SELECT id, parent_id FROM source_rows), hierarchy AS (SELECT id FROM entities START WITH parent_id IS NULL CONNECT BY parent_id = PRIOR id) SELECT id FROM hierarchy",
+            rule: "SQBRSQL036",
+            expected_count: 0,
+        },
         test_types::PlainSqlLintTestCase {
             description: "recursive CTE",
             sql: "WITH RECURSIVE numbers AS (SELECT 1 UNION ALL SELECT 2) SELECT * FROM numbers",

{sqlbuild-0.108.0 → sqlbuild-0.109.0}/pyproject.toml

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

{sqlbuild-0.108.0 → sqlbuild-0.109.0}/src/sqlbuild/cli/commands/_helpers/test/inspection.py

@@ -19,6 +19,11 @@ def write_test_plan_inspection(*, stream: TextIO, plan_output: PlanOutput) -> in
         _write_names(stream=stream, label="mocked refs", names=entry.mock_ref_names)
         _write_names(stream=stream, label="mocked seeds", names=entry.mock_seed_names)
         _write_names(stream=stream, label="mocked dbt refs", names=entry.mock_dbt_ref_names)
+        _write_names(
+            stream=stream,
+            label="mocked table functions",
+            names=entry.mock_table_function_names,
+        )
         _write_names(
             stream=stream,
             label="real models",

{sqlbuild-0.108.0 → sqlbuild-0.109.0}/src/sqlbuild/compiler/compile/_helpers/assembly/project.py

@@ -1439,6 +1439,7 @@ def _assemble_compiled_sql_test(
             mock_source_names=model_payload.mock_source_names,
             mock_seed_names=model_payload.mock_seed_names,
             mock_dbt_ref_names=model_payload.mock_dbt_ref_names,
+            mock_table_function_names=model_payload.mock_table_function_names,
             expected_ctes=model_payload.expected_ctes,
             expected_model_names=model_payload.expected_model_names,
             assertion_ctes=model_payload.assertion_ctes,

{sqlbuild-0.108.0 → sqlbuild-0.109.0}/src/sqlbuild/compiler/compile/_helpers/attachment/sql_tests.py

@@ -273,6 +273,7 @@ def build_test_inputs(
                     known_model_names=known_model_names,
                     known_seed_names=known_seed_names,
                     known_source_names=known_source_names,
+                    known_table_function_names=known_table_function_names,
                     loaded_macros=loaded_macros,
                 )
                 test_payload: (
@@ -387,6 +388,7 @@ def _build_test_input_payload(
                 mock_source_names=model_payload.mock_source_names,
                 mock_seed_names=model_payload.mock_seed_names,
                 mock_dbt_ref_names=model_payload.mock_dbt_ref_names,
+                mock_table_function_names=model_payload.mock_table_function_names,
                 expected_ctes=model_payload.expected_ctes,
                 expected_model_names=model_payload.expected_model_names,
                 assertion_ctes=model_payload.assertion_ctes,
@@ -678,6 +680,7 @@ def validate_test_ctes(
     known_model_names: set[str],
     known_seed_names: set[str],
     known_source_names: set[str],
+    known_table_function_names: set[str],
     loaded_macros: dict[str, LoadedMacro],
 ) -> None:
     """Validate SQL-native test CTE targets against discovered inputs."""
@@ -705,6 +708,13 @@ def validate_test_ctes(
             raise CompileInputError(
                 f"SQL test file {test_file.relative_path} mocks unknown seed '{mock_seed_name}'"
             )
+    mock_table_function_name: str
+    for mock_table_function_name in model_payload.mock_table_function_names:
+        if mock_table_function_name not in known_table_function_names:
+            raise CompileInputError(
+                f"SQL test file {test_file.relative_path} mocks unknown table function "
+                f"'{mock_table_function_name}'"
+            )
     macro_mock_name: str
     for macro_mock_name in model_payload.macro_mocks:
         if macro_mock_name not in loaded_macros:

{sqlbuild-0.108.0 → sqlbuild-0.109.0}/src/sqlbuild/compiler/compile/_helpers/sql_tests/core.py

@@ -36,6 +36,7 @@ from sqlbuild.compiler.compile.constants import (
     SQL_WITH_KEYWORD,
     TABLE_FN_ACTUAL_TEST_CTE_NAME,
     TABLE_FN_EXPECTED_TEST_CTE_NAME,
+    TABLE_FN_TEST_CTE_PREFIX,
     UDF_ACTUAL_TEST_CTE_NAME,
     UDF_EXPECTED_TEST_CTE_NAME,
 )
@@ -392,6 +393,7 @@ def _classify_model_sql_test_ctes(
     mock_source_names: list[str] = []
     mock_seed_names: list[str] = []
     mock_dbt_ref_names: list[str] = []
+    mock_table_function_names: list[str] = []
     expected_ctes: list[CompileSqlTestCte] = []
     expected_model_names: list[str] = []
     assertion_ctes: list[CompileSqlTestCte] = []
@@ -467,6 +469,17 @@ def _classify_model_sql_test_ctes(
             )
             authored_ctes.append(cte)
             continue
+        if cte.name.startswith(TABLE_FN_TEST_CTE_PREFIX):
+            mock_table_function_names.append(
+                _require_prefixed_name(
+                    cte_name=cte.name,
+                    prefix=TABLE_FN_TEST_CTE_PREFIX,
+                    label="__table_fn__<function>",
+                    file_label=file_label,
+                )
+            )
+            authored_ctes.append(cte)
+            continue
         if cte.name.startswith(EXPECTED_TEST_CTE_PREFIX):
             expected_model_names.append(
                 _require_prefixed_name(
@@ -501,11 +514,12 @@ def _classify_model_sql_test_ctes(
         *mock_source_names,
         *mock_seed_names,
         *mock_dbt_ref_names,
+        *mock_table_function_names,
     )
     if not mock_target_names:
         raise CompileInputError(
             f"SQL test '{file_label}' must define at least one __ref__*, __source__*, "
-            "__seed__*, or __dbt_ref__* mock CTE"
+            "__seed__*, __dbt_ref__*, or __table_fn__* mock CTE"
         )
     check_names: tuple[str, ...] = (*expected_model_names, *assertion_names)
     if not check_names:
@@ -520,6 +534,7 @@ def _classify_model_sql_test_ctes(
         mock_source_names=tuple(mock_source_names),
         mock_seed_names=tuple(mock_seed_names),
         mock_dbt_ref_names=tuple(mock_dbt_ref_names),
+        mock_table_function_names=tuple(mock_table_function_names),
         expected_ctes=tuple(expected_ctes),
         expected_model_names=tuple(expected_model_names),
         assertion_ctes=tuple(assertion_ctes),
@@ -536,6 +551,7 @@ def _is_model_mode_cte(cte_name: str) -> bool:
             SOURCE_TEST_CTE_PREFIX,
             SEED_TEST_CTE_PREFIX,
             DBT_REF_TEST_CTE_PREFIX,
+            TABLE_FN_TEST_CTE_PREFIX,
             EXPECTED_TEST_CTE_PREFIX,
             ASSERT_TEST_CTE_PREFIX,
         )

{sqlbuild-0.108.0 → sqlbuild-0.109.0}/src/sqlbuild/compiler/compile/constants.py

@@ -111,6 +111,7 @@ REF_TEST_CTE_PREFIX: str = SqlReferenceKind.REF.fixture_cte_prefix
 SOURCE_TEST_CTE_PREFIX: str = SqlReferenceKind.SOURCE.fixture_cte_prefix
 SEED_TEST_CTE_PREFIX: str = SqlReferenceKind.SEED.fixture_cte_prefix
 DBT_REF_TEST_CTE_PREFIX: str = SqlReferenceKind.DBT_REF.fixture_cte_prefix
+TABLE_FN_TEST_CTE_PREFIX: str = SqlReferenceKind.TABLE_FUNCTION.fixture_cte_prefix
 MACRO_TEST_CTE_PREFIX: str = "__macro__"
 MACRO_ACTUAL_TEST_CTE_NAME: str = "__macro_actual__"
 MACRO_EXPECTED_TEST_CTE_NAME: str = "__macro_expected__"

{sqlbuild-0.108.0 → sqlbuild-0.109.0}/src/sqlbuild/compiler/compile/models.py

@@ -926,6 +926,7 @@ class CompileModelSqlTestCtes:
     mock_source_names: tuple[str, ...] = field(default_factory=tuple)
     mock_seed_names: tuple[str, ...] = field(default_factory=tuple)
     mock_dbt_ref_names: tuple[str, ...] = field(default_factory=tuple)
+    mock_table_function_names: tuple[str, ...] = field(default_factory=tuple)
     expected_ctes: tuple[CompileSqlTestCte, ...] = field(default_factory=tuple)
     expected_model_names: tuple[str, ...] = field(default_factory=tuple)
     assertion_ctes: tuple[CompileSqlTestCte, ...] = field(default_factory=tuple)
@@ -960,6 +961,7 @@ class CompileModelSqlTestInputPayload:
     mock_source_names: tuple[str, ...] = field(default_factory=tuple)
     mock_seed_names: tuple[str, ...] = field(default_factory=tuple)
     mock_dbt_ref_names: tuple[str, ...] = field(default_factory=tuple)
+    mock_table_function_names: tuple[str, ...] = field(default_factory=tuple)
     expected_ctes: tuple[CompileSqlTestCte, ...] = field(default_factory=tuple)
     expected_model_names: tuple[str, ...] = field(default_factory=tuple)
     assertion_ctes: tuple[CompileSqlTestCte, ...] = field(default_factory=tuple)
@@ -1007,6 +1009,7 @@ class CompiledModelSqlTestPayload:
     mock_source_names: tuple[str, ...] = field(default_factory=tuple)
     mock_seed_names: tuple[str, ...] = field(default_factory=tuple)
     mock_dbt_ref_names: tuple[str, ...] = field(default_factory=tuple)
+    mock_table_function_names: tuple[str, ...] = field(default_factory=tuple)
     expected_ctes: tuple[CompileSqlTestCte, ...] = field(default_factory=tuple)
     expected_model_names: tuple[str, ...] = field(default_factory=tuple)
     assertion_ctes: tuple[CompileSqlTestCte, ...] = field(default_factory=tuple)

{sqlbuild-0.108.0 → sqlbuild-0.109.0}/src/sqlbuild/compiler/planner/_helpers/resolve/refs.py

@@ -253,6 +253,42 @@ def resolve_table_function_references(
     return "".join(parts)
 
 
+def resolve_table_function_fixture_references(
+    *, query_sql: str, fixtures: dict[str, str]
+) -> tuple[str, frozenset[str]]:
+    """Replace complete table-function invocations with model-test fixture relations."""
+
+    parts: list[str] = []
+    last_index: int = 0
+    reached: set[str] = set()
+    match: re.Match[str]
+    for match in _iter_executable_matches(sql=query_sql, pattern=_TABLE_FUNCTION_PATTERN):
+        if match.start() < last_index:
+            continue
+        function_name: str = match.group(1)
+        fixture_sql: str | None = fixtures.get(function_name)
+        if fixture_sql is None:
+            continue
+        call_suffix_start: int = _skip_whitespace(sql=query_sql, start=match.end())
+        if (
+            call_suffix_start >= len(query_sql)
+            or query_sql[call_suffix_start] != SQL_FUNCTION_CALL_OPEN_PAREN
+        ):
+            continue
+        call_suffix_end: int = find_matching_paren(
+            sql=query_sql,
+            open_paren_index=call_suffix_start,
+            context="SQL table function fixture call",
+        )
+        parts.append(query_sql[last_index : match.start()])
+        parts.append(fixture_sql)
+        last_index = call_suffix_end + 1
+        reached.add(function_name)
+
+    parts.append(query_sql[last_index:])
+    return "".join(parts), frozenset(reached)
+
+
 def _iter_executable_matches(*, sql: str, pattern: re.Pattern[str]) -> Iterator[re.Match[str]]:
     index: int = 0
     while index < len(sql):

{sqlbuild-0.108.0 → sqlbuild-0.109.0}/src/sqlbuild/compiler/planner/_helpers/sql_tests/assembly.py

@@ -13,6 +13,7 @@ from sqlbuild.compiler.compile.constants import (
     REF_TEST_CTE_PREFIX,
     SEED_TEST_CTE_PREFIX,
     SOURCE_TEST_CTE_PREFIX,
+    TABLE_FN_TEST_CTE_PREFIX,
 )
 from sqlbuild.compiler.compile.models import (
     CompiledDirectLogicSqlTestPayload,
@@ -26,6 +27,7 @@ from sqlbuild.compiler.compile.models import (
 )
 from sqlbuild.compiler.compile.types import CompiledResourceType, SqlTestMode
 from sqlbuild.compiler.planner._helpers.resolve.refs import (
+    resolve_table_function_fixture_references,
     resolve_table_function_references,
     resolve_udf_references,
 )
@@ -86,6 +88,7 @@ class _TextualChainResolver:
     mock_sources: dict[str, str]
     mock_seeds: dict[str, str]
     mock_dbt_refs: dict[str, str]
+    mock_table_functions: dict[str, str]
     helper_ctes: tuple[CompileSqlTestCte, ...]
     function_locations: dict[str, CompiledRelationLocation]
     adapter: BaseAdapter
@@ -108,6 +111,7 @@ class _TextualChainResolver:
                 mock_sources=self.mock_sources,
                 mock_seeds=self.mock_seeds,
                 mock_dbt_refs=self.mock_dbt_refs,
+                mock_table_functions=self.mock_table_functions,
                 helper_ctes=self.helper_ctes,
                 resolved_chain=self.resolved,
                 function_locations=self.function_locations,
@@ -162,6 +166,7 @@ def plan_test(
     mock_sources: dict[str, str] = _extract_mock_sources(test)
     mock_seeds: dict[str, str] = _extract_mock_seeds(test)
     mock_dbt_refs: dict[str, str] = _extract_mock_dbt_refs(test)
+    mock_table_functions: dict[str, str] = _extract_mock_table_functions(test)
     helper_ctes: tuple[CompileSqlTestCte, ...] = _extract_helper_ctes(test)
     expected_map: dict[str, str] = _extract_expected_ctes(test)
     assertion_map: dict[str, str] = _extract_assertion_ctes(test)
@@ -202,6 +207,7 @@ def plan_test(
         mock_sources=mock_sources,
         mock_seeds=mock_seeds,
         mock_dbt_refs=mock_dbt_refs,
+        mock_table_functions=mock_table_functions,
         helper_ctes=helper_ctes,
         function_locations=function_locations,
         adapter=adapter,
@@ -227,14 +233,24 @@ def plan_test(
             dep
             for dep in model.deps
             if dep.resource_type in {CompiledResourceType.UDF, CompiledResourceType.TABLE_FN}
+            and not (
+                dep.resource_type == CompiledResourceType.TABLE_FN
+                and dep.name in mock_table_functions
+            )
         )
 
         query_sql: str = _resolve_test_model_query_sql(model=model, test=test)
         step_sql: str | None = None
         if sql_analysis_enabled:
+            analysis_query_sql, reached_table_functions = _resolve_table_function_fixtures(
+                query_sql=query_sql,
+                mock_table_functions=mock_table_functions,
+                helper_ctes=helper_ctes,
+            )
+            reachable_mocks.update(reached_table_functions)
             sql_analysis_sql: SqlAnalysisResolvedTestSql | None = (
                 try_resolve_test_model_sql_with_sql_analysis(
-                    query_sql=query_sql,
+                    query_sql=analysis_query_sql,
                     mock_refs=mock_refs,
                     mock_sources=mock_sources,
                     mock_seeds=mock_seeds,
@@ -270,64 +286,33 @@ def plan_test(
             )
         )
 
-    assertion_steps: tuple[SqlTestAssertionStep, ...] = _build_assertion_steps(
+    assertion_steps: tuple[SqlTestAssertionStep, ...]
+    assertion_reached_table_functions: frozenset[str]
+    assertion_steps, assertion_reached_table_functions = _build_assertion_steps(
         assertion_map=assertion_map,
         test=test,
         function_locations=function_locations,
         qualified_function_locations=qualified_function_locations,
         helper_ctes=helper_ctes,
+        mock_table_functions=mock_table_functions,
         textual_chain=textual_chain,
         sql_analysis_resolved=sql_analysis_resolved,
         adapter=adapter,
         sql_analysis_enabled=sql_analysis_enabled,
     )
     reachable_mocks.update(textual_chain.reachable_mocks)
-
-    unreachable_ref: str
-    for unreachable_ref in sorted(set(mock_refs) - reachable_mocks):
-        warnings.append(
-            PlanWarning(
-                model_name=None,
-                severity=WarningSeverity.WARNING,
-                message=(
-                    f"test '{test.name}' mock __ref__{unreachable_ref}"
-                    f" is unreachable because a downstream model is"
-                    f" also in the expected chain"
-                ),
-            )
-        )
-
-    unreachable_source: str
-    for unreachable_source in sorted(set(mock_sources) - reachable_mocks):
-        warnings.append(
-            PlanWarning(
-                model_name=None,
-                severity=WarningSeverity.WARNING,
-                message=(f"test '{test.name}' mock __source__{unreachable_source} is unreachable"),
-            )
-        )
-
-    unreachable_seed: str
-    for unreachable_seed in sorted(set(mock_seeds) - reachable_mocks):
-        warnings.append(
-            PlanWarning(
-                model_name=None,
-                severity=WarningSeverity.WARNING,
-                message=(f"test '{test.name}' mock __seed__{unreachable_seed} is unreachable"),
-            )
-        )
-
-    unreachable_dbt_ref: str
-    for unreachable_dbt_ref in sorted(set(mock_dbt_refs) - reachable_mocks):
-        warnings.append(
-            PlanWarning(
-                model_name=None,
-                severity=WarningSeverity.WARNING,
-                message=(
-                    f"test '{test.name}' mock __dbt_ref__{unreachable_dbt_ref} is unreachable"
-                ),
-            )
+    reachable_mocks.update(assertion_reached_table_functions)
+    warnings.extend(
+        _unreachable_mock_warnings(
+            test_name=test.name,
+            reachable_mocks=reachable_mocks,
+            mock_refs=mock_refs,
+            mock_sources=mock_sources,
+            mock_seeds=mock_seeds,
+            mock_dbt_refs=mock_dbt_refs,
+            mock_table_functions=mock_table_functions,
         )
+    )
 
     entry: SqlTestPlanEntry = SqlTestPlanEntry(
         key=test.key,
@@ -344,6 +329,7 @@ def plan_test(
         mock_source_names=tuple(sorted(mock_sources)),
         mock_seed_names=tuple(sorted(mock_seeds)),
         mock_dbt_ref_names=tuple(sorted(mock_dbt_refs)),
+        mock_table_function_names=tuple(sorted(mock_table_functions)),
         chain=tuple(chain_steps),
         assertions=assertion_steps,
         scope_deps=test.scope_deps,
@@ -353,6 +339,43 @@ def plan_test(
     return entry, tuple(warnings)
 
 
+def _unreachable_mock_warnings(
+    *,
+    test_name: str,
+    reachable_mocks: set[str],
+    mock_refs: dict[str, str],
+    mock_sources: dict[str, str],
+    mock_seeds: dict[str, str],
+    mock_dbt_refs: dict[str, str],
+    mock_table_functions: dict[str, str],
+) -> tuple[PlanWarning, ...]:
+    warnings: list[PlanWarning] = []
+    messages_by_mock: tuple[tuple[set[str], str, str], ...] = (
+        (
+            set(mock_refs),
+            "__ref__",
+            " is unreachable because a downstream model is also in the expected chain",
+        ),
+        (set(mock_sources), "__source__", " is unreachable"),
+        (set(mock_seeds), "__seed__", " is unreachable"),
+        (set(mock_dbt_refs), "__dbt_ref__", " is unreachable"),
+        (set(mock_table_functions), "__table_fn__", " is unreachable"),
+    )
+    names: set[str]
+    prefix: str
+    suffix: str
+    for names, prefix, suffix in messages_by_mock:
+        for name in sorted(names - reachable_mocks):
+            warnings.append(
+                PlanWarning(
+                    model_name=None,
+                    severity=WarningSeverity.WARNING,
+                    message=f"test '{test_name}' mock {prefix}{name}{suffix}",
+                )
+            )
+    return tuple(warnings)
+
+
 def resolve_test_model_chain_names(
     *,
     test: CompiledSqlTest,
@@ -387,24 +410,32 @@ def _build_assertion_steps(
     function_locations: dict[str, CompiledRelationLocation],
     qualified_function_locations: dict[str, str],
     helper_ctes: tuple[CompileSqlTestCte, ...],
+    mock_table_functions: dict[str, str],
     textual_chain: _TextualChainResolver,
     sql_analysis_resolved: dict[str, SqlAnalysisResolvedTestSql],
     adapter: BaseAdapter,
     sql_analysis_enabled: bool,
-) -> tuple[SqlTestAssertionStep, ...]:
+) -> tuple[tuple[SqlTestAssertionStep, ...], frozenset[str]]:
     mock_refs: dict[str, str] = _extract_mock_refs(test)
     mock_sources: dict[str, str] = _extract_mock_sources(test)
     mock_seeds: dict[str, str] = _extract_mock_seeds(test)
     mock_dbt_refs: dict[str, str] = _extract_mock_dbt_refs(test)
     assertion_steps: list[SqlTestAssertionStep] = []
+    reached_table_functions: set[str] = set()
     assertion_name: str
     assertion_sql: str
     for assertion_name, assertion_sql in assertion_map.items():
+        fixture_resolved_assertion_sql, reached = _resolve_table_function_fixtures(
+            query_sql=assertion_sql,
+            mock_table_functions=mock_table_functions,
+            helper_ctes=helper_ctes,
+        )
+        reached_table_functions.update(reached)
         resolved_assertion_sql: str | None = None
         if sql_analysis_enabled:
             analyzed_assertion_sql: SqlAnalysisResolvedTestSql | None = (
                 try_resolve_test_model_sql_with_sql_analysis(
-                    query_sql=assertion_sql,
+                    query_sql=fixture_resolved_assertion_sql,
                     mock_refs=mock_refs,
                     mock_sources=mock_sources,
                     mock_seeds=mock_seeds,
@@ -422,7 +453,7 @@ def _build_assertion_steps(
                 resolved_assertion_sql = analyzed_assertion_sql.resolved_sql
         if resolved_assertion_sql is None:
             resolved_assertion_sql = _resolve_assertion_sql(
-                sql=assertion_sql,
+                sql=fixture_resolved_assertion_sql,
                 resolved_chain=textual_chain.resolve_all(),
                 mock_refs=mock_refs,
                 mock_sources=mock_sources,
@@ -438,7 +469,7 @@ def _build_assertion_steps(
                 resolved_sql=resolved_assertion_sql,
             )
         )
-    return tuple(assertion_steps)
+    return tuple(assertion_steps), frozenset(reached_table_functions)
 
 
 def _plan_direct_logic_test(
@@ -561,6 +592,7 @@ def _resolve_assertion_sql(
         mock_sources=mock_sources,
         mock_seeds=mock_seeds,
         mock_dbt_refs=mock_dbt_refs,
+        mock_table_functions={},
         helper_ctes=helper_ctes,
         resolved_chain=assertion_resolved_chain,
         function_locations=function_locations,
@@ -635,6 +667,7 @@ def _resolve_test_model_sql(
     mock_sources: dict[str, str],
     mock_seeds: dict[str, str],
     mock_dbt_refs: dict[str, str],
+    mock_table_functions: dict[str, str],
     helper_ctes: tuple[CompileSqlTestCte, ...],
     resolved_chain: dict[str, str],
     function_locations: dict[str, CompiledRelationLocation],
@@ -723,6 +756,12 @@ def _resolve_test_model_sql(
     result = replace_uncommented_pattern(
         pattern=_DBT_REF_PATTERN, replacement=_replace_dbt_ref, sql=result
     )
+    result, reached_table_functions = _resolve_table_function_fixtures(
+        query_sql=result,
+        mock_table_functions=mock_table_functions,
+        helper_ctes=helper_ctes,
+    )
+    reachable_mocks.update(reached_table_functions)
     result = resolve_udf_references(
         query_sql=result,
         function_locations=function_locations,
@@ -847,6 +886,20 @@ def _wrap_mock_with_helpers(
     return f"({mock_body})"
 
 
+def _resolve_table_function_fixtures(
+    *,
+    query_sql: str,
+    mock_table_functions: dict[str, str],
+    helper_ctes: tuple[CompileSqlTestCte, ...],
+) -> tuple[str, frozenset[str]]:
+    helper_with: str = _build_helper_with_clause(helper_ctes)
+    fixtures: dict[str, str] = {
+        name: _wrap_mock_with_helpers(mock_body=body, helper_with=helper_with)
+        for name, body in mock_table_functions.items()
+    }
+    return resolve_table_function_fixture_references(query_sql=query_sql, fixtures=fixtures)
+
+
 def _build_helper_with_clause(
     helper_ctes: tuple[CompileSqlTestCte, ...],
 ) -> str:
@@ -973,6 +1026,20 @@ def _extract_mock_dbt_refs(test: CompiledSqlTest) -> dict[str, str]:
     return result
 
 
+def _extract_mock_table_functions(test: CompiledSqlTest) -> dict[str, str]:
+    """Extract mock table-function CTE bodies keyed by function name."""
+
+    result: dict[str, str] = {}
+    if not isinstance(test.payload, CompiledModelSqlTestPayload):
+        return result
+    cte: CompileSqlTestCte
+    for cte in test.payload.authored_ctes:
+        if cte.name.startswith(TABLE_FN_TEST_CTE_PREFIX):
+            name: str = cte.name.removeprefix(TABLE_FN_TEST_CTE_PREFIX)
+            result[name] = cte.sql_body
+    return result
+
+
 def _dbt_ref_fixture_name(*, package_name: str, model_name: str | None) -> str:
     if model_name is None:
         return package_name
@@ -997,6 +1064,8 @@ def _extract_helper_ctes(
             continue
         if cte.name.startswith(DBT_REF_TEST_CTE_PREFIX):
             continue
+        if cte.name.startswith(TABLE_FN_TEST_CTE_PREFIX):
+            continue
         if cte.name.startswith(ASSERT_TEST_CTE_PREFIX):
             continue
         helpers.append(cte)

{sqlbuild-0.108.0 → sqlbuild-0.109.0}/src/sqlbuild/compiler/planner/models.py

@@ -1167,6 +1167,7 @@ class SqlTestPlanEntry:
     mock_source_names: tuple[str, ...] = field(default_factory=tuple)
     mock_seed_names: tuple[str, ...] = field(default_factory=tuple)
     mock_dbt_ref_names: tuple[str, ...] = field(default_factory=tuple)
+    mock_table_function_names: tuple[str, ...] = field(default_factory=tuple)
     chain: tuple[ChainStep, ...] = field(default_factory=tuple)
     assertions: tuple[SqlTestAssertionStep, ...] = field(default_factory=tuple)
     scope_deps: tuple[CompiledObjectKey, ...] = field(default_factory=tuple)