pytrilogy 0.0.2.25__py3-none-any.whl → 0.0.2.27__py3-none-any.whl

trilogy/core/models.py

@@ -73,6 +73,7 @@ from collections import UserList, UserDict
 from functools import cached_property
 from abc import ABC
 from collections import defaultdict
+import hashlib
 
 LOGGER_PREFIX = "[MODELS]"
 
@@ -190,6 +191,13 @@ class ConstantInlineable(ABC):
         raise NotImplementedError
 
 
+class HasUUID(ABC):
+
+    @property
+    def uuid(self) -> str:
+        return hashlib.md5(str(self).encode()).hexdigest()
+
+
 class SelectTypeMixin(BaseModel):
     where_clause: Union["WhereClause", None] = Field(default=None)
     having_clause: Union["HavingClause", None] = Field(default=None)
@@ -1606,7 +1614,7 @@ class RawSQLStatement(BaseModel):
     meta: Optional[Metadata] = Field(default_factory=lambda: Metadata())
 
 
-class SelectStatement(Mergeable, Namespaced, SelectTypeMixin, BaseModel):
+class SelectStatement(HasUUID, Mergeable, Namespaced, SelectTypeMixin, BaseModel):
     selection: List[SelectItem]
     order_by: Optional[OrderBy] = None
     limit: Optional[int] = None
@@ -1711,7 +1719,7 @@ class SelectStatement(Mergeable, Namespaced, SelectTypeMixin, BaseModel):
     def to_datasource(
         self,
         namespace: str,
-        identifier: str,
+        name: str,
         address: Address,
         grain: Grain | None = None,
     ) -> Datasource:
@@ -1724,19 +1732,34 @@ class SelectStatement(Mergeable, Namespaced, SelectTypeMixin, BaseModel):
             # if the concept is a locally derived concept, it cannot ever be partial
             # but if it's a concept pulled in from upstream and we have a where clause, it should be partial
             ColumnAssignment(
-                alias=c.address.replace(".", "_"),
+                alias=(
+                    c.name.replace(".", "_")
+                    if c.namespace == DEFAULT_NAMESPACE
+                    else c.address.replace(".", "_")
+                ),
                 concept=c,
                 modifiers=modifiers if c.address not in self.locally_derived else [],
             )
             for c in self.output_components
         ]
 
+        condition = None
+        if self.where_clause:
+            condition = self.where_clause.conditional
+        if self.having_clause:
+            if condition:
+                condition = self.having_clause.conditional + condition
+            else:
+                condition = self.having_clause.conditional
+
         new_datasource = Datasource(
-            identifier=identifier,
+            name=name,
             address=address,
             grain=grain or self.grain,
             columns=columns,
             namespace=namespace,
+            where=WhereClause(conditional=condition) if condition else None,
+            non_partial_for=WhereClause(conditional=condition) if condition else None,
         )
         for column in columns:
             column.concept = column.concept.with_grain(new_datasource.grain)
@@ -1859,7 +1882,7 @@ class AlignClause(Namespaced, BaseModel):
         return AlignClause(items=[x.with_namespace(namespace) for x in self.items])
 
 
-class MultiSelectStatement(SelectTypeMixin, Mergeable, Namespaced, BaseModel):
+class MultiSelectStatement(HasUUID, SelectTypeMixin, Mergeable, Namespaced, BaseModel):
     selects: List[SelectStatement]
     align: AlignClause
     namespace: str
@@ -2021,7 +2044,7 @@ class DatasourceMetadata(BaseModel):
     line_no: int | None = None
 
 
-class MergeStatementV2(Namespaced, BaseModel):
+class MergeStatementV2(HasUUID, Namespaced, BaseModel):
     source: Concept
     target: Concept
     modifiers: List[Modifier] = Field(default_factory=list)
@@ -2035,8 +2058,8 @@ class MergeStatementV2(Namespaced, BaseModel):
         return new
 
 
-class Datasource(Namespaced, BaseModel):
-    identifier: str
+class Datasource(HasUUID, Namespaced, BaseModel):
+    name: str
     columns: List[ColumnAssignment]
     address: Union[Address, str]
     grain: Grain = Field(
@@ -2047,6 +2070,7 @@ class Datasource(Namespaced, BaseModel):
         default_factory=lambda: DatasourceMetadata(freshness_concept=None)
     )
     where: Optional[WhereClause] = None
+    non_partial_for: Optional[WhereClause] = None
 
     def merge_concept(
         self, source: Concept, target: Concept, modifiers: List[Modifier]
@@ -2070,10 +2094,14 @@ class Datasource(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):
@@ -2142,13 +2170,13 @@ class Datasource(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 = (
@@ -2157,7 +2185,7 @@ class Datasource(Namespaced, BaseModel):
             else namespace
         )
         return Datasource(
-            identifier=self.identifier,
+            name=self.name,
             namespace=new_namespace,
             grain=self.grain.with_namespace(namespace),
             address=self.address,
@@ -2207,19 +2235,6 @@ class Datasource(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):
@@ -2247,6 +2262,7 @@ class InstantiatedUnnestJoin(BaseModel):
 class ConceptPair(BaseModel):
     left: Concept
     right: Concept
+    existing_datasource: Union[Datasource, "QueryDatasource"]
     modifiers: List[Modifier] = Field(default_factory=list)
 
     @property
@@ -2258,17 +2274,23 @@ class ConceptPair(BaseModel):
         return Modifier.NULLABLE in self.modifiers
 
 
+class CTEConceptPair(ConceptPair):
+    cte: CTE
+
+
 class BaseJoin(BaseModel):
-    left_datasource: Union[Datasource, "QueryDatasource"]
     right_datasource: Union[Datasource, "QueryDatasource"]
-    concepts: List[Concept]
     join_type: JoinType
-    filter_to_mutual: bool = False
+    concepts: Optional[List[Concept]] = None
+    left_datasource: Optional[Union[Datasource, "QueryDatasource"]] = None
     concept_pairs: list[ConceptPair] | None = None
 
     def __init__(self, **data: Any):
         super().__init__(**data)
-        if self.left_datasource.full_name == self.right_datasource.full_name:
+        if (
+            self.left_datasource
+            and self.left_datasource.identifier == self.right_datasource.identifier
+        ):
             raise SyntaxError(
                 f"Cannot join a dataself to itself, joining {self.left_datasource} and"
                 f" {self.right_datasource}"
@@ -2278,8 +2300,10 @@ class BaseJoin(BaseModel):
         # if we have a list of concept pairs
         if self.concept_pairs:
             return
-
-        for concept in self.concepts:
+        if self.concepts == []:
+            return
+        assert self.left_datasource and self.right_datasource
+        for concept in self.concepts or []:
             include = True
             for ds in [self.left_datasource, self.right_datasource]:
                 synonyms = []
@@ -2289,13 +2313,10 @@ class BaseJoin(BaseModel):
                     concept.address not in [c.address for c in ds.output_concepts]
                     and concept.address not in synonyms
                 ):
-                    if self.filter_to_mutual:
-                        include = False
-                    else:
-                        raise SyntaxError(
-                            f"Invalid join, missing {concept} on {ds.name}, have"
-                            f" {[c.address for c in ds.output_concepts]}"
-                        )
+                    raise SyntaxError(
+                        f"Invalid join, missing {concept} on {ds.name}, have"
+                        f" {[c.address for c in ds.output_concepts]}"
+                    )
             if include:
                 final_concepts.append(concept)
         if not final_concepts and self.concepts:
@@ -2312,7 +2333,7 @@ class BaseJoin(BaseModel):
                     self.concepts = []
                     return
                 # if everything is at abstract grain, we can skip joins
-                if all([c.grain == Grain() for c in ds.output_concepts]):
+                if all([c.grain.abstract for c in ds.output_concepts]):
                     self.concepts = []
                     return
 
@@ -2330,21 +2351,27 @@ class BaseJoin(BaseModel):
 
     @property
     def unique_id(self) -> str:
-        # TODO: include join type?
-        return (
-            self.left_datasource.name
-            + self.right_datasource.name
-            + self.join_type.value
-        )
+        return str(self)
+
+    @property
+    def input_concepts(self) -> List[Concept]:
+        base = []
+        if self.concept_pairs:
+            for pair in self.concept_pairs:
+                base += [pair.left, pair.right]
+        elif self.concepts:
+            base += self.concepts
+        return base
 
     def __str__(self):
         if self.concept_pairs:
             return (
-                f"{self.join_type.value} on"
-                f" {','.join([str(k.left)+'='+str(k.right) for k in self.concept_pairs])}"
+                f"{self.join_type.value} {self.right_datasource.name} on"
+                f" {','.join([str(k.existing_datasource.name) + '.'+ str(k.left)+'='+str(k.right) for k in self.concept_pairs])}"
             )
         return (
-            f"{self.join_type.value} on" f" {','.join([str(k) for k in self.concepts])}"
+            f"{self.join_type.value} {self.right_datasource.name} on"
+            f" {','.join([str(k) for k in self.concepts])}"
         )
 
 
@@ -2374,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 [
@@ -2389,19 +2420,9 @@ class QueryDatasource(BaseModel):
         for join in v:
             if not isinstance(join, BaseJoin):
                 continue
-            if join.left_datasource.identifier == join.right_datasource.identifier:
-                raise SyntaxError(
-                    f"Cannot join a datasource to itself, joining {join.left_datasource}"
-                )
-            pairing = "".join(
-                sorted(
-                    [join.left_datasource.identifier, join.right_datasource.identifier]
-                )
-            )
+            pairing = str(join)
             if pairing in unique_pairs:
-                raise SyntaxError(
-                    f"Duplicate join {join.left_datasource.identifier} and {join.right_datasource.identifier}"
-                )
+                raise SyntaxError(f"Duplicate join {str(join)}")
             unique_pairs.add(pairing)
         return v
 
@@ -2448,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:
@@ -2498,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:
@@ -2512,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]
@@ -2552,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 "")
@@ -2568,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(
@@ -2623,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:
@@ -2666,7 +2696,12 @@ class CTE(BaseModel):
                         isinstance(join, Join)
                         and (
                             join.right_cte.name != removed_cte
-                            and join.left_cte.name != removed_cte
+                            and any(
+                                [
+                                    x.cte.name != removed_cte
+                                    for x in (join.joinkey_pairs or [])
+                                ]
+                            )
                         )
                     )
                 ]
@@ -2715,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
             ]
         ):
@@ -2726,35 +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.name == parent.name:
+            if (
+                join.left_cte
+                and join.left_cte.safe_identifier == parent.safe_identifier
+            ):
                 join.inline_cte(parent)
-            if join.right_cte.name == parent.name:
+            if join.joinkey_pairs:
+                for pair in join.joinkey_pairs:
+                    if pair.cte and pair.cte.safe_identifier == parent.safe_identifier:
+                        join.inline_cte(parent)
+            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
@@ -2961,55 +3010,50 @@ class JoinKey(BaseModel):
 
 
 class Join(BaseModel):
-    left_cte: CTE
+
     right_cte: CTE
     jointype: JoinType
-    joinkeys: List[JoinKey]
-    joinkey_pairs: List[ConceptPair] | None = None
+    left_cte: CTE | None = None
+    joinkey_pairs: List[CTEConceptPair] | None = None
     inlined_ctes: set[str] = Field(default_factory=set)
 
     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.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
-
-    @property
-    def left_ref(self) -> str:
-        if self.left_cte.name in self.inlined_ctes:
-            return f"{self.left_cte.source.datasources[0].safe_location} as {self.left_cte.source.datasources[0].identifier}"
-        return self.left_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:
-        return self.left_name + self.right_name + self.jointype.value
+        return str(self)
 
     def __str__(self):
         if self.joinkey_pairs:
             return (
-                f"{self.jointype.value} JOIN {self.left_name} and"
+                f"{self.jointype.value} join"
                 f" {self.right_name} on"
-                f" {','.join([str(k.left)+'='+str(k.right)+str(k.modifiers) for k in self.joinkey_pairs])}"
+                f" {','.join([k.cte.name + '.'+str(k.left.address)+'='+str(k.right.address) for k in self.joinkey_pairs])}"
             )
-        return (
-            f"{self.jointype.value} JOIN {self.left_name} and"
-            f" {self.right_name} on {','.join([str(k) for k in self.joinkeys])}"
-        )
+        elif self.left_cte:
+            return (
+                f"{self.jointype.value} JOIN {self.left_cte.name} and"
+                f" {self.right_name} on {','.join([str(k) for k in self.joinkey_pairs])}"
+            )
+        return f"{self.jointype.value} JOIN  {self.right_name} on {','.join([str(k) for k in self.joinkey_pairs])}"
 
 
 class UndefinedConcept(Concept, Mergeable, Namespaced):
@@ -3227,7 +3271,7 @@ class EnvironmentConceptDict(dict):
         return super().items()
 
 
-class ImportStatement(BaseModel):
+class ImportStatement(HasUUID, BaseModel):
     alias: str
     path: Path
     environment: Union["Environment", None] = None
@@ -3270,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)
@@ -3384,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
 
@@ -3402,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:
@@ -3432,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(
@@ -3502,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
@@ -4223,6 +4285,9 @@ class AggregateWrapper(Mergeable, Namespaced, SelectContext, BaseModel):
 class WhereClause(Mergeable, ConceptArgs, Namespaced, SelectContext, BaseModel):
     conditional: Union[SubselectComparison, Comparison, Conditional, "Parenthetical"]
 
+    def __repr__(self):
+        return str(self.conditional)
+
     @property
     def input(self) -> List[Concept]:
         return self.conditional.input
@@ -4341,7 +4406,7 @@ class Limit(BaseModel):
     count: int
 
 
-class ConceptDeclarationStatement(BaseModel):
+class ConceptDeclarationStatement(HasUUID, BaseModel):
     concept: Concept
 
 
@@ -4349,7 +4414,7 @@ class ConceptDerivation(BaseModel):
     concept: Concept
 
 
-class RowsetDerivationStatement(Namespaced, BaseModel):
+class RowsetDerivationStatement(HasUUID, Namespaced, BaseModel):
     name: str
     select: SelectStatement | MultiSelectStatement
     namespace: str
@@ -4614,7 +4679,7 @@ class TupleWrapper(Generic[VT], tuple):
         return cls(v, type=arg_to_datatype(v[0]))
 
 
-class PersistStatement(BaseModel):
+class PersistStatement(HasUUID, BaseModel):
     datasource: Datasource
     select: SelectStatement
     meta: Optional[Metadata] = Field(default_factory=lambda: Metadata())