pytrilogy 0.0.2.26__tar.gz → 0.0.2.28__tar.gz

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

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

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

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

{pytrilogy-0.0.2.26 → pytrilogy-0.0.2.28}/pytrilogy.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ tests/test_declarations.py
 tests/test_derived_concepts.py
 tests/test_discovery_nodes.py
 tests/test_environment.py
+tests/test_executor.py
 tests/test_functions.py
 tests/test_imports.py
 tests/test_metadata.py

{pytrilogy-0.0.2.26 → pytrilogy-0.0.2.28}/tests/test_environment.py

@@ -20,7 +20,7 @@ def test_environment_from_path():
 
     env = Environment.from_file(Path(__file__).parent / "test_env.preql")
 
-    assert "id" in env.concepts
+    assert "local.id" in env.concepts
 
 
 def test_environment_merge():

pytrilogy-0.0.2.28/tests/test_executor.py

@@ -0,0 +1,8 @@
+from trilogy import Dialects
+from pathlib import Path
+
+
+def test_file_parsing():
+    target = Path(__file__).parent / "test_env.preql"
+    parsed = Dialects.DUCK_DB.default_executor().parse_file(target)
+    assert len(list(parsed)) == 1

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

@@ -178,7 +178,7 @@ select
     )
 
     for name in ["name_alphabetical", "name_alphabetical_2"]:
-        assert name in env.concepts
+        assert f"local.{name}" in env.concepts
         assert env.concepts[name].purpose == Purpose.PROPERTY
         assert env.concepts[name].keys == (env.concepts["id"],)
 
@@ -197,7 +197,6 @@ select
     )
 
     for name in ["join_id"]:
-        assert name in env.concepts
         assert env.concepts[name].purpose == Purpose.PROPERTY
         assert env.concepts[name].keys == (
             env.concepts["id"],
@@ -225,7 +224,6 @@ select
     )
     # assert output_purpose == Purpose.METRIC
     for name in ["test_name_count"]:
-        assert name in env.concepts
         assert env.concepts[name].purpose == Purpose.METRIC
 
 
@@ -491,6 +489,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.28}/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.28}/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.28}/tests/test_undefined_concept.py

@@ -32,6 +32,6 @@ def test_undefined_concept_dict():
     try:
         env["orid"]
     except UndefinedConceptException as e:
-        assert e.suggestions == ["order_id"]
+        assert e.suggestions == ["local.order_id"]
         assert "suggestions" in e.message.lower()
         assert "order_id" in e.message.lower()

{pytrilogy-0.0.2.26 → pytrilogy-0.0.2.28}/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.28"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

{pytrilogy-0.0.2.26 → pytrilogy-0.0.2.28}/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.28}/trilogy/core/models.py

@@ -606,6 +606,8 @@ class Concept(Mergeable, Namespaced, SelectContext, BaseModel):
         return self.grain.components_copy if self.grain else []
 
     def with_namespace(self, namespace: str) -> "Concept":
+        if namespace == self.namespace:
+            return self
         return self.__class__(
             name=self.name,
             datatype=self.datatype,
@@ -1719,7 +1721,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 +1755,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 +2061,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 +2096,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 +2172,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 +2187,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 +2237,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 +2291,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 +2403,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 +2471,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 +2517,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 +2533,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 +2575,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 +2591,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 +2647,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 +2752,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 +2763,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 +3022,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:
@@ -3245,7 +3255,6 @@ class EnvironmentConceptDict(dict):
                 )
                 self.undefined[key] = undefined
                 return undefined
-
             matches = self._find_similar_concepts(key)
             message = f"Undefined concept: {key}."
             if matches:
@@ -3255,8 +3264,15 @@ class EnvironmentConceptDict(dict):
                 raise UndefinedConceptException(f"line: {line_no}: " + message, matches)
             raise UndefinedConceptException(message, matches)
 
-    def _find_similar_concepts(self, concept_name):
-        matches = difflib.get_close_matches(concept_name, self.keys())
+    def _find_similar_concepts(self, concept_name: str):
+        def strip_local(input: str):
+            if input.startswith(f"{DEFAULT_NAMESPACE}."):
+                return input[len(DEFAULT_NAMESPACE) + 1 :]
+            return input
+
+        matches = difflib.get_close_matches(
+            strip_local(concept_name), [strip_local(x) for x in self.keys()]
+        )
         return matches
 
     def items(self) -> ItemsView[str, Concept]:  # type: ignore
@@ -3306,7 +3322,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)
@@ -3315,7 +3333,6 @@ class Environment(BaseModel):
 
     materialized_concepts: List[Concept] = Field(default_factory=list)
     alias_origin_lookup: Dict[str, Concept] = Field(default_factory=dict)
-    canonical_map: Dict[str, str] = Field(default_factory=dict)
     _parse_count: int = 0
 
     @classmethod
@@ -3420,14 +3437,52 @@ 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))
+
+        same_namespace = alias == self.namespace
+
+        if not exists:
+            self.imports[alias].append(imp_stm)
+
+        for k, concept in source.concepts.items():
+            if same_namespace:
+                new = self.add_concept(concept, _ignore_cache=True)
+            else:
+                new = self.add_concept(
+                    concept.with_namespace(alias), _ignore_cache=True
+                )
+
+                k = address_with_namespace(k, alias)
+            # set this explicitly, to handle aliasing
+            self.concepts[k] = new
+
+        for _, datasource in source.datasources.items():
+            if same_namespace:
+                self.add_datasource(datasource, _ignore_cache=True)
+            else:
+                self.add_datasource(
+                    datasource.with_namespace(alias), _ignore_cache=True
+                )
+        for key, val in source.alias_origin_lookup.items():
+            if same_namespace:
+                self.alias_origin_lookup[key] = val
+            else:
+                self.alias_origin_lookup[address_with_namespace(key, alias)] = (
+                    val.with_namespace(alias)
+                )
+
         self.gen_concept_list_caches()
         return self
 
@@ -3438,18 +3493,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 +3520,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(
@@ -3522,8 +3573,6 @@ class Environment(BaseModel):
             existing = self.validate_concept(concept, meta=meta)
             if existing:
                 concept = existing
-        if concept.namespace == DEFAULT_NAMESPACE:
-            self.concepts[concept.name] = concept
         self.concepts[concept.address] = concept
         from trilogy.core.environment_helpers import generate_related_concepts
 
@@ -3538,8 +3587,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
@@ -3605,7 +3660,6 @@ class Environment(BaseModel):
                 v.pseudonyms.add(source.address)
             if v.address == source.address:
                 replacements[k] = target
-                self.canonical_map[k] = target.address
                 v.pseudonyms.add(target.address)
             # we need to update keys and grains of all concepts
             else:

{pytrilogy-0.0.2.26 → pytrilogy-0.0.2.28}/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: