pytrilogy 0.0.2.26__tar.gz → 0.0.2.27__tar.gz

{pytrilogy-0.0.2.26/pytrilogy.egg-info → pytrilogy-0.0.2.27}/PKG-INFO

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

{pytrilogy-0.0.2.26 → pytrilogy-0.0.2.27/pytrilogy.egg-info}/PKG-INFO

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

{pytrilogy-0.0.2.26 → pytrilogy-0.0.2.27}/tests/test_parsing.py

@@ -491,6 +491,28 @@ select x;
     assert "abcdef as test" in results, results
 
 
+def test_datasource_where_equivalent():
+
+    text = """
+key x int;
+key y int;
+
+datasource test (
+x:x,
+y:~y)
+grain(x)
+complete where y > 10
+address `abc:def`
+;
+
+
+"""
+    env, parsed = parse_text(text)
+
+    ds = parsed[-1]
+    assert ds.non_partial_for.conditional.right == 10
+
+
 def test_filter_concise():
 
     text = """

{pytrilogy-0.0.2.26 → pytrilogy-0.0.2.27}/tests/test_partial_handling.py

@@ -74,7 +74,7 @@ def setup_titanic(env: Environment):
 
     env.add_datasource(
         Datasource(
-            identifier="raw_data",
+            name="raw_data",
             address="raw_titanic",
             columns=[
                 ColumnAssignment(alias="passengerid", concept=id),

{pytrilogy-0.0.2.26 → pytrilogy-0.0.2.27}/tests/test_query_processing.py

@@ -134,7 +134,7 @@ def test_query_aggregation(test_environment, test_environment_graph):
         environment=test_environment, graph=test_environment_graph, statement=select
     )
 
-    assert {datasource.identifier} == {"local_revenue_at_local_order_id_at_abstract"}
+    assert {datasource.identifier} == {"revenue_at_local_order_id_at_abstract"}
     check = datasource
     assert len(check.input_concepts) == 2
     assert check.input_concepts[0].name == "revenue"

{pytrilogy-0.0.2.26 → pytrilogy-0.0.2.27}/trilogy/__init__.py

@@ -4,6 +4,6 @@ from trilogy.executor import Executor
 from trilogy.parser import parse
 from trilogy.constants import CONFIG
 
-__version__ = "0.0.2.26"
+__version__ = "0.0.2.27"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

{pytrilogy-0.0.2.26 → pytrilogy-0.0.2.27}/trilogy/core/graph_models.py

@@ -6,7 +6,7 @@ from trilogy.core.models import Concept, Datasource
 def concept_to_node(input: Concept) -> str:
     # if input.purpose == Purpose.METRIC:
     #     return f"c~{input.namespace}.{input.name}@{input.grain}"
-    return f"c~{input.namespace}.{input.name}@{input.grain}"
+    return f"c~{input.address}@{input.grain}"
 
 
 def datasource_to_node(input: Datasource) -> str:
@@ -14,7 +14,7 @@ def datasource_to_node(input: Datasource) -> str:
     #     return "ds~join~" + ",".join(
     #         [datasource_to_node(sub) for sub in input.datasources]
     #     )
-    return f"ds~{input.namespace}.{input.identifier}"
+    return f"ds~{input.identifier}"
 
 
 class ReferenceGraph(nx.DiGraph):

{pytrilogy-0.0.2.26 → pytrilogy-0.0.2.27}/trilogy/core/models.py

@@ -1719,7 +1719,7 @@ class SelectStatement(HasUUID, Mergeable, Namespaced, SelectTypeMixin, BaseModel
     def to_datasource(
         self,
         namespace: str,
-        identifier: str,
+        name: str,
         address: Address,
         grain: Grain | None = None,
     ) -> Datasource:
@@ -1753,7 +1753,7 @@ class SelectStatement(HasUUID, Mergeable, Namespaced, SelectTypeMixin, BaseModel
                 condition = self.having_clause.conditional
 
         new_datasource = Datasource(
-            identifier=identifier,
+            name=name,
             address=address,
             grain=grain or self.grain,
             columns=columns,
@@ -2059,7 +2059,7 @@ class MergeStatementV2(HasUUID, Namespaced, BaseModel):
 
 
 class Datasource(HasUUID, Namespaced, BaseModel):
-    identifier: str
+    name: str
     columns: List[ColumnAssignment]
     address: Union[Address, str]
     grain: Grain = Field(
@@ -2094,10 +2094,14 @@ class Datasource(HasUUID, Namespaced, BaseModel):
         self.add_column(target, original[0].alias, modifiers)
 
     @property
-    def env_label(self) -> str:
+    def identifier(self) -> str:
         if not self.namespace or self.namespace == DEFAULT_NAMESPACE:
-            return self.identifier
-        return f"{self.namespace}.{self.identifier}"
+            return self.name
+        return f"{self.namespace}.{self.name}"
+
+    @property
+    def safe_identifier(self) -> str:
+        return self.identifier.replace(".", "_")
 
     @property
     def condition(self):
@@ -2166,13 +2170,13 @@ class Datasource(HasUUID, Namespaced, BaseModel):
         return self
 
     def __repr__(self):
-        return f"Datasource<{self.namespace}.{self.identifier}@<{self.grain}>"
+        return f"Datasource<{self.identifier}@<{self.grain}>"
 
     def __str__(self):
         return self.__repr__()
 
     def __hash__(self):
-        return self.full_name.__hash__()
+        return self.identifier.__hash__()
 
     def with_namespace(self, namespace: str):
         new_namespace = (
@@ -2181,7 +2185,7 @@ class Datasource(HasUUID, Namespaced, BaseModel):
             else namespace
         )
         return Datasource(
-            identifier=self.identifier,
+            name=self.name,
             namespace=new_namespace,
             grain=self.grain.with_namespace(namespace),
             address=self.address,
@@ -2231,19 +2235,6 @@ class Datasource(HasUUID, Namespaced, BaseModel):
             f" {existing}."
         )
 
-    @property
-    def name(self) -> str:
-        return self.identifier
-        # TODO: namespace all references
-        # return f'{self.namespace}_{self.identifier}'
-
-    @property
-    def full_name(self) -> str:
-        if not self.namespace:
-            return self.identifier
-        namespace = self.namespace.replace(".", "_") if self.namespace else ""
-        return f"{namespace}_{self.identifier}"
-
     @property
     def safe_location(self) -> str:
         if isinstance(self.address, Address):
@@ -2298,7 +2289,7 @@ class BaseJoin(BaseModel):
         super().__init__(**data)
         if (
             self.left_datasource
-            and self.left_datasource.full_name == self.right_datasource.full_name
+            and self.left_datasource.identifier == self.right_datasource.identifier
         ):
             raise SyntaxError(
                 f"Cannot join a dataself to itself, joining {self.left_datasource} and"
@@ -2410,6 +2401,10 @@ class QueryDatasource(BaseModel):
     def __repr__(self):
         return f"{self.identifier}@<{self.grain}>"
 
+    @property
+    def safe_identifier(self):
+        return self.identifier.replace(".", "_")
+
     @property
     def non_partial_concept_addresses(self) -> List[str]:
         return [
@@ -2474,10 +2469,6 @@ class QueryDatasource(BaseModel):
     def name(self):
         return self.identifier
 
-    @property
-    def full_name(self):
-        return self.identifier
-
     @property
     def group_required(self) -> bool:
         if self.force_group is True:
@@ -2524,10 +2515,12 @@ class QueryDatasource(BaseModel):
         merged_datasources = {}
 
         for ds in [*self.datasources, *other.datasources]:
-            if ds.full_name in merged_datasources:
-                merged_datasources[ds.full_name] = merged_datasources[ds.full_name] + ds
+            if ds.safe_identifier in merged_datasources:
+                merged_datasources[ds.safe_identifier] = (
+                    merged_datasources[ds.safe_identifier] + ds
+                )
             else:
-                merged_datasources[ds.full_name] = ds
+                merged_datasources[ds.safe_identifier] = ds
 
         final_source_map = defaultdict(set)
         for key in self.source_map:
@@ -2538,7 +2531,9 @@ class QueryDatasource(BaseModel):
             if key not in final_source_map:
                 final_source_map[key] = other.source_map[key]
         for k, v in final_source_map.items():
-            final_source_map[k] = set(merged_datasources[x.full_name] for x in list(v))
+            final_source_map[k] = set(
+                merged_datasources[x.safe_identifier] for x in list(v)
+            )
         self_hidden = self.hidden_concepts or []
         other_hidden = other.hidden_concepts or []
         hidden = [x for x in self_hidden if x.address in other_hidden]
@@ -2578,7 +2573,7 @@ class QueryDatasource(BaseModel):
         )
         # partial = "_".join([str(c.address).replace(".", "_") for c in self.partial_concepts])
         return (
-            "_join_".join([d.full_name for d in self.datasources])
+            "_join_".join([d.identifier for d in self.datasources])
             + (f"_at_{grain}" if grain else "_at_abstract")
             + (f"_filtered_by_{filters}" if filters else "")
             # + (f"_partial_{partial}" if partial else "")
@@ -2594,8 +2589,9 @@ class QueryDatasource(BaseModel):
         for x in self.datasources:
             # query datasources should be referenced by their alias, always
             force_alias = isinstance(x, QueryDatasource)
+            #
             use_raw_name = isinstance(x, Datasource) and not force_alias
-            if source and x.identifier != source:
+            if source and x.safe_identifier != source:
                 continue
             try:
                 return x.get_alias(
@@ -2649,6 +2645,14 @@ class CTE(BaseModel):
     base_name_override: Optional[str] = None
     base_alias_override: Optional[str] = None
 
+    @property
+    def identifier(self):
+        return self.name
+
+    @property
+    def safe_identifier(self):
+        return self.name
+
     @computed_field  # type: ignore
     @property
     def output_lcl(self) -> LooseConceptList:
@@ -2746,7 +2750,7 @@ class CTE(BaseModel):
             return False
         if any(
             [
-                x.identifier == ds_being_inlined.identifier
+                x.safe_identifier == ds_being_inlined.safe_identifier
                 for x in self.source.datasources
             ]
         ):
@@ -2757,39 +2761,49 @@ class CTE(BaseModel):
             *[
                 x
                 for x in self.source.datasources
-                if x.identifier != qds_being_inlined.identifier
+                if x.safe_identifier != qds_being_inlined.safe_identifier
             ],
         ]
         # need to identify this before updating joins
         if self.base_name == parent.name:
             self.base_name_override = ds_being_inlined.safe_location
-            self.base_alias_override = ds_being_inlined.identifier
+            self.base_alias_override = ds_being_inlined.safe_identifier
 
         for join in self.joins:
             if isinstance(join, InstantiatedUnnestJoin):
                 continue
-            if join.left_cte and join.left_cte.name == parent.name:
+            if (
+                join.left_cte
+                and join.left_cte.safe_identifier == parent.safe_identifier
+            ):
                 join.inline_cte(parent)
             if join.joinkey_pairs:
                 for pair in join.joinkey_pairs:
-                    if pair.cte and pair.cte.name == parent.name:
+                    if pair.cte and pair.cte.safe_identifier == parent.safe_identifier:
                         join.inline_cte(parent)
-            if join.right_cte.name == parent.name:
+            if join.right_cte.safe_identifier == parent.safe_identifier:
                 join.inline_cte(parent)
         for k, v in self.source_map.items():
             if isinstance(v, list):
                 self.source_map[k] = [
-                    ds_being_inlined.name if x == parent.name else x for x in v
+                    (
+                        ds_being_inlined.safe_identifier
+                        if x == parent.safe_identifier
+                        else x
+                    )
+                    for x in v
                 ]
-            elif v == parent.name:
-                self.source_map[k] = [ds_being_inlined.name]
+            elif v == parent.safe_identifier:
+                self.source_map[k] = [ds_being_inlined.safe_identifier]
 
         # zip in any required values for lookups
         for k in ds_being_inlined.output_lcl.addresses:
             if k in self.source_map and self.source_map[k]:
                 continue
-            self.source_map[k] = [ds_being_inlined.name]
-        self.parent_ctes = [x for x in self.parent_ctes if x.name != parent.name]
+            self.source_map[k] = [ds_being_inlined.safe_identifier]
+        self.parent_ctes = [
+            x for x in self.parent_ctes if x.safe_identifier != parent.safe_identifier
+        ]
         if force_group:
             self.group_to_grain = True
         return True
@@ -3006,28 +3020,22 @@ class Join(BaseModel):
     def inline_cte(self, cte: CTE):
         self.inlined_ctes.add(cte.name)
 
-    # @property
-    # def left_name(self) -> str:
-    #     if self.left_cte.name in self.inlined_ctes:
-    #         return self.left_cte.source.datasources[0].identifier
-    #     return self.left_cte.name
-
     def get_name(self, cte: CTE):
-        if cte.name in self.inlined_ctes:
-            return cte.source.datasources[0].identifier
-        return cte.name
+        if cte.identifier in self.inlined_ctes:
+            return cte.source.datasources[0].safe_identifier
+        return cte.safe_identifier
 
     @property
     def right_name(self) -> str:
-        if self.right_cte.name in self.inlined_ctes:
-            return self.right_cte.source.datasources[0].identifier
-        return self.right_cte.name
+        if self.right_cte.identifier in self.inlined_ctes:
+            return self.right_cte.source.datasources[0].safe_identifier
+        return self.right_cte.safe_identifier
 
     @property
     def right_ref(self) -> str:
-        if self.right_cte.name in self.inlined_ctes:
-            return f"{self.right_cte.source.datasources[0].safe_location} as {self.right_cte.source.datasources[0].identifier}"
-        return self.right_cte.name
+        if self.right_cte.identifier in self.inlined_ctes:
+            return f"{self.right_cte.source.datasources[0].safe_location} as {self.right_cte.source.datasources[0].safe_identifier}"
+        return self.right_cte.safe_identifier
 
     @property
     def unique_id(self) -> str:
@@ -3306,7 +3314,9 @@ class Environment(BaseModel):
     ] = Field(default_factory=EnvironmentDatasourceDict)
     functions: Dict[str, Function] = Field(default_factory=dict)
     data_types: Dict[str, DataType] = Field(default_factory=dict)
-    imports: Dict[str, ImportStatement] = Field(default_factory=dict)
+    imports: Dict[str, list[ImportStatement]] = Field(
+        default_factory=lambda: defaultdict(list)
+    )
     namespace: str = DEFAULT_NAMESPACE
     working_path: str | Path = Field(default_factory=lambda: os.getcwd())
     environment_config: EnvironmentOptions = Field(default_factory=EnvironmentOptions)
@@ -3420,14 +3430,28 @@ class Environment(BaseModel):
             f"Assignment to concept '{lookup}'  is a duplicate declaration;"
         )
 
-    def add_import(self, alias: str, environment: Environment):
-        self.imports[alias] = ImportStatement(
-            alias=alias, path=Path(environment.working_path)
-        )
-        for key, concept in environment.concepts.items():
-            self.concepts[f"{alias}.{key}"] = concept.with_namespace(alias)
-        for key, datasource in environment.datasources.items():
-            self.datasources[f"{alias}.{key}"] = datasource.with_namespace(alias)
+    def add_import(
+        self, alias: str, source: Environment, imp_stm: ImportStatement | None = None
+    ):
+        exists = False
+        existing = self.imports[alias]
+        if imp_stm:
+            if any([x.path == imp_stm.path for x in existing]):
+                exists = True
+
+        else:
+            if any([x.path == source.working_path for x in existing]):
+                exists = True
+            imp_stm = ImportStatement(alias=alias, path=Path(source.working_path))
+
+        if not exists:
+            self.imports[alias].append(imp_stm)
+
+        for _, concept in source.concepts.items():
+            self.add_concept(concept.with_namespace(alias), _ignore_cache=True)
+
+        for _, datasource in source.datasources.items():
+            self.add_datasource(datasource.with_namespace(alias), _ignore_cache=True)
         self.gen_concept_list_caches()
         return self
 
@@ -3438,18 +3462,15 @@ class Environment(BaseModel):
         apath[-1] = apath[-1] + ".preql"
 
         target: Path = Path(self.working_path, *apath)
+        if alias in self.imports:
+            imports = self.imports[alias]
+            for x in imports:
+                if x.path == target:
+                    return imports
         if env:
-            self.imports[alias] = ImportStatement(
-                alias=alias, path=target, environment=env
+            self.imports[alias].append(
+                ImportStatement(alias=alias, path=target, environment=env)
             )
-
-        elif alias in self.imports:
-            current = self.imports[alias]
-            env = self.imports[alias].environment
-            if current.path != target:
-                raise ImportError(
-                    f"Attempted to import {target} with alias {alias} but {alias} is already imported from {current.path}"
-                )
         else:
             try:
                 with open(target, "r", encoding="utf-8") as f:
@@ -3468,14 +3489,13 @@ class Environment(BaseModel):
                     f"Unable to import file {target.parent}, parsing error: {e}"
                 )
             env = nparser.environment
-        if env:
-            for _, concept in env.concepts.items():
-                self.add_concept(concept.with_namespace(alias))
+        for _, concept in env.concepts.items():
+            self.add_concept(concept.with_namespace(alias))
 
-            for _, datasource in env.datasources.items():
-                self.add_datasource(datasource.with_namespace(alias))
+        for _, datasource in env.datasources.items():
+            self.add_datasource(datasource.with_namespace(alias))
         imps = ImportStatement(alias=alias, path=target, environment=env)
-        self.imports[alias] = imps
+        self.imports[alias].append(imps)
         return imps
 
     def parse(
@@ -3538,8 +3558,14 @@ class Environment(BaseModel):
         meta: Meta | None = None,
         _ignore_cache: bool = False,
     ):
-        self.datasources[datasource.env_label] = datasource
+        self.datasources[datasource.identifier] = datasource
+
+        eligible_to_promote_roots = datasource.non_partial_for is None
+        # mark this as canonical source
         for current_concept in datasource.output_concepts:
+            if not eligible_to_promote_roots:
+                continue
+
             current_derivation = current_concept.derivation
             # TODO: refine this section;
             # too hacky for maintainability

{pytrilogy-0.0.2.26 → pytrilogy-0.0.2.27}/trilogy/core/optimizations/inline_datasource.py

@@ -63,14 +63,14 @@ class InlineDatasource(OptimizationRule):
         for replaceable in to_inline:
             if replaceable.name not in self.candidates[cte.name]:
                 self.candidates[cte.name].add(replaceable.name)
-                self.count[replaceable.source.name] += 1
+                self.count[replaceable.source.identifier] += 1
                 return True
             if (
-                self.count[replaceable.source.name]
+                self.count[replaceable.source.identifier]
                 > CONFIG.optimizations.constant_inline_cutoff
             ):
                 self.log(
-                    f"Skipping inlining raw datasource {replaceable.source.name} ({replaceable.name}) due to multiple references"
+                    f"Skipping inlining raw datasource {replaceable.source.identifier} ({replaceable.name}) due to multiple references"
                 )
                 continue
             if not replaceable.source.datasources[0].grain.issubset(replaceable.grain):
@@ -81,7 +81,7 @@ class InlineDatasource(OptimizationRule):
             result = cte.inline_parent_datasource(replaceable, force_group=force_group)
             if result:
                 self.log(
-                    f"Inlined parent {replaceable.name} with {replaceable.source.name}"
+                    f"Inlined parent {replaceable.name} with {replaceable.source.identifier}"
                 )
                 optimized = True
             else:

{pytrilogy-0.0.2.26 → pytrilogy-0.0.2.27}/trilogy/core/processing/node_generators/select_merge_node.py

@@ -193,6 +193,7 @@ def create_select_node(
     g,
     environment: Environment,
     depth: int,
+    conditions: WhereClause | None = None,
 ) -> StrategyNode:
     ds_name = ds_name.split("~")[1]
     all_concepts = [
@@ -231,6 +232,7 @@ def create_select_node(
         c.concept for c in datasource.columns if c.is_nullable and c.concept in all_lcl
     ]
     nullable_lcl = LooseConceptList(concepts=nullable_concepts)
+    partial_is_full = conditions and (conditions == datasource.non_partial_for)
 
     bcandidate: StrategyNode = SelectNode(
         input_concepts=[c.concept for c in datasource.columns],
@@ -239,12 +241,15 @@ def create_select_node(
         g=g,
         parents=[],
         depth=depth,
-        partial_concepts=[c for c in all_concepts if c in partial_lcl],
+        partial_concepts=(
+            [] if partial_is_full else [c for c in all_concepts if c in partial_lcl]
+        ),
         nullable_concepts=[c for c in all_concepts if c in nullable_lcl],
         accept_partial=accept_partial,
         datasource=datasource,
         grain=Grain(components=all_concepts),
         conditions=datasource.where.conditional if datasource.where else None,
+        render_condition=not partial_is_full,
     )
 
     # we need to nest the group node one further
@@ -312,6 +317,7 @@ def gen_select_merge_node(
             accept_partial=accept_partial,
             environment=environment,
             depth=depth,
+            conditions=conditions,
         )
         for k, subgraph in sub_nodes.items()
     ]

{pytrilogy-0.0.2.26 → pytrilogy-0.0.2.27}/trilogy/core/processing/nodes/base_node.py

@@ -165,6 +165,7 @@ class StrategyNode:
         hidden_concepts: List[Concept] | None = None,
         existence_concepts: List[Concept] | None = None,
         virtual_output_concepts: List[Concept] | None = None,
+        render_condition: bool = True,
     ):
         self.input_concepts: List[Concept] = (
             unique(input_concepts, "address") if input_concepts else []
@@ -208,6 +209,7 @@ class StrategyNode:
             )
         self.validate_parents()
         self.log = True
+        self.render_condition = render_condition
 
     def add_parents(self, parents: list["StrategyNode"]):
         self.parents += parents
@@ -380,6 +382,7 @@ class StrategyNode:
             hidden_concepts=list(self.hidden_concepts),
             existence_concepts=list(self.existence_concepts),
             virtual_output_concepts=list(self.virtual_output_concepts),
+            render_condition=self.render_condition,
         )
 
 

{pytrilogy-0.0.2.26 → pytrilogy-0.0.2.27}/trilogy/core/processing/nodes/merge_node.py

@@ -89,8 +89,8 @@ def deduplicate_nodes_and_joins(
             joins = [
                 j
                 for j in joins
-                if j.left_node.resolve().full_name not in removed
-                and j.right_node.resolve().full_name not in removed
+                if j.left_node.resolve().identifier not in removed
+                and j.right_node.resolve().identifier not in removed
             ]
     return joins, merged
 
@@ -155,8 +155,8 @@ class MergeNode(StrategyNode):
         for join in node_joins:
             left = join.left_node.resolve()
             right = join.right_node.resolve()
-            if left.full_name == right.full_name:
-                raise SyntaxError(f"Cannot join node {left.full_name} to itself")
+            if left.identifier == right.identifier:
+                raise SyntaxError(f"Cannot join node {left.identifier} to itself")
             joins.append(
                 BaseJoin(
                     left_datasource=left,
@@ -168,7 +168,7 @@ class MergeNode(StrategyNode):
             )
         return joins
 
-    def create_full_joins(self, dataset_list: List[QueryDatasource]):
+    def create_full_joins(self, dataset_list: List[QueryDatasource | Datasource]):
         joins = []
         seen = set()
         for left_value in dataset_list:
@@ -198,7 +198,7 @@ class MergeNode(StrategyNode):
         environment: Environment,
     ) -> List[BaseJoin | UnnestJoin]:
         # only finally, join between them for unique values
-        dataset_list: List[QueryDatasource] = sorted(
+        dataset_list: List[QueryDatasource | Datasource] = sorted(
             final_datasets, key=lambda x: -len(x.grain.components_copy)
         )
 
@@ -238,13 +238,13 @@ class MergeNode(StrategyNode):
         merged: dict[str, QueryDatasource | Datasource] = {}
         final_joins: List[NodeJoin] | None = self.node_joins
         for source in parent_sources:
-            if source.full_name in merged:
+            if source.identifier in merged:
                 logger.info(
-                    f"{self.logging_prefix}{LOGGER_PREFIX} merging parent node with {source.full_name} into existing"
+                    f"{self.logging_prefix}{LOGGER_PREFIX} merging parent node with {source.identifier} into existing"
                 )
-                merged[source.full_name] = merged[source.full_name] + source
+                merged[source.identifier] = merged[source.identifier] + source
             else:
-                merged[source.full_name] = source
+                merged[source.identifier] = source
 
         # it's possible that we have more sources than we need
         final_joins, merged = deduplicate_nodes_and_joins(