pytrilogy 0.0.1.110__py3-none-any.whl → 0.0.1.111__py3-none-any.whl

trilogy/core/processing/concept_strategies_v3.py

@@ -1,7 +1,6 @@
 from collections import defaultdict
 from typing import List, Optional, Callable
 
-
 from trilogy.constants import logger
 from trilogy.core.enums import PurposeLineage, Granularity, FunctionType
 from trilogy.core.env_processor import generate_graph
@@ -278,9 +277,10 @@ def generate_node(
         logger.info(
             f"{depth_to_prefix(depth)}{LOGGER_PREFIX} for {concept.address}, generating multiselect node with optional {[x.address for x in local_optional]}"
         )
-        return gen_concept_merge_node(
+        node = gen_concept_merge_node(
             concept, local_optional, environment, g, depth + 1, source_concepts, history
         )
+        return node
     elif concept.derivation == PurposeLineage.CONSTANT:
         logger.info(
             f"{depth_to_prefix(depth)}{LOGGER_PREFIX} for {concept.address}, generating constant node"
@@ -340,13 +340,15 @@ def validate_stack(
     stack: List[StrategyNode],
     concepts: List[Concept],
     accept_partial: bool = False,
-) -> tuple[ValidationResult, set[str], set[str], set[str]]:
+) -> tuple[ValidationResult, set[str], set[str], set[str], set[str]]:
     found_map = defaultdict(set)
     found_addresses: set[str] = set()
     non_partial_addresses: set[str] = set()
     partial_addresses: set[str] = set()
+    virtual_addresses: set[str] = set()
     for node in stack:
-        for concept in node.resolve().output_concepts:
+        resolved = node.resolve()
+        for concept in resolved.output_concepts:
             found_map[str(node)].add(concept)
             if concept not in node.partial_concepts:
                 found_addresses.add(concept.address)
@@ -354,11 +356,20 @@ def validate_stack(
                 # remove it from our partial tracking
                 if concept.address in partial_addresses:
                     partial_addresses.remove(concept.address)
+                if concept.address in virtual_addresses:
+                    virtual_addresses.remove(concept.address)
             if concept in node.partial_concepts:
+                if concept.address in non_partial_addresses:
+                    continue
                 partial_addresses.add(concept.address)
                 if accept_partial:
                     found_addresses.add(concept.address)
                     found_map[str(node)].add(concept)
+        for concept in node.virtual_output_concepts:
+            if concept.address in non_partial_addresses:
+                continue
+            found_addresses.add(concept.address)
+            virtual_addresses.add(concept.address)
     # zip in those we know we found
     if not all([c.address in found_addresses for c in concepts]):
         return (
@@ -366,12 +377,25 @@ def validate_stack(
             found_addresses,
             {c.address for c in concepts if c.address not in found_addresses},
             partial_addresses,
+            virtual_addresses,
         )
     graph_count, graphs = get_disconnected_components(found_map)
     if graph_count in (0, 1):
-        return ValidationResult.COMPLETE, found_addresses, set(), partial_addresses
+        return (
+            ValidationResult.COMPLETE,
+            found_addresses,
+            set(),
+            partial_addresses,
+            virtual_addresses,
+        )
     # if we have too many subgraphs, we need to keep searching
-    return ValidationResult.DISCONNECTED, found_addresses, set(), partial_addresses
+    return (
+        ValidationResult.DISCONNECTED,
+        found_addresses,
+        set(),
+        partial_addresses,
+        virtual_addresses,
+    )
 
 
 def depth_to_prefix(depth: int) -> str:
@@ -404,7 +428,10 @@ def search_concepts(
         accept_partial=accept_partial,
         history=history,
     )
-    history.search_to_history(mandatory_list, accept_partial, result)
+    # a node may be mutated after be cached; always store a copy
+    history.search_to_history(
+        mandatory_list, accept_partial, result.copy() if result else None
+    )
     return result
 
 
@@ -472,13 +499,13 @@ def _search_concepts(
                     skip.add(priority_concept.address)
                 break
         attempted.add(priority_concept.address)
-        complete, found, missing, partial = validate_stack(
+        complete, found, missing, partial, virtual = validate_stack(
             stack, mandatory_list, accept_partial
         )
 
         logger.info(
             f"{depth_to_prefix(depth)}{LOGGER_PREFIX} finished concept loop for {priority_concept} flag for accepting partial addresses is "
-            f" {accept_partial} (complete: {complete}), have {found} from {[n for n in stack]} (missing {missing} partial {partial}), attempted {attempted}"
+            f" {accept_partial} (complete: {complete}), have {found} from {[n for n in stack]} (missing {missing} partial {partial} virtual {virtual}), attempted {attempted}"
         )
         # early exit if we have a complete stack with one node
         # we can only early exit if we have a complete stack
@@ -489,7 +516,7 @@ def _search_concepts(
             break
 
     logger.info(
-        f"{depth_to_prefix(depth)}{LOGGER_PREFIX} finished sourcing loop (complete: {complete}), have {found} from {[n for n in stack]} (missing {all_mandatory - found}), attempted {attempted}"
+        f"{depth_to_prefix(depth)}{LOGGER_PREFIX} finished sourcing loop (complete: {complete}), have {found} from {[n for n in stack]} (missing {all_mandatory - found}), attempted {attempted}, virtual {virtual}"
     )
     if complete == ValidationResult.COMPLETE:
         all_partial = [
@@ -503,24 +530,22 @@ def _search_concepts(
                 ]
             )
         ]
+        non_virtual = [c for c in mandatory_list if c.address not in virtual]
         if len(stack) == 1:
+            output = stack[0]
             logger.info(
-                f"{depth_to_prefix(depth)}{LOGGER_PREFIX} Source stack has single node, returning just that node"
+                f"{depth_to_prefix(depth)}{LOGGER_PREFIX} Source stack has single node, returning that {type(output)}"
             )
-            return stack[0]
+            return output
 
         output = MergeNode(
-            input_concepts=mandatory_list,
-            output_concepts=mandatory_list,
+            input_concepts=non_virtual,
+            output_concepts=non_virtual,
             environment=environment,
             g=g,
             parents=stack,
             depth=depth,
             partial_concepts=all_partial,
-            # always hide merge concepts
-            hidden_concepts=[
-                x for x in mandatory_list if x.derivation == PurposeLineage.MERGE
-            ],
         )
 
         # ensure we can resolve our final merge
@@ -573,7 +598,7 @@ def _search_concepts(
             )
             return partial_search
     logger.error(
-        f"{depth_to_prefix(depth)}{LOGGER_PREFIX} Could not resolve concepts {[c.address for c in mandatory_list]}, network outcome was {complete}, missing {all_mandatory - found}"
+        f"{depth_to_prefix(depth)}{LOGGER_PREFIX} Could not resolve concepts {[c.address for c in mandatory_list]}, network outcome was {complete}, missing {all_mandatory - found},"
     )
     return None
 

trilogy/core/processing/node_generators/basic_node.py

@@ -8,6 +8,7 @@ from trilogy.core.processing.nodes import StrategyNode, History, MergeNode
 from trilogy.core.processing.node_generators.common import (
     resolve_function_parent_concepts,
 )
+from trilogy.utility import unique
 from trilogy.constants import logger
 
 LOGGER_PREFIX = "[GEN_BASIC_NODE]"
@@ -37,6 +38,7 @@ def gen_basic_node(
         attempts.append((parent_concepts + local_optional, local_optional + [concept]))
 
     for attempt, output in reversed(attempts):
+        attempt = unique(attempt, "address")
         parent_node = source_concepts(
             mandatory_list=attempt,
             environment=environment,

trilogy/core/processing/node_generators/common.py

@@ -56,7 +56,9 @@ def resolve_filter_parent_concepts(
     base_existence = []
     base_rows = [direct_parent]
     base_rows += concept.lineage.where.row_arguments
-    base_existence += concept.lineage.where.existence_arguments
+    # TODO: pass tuple groups through
+    for ctuple in concept.lineage.where.existence_arguments:
+        base_existence += list(ctuple)
     if direct_parent.grain:
         base_rows += direct_parent.grain.components_copy
     if (

trilogy/core/processing/node_generators/concept_merge_node.py

@@ -56,6 +56,7 @@ def gen_concept_merge_node(
 
     # get additional concepts that should be merged across the environments
     additional_merge: List[Concept] = [*lineage.concepts]
+    target_namespaces = set(x.namespace for x in [concept] + local_optional)
     for x in local_optional:
         if x.address in environment.merged_concepts:
             ms = environment.merged_concepts[x.address].lineage
@@ -64,6 +65,8 @@ def gen_concept_merge_node(
 
     for select in lineage.concepts:
         # if it's a merge concept, filter it out of the optional
+        if select.namespace not in target_namespaces:
+            continue
         sub_optional = [
             x
             for x in local_optional
@@ -76,6 +79,9 @@ def gen_concept_merge_node(
         ]
         sub_optional += sub_additional_merge
         final: List[Concept] = unique([select] + sub_optional, "address")
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} generating concept merge parent node with {[x.address for x in final]}"
+        )
         snode: StrategyNode = source_concepts(
             mandatory_list=final,
             environment=environment,
@@ -111,17 +117,18 @@ def gen_concept_merge_node(
 
     additional_relevant = [x for x in outputs if x.address in enrichment]
     final_outputs = outputs + additional_relevant + [concept]
+    virtual_outputs = [x for x in final_outputs if x.derivation == PurposeLineage.MERGE]
     node = MergeNode(
         input_concepts=[x for y in base_parents for x in y.output_concepts],
-        output_concepts=[x for x in final_outputs],
-        hidden_concepts=[
-            x for x in final_outputs if x.derivation == PurposeLineage.MERGE
+        output_concepts=[
+            x for x in final_outputs if x.derivation != PurposeLineage.MERGE
         ],
         environment=environment,
         g=g,
         depth=depth,
         parents=base_parents,
         node_joins=node_joins,
+        virtual_output_concepts=virtual_outputs,
     )
 
     qds = node.rebuild_cache()
@@ -149,9 +156,17 @@ def gen_concept_merge_node(
             f"{padding(depth)}{LOGGER_PREFIX} all enriched concepts returned from base merge concept node; exiting early"
         )
         return node
+    missing = [
+        x
+        for x in local_optional
+        if x.address not in [y.address for y in node.output_concepts]
+    ]
+    logger.info(
+        f"{padding(depth)}{LOGGER_PREFIX} generating merge concept enrichment node for missing {[x.address for x in missing]}"
+    )
     enrich_node: MergeNode = source_concepts(  # this fetches the parent + join keys
         # to then connect to the rest of the query
-        mandatory_list=additional_relevant + local_optional,
+        mandatory_list=additional_relevant + missing,
         environment=environment,
         g=g,
         depth=depth + 1,
@@ -159,7 +174,7 @@ def gen_concept_merge_node(
     )
     if not enrich_node:
         logger.info(
-            f"{padding(depth)}{LOGGER_PREFIX} Cannot generate merge concept enrichment node for {concept} with optional {local_optional}, returning just merge concept"
+            f"{padding(depth)}{LOGGER_PREFIX} Cannot generate merge concept enrichment node for {concept.address} with optional {[x.address for x in local_optional]}, returning just merge concept"
         )
         return node
 
@@ -170,12 +185,12 @@ def gen_concept_merge_node(
     return MergeNode(
         input_concepts=enrich_node.output_concepts + node.output_concepts,
         # also filter out the
-        output_concepts=node.output_concepts + local_optional,
-        hidden_concepts=[
+        output_concepts=[
             x
             for x in node.output_concepts + local_optional
-            if x.derivation == PurposeLineage.MERGE
+            if x.derivation != PurposeLineage.MERGE
         ],
+        hidden_concepts=[],
         environment=environment,
         g=g,
         depth=depth,
@@ -195,4 +210,5 @@ def gen_concept_merge_node(
             )
         ],
         partial_concepts=node.partial_concepts,
+        virtual_output_concepts=virtual_outputs,
     )

trilogy/core/processing/node_generators/filter_node.py

@@ -2,11 +2,14 @@ from typing import List
 
 
 from trilogy.core.enums import JoinType
-from trilogy.core.models import (
-    Concept,
-    Environment,
+from trilogy.core.models import Concept, Environment, FilterItem
+from trilogy.core.processing.nodes import (
+    FilterNode,
+    MergeNode,
+    NodeJoin,
+    History,
+    StrategyNode,
 )
-from trilogy.core.processing.nodes import FilterNode, MergeNode, NodeJoin, History
 from trilogy.core.processing.node_generators.common import (
     resolve_filter_parent_concepts,
 )
@@ -25,16 +28,19 @@ def gen_filter_node(
     depth: int,
     source_concepts,
     history: History | None = None,
-) -> MergeNode | FilterNode | None:
+) -> StrategyNode | None:
     immediate_parent, parent_row_concepts, parent_existence_concepts = (
         resolve_filter_parent_concepts(concept)
     )
+    if not isinstance(concept.lineage, FilterItem):
+        raise SyntaxError('Filter node must have a lineage of type "FilterItem"')
+    where = concept.lineage.where
 
     logger.info(
         f"{padding(depth)}{LOGGER_PREFIX} fetching filter node row parents {[x.address for x in parent_row_concepts]}"
     )
     core_parents = []
-    parent = source_concepts(
+    parent: StrategyNode = source_concepts(
         mandatory_list=parent_row_concepts,
         environment=environment,
         g=g,
@@ -43,7 +49,28 @@ def gen_filter_node(
     )
 
     if not parent:
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} filter node row parents {[x.address for x in parent_row_concepts]} could not be found"
+        )
         return None
+
+    if not local_optional and not parent_existence_concepts:
+        optimized_pushdown = True
+    else:
+        optimized_pushdown = False
+
+    if optimized_pushdown:
+        if parent.conditions:
+            parent.conditions = parent.conditions + where.conditional
+        else:
+            parent.conditions = where.conditional
+        parent.output_concepts = [concept]
+        parent.rebuild_cache()
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} returning optimized filter node with pushdown to parent with condition {where.conditional}"
+        )
+        return parent
+
     core_parents.append(parent)
     if parent_existence_concepts:
         logger.info(
@@ -57,6 +84,9 @@ def gen_filter_node(
             history=history,
         )
         if not parent_existence:
+            logger.info(
+                f"{padding(depth)}{LOGGER_PREFIX} filter existence node parents could not be found"
+            )
             return None
         core_parents.append(parent_existence)
 

trilogy/core/processing/node_generators/node_merge_node.py

@@ -10,6 +10,7 @@ from trilogy.utility import unique
 from trilogy.core.exceptions import AmbiguousRelationshipResolutionException
 from trilogy.core.processing.utility import padding
 from trilogy.core.processing.graph_utils import extract_mandatory_subgraphs
+from trilogy.core.enums import PurposeLineage
 
 LOGGER_PREFIX = "[GEN_MERGE_NODE]"
 
@@ -65,13 +66,13 @@ def identify_ds_join_paths(
         ]
         if partial and not accept_partial:
             return None
-        # join_candidates.append({"paths": paths, "datasource": datasource})
+
         return PathInfo(
             paths=paths,
             datasource=datasource,
             reduced_concepts=reduce_path_concepts(paths, g),
             concept_subgraphs=extract_mandatory_subgraphs(paths, g),
-        )  # {"paths": paths, "datasource": datasource}
+        )
     return None
 
 
@@ -88,14 +89,7 @@ def gen_merge_node(
     join_candidates: List[PathInfo] = []
     # anchor on datasources
     final_all_concepts = []
-    # implicit_upstream = {}
     for x in all_concepts:
-        # if x.derivation in (PurposeLineage.AGGREGATE, PurposeLineage.BASIC):
-        #     final_all_concepts +=resolve_function_parent_concepts(x)
-        # elif x.derivation == PurposeLineage.FILTER:
-        #     final_all_concepts +=resolve_filter_parent_concepts(x)
-        # else:
-        #     final_all_concepts.append(x)
         final_all_concepts.append(x)
     for datasource in environment.datasources.values():
         path = identify_ds_join_paths(final_all_concepts, g, datasource, accept_partial)
@@ -104,18 +98,25 @@ def gen_merge_node(
     join_candidates.sort(key=lambda x: sum([len(v) for v in x.paths.values()]))
     if not join_candidates:
         return None
-    for join_candidate in join_candidates:
-        logger.info(
-            f"{padding(depth)}{LOGGER_PREFIX} Join candidate: {join_candidate.paths}"
-        )
-    join_additions: List[set[str]] = []
+    join_additions: list[set[str]] = []
     for candidate in join_candidates:
         join_additions.append(candidate.reduced_concepts)
-    if not all(
-        [x.issubset(y) or y.issubset(x) for x in join_additions for y in join_additions]
-    ):
+
+    common: set[str] = set()
+    final_candidates: list[set[str]] = []
+    # find all values that show up in every join_additions
+    for ja in join_additions:
+        if not common:
+            common = ja
+        else:
+            common = common.intersection(ja)
+        if all(ja.issubset(y) for y in join_additions):
+            final_candidates.append(ja)
+
+    if not final_candidates:
+        filtered_paths = [x.difference(common) for x in join_additions]
         raise AmbiguousRelationshipResolutionException(
-            f"Ambiguous concept join resolution - possible paths =  {join_additions}. Include an additional concept to disambiguate",
+            f"Ambiguous concept join resolution fetching {[x.address for x in all_concepts]} - unique values in possible paths = {filtered_paths}. Include an additional concept to disambiguate",
             join_additions,
         )
     if not join_candidates:
@@ -123,9 +124,10 @@ def gen_merge_node(
             f"{padding(depth)}{LOGGER_PREFIX} No additional join candidates could be found"
         )
         return None
-    shortest: PathInfo = sorted(join_candidates, key=lambda x: len(x.reduced_concepts))[
-        0
-    ]
+    shortest: PathInfo = sorted(
+        [x for x in join_candidates if x.reduced_concepts in final_candidates],
+        key=lambda x: len(x.reduced_concepts),
+    )[0]
     logger.info(f"{padding(depth)}{LOGGER_PREFIX} final path is {shortest.paths}")
     # logger.info(f'{padding(depth)}{LOGGER_PREFIX} final reduced concepts are {shortest.concs}')
     parents = []
@@ -145,11 +147,20 @@ def gen_merge_node(
                 f"{padding(depth)}{LOGGER_PREFIX} Unable to instantiate target subgraph"
             )
             return None
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} finished subgraph fetch for {[c.address for c in graph]}, have parent {type(parent)}"
+        )
         parents.append(parent)
 
     return MergeNode(
-        input_concepts=[environment.concepts[x] for x in shortest.reduced_concepts],
-        output_concepts=all_concepts,
+        input_concepts=[
+            environment.concepts[x]
+            for x in shortest.reduced_concepts
+            if environment.concepts[x].derivation != PurposeLineage.MERGE
+        ],
+        output_concepts=[
+            x for x in all_concepts if x.derivation != PurposeLineage.MERGE
+        ],
         environment=environment,
         g=g,
         parents=parents,

trilogy/core/processing/node_generators/rowset_node.py

@@ -35,8 +35,26 @@ def gen_rowset_node(
     lineage: RowsetItem = concept.lineage
     rowset: RowsetDerivationStatement = lineage.rowset
     select: SelectStatement | MultiSelectStatement = lineage.rowset.select
+    parents: List[StrategyNode] = []
     if where := select.where_clause:
-        targets = select.output_components + where.conditional.concept_arguments
+        targets = select.output_components + where.conditional.row_arguments
+        for sub_select in where.conditional.existence_arguments:
+            logger.info(
+                f"{padding(depth)}{LOGGER_PREFIX} generating parent existence node with {[x.address for x in sub_select]}"
+            )
+            parent_check = source_concepts(
+                mandatory_list=sub_select,
+                environment=environment,
+                g=g,
+                depth=depth + 1,
+                history=history,
+            )
+            if not parent_check:
+                logger.info(
+                    f"{padding(depth)}{LOGGER_PREFIX} Cannot generate parent existence node for rowset node for {concept}"
+                )
+                return None
+            parents.append(parent_check)
     else:
         targets = select.output_components
     node: StrategyNode = source_concepts(
@@ -46,6 +64,14 @@ def gen_rowset_node(
         depth=depth + 1,
         history=history,
     )
+
+    # add our existence concepts in
+    if parents:
+        node.parents += parents
+        for parent in parents:
+            for x in parent.output_concepts:
+                if x.address not in node.output_lcl:
+                    node.existence_concepts.append(x)
     if not node:
         logger.info(
             f"{padding(depth)}{LOGGER_PREFIX} Cannot generate rowset node for {concept}"
@@ -53,11 +79,7 @@ def gen_rowset_node(
         return None
     node.conditions = select.where_clause.conditional if select.where_clause else None
     enrichment = set([x.address for x in local_optional])
-    rowset_relevant = [
-        x
-        for x in rowset.derived_concepts
-        # if x.address == concept.address or x.address in enrichment
-    ]
+    rowset_relevant = [x for x in rowset.derived_concepts]
     select_hidden = set([x.address for x in select.hidden_components])
     rowset_hidden = [
         x
@@ -86,9 +108,11 @@ def gen_rowset_node(
     # but don't include anything aggregate at this point
     node.rebuild_cache()
     assert node.resolution_cache
+
     node.resolution_cache.grain = concept_list_to_grain(
         node.output_concepts, parent_sources=node.resolution_cache.datasources
     )
+
     possible_joins = concept_to_relevant_joins(additional_relevant)
     if not local_optional:
         logger.info(

trilogy/core/processing/node_generators/select_node.py

@@ -53,7 +53,7 @@ def dm_to_strategy_node(
         # we have to group
         else:
             logger.info(
-                f"{padding(depth)}{LOGGER_PREFIX} not all grain components are in output {str(dm.matched)}, group to actual grain"
+                f"{padding(depth)}{LOGGER_PREFIX} not all grain components {target_grain} are in output {str(dm.matched)}, group to actual grain"
             )
             force_group = True
     elif all([x in dm.matched for x in datasource.grain.components]):
@@ -76,7 +76,7 @@ def dm_to_strategy_node(
         partial_concepts=dm.partial.concepts,
         accept_partial=accept_partial,
         datasource=datasource,
-        grain=Grain(components=dm.matched.concepts),
+        grain=datasource.grain,
     )
     # we need to nest the group node one further
     if force_group is True:
@@ -317,13 +317,19 @@ def gen_select_node_from_table(
         )
         if target_grain and target_grain.issubset(datasource.grain):
 
-            if all([x in all_lcl for x in target_grain.components]):
+            if (
+                all([x in all_lcl for x in target_grain.components])
+                and target_grain == datasource.grain
+            ):
+                logger.info(
+                    f"{padding(depth)}{LOGGER_PREFIX} target grain components match all lcl, group to false"
+                )
                 force_group = False
             # if we are not returning the grain
             # we have to group
             else:
                 logger.info(
-                    f"{padding(depth)}{LOGGER_PREFIX} not all grain components are in output {str(all_lcl)}, group to actual grain"
+                    f"{padding(depth)}{LOGGER_PREFIX} not all grain components {target_grain} are in output {str(all_lcl)}, group to actual grain"
                 )
                 force_group = True
         elif all([x in all_lcl for x in datasource.grain.components]):
@@ -363,7 +369,7 @@ def gen_select_node_from_table(
         else:
             candidate = bcandidate
         logger.info(
-            f"{padding(depth)}{LOGGER_PREFIX} found select node with {datasource.identifier}, returning {candidate.output_lcl}"
+            f"{padding(depth)}{LOGGER_PREFIX} found select node with {datasource.identifier}, force group is {force_group}, returning {candidate.output_lcl}"
         )
         candidates[datasource.identifier] = candidate
         scores[datasource.identifier] = -len(partial_concepts)
@@ -467,6 +473,8 @@ def gen_select_node(
         target_grain = Grain()
         for ac in all_concepts:
             target_grain += ac.grain
+    if target_grain.abstract:
+        target_grain = Grain(components=all_concepts)
     if materialized_lcl != all_lcl:
         logger.info(
             f"{padding(depth)}{LOGGER_PREFIX} Skipping select node generation for {concept.address} "
@@ -513,13 +521,15 @@ def gen_select_node(
                 [c.address in [x.address for x in p.partial_concepts] for p in parents]
             )
         ]
-        force_group = False
+        force_group = None
+        inferred_grain = sum([x.grain for x in parents if x.grain], Grain())
         for candidate in parents:
             if candidate.grain and not candidate.grain.issubset(target_grain):
                 force_group = True
         if len(parents) == 1:
             candidate = parents[0]
         else:
+
             candidate = MergeNode(
                 output_concepts=[concept] + found,
                 input_concepts=[concept] + found,
@@ -528,13 +538,13 @@ def gen_select_node(
                 parents=parents,
                 depth=depth,
                 partial_concepts=all_partial,
-                grain=sum([x.grain for x in parents if x.grain], Grain()),
+                grain=inferred_grain,
             )
         candidate.depth += 1
-        source_grain = candidate.grain
+        # source_grain = candidate.grain
         if force_group:
             logger.info(
-                f"{padding(depth)}{LOGGER_PREFIX} datasource grain {source_grain} does not match target grain {target_grain} for select, adding group node"
+                f"{padding(depth)}{LOGGER_PREFIX} datasource grain {inferred_grain} does not match target grain {target_grain} for select, adding group node"
             )
             return GroupNode(
                 output_concepts=candidate.output_concepts,
@@ -545,6 +555,10 @@ def gen_select_node(
                 depth=depth,
                 partial_concepts=candidate.partial_concepts,
             )
+        else:
+            logger.info(
+                f"{padding(depth)}{LOGGER_PREFIX} datasource grain {inferred_grain} matches target grain {target_grain} for select, returning without group"
+            )
         return candidate
 
     if not accept_partial_optional: