pytrilogy 0.3.483__tar.gz → 0.3.485__tar.gz

{pytrilogy-0.3.483 → pytrilogy-0.3.485}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytrilogy
-Version: 0.3.483
+Version: 0.3.485
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11

{pytrilogy-0.3.483 → pytrilogy-0.3.485}/trilogy/__init__.py

@@ -7,7 +7,7 @@ if TYPE_CHECKING:
     from trilogy.executor import Executor
     from trilogy.parser import parse
 
-__version__ = "0.3.483"
+__version__ = "0.3.485"
 
 __all__ = [
     "CONFIG",

{pytrilogy-0.3.483 → pytrilogy-0.3.485}/trilogy/core/graph_models.py

@@ -132,6 +132,11 @@ def datasource_has_filter_sensitive_aggregate(
     return True
 
 
+def _reads_subselect(groups: Iterable[tuple[BuildConcept, ...]]) -> bool:
+    """A literal `in (...)` list reports one empty existence group."""
+    return any(group for group in groups)
+
+
 def _datasource_is_exact_match(
     ds: BuildDatasource,
     criteria: SearchCriteria,
@@ -158,7 +163,7 @@ def _datasource_is_exact_match(
         requested_addresses = relevant_concepts or ds_output_addresses
         if (
             allow_filter_application
-            and not conditions.existence_arguments
+            and not _reads_subselect(conditions.existence_arguments)
             and condition_addresses.issubset(ds_output_addresses)
             and condition_addresses.issubset(requested_addresses)
         ) and requested_addresses.isdisjoint(partial_addresses):
@@ -173,7 +178,7 @@ def _datasource_is_exact_match(
             has_aggregate_output
             and partial_addresses
             and allow_filter_application
-            and not conditions.existence_arguments
+            and not _reads_subselect(conditions.existence_arguments)
             and condition_addresses
             and condition_addresses.issubset(ds_output_addresses - partial_addresses)
         ):
@@ -188,7 +193,7 @@ def _datasource_is_exact_match(
             has_aggregate_output
             and canonical_to_concept is not None
             and allow_filter_application
-            and not conditions.existence_arguments
+            and not _reads_subselect(conditions.existence_arguments)
             and condition_addresses
         ):
             ds_grain_components = set(ds.grain.components)
@@ -275,7 +280,7 @@ def _get_collective_condition_matches(
     if not datasources:
         return keep
     for atom in decompose_condition(conditions.conditional):
-        if any(arg for group in atom.existence_arguments for arg in group):
+        if _reads_subselect(atom.existence_arguments):
             return set()
         if not is_scalar_condition(atom):
             return set()

{pytrilogy-0.3.483 → pytrilogy-0.3.485}/trilogy/core/processing/v4_helper/group_graph.py

@@ -2344,7 +2344,13 @@ def build_group_graph(
         environment,
         rollup_padded,
     )
-    _rehome_groups(group_graph, group_edges, attrs, buckets, concept_attrs, environment)
+    grouping = _elect_grouping_providers(
+        group_graph, group_edges, attrs, concept_attrs, environment
+    )
+    _state_projection_grains(attrs, buckets, grouping)
+    _rehome_groups(
+        group_graph, group_edges, attrs, buckets, concept_attrs, environment, grouping
+    )
     trace_group_graph(
         "FINAL added, concept sets computed, sources regrafted",
         group_graph,
@@ -2452,13 +2458,12 @@ def trace_group_graph(
 @dataclass(frozen=True)
 class RowProvider:
     """The row source a regraftable group is re-homed onto: the parent it
-    reads, the grain it adopts from a grouping provider, the lineage parents
-    that parent replaces, the dimension ROOT minted for it, and whether the
-    parent renders the group inline. Once elected (`_as_rewrite`) it holds
-    only what the graph lacks: `parent` is None when already a parent."""
+    reads, the lineage parents that parent replaces, the dimension ROOT minted
+    for it, and whether the parent renders the group inline. Once elected
+    (`_as_rewrite`) it holds only what the graph lacks: `parent` is None when
+    already a parent."""
 
     parent: str | None
-    grain: frozenset[str] | None = None
     drop: frozenset[str] = frozenset()
     minted: GroupBucket | None = None
     # the parent renders the group in its own SELECT: the group folds into it
@@ -2473,7 +2478,6 @@ def _regraft_candidate(
     *,
     allow_partial: bool,
     environment: BuildEnvironment | None = None,
-    grain: frozenset[str] | None = None,
 ) -> str | None:
     """Find the richest row-compatible sibling to source `gid`'s inputs.
 
@@ -2506,8 +2510,7 @@ def _regraft_candidate(
     merge.
     """
     current = attrs[gid]
-    if grain is None:
-        grain = current.grain_components
+    grain = current.grain_components
     needed = set(current.input_concepts)
     if not needed:
         return None
@@ -2586,14 +2589,16 @@ def _grain_needed_by_independent_sibling(
     attrs: dict[str, GroupAttrs],
     gid: str,
     provider_gid: str,
+    grouping: dict[str, str],
 ) -> bool:
     """Whether an independent FINAL-bound group co-grains on the provider's grain.
 
     Grafting the projection onto the provider fuses it into that group, which
     re-labels the provider's grouping key as this alias. Groups inside the
-    provider's own lineage follow that relabeling, but one that merges with it as
-    a separate arm does not: it would look for a key that no longer exists and
-    the merge would degenerate to a cross join.
+    provider's own lineage follow that relabeling, and so does a projection
+    placed at the same provider, but one that merges with it as a separate arm
+    does not: it would look for a key that no longer exists and the merge
+    would degenerate to a cross join.
     """
     provider_grain = attrs[provider_gid].grain_components
     if not provider_grain:
@@ -2601,6 +2606,7 @@ def _grain_needed_by_independent_sibling(
     related = (
         nx.ancestors(group_graph, provider_gid)
         | nx.descendants(group_graph, provider_gid)
+        | {g for g, p in grouping.items() if p == provider_gid}
         | {gid, provider_gid, FINAL_NODE_ID}
     )
     for other in group_graph.nodes:
@@ -2680,7 +2686,6 @@ def _synthetic_dimension_regraft_parent(
     buckets: dict[str, GroupBucket],
     concept_attrs: dict[str, ConceptAttrs],
     gid: str,
-    grain: frozenset[str],
 ) -> RowProvider | None:
     current = attrs[gid]
     if current.derivation != Derivation.BASIC:
@@ -2691,7 +2696,7 @@ def _synthetic_dimension_regraft_parent(
     # condition's derived arg needs.
     if current.depth_label == DepthLabel.D1:
         return None
-    key = set(grain)
+    key = set(current.grain_components)
     if not key:
         return None
     lineage_preds = lineage_predecessors(group_graph, group_edges, gid)
@@ -2860,6 +2865,45 @@ def _inline_window(
     return parent
 
 
+def _elect_grouping_providers(
+    group_graph: nx.DiGraph,
+    group_edges: EdgeMap,
+    attrs: dict[str, GroupAttrs],
+    concept_attrs: dict[str, ConceptAttrs],
+    environment: BuildEnvironment,
+) -> dict[str, str]:
+    """Each terminal scalar projection's grouping provider, elected over the
+    graph stage 2 built. A WINDOW that renders the projection inline outranks
+    it: that projection folds and keeps its grain."""
+    providers: dict[str, str] = {}
+    for gid in group_graph.nodes:
+        if gid == FINAL_NODE_ID:
+            continue
+        provider = _terminal_basic_grouping_provider(
+            group_graph, attrs, gid, environment
+        )
+        if provider is None or _inline_window(
+            group_graph, group_edges, attrs, concept_attrs, gid
+        ):
+            continue
+        providers[gid] = provider
+    return providers
+
+
+def _state_projection_grains(
+    attrs: dict[str, GroupAttrs],
+    buckets: dict[str, GroupBucket],
+    grouping: dict[str, str],
+) -> None:
+    """Place each terminal projection at its grouping provider's grain. No
+    provider is a BASIC, so no statement reads another."""
+    for gid, provider in grouping.items():
+        grain = attrs[provider].grain_components
+        attrs[gid].grain_components = grain
+        if gid in buckets:
+            buckets[gid].grain_components = grain
+
+
 def _elect_row_provider(
     group_graph: nx.DiGraph,
     group_edges: EdgeMap,
@@ -2867,45 +2911,42 @@ def _elect_row_provider(
     buckets: dict[str, GroupBucket],
     concept_attrs: dict[str, ConceptAttrs],
     environment: BuildEnvironment,
+    grouping: dict[str, str],
     gid: str,
 ) -> RowProvider | None:
     """Pick `gid`'s row source over the graph; mutates nothing. The choices,
-    in order: a WINDOW that renders it inline, a terminal BASIC's grouping
-    provider, a full-coverage sibling, a dimension ROOT, a partial spine."""
-    window = _inline_window(group_graph, group_edges, attrs, concept_attrs, gid)
-    if window is not None:
-        return RowProvider(window, inline=True)
-    grain = None
-    provider_gid = _terminal_basic_grouping_provider(
-        group_graph, attrs, gid, environment
-    )
-    if provider_gid is not None:
-        grain = attrs[provider_gid].grain_components
-        if not _grain_needed_by_independent_sibling(
-            group_graph, attrs, gid, provider_gid
-        ):
-            # Placed at the provider's grain, the projection has no use for
-            # a finer relation the provider was built from. Joined back, it
-            # pairs the provider's groups on a non-key (a region domain on
-            # a nullable description) and drops or multiplies them.
-            provider_ancestors = nx.ancestors(group_graph, provider_gid)
-            drop = frozenset(
-                pred
-                for pred in lineage_predecessors(group_graph, group_edges, gid)
-                if pred in provider_ancestors
-            )
-            return RowProvider(provider_gid, grain, drop)
-    own_grain = attrs[gid].grain_components if grain is None else grain
+    in order: a WINDOW that renders it inline, its grouping provider (whose
+    grain it already stands at), a full-coverage sibling, a dimension ROOT, a
+    partial spine."""
+    grouping_provider = grouping.get(gid)
+    if grouping_provider is None:
+        window = _inline_window(group_graph, group_edges, attrs, concept_attrs, gid)
+        if window is not None:
+            return RowProvider(window, inline=True)
+    elif not _grain_needed_by_independent_sibling(
+        group_graph, attrs, gid, grouping_provider, grouping
+    ):
+        # Placed at the provider's grain, the projection has no use for a
+        # finer relation the provider was built from. Joined back, it pairs
+        # the provider's groups on a non-key (a region domain on a nullable
+        # description) and drops or multiplies them.
+        provider_ancestors = nx.ancestors(group_graph, grouping_provider)
+        drop = frozenset(
+            pred
+            for pred in lineage_predecessors(group_graph, group_edges, gid)
+            if pred in provider_ancestors
+        )
+        return RowProvider(grouping_provider, drop)
     parent_gid = _regraft_candidate(
         group_graph, group_edges, attrs, gid, allow_partial=False
     )
     if parent_gid is not None:
-        return RowProvider(parent_gid, grain)
+        return RowProvider(parent_gid)
     dimension = _synthetic_dimension_regraft_parent(
-        group_graph, group_edges, attrs, buckets, concept_attrs, gid, own_grain
+        group_graph, group_edges, attrs, buckets, concept_attrs, gid
     )
     if dimension is not None:
-        return replace(dimension, grain=grain)
+        return dimension
     parent_gid = _regraft_candidate(
         group_graph,
         group_edges,
@@ -2913,11 +2954,8 @@ def _elect_row_provider(
         gid,
         allow_partial=True,
         environment=environment,
-        grain=own_grain,
     )
-    if parent_gid is None and grain is None:
-        return None
-    return RowProvider(parent_gid, grain)
+    return None if parent_gid is None else RowProvider(parent_gid)
 
 
 def _apply_row_provider(
@@ -2928,10 +2966,6 @@ def _apply_row_provider(
     gid: str,
     provider: RowProvider,
 ) -> None:
-    if provider.grain is not None:
-        attrs[gid].grain_components = provider.grain
-        if gid in buckets:
-            buckets[gid].grain_components = provider.grain
     minted = provider.minted
     if minted is not None and minted.group_id not in group_graph:
         group_graph.add_node(minted.group_id)
@@ -2947,23 +2981,13 @@ def _apply_row_provider(
 
 
 def _as_rewrite(
-    group_graph: nx.DiGraph,
-    attrs: dict[str, GroupAttrs],
-    buckets: dict[str, GroupBucket],
-    gid: str,
-    provider: RowProvider,
+    group_graph: nx.DiGraph, gid: str, provider: RowProvider
 ) -> RowProvider | None:
     """`provider` less what the graph stage 2 built already holds, or None
-    when it changes nothing: its parent is already a parent, its grain is
-    already the group's, and it drops and mints nothing."""
+    when it changes nothing: its parent is already a parent, and it drops and
+    mints nothing."""
     if provider.inline:
         return provider
-    grain = provider.grain
-    bucket = buckets.get(gid)
-    if grain == attrs[gid].grain_components and (
-        bucket is None or grain == bucket.grain_components
-    ):
-        grain = None
     drop = frozenset(p for p in provider.drop if group_graph.has_edge(p, gid))
     minted = provider.minted
     if minted is not None and minted.group_id in group_graph:
@@ -2971,9 +2995,9 @@ def _as_rewrite(
     parent = provider.parent
     if parent is not None and group_graph.has_edge(parent, gid):
         parent = None
-    if parent is None and grain is None and not drop and minted is None:
+    if parent is None and not drop and minted is None:
         return None
-    return RowProvider(parent, grain, drop, minted)
+    return RowProvider(parent, drop, minted)
 
 
 def _elect_row_providers(
@@ -2983,6 +3007,7 @@ def _elect_row_providers(
     buckets: dict[str, GroupBucket],
     concept_attrs: dict[str, ConceptAttrs],
     environment: BuildEnvironment,
+    grouping: dict[str, str],
 ) -> dict[str, RowProvider]:
     """Each regraftable group whose best row source is already built, elected
     over the graph as stage 2 built it, as the rewrite it makes of that graph.
@@ -3000,10 +3025,17 @@ def _elect_row_providers(
         ):
             continue
         provider = _elect_row_provider(
-            group_graph, group_edges, attrs, buckets, concept_attrs, environment, gid
+            group_graph,
+            group_edges,
+            attrs,
+            buckets,
+            concept_attrs,
+            environment,
+            grouping,
+            gid,
         )
         if provider is not None:
-            provider = _as_rewrite(group_graph, attrs, buckets, gid, provider)
+            provider = _as_rewrite(group_graph, gid, provider)
         if provider is not None:
             providers[gid] = provider
     folded = _folds(providers)
@@ -3029,12 +3061,14 @@ def _rehome_groups(
     buckets: dict[str, GroupBucket],
     concept_attrs: dict[str, ConceptAttrs],
     environment: BuildEnvironment,
+    grouping: dict[str, str],
 ) -> None:
     """Elect every group's row provider over the graph as stage 2 built it,
-    then fold each group its provider renders inline and apply the rest: no
-    election reads another's fold, edges or adopted grain."""
+    each projection already at its grouping provider's grain, then fold each
+    group its provider renders inline and apply the rest: no election reads
+    another's fold or edges."""
     providers = _elect_row_providers(
-        group_graph, group_edges, attrs, buckets, concept_attrs, environment
+        group_graph, group_edges, attrs, buckets, concept_attrs, environment, grouping
     )
     for gid, parent in _folds(providers).items():
         _absorb_group(gid, parent, group_graph, group_edges, attrs, buckets)

{pytrilogy-0.3.483 → pytrilogy-0.3.485}/trilogy/core/processing/v4_helper/network_build.py

@@ -96,6 +96,7 @@ from trilogy.core.processing.v4_helper.projection import (
 def _condition_fit(
     datasource: BuildDatasource | BuildUnionDatasource,
     conditions: BuildWhereClause | None,
+    environment: BuildEnvironment,
 ) -> ConditionFit:
     if conditions is None:
         return ConditionFit.NEUTRAL
@@ -104,9 +105,20 @@ def _condition_fit(
         conditions.conditional, non_partial_for.conditional
     ):
         return ConditionFit.IMPLIED_EXACT
-    if isinstance(
-        datasource, BuildDatasource
-    ) and datasource_has_filter_sensitive_aggregate(datasource, conditions):
+    # A condition on a property of the grain's keys selects whole groups, so
+    # the aggregate is kept (`Cover.joined_case_exact`); the map is only built
+    # when the plain check would refuse.
+    if (
+        isinstance(datasource, BuildDatasource)
+        and datasource_has_filter_sensitive_aggregate(datasource, conditions)
+        and datasource_has_filter_sensitive_aggregate(
+            datasource,
+            conditions,
+            canonical_to_concept={
+                c.canonical_address: c for c in environment.concepts.values()
+            },
+        )
+    ):
         return ConditionFit.SENSITIVE
     return ConditionFit.NEUTRAL
 
@@ -257,7 +269,7 @@ def _candidate(
         node=node,
         datasource=datasource,
         bindings=_bindings_for(emitted, partial, stored, equivalence),
-        condition=_condition_fit(datasource, conditions),
+        condition=_condition_fit(datasource, conditions, environment),
         is_union=isinstance(datasource, BuildUnionDatasource),
         grain=_grain_classes(datasource, equivalence),
     )

{pytrilogy-0.3.483 → pytrilogy-0.3.485}/trilogy/core/processing/v4_helper/network_model.py

@@ -509,10 +509,11 @@ class SolutionCost:
     # connector's subplan. At equal scan count the cover storing the column
     # wins, instead of whichever source sorts first.
     derived_terminals: int
-    # Sources read in full beside a twin the WHERE pre-filters: a `complete
-    # where` binding the query implies (IMPLIED_EXACT) reading the same
-    # columns holds only the rows the query keeps, so it outranks them.
-    unfiltered_sources: int
+    # Sources another candidate reading the same columns holds no more of the
+    # query's rows than (`Cost.filtered_dominated_le`): one read in full beside
+    # a twin the WHERE pre-filters (IMPLIED_EXACT), or a pre-filtered table
+    # beside a coarser source that applies the same WHERE.
+    dominated_reads: int
     connectors: int
     derived_joins: int
 

{pytrilogy-0.3.483 → pytrilogy-0.3.485}/trilogy/core/processing/v4_helper/network_search.py

@@ -39,6 +39,7 @@ from _preql_import_resolver import enumerate_network_covers
 from trilogy.core.graph_models import ReferenceGraph
 from trilogy.core.models.build import (
     BuildConcept,
+    BuildDatasource,
     BuildUnionDatasource,
     BuildWhereClause,
 )
@@ -287,24 +288,65 @@ def _stored_key(candidate: SourceCandidate, address: str) -> bool:
     return binding is not None and binding.stored
 
 
-def _has_filtered_twin(network: SourceNetwork, node: str, read: frozenset[str]) -> bool:
-    """Another source the WHERE pre-filters (IMPLIED_EXACT) reads every value
-    `node` provides or joins on from the same column, so it holds the rows of
-    `node` the query keeps."""
+def _reads_alike(
+    candidate: SourceCandidate, other: SourceCandidate, read: frozenset[str]
+) -> bool:
+    return all(
+        (mine := candidate.bindings.get(address)) is not None
+        and (theirs := other.bindings.get(address)) is not None
+        and mine.address == theirs.address
+        for address in read
+    )
+
+
+def _arm_columns(network: SourceNetwork, candidate: SourceCandidate) -> frozenset[str]:
+    arm = candidate.datasource.non_partial_for if candidate.datasource else None
+    return frozenset(
+        network.equivalence.get(c.address, c.address)
+        for c in (arm.conditional.concept_arguments if arm else ())
+    )
+
+
+def _filters_coarser(
+    network: SourceNetwork, coarse: SourceCandidate, filtered: SourceCandidate
+) -> bool:
+    """`coarse`'s grain is a function of `filtered`'s rows and `coarse` binds
+    the WHERE columns `filtered`'s arm reads, so under that WHERE it reads no
+    more rows (`Cost.filtered_dominated_le`)."""
+    arm = _arm_columns(network, filtered)
+    return (
+        bool(arm)
+        and coarse.grain != filtered.grain
+        and all(filtered.binds(address) for address in coarse.grain)
+        and all(coarse.binds(address) for address in arm)
+    )
+
+
+def _dominated_read(network: SourceNetwork, node: str, read: frozenset[str]) -> bool:
+    """Another candidate reading every value `node` provides or joins on, from
+    the same columns, holds no more of the rows the query keeps: a source the
+    WHERE pre-filters (IMPLIED_EXACT) beside one read in full, unless the full
+    one is the coarser and applies that WHERE itself; or a row-complete source
+    at a coarser grain applying the arm of a pre-filtered `node`."""
     candidate = network.candidates[node]
-    if not read or candidate.condition.partial_is_full:
+    if not read:
         return False
-    return any(
-        other.condition.partial_is_full
-        and all(
-            (mine := candidate.bindings.get(address)) is not None
-            and (theirs := other.bindings.get(address)) is not None
-            and mine.address == theirs.address
-            for address in read
-        )
-        for name, other in network.candidates.items()
-        if name != node
-    )
+    filtered = candidate.condition.partial_is_full
+    for name, other in network.candidates.items():
+        if name == node or not _reads_alike(candidate, other, read):
+            continue
+        if filtered:
+            if (
+                network.row_complete(name)
+                and all(other.binds_fully(address) for address in read)
+                and _filters_coarser(network, other, candidate)
+            ):
+                return True
+        elif other.condition.partial_is_full and not _filters_coarser(
+            network, candidate, other
+        ):
+            return True
+    return False
 
 
 def _solution_for(
@@ -364,10 +406,10 @@ def _solution_for(
             for address in addresses
             if not _stored_key(network.candidates[node], address)
         ),
-        unfiltered_sources=sum(
+        dominated_reads=sum(
             1
             for node in sources
-            if _has_filtered_twin(network, node, assignments[node] | joined_on[node])
+            if _dominated_read(network, node, assignments[node] | joined_on[node])
         ),
         connectors=len(connectors),
         derived_joins=derived_joins,
@@ -478,7 +520,11 @@ def search_sources(network: SourceNetwork) -> SearchResult:
             continue
         connected = _reduce(network, cover, targets)
         key = tuple(sorted(connected))
-        if key in seen or not _reads_a_scan(network, connected):
+        if (
+            key in seen
+            or not _reads_a_scan(network, connected)
+            or _bridges_unclaimed_rows(network, connected)
+        ):
             continue
         seen.add(key)
         reduced.append((connected, _binding_profile(network, connected, targets)))
@@ -501,6 +547,34 @@ def search_sources(network: SourceNetwork) -> SearchResult:
     return SearchResult(solution=best, limit=limit)
 
 
+def _unclaimed_partial(candidate: SourceCandidate) -> bool:
+    """A `partial datasource` the WHERE does not complete: every grain column
+    holds only some rows, and no `~` claims the rest have none."""
+    datasource = candidate.datasource
+    if candidate.condition.partial_is_full or not isinstance(
+        datasource, BuildDatasource
+    ):
+        return False
+    grain = [candidate.bindings.get(address) for address in candidate.grain]
+    return bool(grain) and all(
+        binding is not None
+        and binding.partial
+        and binding.address not in datasource.column_level_partial_addresses
+        for binding in grain
+    )
+
+
+def _bridges_unclaimed_rows(network: SourceNetwork, sources: frozenset[str]) -> bool:
+    """A source holding an unknown subset of its rows relates the sources on
+    either side of it only for that subset (`Cost.unimplied_partial_summary_loses_rows`):
+    it may end a join path, never be the only link between two others."""
+    return len(sources) > 2 and any(
+        _unclaimed_partial(network.candidates[node])
+        and not is_connected(network, sources - {node})
+        for node in sources
+    )
+
+
 def _reads_a_scan(network: SourceNetwork, sources: frozenset[str]) -> bool:
     """A derived connector exists to RELATE scans, so a cover made only of
     connectors reads no rows and is not an answer, however cheap it prices

{pytrilogy-0.3.483 → pytrilogy-0.3.485}/trilogy/core/validation/datasource.py

@@ -652,10 +652,16 @@ def validate_assertions(
 
     A refresh checks them against a staged build; here there is one asset and
     no previous one, so an assertion that reads ``prior(...)`` is reported but
-    not run.
+    not run. Every assertion is still planned against the asset, so one its
+    columns cannot answer fails here rather than at the next build.
     """
     from trilogy.core.assertions import plan_assertion
-    from trilogy.execution.assertions import evaluate_assertion, render_assertion
+    from trilogy.execution.assertions import (
+        UnanswerableAssertionError,
+        check_answerable,
+        evaluate_assertion,
+        render_assertion,
+    )
 
     declared = env.datasources.get(datasource.identifier)
     if declared is None or not declared.assertions:
@@ -663,6 +669,19 @@ def validate_assertions(
     results: list[ValidationTest] = []
     for assertion in declared.assertions:
         spelled = render_assertion(assertion)
+        if exec is not None:
+            try:
+                check_answerable(exec, declared, assertion)
+            except UnanswerableAssertionError as exc:
+                results.append(
+                    ValidationTest(
+                        check_type=ExpectationType.ASSERTION,
+                        expected=spelled,
+                        ran=True,
+                        result=DatasourceModelValidationError(str(exc)),
+                    )
+                )
+                continue
         if exec is None or plan_assertion(assertion.condition).uses_prior:
             results.append(
                 ValidationTest(