pytrilogy 0.0.3.32__tar.gz → 0.0.3.34__tar.gz

{pytrilogy-0.0.3.32/pytrilogy.egg-info → pytrilogy-0.0.3.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytrilogy
-Version: 0.0.3.32
+Version: 0.0.3.34
 Summary: Declarative, typed query language that compiles to SQL.
 Home-page: 
 Author: 

{pytrilogy-0.0.3.32 → pytrilogy-0.0.3.34/pytrilogy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytrilogy
-Version: 0.0.3.32
+Version: 0.0.3.34
 Summary: Declarative, typed query language that compiles to SQL.
 Home-page: 
 Author: 

{pytrilogy-0.0.3.32 → pytrilogy-0.0.3.34}/tests/test_query_processing.py

@@ -164,7 +164,9 @@ def test_query_aggregation(test_environment, test_environment_graph):
     select = SelectStatement(selection=[test_environment.concepts["total_revenue"]])
     datasource = get_query_datasources(environment=test_environment, statement=select)
 
-    assert {datasource.identifier} == {"revenue_at_local_order_id_at_abstract"}
+    assert {datasource.identifier} == {
+        "revenue_at_local_order_id_grouped_by__at_abstract"
+    }
     check = datasource
     assert len(check.input_concepts) == 2
     assert check.input_concepts[0].name == "revenue"

{pytrilogy-0.0.3.32 → pytrilogy-0.0.3.34}/tests/test_user_functions.py

@@ -119,9 +119,6 @@ select rowset.total;
 
 
 def test_user_function_case():
-    from trilogy.hooks.query_debugger import DebuggingHook
-
-    DebuggingHook()
     x = Dialects.DUCK_DB.default_executor()
 
     results = x.execute_query(
@@ -228,3 +225,69 @@ select
     )
     results = results.fetchall()
     assert results[0].quad_test == 16.414213562373096
+
+
+def test_user_function_nesting():
+    x = Dialects.DUCK_DB.default_executor()
+
+    results = x.execute_query(
+        """
+key x int;
+key y int;
+property x.price float;
+
+datasource raw_data (
+x: x,
+price: price
+)
+grain (x)
+query '''
+select 1 as x, 2.0 as price
+union all
+select 2 as x, 3.0 as price
+union all
+select 10 as x, 5.0 as price
+''';
+
+datasource join_x_y (
+x: x,
+y: y)
+grain (x, y)
+query '''
+select 1 as x, 1 as y
+union all
+select 2 as x, 1 as y
+union all
+select 10 as x, 2 as y
+''';
+
+def weekday_sales(weekday) ->  
+    SUM(CASE WHEN 10 = weekday THEN x ELSE 0 END) + 
+    SUM(CASE WHEN 10 = weekday THEN price ELSE 0.0 END)
+;
+
+def plus_two(a) -> a + 2;
+
+# auto random_no_f <- SUM(CASE WHEN 10 = weekday THEN x ELSE 0 END) + SUM(CASE WHEN 10 = weekday THEN price ELSE 0.0 END) +2;
+auto random_one_f <- @weekday_sales(10) +2;
+auto random <- @plus_two(@weekday_sales(10));
+                
+"""
+    )
+    # assert x.environment.concepts['random_no_f'].purpose == Purpose.METRIC, x.environment.concepts['random']
+    assert (
+        x.environment.concepts["random_one_f"].purpose == Purpose.METRIC
+    ), x.environment.concepts["random"]
+    assert (
+        x.environment.concepts["random"].purpose == Purpose.METRIC
+    ), x.environment.concepts["random"]
+
+    results = x.execute_query(
+        """select 
+        y,
+        @plus_two(@weekday_sales(10)) -> test2
+    order by y asc;"""
+    )
+    results = results.fetchall()
+    assert results[0].test2 == 10
+    assert results[1].test2 == 17

{pytrilogy-0.0.3.32 → pytrilogy-0.0.3.34}/trilogy/__init__.py

@@ -4,6 +4,6 @@ from trilogy.dialect.enums import Dialects
 from trilogy.executor import Executor
 from trilogy.parser import parse
 
-__version__ = "0.0.3.32"
+__version__ = "0.0.3.34"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

{pytrilogy-0.0.3.32 → pytrilogy-0.0.3.34}/trilogy/authoring/__init__.py

@@ -19,12 +19,15 @@ from trilogy.core.models.author import (
     Conditional,
     FilterItem,
     Function,
+    FunctionCallWrapper,
     HavingClause,
     MagicConstants,
     Metadata,
+    MultiSelectLineage,
     OrderBy,
     OrderItem,
     Parenthetical,
+    RowsetItem,
     SubselectComparison,
     WhereClause,
     WindowItem,
@@ -103,4 +106,7 @@ __all__ = [
     "RawSQLStatement",
     "Datasource",
     "DatasourceMetadata",
+    "MultiSelectLineage",
+    "RowsetItem",
+    "FunctionCallWrapper",
 ]

{pytrilogy-0.0.3.32 → pytrilogy-0.0.3.34}/trilogy/core/enums.py

@@ -27,6 +27,7 @@ class Purpose(Enum):
     CONSTANT = "const"
     KEY = "key"
     PROPERTY = "property"
+    UNIQUE_PROPERTY = "unique_property"
     METRIC = "metric"
     ROWSET = "rowset"
     AUTO = "auto"

{pytrilogy-0.0.3.32 → pytrilogy-0.0.3.34}/trilogy/core/models/author.py

@@ -1089,7 +1089,7 @@ class Concept(Addressable, DataTyped, ConceptArgs, Mergeable, Namespaced, BaseMo
             pseudonyms=self.pseudonyms,
         )
 
-    @property
+    @cached_property
     def sources(self) -> List["ConceptRef"]:
         if self.lineage:
             output: List[ConceptRef] = []
@@ -1326,7 +1326,7 @@ class OrderItem(Mergeable, ConceptArgs, Namespaced, BaseModel):
 
 class WindowItem(DataTyped, ConceptArgs, Mergeable, Namespaced, BaseModel):
     type: WindowType
-    content: ConceptRef
+    content: FuncArgs
     order_by: List["OrderItem"]
     over: List["ConceptRef"] = Field(default_factory=list)
     index: Optional[int] = None
@@ -1335,7 +1335,7 @@ class WindowItem(DataTyped, ConceptArgs, Mergeable, Namespaced, BaseModel):
         return self.__repr__()
 
     def __repr__(self):
-        return f"{self.type}({self.content} {self.index}, {self.over}, {self.order_by})"
+        return f"{self.type.value} {self.content} by {self.index} over {self.over} order {self.order_by}"
 
     @field_validator("content", mode="before")
     def enforce_concept_ref(cls, v):
@@ -1358,7 +1358,11 @@ class WindowItem(DataTyped, ConceptArgs, Mergeable, Namespaced, BaseModel):
     ) -> "WindowItem":
         output = WindowItem.model_construct(
             type=self.type,
-            content=self.content.with_merge(source, target, modifiers),
+            content=(
+                self.content.with_merge(source, target, modifiers)
+                if isinstance(self.content, Mergeable)
+                else self.content
+            ),
             over=[x.with_merge(source, target, modifiers) for x in self.over],
             order_by=[x.with_merge(source, target, modifiers) for x in self.order_by],
             index=self.index,
@@ -1379,7 +1383,11 @@ class WindowItem(DataTyped, ConceptArgs, Mergeable, Namespaced, BaseModel):
     def with_namespace(self, namespace: str) -> "WindowItem":
         return WindowItem.model_construct(
             type=self.type,
-            content=self.content.with_namespace(namespace),
+            content=(
+                self.content.with_namespace(namespace)
+                if isinstance(self.content, Namespaced)
+                else self.content
+            ),
             over=[x.with_namespace(namespace) for x in self.over],
             order_by=[x.with_namespace(namespace) for x in self.order_by],
             index=self.index,
@@ -1387,7 +1395,8 @@ class WindowItem(DataTyped, ConceptArgs, Mergeable, Namespaced, BaseModel):
 
     @property
     def concept_arguments(self) -> List[ConceptRef]:
-        output = [self.content]
+        output = []
+        output += get_concept_arguments(self.content)
         for order in self.order_by:
             output += get_concept_arguments(order)
         for item in self.over:
@@ -1787,6 +1796,10 @@ class FunctionCallWrapper(
             ],
         )
 
+    def with_reference_replacement(self, source, target):
+        raise NotImplementedError("Cannot reference replace")
+        return self
+
     def with_merge(
         self, source: Concept, target: Concept, modifiers: List[Modifier]
     ) -> "FunctionCallWrapper":

{pytrilogy-0.0.3.32 → pytrilogy-0.0.3.34}/trilogy/core/models/build.py

@@ -1646,7 +1646,7 @@ class Factory:
 
     @build.register
     def _(self, base: WindowItem) -> BuildWindowItem:
-
+        # to do proper discovery, we need to inject virtual intermediate ocncepts
         return BuildWindowItem.model_construct(
             type=base.type,
             content=self.build(base.content),

{pytrilogy-0.0.3.32 → pytrilogy-0.0.3.34}/trilogy/core/models/build_environment.py

@@ -31,19 +31,12 @@ class BuildEnvironmentConceptDict(dict):
     def raise_undefined(
         self, key: str, line_no: int | None = None, file: Path | str | None = None
     ) -> Never:
-
-        matches = self._find_similar_concepts(key)
-        message = f"Undefined concept: {key}."
-        if matches:
-            message += f" Suggestions: {matches}"
-
-        if line_no:
-            if file:
-                raise UndefinedConceptException(
-                    f"{file}: {line_no}: " + message, matches
-                )
-            raise UndefinedConceptException(f"line: {line_no}: " + message, matches)
-        raise UndefinedConceptException(message, matches)
+        # build environment should never check for missing values.
+        if line_no is not None:
+            message = f"Concept '{key}' not found in environment at line {line_no}."
+        else:
+            message = f"Concept '{key}' not found in environment."
+        raise UndefinedConceptException(message, [])
 
     def __getitem__(
         self, key: str, line_no: int | None = None, file: Path | None = None

{pytrilogy-0.0.3.32 → pytrilogy-0.0.3.34}/trilogy/core/models/environment.py

@@ -686,7 +686,8 @@ class Environment(BaseModel):
                 replacements[k] = target
             # we need to update keys and grains of all concepts
             else:
-                replacements[k] = v.with_merge(source, target, modifiers)
+                if source.address in v.sources or source.address in v.grain.components:
+                    replacements[k] = v.with_merge(source, target, modifiers)
         self.concepts.update(replacements)
         for k, ds in self.datasources.items():
             if source.address in ds.output_lcl:

{pytrilogy-0.0.3.32 → pytrilogy-0.0.3.34}/trilogy/core/models/execute.py

@@ -282,6 +282,7 @@ class CTE(BaseModel):
             **self.existence_source_map,
             **other.existence_source_map,
         }
+
         return self
 
     @property
@@ -637,7 +638,7 @@ class QueryDatasource(BaseModel):
                     and CONFIG.validate_missing
                 ):
                     raise SyntaxError(
-                        f"On query datasource missing source map for {concept.address} on {key}, have {v}"
+                        f"On query datasource missing source map for {concept.address} on {key} with pseudonyms {concept.pseudonyms}, have {v}"
                     )
         return v
 
@@ -764,8 +765,15 @@ class QueryDatasource(BaseModel):
     def identifier(self) -> str:
         filters = abs(hash(str(self.condition))) if self.condition else ""
         grain = "_".join([str(c).replace(".", "_") for c in self.grain.components])
+        group = ""
+        if self.source_type == SourceType.GROUP:
+            keys = [
+                x.address for x in self.output_concepts if x.purpose != Purpose.METRIC
+            ]
+            group = "_grouped_by_" + "_".join(keys)
         return (
             "_join_".join([d.identifier for d in self.datasources])
+            + group
             + (f"_at_{grain}" if grain else "_at_abstract")
             + (f"_filtered_by_{filters}" if filters else "")
         )

{pytrilogy-0.0.3.32 → pytrilogy-0.0.3.34}/trilogy/core/optimization.py

@@ -94,6 +94,11 @@ def filter_irrelevant_ctes(
     inverse_map = gen_inverse_map(input)
     recurse(root_cte, inverse_map)
     final = [cte for cte in input if cte.name in relevant_ctes]
+    filtered = [cte for cte in input if cte.name not in relevant_ctes]
+    if filtered:
+        logger.info(
+            f"[Optimization][Irrelevent CTE filtering] Removing redundant CTEs {[x.name for x in filtered]}"
+        )
     if len(final) == len(input):
         return input
     return filter_irrelevant_ctes(final, root_cte)
@@ -130,6 +135,9 @@ def is_direct_return_eligible(cte: CTE | UnionCTE) -> CTE | UnionCTE | None:
     if not output_addresses.issubset(parent_output_addresses):
         return None
     if not direct_parent.grain == cte.grain:
+        logger.info("grain mismatch, cannot early exit")
+        logger.info(direct_parent.grain)
+        logger.info(cte.grain)
         return None
 
     assert isinstance(cte, CTE)

{pytrilogy-0.0.3.32 → pytrilogy-0.0.3.34}/trilogy/core/processing/concept_strategies_v3.py

@@ -625,6 +625,7 @@ def validate_stack(
         for concept in resolved.output_concepts:
             if concept.address in resolved.hidden_concepts:
                 continue
+
             validate_concept(
                 concept,
                 node,
@@ -773,6 +774,8 @@ def _search_concepts(
 ) -> StrategyNode | None:
     # these are the concepts we need in the output projection
     mandatory_list = unique(mandatory_list, "address")
+    # cache our values before an filter injection
+    original_mandatory = [*mandatory_list]
     for x in mandatory_list:
         if isinstance(x, UndefinedConcept):
             raise SyntaxError(f"Undefined concept {x.address}")
@@ -857,7 +860,7 @@ def _search_concepts(
             and priority_concept.address not in conditions.row_arguments
         ):
             logger.info(
-                f"{depth_to_prefix(depth)}{LOGGER_PREFIX} Force including conditions to push filtering above complex condition that is not condition member or parent"
+                f"{depth_to_prefix(depth)}{LOGGER_PREFIX} Force including conditions in {priority_concept.address} to push filtering above complex condition that is not condition member or parent"
             )
             local_conditions = conditions
 
@@ -921,7 +924,7 @@ def _search_concepts(
         mandatory_completion = [c.address for c in completion_mandatory]
         logger.info(
             f"{depth_to_prefix(depth)}{LOGGER_PREFIX} finished concept loop for {priority_concept} {priority_concept.derivation} condition {conditions} flag for accepting partial addresses is"
-            f" {accept_partial} (complete: {complete}), have {found} from {[n for n in stack]} (missing {missing} partial {partial} virtual {virtual}), attempted {attempted}, mandatory w/ filter {mandatory_completion}"
+            f" {accept_partial} (complete: {complete}), have {found} from {[n for n in stack]} (missing {missing} synonyms  partial {partial} virtual {virtual}), attempted {attempted}, mandatory w/ filter {mandatory_completion}"
         )
         if complete == ValidationResult.INCOMPLETE_CONDITION:
             cond_dict = {str(node): node.preexisting_conditions for node in stack}
@@ -933,7 +936,23 @@ def _search_concepts(
         if complete == ValidationResult.COMPLETE and (
             not accept_partial or (accept_partial and not partial)
         ):
+            logger.info(
+                f"{depth_to_prefix(depth)}{LOGGER_PREFIX} breaking loop, complete"
+            )
             break
+        elif complete == ValidationResult.COMPLETE and accept_partial and partial:
+            if len(attempted) == len(mandatory_list):
+                logger.info(
+                    f"{depth_to_prefix(depth)}{LOGGER_PREFIX} Breaking as we have attempted all nodes"
+                )
+                break
+            logger.info(
+                f"{depth_to_prefix(depth)}{LOGGER_PREFIX} Found complete stack with partials {partial}, continuing search, attempted {attempted} all {len(mandatory_list)}"
+            )
+        else:
+            logger.info(
+                f"{depth_to_prefix(depth)}{LOGGER_PREFIX} Not complete, continuing search"
+            )
         # if we have attempted on root node, we've tried them all.
         # inject in another search with filter concepts
         if priority_concept.derivation == Derivation.ROOT:
@@ -948,6 +967,11 @@ def _search_concepts(
     if complete == ValidationResult.COMPLETE:
         condition_required = True
         non_virtual = [c for c in completion_mandatory if c.address not in virtual]
+        non_virtual_output = [c for c in original_mandatory if c.address not in virtual]
+        non_virtual_different = len(completion_mandatory) != len(original_mandatory)
+        non_virtual_difference_values = set(
+            [x.address for x in completion_mandatory]
+        ).difference(set([x.address for x in original_mandatory]))
         if not conditions:
             condition_required = False
             non_virtual = [c for c in mandatory_list if c.address not in virtual]
@@ -966,7 +990,19 @@ def _search_concepts(
             )
         if len(stack) == 1:
             output: StrategyNode = stack[0]
-            # _ = restrict_node_outputs_targets(output, mandatory_list, depth)
+            if non_virtual_different:
+                logger.info(
+                    f"{depth_to_prefix(depth)}{LOGGER_PREFIX} Found different non-virtual output concepts ({non_virtual_difference_values}), removing condition injected values"
+                )
+                output.set_output_concepts(
+                    [
+                        x
+                        for x in output.output_concepts
+                        if x.address in non_virtual_output
+                    ],
+                    rebuild=False,
+                )
+
             logger.info(
                 f"{depth_to_prefix(depth)}{LOGGER_PREFIX} Source stack has single node, returning that {type(output)}"
             )
@@ -995,6 +1031,30 @@ def _search_concepts(
         logger.info(
             f"{depth_to_prefix(depth)}{LOGGER_PREFIX} Graph is connected, returning {type(output)} node partial {[c.address for c in output.partial_concepts]}"
         )
+        if condition_required and conditions and non_virtual_different:
+            logger.info(
+                f"{depth_to_prefix(depth)}{LOGGER_PREFIX} Conditions {conditions} were injected, checking if we need a group to restore grain"
+            )
+            result = GroupNode.check_if_required(
+                downstream_concepts=original_mandatory,
+                parents=[output.resolve()],
+                environment=environment,
+                depth=depth,
+            )
+            logger.info(f"gcheck result is {result}")
+            if result.required:
+                logger.info(
+                    f"{depth_to_prefix(depth)}{LOGGER_PREFIX} Adding group node"
+                )
+                return GroupNode(
+                    output_concepts=original_mandatory,
+                    input_concepts=original_mandatory,
+                    environment=environment,
+                    parents=[output],
+                    partial_concepts=output.partial_concepts,
+                    preexisting_conditions=conditions.conditional,
+                    depth=depth,
+                )
         return output
 
     # if we can't find it after expanding to a merge, then

{pytrilogy-0.0.3.32 → pytrilogy-0.0.3.34}/trilogy/core/processing/node_generators/group_node.py

@@ -149,7 +149,9 @@ def gen_group_node(
         g=g,
         depth=depth,
         source_concepts=source_concepts,
-        log_lambda=create_log_lambda(LOGGER_PREFIX, depth, logger),
+        log_lambda=create_log_lambda(
+            LOGGER_PREFIX + f" for {concept.address}", depth, logger
+        ),
         history=history,
         conditions=conditions,
     )

{pytrilogy-0.0.3.32 → pytrilogy-0.0.3.34}/trilogy/core/processing/node_generators/rowset_node.py

@@ -117,7 +117,11 @@ def gen_rowset_node(
         f"{padding(depth)}{LOGGER_PREFIX} final output is {[x.address for x in node.output_concepts]}"
     )
     if not local_optional or all(
-        x.address in node.output_concepts and x.address not in node.partial_concepts
+        (
+            x.address in node.output_concepts
+            or (z in x.pseudonyms for z in node.output_concepts)
+        )
+        and x.address not in node.partial_concepts
         for x in local_optional
     ):
         logger.info(

{pytrilogy-0.0.3.32 → pytrilogy-0.0.3.34}/trilogy/core/processing/node_generators/select_merge_node.py

@@ -344,12 +344,14 @@ def create_datasource_node(
         for c in datasource.columns
         if not c.is_complete and c.concept.address in all_concepts
     ]
+
     partial_lcl = LooseBuildConceptList(concepts=partial_concepts)
     nullable_concepts = [
         c.concept
         for c in datasource.columns
         if c.is_nullable and c.concept.address in all_concepts
     ]
+
     nullable_lcl = LooseBuildConceptList(concepts=nullable_concepts)
     partial_is_full = conditions and (conditions == datasource.non_partial_for)
 

{pytrilogy-0.0.3.32 → pytrilogy-0.0.3.34}/trilogy/core/processing/nodes/group_node.py

@@ -2,7 +2,7 @@ from dataclasses import dataclass
 from typing import List, Optional
 
 from trilogy.constants import logger
-from trilogy.core.enums import SourceType
+from trilogy.core.enums import Purpose, SourceType
 from trilogy.core.models.build import (
     BuildComparison,
     BuildConcept,
@@ -78,7 +78,9 @@ class GroupNode(StrategyNode):
         downstream_concepts: List[BuildConcept],
         parents: list[QueryDatasource | BuildDatasource],
         environment: BuildEnvironment,
+        depth: int = 0,
     ) -> GroupRequiredResponse:
+        padding = "\t" * depth
         target_grain = BuildGrain.from_concepts(
             downstream_concepts,
             environment=environment,
@@ -95,12 +97,67 @@ class GroupNode(StrategyNode):
         lookups: list[BuildConcept | str] = [
             concept_map[x] if x in concept_map else x for x in comp_grain.components
         ]
+
         comp_grain = BuildGrain.from_concepts(lookups, environment=environment)
+
         # dynamically select if we need to group
         # because sometimes, we are already at required grain
         if comp_grain.issubset(target_grain):
+
+            logger.info(
+                f"{padding}{LOGGER_PREFIX} Group requirement check: {comp_grain}, {target_grain}, is subset, no grain required"
+            )
             return GroupRequiredResponse(target_grain, comp_grain, False)
+        # find out what extra is in the comp grain vs target grain
+        difference = [
+            environment.concepts[c] for c in (comp_grain - target_grain).components
+        ]
+        logger.info(
+            f"{padding}{LOGGER_PREFIX} Group requirement check: {comp_grain}, {target_grain}, difference {difference}"
+        )
+
+        # if the difference is all unique properties whose keys are in the source grain
+        # we can also suppress the group
+        if all(
+            [
+                x.purpose == Purpose.UNIQUE_PROPERTY
+                and x.keys
+                and all(z in comp_grain.components for z in x.keys)
+                for x in difference
+            ]
+        ):
+            logger.info(
+                f"{padding}{LOGGER_PREFIX} Group requirement check: skipped due to unique property validation"
+            )
+            return GroupRequiredResponse(target_grain, comp_grain, False)
+        if all([x.purpose == Purpose.KEY for x in difference]):
+            logger.info(
+                f"{padding}{LOGGER_PREFIX} checking if downstream is unique properties of key"
+            )
+            replaced_grain_raw: list[set[str]] = [
+                (
+                    x.keys or set()
+                    if x.purpose == Purpose.UNIQUE_PROPERTY
+                    else set([x.address])
+                )
+                for x in downstream_concepts
+                if x.address in target_grain.components
+            ]
+            # flatten the list of lists
+            replaced_grain = [
+                item for sublist in replaced_grain_raw for item in sublist
+            ]
+            # if the replaced grain is a subset of the comp grain, we can skip the group
+            unique_grain_comp = BuildGrain.from_concepts(
+                replaced_grain, environment=environment
+            )
+            if comp_grain.issubset(unique_grain_comp):
+                logger.info(
+                    f"{padding}{LOGGER_PREFIX} Group requirement check: skipped due to unique property validation"
+                )
+                return GroupRequiredResponse(target_grain, comp_grain, False)
 
+        logger.info(f"{padding}{LOGGER_PREFIX} Group requirement check: group required")
         return GroupRequiredResponse(target_grain, comp_grain, True)
 
     def _resolve(self) -> QueryDatasource:

{pytrilogy-0.0.3.32 → pytrilogy-0.0.3.34}/trilogy/core/processing/nodes/merge_node.py

@@ -296,9 +296,21 @@ class MergeNode(StrategyNode):
                 return dataset
 
         pregrain = BuildGrain()
+
         for source in final_datasets:
+            if all(
+                [x.address in self.existence_concepts for x in source.output_concepts]
+            ):
+                logger.info(
+                    f"{self.logging_prefix}{LOGGER_PREFIX} skipping existence only source with {source.output_concepts} from grain accumulation"
+                )
+                continue
             pregrain += source.grain
 
+        pregrain = BuildGrain.from_concepts(
+            pregrain.components, environment=self.environment
+        )
+
         grain = self.grain if self.grain else pregrain
         logger.info(
             f"{self.logging_prefix}{LOGGER_PREFIX} has pre grain {pregrain} and final merge node grain {grain}"
@@ -310,6 +322,7 @@ class MergeNode(StrategyNode):
             )
         else:
             joins = []
+
         logger.info(
             f"{self.logging_prefix}{LOGGER_PREFIX} Final join count for CTE parent count {len(join_candidates)} is {len(joins)}"
         )
@@ -343,7 +356,6 @@ class MergeNode(StrategyNode):
         nullable_concepts = find_nullable_concepts(
             source_map=source_map, joins=joins, datasources=final_datasets
         )
-
         qds = QueryDatasource(
             input_concepts=unique(self.input_concepts, "address"),
             output_concepts=unique(self.output_concepts, "address"),