sqlbuild 0.110.4__tar.gz → 0.110.6__tar.gz

{sqlbuild-0.110.4 → sqlbuild-0.110.6}/Cargo.lock

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

{sqlbuild-0.110.4 → sqlbuild-0.110.6}/PKG-INFO

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

{sqlbuild-0.110.4 → sqlbuild-0.110.6}/crates/sqlbuild-rules-native/Cargo.toml

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

{sqlbuild-0.110.4 → sqlbuild-0.110.6}/pyproject.toml

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

{sqlbuild-0.110.4 → sqlbuild-0.110.6}/src/sqlbuild/adapter/contract/classes/base_adapter.py

@@ -1954,6 +1954,11 @@ class BaseAdapter(RetentionAdapterMixin, StrictAdapter):
 
         return '"' + name.replace('"', '""') + '"'
 
+    def render_exact_identifier(self, name: str) -> str:
+        """Render one explicitly quoted identifier without changing its logical spelling."""
+
+        return self.render_identifier(name)
+
     def render_framework_type(self, type_name: FrameworkType) -> str:
         """Render one framework-internal logical type using generic SQL defaults."""
 

{sqlbuild-0.110.4 → sqlbuild-0.110.6}/src/sqlbuild/adapter/contract/classes/duckdb_backed_adapter.py

@@ -291,6 +291,11 @@ class DuckDbBackedAdapter(UnkeyedDiffMixin, BaseAdapter):
 
         return '"' + name.replace('"', '""') + '"'
 
+    def render_exact_identifier(self, name: str) -> str:
+        """Render one explicitly quoted DuckDB identifier with its exact case."""
+
+        return self.render_identifier(name)
+
     def render_loader_logical_type(self, type_name: LoaderLogicalType) -> str:
         match type_name:
             case LoaderLogicalType.BOOLEAN:

{sqlbuild-0.110.4 → sqlbuild-0.110.6}/src/sqlbuild/adapter/contract/classes/strict_adapter.py

@@ -680,6 +680,11 @@ class StrictAdapter(
         """Render one SQL identifier for this adapter."""
         ...
 
+    @abstractmethod
+    def render_exact_identifier(self, name: str) -> str:
+        """Render one explicitly quoted identifier without changing its logical spelling."""
+        ...
+
     @abstractmethod
     def render_framework_type(self, type_name: FrameworkType) -> str:
         """Render one framework-internal logical type for this adapter."""

{sqlbuild-0.110.4 → sqlbuild-0.110.6}/src/sqlbuild/adapters/bigquery/classes/bigquery_adapter.py

@@ -972,6 +972,9 @@ class BigQueryAdapter(MicrobatchMixin, UnkeyedDiffMixin, BaseAdapter):
     def render_identifier(self, name: str) -> str:
         return "`" + name.replace("`", "``") + "`"
 
+    def render_exact_identifier(self, name: str) -> str:
+        return self.render_identifier(name)
+
     def _quote_sql_string(self, value: str) -> str:
         return "'" + value.replace("'", "''") + "'"
 

{sqlbuild-0.110.4 → sqlbuild-0.110.6}/src/sqlbuild/adapters/databricks/classes/databricks_adapter.py

@@ -728,6 +728,9 @@ class DatabricksAdapter(MicrobatchMixin, UnkeyedDiffMixin, BaseAdapter):
     def render_identifier(self, name: str) -> str:
         return "`" + name.replace("`", "``") + "`"
 
+    def render_exact_identifier(self, name: str) -> str:
+        return self.render_identifier(name)
+
     def render_loader_logical_type(self, type_name: LoaderLogicalType) -> str:
         match type_name:
             case LoaderLogicalType.BOOLEAN:

{sqlbuild-0.110.4 → sqlbuild-0.110.6}/src/sqlbuild/adapters/postgres/classes/postgres_adapter.py

@@ -1660,6 +1660,11 @@ class PostgresAdapter(MicrobatchMixin, UnkeyedDiffMixin, BaseAdapter):
 
         return '"' + name.replace('"', '""') + '"'
 
+    def render_exact_identifier(self, name: str) -> str:
+        """Render one explicitly quoted PostgreSQL identifier with its exact case."""
+
+        return self.render_identifier(name)
+
     def render_loader_logical_type(self, type_name: LoaderLogicalType) -> str:
         match type_name:
             case LoaderLogicalType.BOOLEAN:

{sqlbuild-0.110.4 → sqlbuild-0.110.6}/src/sqlbuild/adapters/snowflake/classes/snowflake_adapter.py

@@ -1064,6 +1064,11 @@ class SnowflakeAdapter(MicrobatchMixin, UnkeyedDiffMixin, BaseAdapter):
 
         return '"' + name.upper().replace('"', '""') + '"'
 
+    def render_exact_identifier(self, name: str) -> str:
+        """Render one explicitly quoted Snowflake identifier with its exact case."""
+
+        return '"' + name.replace('"', '""') + '"'
+
     def render_loader_logical_type(self, type_name: LoaderLogicalType) -> str:
         match type_name:
             case LoaderLogicalType.BOOLEAN:

{sqlbuild-0.110.4 → sqlbuild-0.110.6}/src/sqlbuild/adapters/sqlserver/classes/sqlserver_adapter.py

@@ -954,6 +954,9 @@ class SqlServerAdapter(MicrobatchMixin, UnkeyedDiffMixin, BaseAdapter):
     def render_identifier(self, name: str) -> str:
         return "[" + name.replace("]", "]]") + "]"
 
+    def render_exact_identifier(self, name: str) -> str:
+        return self.render_identifier(name)
+
     def render_framework_type(self, type_name: FrameworkType) -> str:
         match type_name:
             case FrameworkType.STRING:

sqlbuild-0.110.6/src/sqlbuild/compiler/compile/_helpers/analysis/fixture_columns.py

@@ -0,0 +1,151 @@
+"""Fixture-column inference implementation."""
+
+from __future__ import annotations
+
+from typing import Any, cast
+
+from sqlbuild.adapter.contract.models import ExpressionInferenceProfile
+from sqlbuild.compiler.compile._helpers.analysis.columns import (
+    analyze_columns_and_lineage_with_polyglot,
+)
+from sqlbuild.compiler.compile.constants import (
+    POLYGLOT_ARRAY_KIND,
+    POLYGLOT_FUNCTION_KIND,
+    POLYGLOT_LITERAL_KIND,
+    POLYGLOT_STRUCTURED_KINDS,
+)
+from sqlbuild.compiler.compile.models import (
+    FixtureColumnInference,
+    InferredColumn,
+    PolyglotAnalysisResult,
+)
+from sqlbuild.compiler.sql_analysis.constants import POLYGLOT_KIND_NULL
+from sqlbuild.compiler.sql_analysis.main.import_polyglot_sql import import_polyglot_sql
+
+
+def infer_fixture_column_facts(
+    *, query_sql: str, inference_profile: ExpressionInferenceProfile
+) -> FixtureColumnInference | None:
+    """Infer fixture columns and identify explicitly untyped NULL projections."""
+
+    analysis: PolyglotAnalysisResult = analyze_columns_and_lineage_with_polyglot(
+        query_sql=query_sql,
+        inference_profile=inference_profile,
+    )
+    if not analysis.analysis_succeeded or analysis.has_star or analysis.columns is None:
+        return None
+    simple_types, null_literal_names, quoted_names = _simple_projection_facts(
+        query_sql=query_sql,
+        dialect=inference_profile.sql_analysis_dialect,
+    )
+    return FixtureColumnInference(
+        columns=tuple(
+            InferredColumn(
+                name=column.name,
+                type=column.type or simple_types.get(column.name.casefold()),
+                nullability=column.nullability,
+            )
+            for column in analysis.columns
+        ),
+        null_literal_names=null_literal_names,
+        quoted_names=quoted_names,
+    )
+
+
+def _simple_projection_facts(
+    *, query_sql: str, dialect: str | None
+) -> tuple[dict[str, str], frozenset[str], frozenset[str]]:
+    polyglot_sql: Any = import_polyglot_sql()
+    try:
+        payload: dict[str, Any] = polyglot_sql.parse_one(
+            query_sql, dialect=dialect or "generic"
+        ).to_dict()
+    except polyglot_sql.PolyglotError:
+        return {}, frozenset(), frozenset()
+    direct_select_payload: object = payload.get("select")
+    select_payload: dict[str, Any] | None = _first_select(payload)
+    if select_payload is None:
+        return {}, frozenset(), frozenset()
+    types, null_literal_names, quoted_names = _collect_projection_facts(
+        select_payload=select_payload
+    )
+    effective_null_literal_names: frozenset[str] = (
+        null_literal_names if isinstance(direct_select_payload, dict) else frozenset()
+    )
+    return types, effective_null_literal_names, quoted_names
+
+
+def _collect_projection_facts(
+    *, select_payload: dict[str, Any]
+) -> tuple[dict[str, str], frozenset[str], frozenset[str]]:
+    types: dict[str, str] = {}
+    null_literal_names: set[str] = set()
+    quoted_names: set[str] = set()
+    for expression in select_payload.get("expressions", []):
+        alias_payload: object = expression.get("alias") if isinstance(expression, dict) else None
+        if not isinstance(alias_payload, dict):
+            continue
+        alias: object = alias_payload.get("alias")
+        value: object = alias_payload.get("this")
+        if not isinstance(alias, dict) or not isinstance(value, dict):
+            continue
+        name: object = alias.get("name")
+        if not isinstance(name, str):
+            continue
+        if alias.get("quoted") is True:
+            quoted_names.add(name.casefold())
+        raw_value_kind: object = next(iter(value), "")
+        if not isinstance(raw_value_kind, str):
+            continue
+        value_payload: object = value.get(raw_value_kind)
+        if raw_value_kind == POLYGLOT_KIND_NULL:
+            null_literal_names.add(name.casefold())
+            continue
+        inferred_type: str | None = _simple_expression_type(
+            value_kind=raw_value_kind,
+            value_payload=value_payload,
+        )
+        if inferred_type is not None:
+            types[name.casefold()] = inferred_type
+    return types, frozenset(null_literal_names), frozenset(quoted_names)
+
+
+def _simple_expression_type(*, value_kind: str, value_payload: object) -> str | None:
+    if value_kind == POLYGLOT_LITERAL_KIND and isinstance(value_payload, dict):
+        value_dict: dict[object, object] = cast(dict[object, object], value_payload)
+        return {
+            "string": "VARCHAR",
+            "number": "NUMBER",
+            "boolean": "BOOLEAN",
+        }.get(str(value_dict.get("literal_type")))
+    if value_kind == POLYGLOT_ARRAY_KIND:
+        return "ARRAY"
+    if value_kind in POLYGLOT_STRUCTURED_KINDS:
+        return "VARIANT"
+    if value_kind == POLYGLOT_FUNCTION_KIND and isinstance(value_payload, dict):
+        value_dict = cast(dict[object, object], value_payload)
+        function_name: str = str(value_dict.get("name") or "").upper()
+        return {
+            "ARRAY_CONSTRUCT": "ARRAY",
+            "OBJECT_CONSTRUCT": "OBJECT",
+            "PARSE_JSON": "VARIANT",
+        }.get(function_name)
+    return None
+
+
+def _first_select(payload: object) -> dict[str, Any] | None:
+    if isinstance(payload, dict):
+        payload_dict: dict[object, object] = cast(dict[object, object], payload)
+        select_payload: object = payload_dict.get("select")
+        if isinstance(select_payload, dict):
+            return cast(dict[str, Any], select_payload)
+        for value in payload_dict.values():
+            found: dict[str, Any] | None = _first_select(value)
+            if found is not None:
+                return found
+    if isinstance(payload, list):
+        for value in payload:
+            found = _first_select(value)
+            if found is not None:
+                return found
+    return None

sqlbuild-0.110.6/src/sqlbuild/compiler/compile/main/_infer_fixture_columns.py

@@ -0,0 +1,20 @@
+"""Public fixture-column inference entrypoint."""
+
+from __future__ import annotations
+
+from sqlbuild.adapter.contract.models import ExpressionInferenceProfile
+from sqlbuild.compiler.compile._helpers.analysis.fixture_columns import (
+    infer_fixture_column_facts as _infer_fixture_column_facts,
+)
+from sqlbuild.compiler.compile.models import FixtureColumnInference
+
+
+def infer_fixture_column_facts(
+    *, query_sql: str, inference_profile: ExpressionInferenceProfile
+) -> FixtureColumnInference | None:
+    """Infer fixture columns and identify explicitly untyped NULL projections."""
+
+    return _infer_fixture_column_facts(
+        query_sql=query_sql,
+        inference_profile=inference_profile,
+    )

{sqlbuild-0.110.4 → sqlbuild-0.110.6}/src/sqlbuild/compiler/compile/models.py

@@ -144,6 +144,15 @@ class InferredColumn:
     nullability: InferredNullability = InferredNullability.UNKNOWN
 
 
+@dataclass(frozen=True)
+class FixtureColumnInference:
+    """Inferred fixture columns plus outputs that are explicitly bare NULL literals."""
+
+    columns: tuple[InferredColumn, ...]
+    null_literal_names: frozenset[str]
+    quoted_names: frozenset[str]
+
+
 @dataclass(frozen=True)
 class DynamicColumnFamilyProof:
     """Compiler evidence for one declared runtime-generated column family."""

sqlbuild-0.110.6/src/sqlbuild/compiler/pipeline/_helpers/analysis_selection.py

@@ -0,0 +1,69 @@
+"""Selection policy for deep model SQL analysis."""
+
+from __future__ import annotations
+
+from sqlbuild.compiler.compile.models import (
+    CompileAnalysisSelection,
+    CompiledObjectKey,
+    CompiledProject,
+)
+from sqlbuild.compiler.discovery.models import DiscoveredProjectInputs
+from sqlbuild.compiler.pipeline.models import CompilePipelineOptions
+from sqlbuild.compiler.planner.main.selection._resolve_planner_scopes import (
+    resolve_planner_scopes,
+)
+from sqlbuild.compiler.planner.models import (
+    PlannerPolicies,
+    PlannerScopeResolution,
+    PlannerSelection,
+)
+
+
+def resolve_compile_analysis_selection(
+    *,
+    options: CompilePipelineOptions,
+    discovered_inputs: DiscoveredProjectInputs,
+) -> CompileAnalysisSelection | None:
+    """Limit analysis when selectors cannot resolve through Python graph nodes."""
+
+    has_python_nodes: bool = bool(
+        discovered_inputs.loader_functions
+        or discovered_inputs.task_functions
+        or discovered_inputs.asset_functions
+        or discovered_inputs.check_functions
+    )
+    if options.resolve_python_run_selectors and has_python_nodes:
+        return CompileAnalysisSelection(no_cache=options.no_cache)
+    return CompileAnalysisSelection(
+        select=options.select,
+        exclude=options.exclude,
+        auto_load_sources=options.auto_load_sources,
+        no_cache=options.no_cache,
+    )
+
+
+def resolve_configured_rule_selection(
+    *,
+    options: CompilePipelineOptions,
+    discovered_inputs: DiscoveredProjectInputs,
+    project: CompiledProject,
+) -> frozenset[CompiledObjectKey] | None:
+    """Align configured-rule subjects with models that received deep SQL analysis."""
+
+    analysis_selection: CompileAnalysisSelection | None = resolve_compile_analysis_selection(
+        options=options,
+        discovered_inputs=discovered_inputs,
+    )
+    if analysis_selection is None or (
+        not analysis_selection.select and not analysis_selection.exclude
+    ):
+        return None
+    scopes: PlannerScopeResolution = resolve_planner_scopes(
+        project=project,
+        selection=PlannerSelection(
+            select=analysis_selection.select,
+            exclude=analysis_selection.exclude,
+        ),
+        policies=PlannerPolicies(auto_load_sources=analysis_selection.auto_load_sources),
+    )
+    return frozenset(model.key for model in scopes.stale_warning_scope.models_by_name.values())

{sqlbuild-0.110.4 → sqlbuild-0.110.6}/src/sqlbuild/compiler/pipeline/main/compile.py

@@ -22,6 +22,9 @@ from sqlbuild.compiler.graph.main._build_lineage_downstream_deps import (
 from sqlbuild.compiler.graph.main._build_lineage_upstream_deps import (
     build_lineage_upstream_deps,
 )
+from sqlbuild.compiler.pipeline._helpers.analysis_selection import (
+    resolve_configured_rule_selection,
+)
 from sqlbuild.compiler.pipeline._helpers.deferred_locations import (
     build_deferred_locations,
     gather_deferred_relations,
@@ -106,7 +109,11 @@ def run_compile_pipeline(
         config=rules_config,
         project_dir=project_dir,
         dialect=adapter.sql_analysis_dialect() or "generic",
-        selected_keys=None,
+        selected_keys=resolve_configured_rule_selection(
+            options=resolved_options,
+            discovered_inputs=discovered_inputs,
+            project=project,
+        ),
     )
     if on_progress is not None:
         on_progress(

{sqlbuild-0.110.4 → sqlbuild-0.110.6}/src/sqlbuild/compiler/planner/_helpers/fixtures/completion.py

@@ -10,7 +10,7 @@ from sqlbuild.adapter.contract.classes.base_adapter import BaseAdapter
 from sqlbuild.compiler.compile.main._analyze_columns_and_lineage import (
     analyze_resolved_column_reads,
 )
-from sqlbuild.compiler.compile.main._infer_fixture_columns import infer_fixture_columns
+from sqlbuild.compiler.compile.main._infer_fixture_columns import infer_fixture_column_facts
 from sqlbuild.compiler.compile.models import (
     CompiledLineageColumnFact,
     CompiledLineageSourceFact,
@@ -18,6 +18,7 @@ from sqlbuild.compiler.compile.models import (
     CompiledProject,
     CompileSqlReference,
     DynamicColumnContractProof,
+    FixtureColumnInference,
     InferredColumn,
 )
 from sqlbuild.compiler.compile.types import CompiledResourceType
@@ -58,16 +59,20 @@ def build_relation_fixture_completion(
     model_map: dict[str, CompiledModel] = context.models_by_name
     fixture_sql_by_key: dict[FixtureKey, str] = {}
     inferred_by_fixture: dict[FixtureKey, tuple[InferredColumn, ...]] = {}
+    null_literal_names_by_fixture: dict[FixtureKey, frozenset[str]] = {}
+    quoted_names_by_fixture: dict[FixtureKey, frozenset[str]] = {}
     for resource_type, fixtures in fixture_groups:
         for name, sql in fixtures.items():
             key: FixtureKey = (resource_type, name)
             fixture_sql_by_key[key] = sql
-            inferred: tuple[InferredColumn, ...] | None = infer_fixture_columns(
+            inference: FixtureColumnInference | None = infer_fixture_column_facts(
                 query_sql=sql,
                 inference_profile=adapter.expression_inference_profile(),
             )
-            if inferred is not None:
-                inferred_by_fixture[key] = inferred
+            if inference is not None:
+                inferred_by_fixture[key] = inference.columns
+                null_literal_names_by_fixture[key] = inference.null_literal_names
+                quoted_names_by_fixture[key] = inference.quoted_names
 
     relations: dict[FixtureKey, FixtureRelationMetadata] = context.relations
     fixture_keys_requiring_analysis: frozenset[FixtureKey] = _fixture_keys_requiring_analysis(
@@ -89,6 +94,10 @@ def build_relation_fixture_completion(
         ordered_model_names=ordered_model_names,
         model_map=model_map,
     )
+    typed_nulls_by_fixture: dict[FixtureKey, dict[str, str]] = _typed_null_fixture_types(
+        null_literal_names_by_fixture=null_literal_names_by_fixture,
+        expected_types=expected_types,
+    )
     diagnostics: list[RelationFixtureDiagnostic] = list(
         _unknown_fixture_column_diagnostics(
             inferred_by_fixture=inferred_by_fixture,
@@ -96,6 +105,7 @@ def build_relation_fixture_completion(
         )
     )
 
+    completed_keys: set[FixtureKey] = set()
     for key, required_columns in required.items():
         inferred: tuple[InferredColumn, ...] | None = inferred_by_fixture.get(key)
         if inferred is None:
@@ -104,7 +114,8 @@ def build_relation_fixture_completion(
         missing: tuple[str, ...] = tuple(
             sorted(name for name in required_columns if name.casefold() not in available_names)
         )
-        if not missing:
+        typed_nulls: dict[str, str] = typed_nulls_by_fixture.get(key, {})
+        if not missing and not typed_nulls:
             continue
         relation: FixtureRelationMetadata | None = relations.get(key)
         metadata: tuple[FixtureColumnMetadata, ...] = (
@@ -172,9 +183,26 @@ def build_relation_fixture_completion(
         nullable_columns.sort(key=lambda column: metadata_order[column.name.casefold()])
         fixture_sql_by_key[key] = _completed_fixture_sql(
             sql=fixture_sql_by_key[key],
+            inferred=inferred,
+            typed_nulls=typed_nulls,
+            quoted_names=quoted_names_by_fixture.get(key, frozenset()),
             completed=tuple(nullable_columns),
             adapter=adapter,
         )
+        completed_keys.add(key)
+
+    for key, typed_nulls in typed_nulls_by_fixture.items():
+        if key in completed_keys:
+            continue
+        inferred = inferred_by_fixture[key]
+        fixture_sql_by_key[key] = _completed_fixture_sql(
+            sql=fixture_sql_by_key[key],
+            inferred=inferred,
+            typed_nulls=typed_nulls,
+            quoted_names=quoted_names_by_fixture.get(key, frozenset()),
+            completed=(),
+            adapter=adapter,
+        )
 
     return RelationFixtureCompletion(
         fixture_sql_by_key=fixture_sql_by_key,
@@ -184,6 +212,24 @@ def build_relation_fixture_completion(
     )
 
 
+def _typed_null_fixture_types(
+    *,
+    null_literal_names_by_fixture: dict[FixtureKey, frozenset[str]],
+    expected_types: dict[FixtureKey, dict[str, str]],
+) -> dict[FixtureKey, dict[str, str]]:
+    result: dict[FixtureKey, dict[str, str]] = {}
+    for key, null_literal_names in null_literal_names_by_fixture.items():
+        fixture_types: dict[str, str] = {}
+        expected_fixture_types: dict[str, str] = expected_types.get(key, {})
+        for name in null_literal_names:
+            expected_type: str | None = expected_fixture_types.get(name)
+            if expected_type is not None:
+                fixture_types[name] = expected_type
+        if fixture_types:
+            result[key] = fixture_types
+    return result
+
+
 def _fixture_keys_requiring_analysis(
     *,
     inferred_by_fixture: dict[FixtureKey, tuple[InferredColumn, ...]],
@@ -607,11 +653,31 @@ def _supplied_columns_form_schema_prefix(
 def _completed_fixture_sql(
     *,
     sql: str,
+    inferred: tuple[InferredColumn, ...],
+    typed_nulls: dict[str, str],
+    quoted_names: frozenset[str],
     completed: tuple[FixtureColumnMetadata, ...],
     adapter: BaseAdapter,
 ) -> str:
     alias: str = adapter.render_identifier(_PARTIAL_FIXTURE_ALIAS)
-    projections: list[str] = [f"{alias}.*"]
+    projections: list[str]
+    if typed_nulls:
+        projections = []
+        for supplied_column in inferred:
+            rendered_name: str = (
+                adapter.render_exact_identifier(supplied_column.name)
+                if supplied_column.name.casefold() in quoted_names
+                else supplied_column.name
+            )
+            source_expression: str = f"{alias}.{rendered_name}"
+            expected_type: str | None = typed_nulls.get(supplied_column.name.casefold())
+            projections.append(
+                source_expression
+                if expected_type is None
+                else f"CAST({source_expression} AS {expected_type}) AS {rendered_name}"
+            )
+    else:
+        projections = [f"{alias}.*"]
     for completed_column in completed:
         projections.append(
             f"CAST(NULL AS {completed_column.type}) AS "

{sqlbuild-0.110.4 → sqlbuild-0.110.6}/src/sqlbuild/compiler/planner/_helpers/sql_tests/fixture_validation.py

@@ -5,10 +5,11 @@ from __future__ import annotations
 import re
 
 from sqlbuild.adapter.contract.classes.base_adapter import BaseAdapter
-from sqlbuild.compiler.compile.main._infer_fixture_columns import infer_fixture_columns
+from sqlbuild.compiler.compile.main._infer_fixture_columns import infer_fixture_column_facts
 from sqlbuild.compiler.compile.models import (
     CompiledProject,
     CompiledSqlTest,
+    FixtureColumnInference,
     InferredColumn,
 )
 from sqlbuild.compiler.compile.types import CompiledResourceType
@@ -65,10 +66,11 @@ def build_validated_test_fixtures(
         for name, sql in fixtures.items():
             inferred_columns: tuple[InferredColumn, ...] | None
             if resource_type == CompiledResourceType.SQL_TEST:
-                inferred_columns = infer_fixture_columns(
+                inference: FixtureColumnInference | None = infer_fixture_column_facts(
                     query_sql=sql,
                     inference_profile=adapter.expression_inference_profile(),
                 )
+                inferred_columns = inference.columns if inference is not None else None
             else:
                 inferred_columns = completion.inferred_by_fixture.get((resource_type, name))
             if inferred_columns is None: