pytrilogy 0.0.2.26__py3-none-any.whl → 0.0.2.28__py3-none-any.whl

{pytrilogy-0.0.2.26.dist-info → pytrilogy-0.0.2.28.dist-info}/METADATA

@@ -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.dist-info → pytrilogy-0.0.2.28.dist-info}/RECORD

@@ -1,8 +1,8 @@
-trilogy/__init__.py,sha256=Cc2rIa67kJZaRPTgItA7vo9mKdPdLIskVp1BDwgHWbc,291
+trilogy/__init__.py,sha256=Oj4rApJpgEd7VNBVDA5Sy1tHnI0ISyXQcfpiH-fv6UY,291
 trilogy/compiler.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/constants.py,sha256=KiyYnctoZen4Hzv8WG2jeN-IE-dfQbWHdVCUeTZYjBg,1270
 trilogy/engine.py,sha256=R5ubIxYyrxRExz07aZCUfrTsoXCHQ8DKFTDsobXdWdA,1102
-trilogy/executor.py,sha256=Gd9KRT1rNAQyF1oDtKMcidg6XWqGMBhPnErrzFpf7Ew,12139
+trilogy/executor.py,sha256=VcZ2U3RUU2al_VJ75AKVwmCJQLltYouxlgTjq4oxPB0,12577
 trilogy/parser.py,sha256=UtuqSiGiCjpMAYgo1bvNq-b7NSzCA5hzbUW31RXaMII,281
 trilogy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/utility.py,sha256=zM__8r29EsyDW7K9VOHz8yvZC2bXFzh7xKy3cL7GKsk,707
@@ -14,20 +14,20 @@ trilogy/core/environment_helpers.py,sha256=DIsoo-GcXmXVPB1JbNh8Oku25Nyef9mexPIdy
 trilogy/core/ergonomics.py,sha256=ASLDd0RqKWrZiG3XcKHo8nyTjaB_8xfE9t4NZ1UvGpc,1639
 trilogy/core/exceptions.py,sha256=NvV_4qLOgKXbpotgRf7c8BANDEvHxlqRPaA53IThQ2o,561
 trilogy/core/functions.py,sha256=IhVpt3n6wEanKHnGu3oA2w6-hKIlxWpEyz7fHN66mpo,10720
-trilogy/core/graph_models.py,sha256=oJUMSpmYhqXlavckHLpR07GJxuQ8dZ1VbB1fB0KaS8c,2036
+trilogy/core/graph_models.py,sha256=mameUTiuCajtihDw_2-W218xyJlvTusOWrEKP1yAWgk,2003
 trilogy/core/internal.py,sha256=jNGFHKENnbMiMCtAgsnLZYVSENDK4b5ALecXFZpTDzQ,1075
-trilogy/core/models.py,sha256=ZPMOWmN4vDvXyLZvyiaN-WZnMDukDwr2nJYFIe6vJKo,158251
+trilogy/core/models.py,sha256=W_0ZfIIEuyHfYsSXGMJOJPNJf7vSljSrRm42nLyiL8w,159702
 trilogy/core/optimization.py,sha256=od_60A9F8J8Nj24MHgrxl4vwRwmBFH13TMdoMQvgVKs,7717
-trilogy/core/query_processor.py,sha256=-fKPlygk3aX1cY60dl4tKNQofKRFl3zhqz5klRIbtq0,17683
+trilogy/core/query_processor.py,sha256=mbcZlgjChrRjDHkdmMbKe-T70UpbBkJhS09MyU5a6UY,17785
 trilogy/core/optimizations/__init__.py,sha256=bWQecbeiwiDx9LJnLsa7dkWxdbl2wcnkcTN69JyP8iI,356
 trilogy/core/optimizations/base_optimization.py,sha256=tWWT-xnTbnEU-mNi_isMNbywm8B9WTRsNFwGpeh3rqE,468
 trilogy/core/optimizations/inline_constant.py,sha256=kHNyc2UoaPVdYfVAPAFwnWuk4sJ_IF5faRtVcDOrBtw,1110
-trilogy/core/optimizations/inline_datasource.py,sha256=AATzQ6YrtW_1-aQFjQyTYqEYKBoMFhek7ADfBr4uUdQ,3634
+trilogy/core/optimizations/inline_datasource.py,sha256=NqUOVl0pOXF1R_roELVW8I0qN7or2wPtAsRmDD9QJso,3658
 trilogy/core/optimizations/predicate_pushdown.py,sha256=1l9WnFOSv79e341typG3tTdk0XGl1J_ToQih3LYoGIY,8435
 trilogy/core/processing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/core/processing/concept_strategies_v3.py,sha256=7MT_x6QFHrbSDmjz21pYdQB5ux419ES4QS-8lO16eyw,36091
 trilogy/core/processing/graph_utils.py,sha256=aq-kqk4Iado2HywDxWEejWc-7PGO6Oa-ZQLAM6XWPHw,1199
-trilogy/core/processing/utility.py,sha256=xNl310JhBda0Vv1SSwg5EtMPmMDAWucxfWd7M53Sb9k,17422
+trilogy/core/processing/utility.py,sha256=xlaKqnoWg-mEwTF-erBF9QXnXZtESrTuYrK2RQb7Wi4,17411
 trilogy/core/processing/node_generators/__init__.py,sha256=-mzYkRsaRNa_dfTckYkKVFSR8h8a3ihEiPJDU_tAmDo,672
 trilogy/core/processing/node_generators/basic_node.py,sha256=WQNgJ1MwrMS_BQ-b3XwGGB6eToDykelAVj_fesJuqe0,2069
 trilogy/core/processing/node_generators/common.py,sha256=eslHTTPFTkmwHwKIuUsbFn54jxj-Avtt-QScqtNwzdg,8945
@@ -37,16 +37,16 @@ trilogy/core/processing/node_generators/group_to_node.py,sha256=R9i_wHipxjXJyfYE
 trilogy/core/processing/node_generators/multiselect_node.py,sha256=_KO9lqzHQoy4VAviO0ttQlmK0tjaqrJj4SJPhmoIYm8,6229
 trilogy/core/processing/node_generators/node_merge_node.py,sha256=dIEv5P2MTViAES2MzqJgccYzM3HldjHrQYFwH00cqyc,14003
 trilogy/core/processing/node_generators/rowset_node.py,sha256=KtdN6t2xM8CJxobc4aQX4W8uX98U6IabeuBF_FtBLR4,4583
-trilogy/core/processing/node_generators/select_merge_node.py,sha256=z1sF04MQsMYbLjE__co5Nwi5hTvMeTZACzTnuBe7lsk,11341
+trilogy/core/processing/node_generators/select_merge_node.py,sha256=vE7GoPu2_okO3jS96oA5O3jFsrkiSqIvIP5WkyfFil0,11596
 trilogy/core/processing/node_generators/select_node.py,sha256=nwXHQF6C-aQUIelx9dyxN2pK3muL-4-6RIqnqQqNwtw,1808
 trilogy/core/processing/node_generators/unnest_node.py,sha256=cZ26CN338CBnd6asML1OBUtNcDzmNlFpY0Vnade4yrc,2256
 trilogy/core/processing/node_generators/window_node.py,sha256=jy3FF8uN0VA7yyrBeR40B9CAqR_5qBP4PiS6Gr-f-7w,2590
 trilogy/core/processing/nodes/__init__.py,sha256=qS5EJDRwwIrCEfS7ibCA2ESE0RPzsAIii1UWd_wNsHA,4760
-trilogy/core/processing/nodes/base_node.py,sha256=sc3HrXkWk-xpsAQ7B7ltX1ZejYAkqFiv8Ei8Jg5VGkQ,15579
+trilogy/core/processing/nodes/base_node.py,sha256=8nEG3OPE_LzFXI48-Y6FS8MyO79LY0Sm0EqYz31WJ1Q,15719
 trilogy/core/processing/nodes/filter_node.py,sha256=GfZ9eghpFDI-s7iQP2UqTljCmn25LT_T5TAxDlh7PkQ,2343
 trilogy/core/processing/nodes/group_node.py,sha256=PrBHaGq_f8RmokUw9lXLGJ5YbjdP77P7Ag0pgR6e2cU,7293
-trilogy/core/processing/nodes/merge_node.py,sha256=2BjE2bTyoMHLfn_pnl1fioJkm1AfWtVKnuzzL4aWS5I,14799
-trilogy/core/processing/nodes/select_node_v2.py,sha256=gS9OQgS2TSEK59BQ9R0i83pTHfGJUxv7AkAmT21sYxI,8067
+trilogy/core/processing/nodes/merge_node.py,sha256=W3eCjmJbs8Wfw7Y5AgIY2pP-ntPCrrMe11UG-QGJvA8,14835
+trilogy/core/processing/nodes/select_node_v2.py,sha256=k5WvqmOkLwnP9SFSF5z33a1SFo4nZ-y9ODLi-P05YkI,8281
 trilogy/core/processing/nodes/unnest_node.py,sha256=mAmFluzm2yeeiQ6NfIB7BU_8atRGh-UJfPf9ROwbhr8,2152
 trilogy/core/processing/nodes/window_node.py,sha256=ro0QfMFi4ZmIn5Q4D0M_vJWfnHH_C0MN7XkVkx8Gygg,1214
 trilogy/dialect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -63,21 +63,21 @@ trilogy/dialect/sql_server.py,sha256=owUZbMFrooYIMj1DSLstPWxPO7K7WAUEWNvDKM-DMt0
 trilogy/hooks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/hooks/base_hook.py,sha256=Xkb-A2qCHozYjum0A36zOy5PwTVwrP3NLDF0U2GpgHo,1100
 trilogy/hooks/graph_hook.py,sha256=onHvMQPwj_KOS3HOTpRFiy7QLLKAiycq2MzJ_Q0Oh5Y,2467
-trilogy/hooks/query_debugger.py,sha256=Pe-Kw1JGngeLqQOMQb0E3-24jXEavqnPCQ-KOfTfjP8,4357
+trilogy/hooks/query_debugger.py,sha256=787umJjdGA057DCC714dqFstzJRUbwmz3MNr66IdpQI,4404
 trilogy/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/parsing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/parsing/common.py,sha256=t7yiL_3f6rz_rouF9et84v5orAgs-EprV4V9ghQ6ql4,10024
 trilogy/parsing/config.py,sha256=Z-DaefdKhPDmSXLgg5V4pebhSB0h590vI0_VtHnlukI,111
 trilogy/parsing/exceptions.py,sha256=92E5i2frv5hj9wxObJZsZqj5T6bglvPzvdvco_vW1Zk,38
 trilogy/parsing/helpers.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-trilogy/parsing/parse_engine.py,sha256=nyNyClknlHVYeHHGrSXWDAuV_E_XQSvFLUZqZ2q97kE,64513
-trilogy/parsing/render.py,sha256=_Jb1or0XFmrj2mHHv7My1VNdWkcpOAYWnRwFW2sh4U0,14052
-trilogy/parsing/trilogy.lark,sha256=NZgFchImZsQ3fyyBh8kwq8esTQOR5QlZ9n6k-F5H8nI,12184
+trilogy/parsing/parse_engine.py,sha256=JwG98fotPpvh5VC-CcHknCTFid9-Zj1Wfo8CyPOnJzs,64431
+trilogy/parsing/render.py,sha256=B9J2GrYQcE76kddMQSeAmvAPX-9pv39mpeSHZ10SNj8,14655
+trilogy/parsing/trilogy.lark,sha256=_z5px2N-e8oLUf7SpPMXXNqbAykDkZOvP4_lPgf5-Uk,12245
 trilogy/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/scripts/trilogy.py,sha256=PHxvv6f2ODv0esyyhWxlARgra8dVhqQhYl0lTrSyVNo,3729
-pytrilogy-0.0.2.26.dist-info/LICENSE.md,sha256=5ZRvtTyCCFwz1THxDTjAu3Lidds9WjPvvzgVwPSYNDo,1042
-pytrilogy-0.0.2.26.dist-info/METADATA,sha256=1tD8kmlqzPcPdU5SiPHkiiSvXXwSqEm4sBvjp1LIDY4,8403
-pytrilogy-0.0.2.26.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
-pytrilogy-0.0.2.26.dist-info/entry_points.txt,sha256=0petKryjvvtEfTlbZC1AuMFumH_WQ9v8A19LvoS6G6c,54
-pytrilogy-0.0.2.26.dist-info/top_level.txt,sha256=cAy__NW_eMAa_yT9UnUNlZLFfxcg6eimUAZ184cdNiE,8
-pytrilogy-0.0.2.26.dist-info/RECORD,,
+pytrilogy-0.0.2.28.dist-info/LICENSE.md,sha256=5ZRvtTyCCFwz1THxDTjAu3Lidds9WjPvvzgVwPSYNDo,1042
+pytrilogy-0.0.2.28.dist-info/METADATA,sha256=Ftsu-RyQ2c7b05KV4JZm7J9f1DEMup2xjMfLUA-PfWQ,8403
+pytrilogy-0.0.2.28.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+pytrilogy-0.0.2.28.dist-info/entry_points.txt,sha256=0petKryjvvtEfTlbZC1AuMFumH_WQ9v8A19LvoS6G6c,54
+pytrilogy-0.0.2.28.dist-info/top_level.txt,sha256=cAy__NW_eMAa_yT9UnUNlZLFfxcg6eimUAZ184cdNiE,8
+pytrilogy-0.0.2.28.dist-info/RECORD,,

{pytrilogy-0.0.2.26.dist-info → pytrilogy-0.0.2.28.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.2.0)
+Generator: setuptools (75.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

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"]

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):

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:

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:

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()
     ]

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,
         )
 
 

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(

trilogy/core/processing/nodes/select_node_v2.py

@@ -49,6 +49,7 @@ class SelectNode(StrategyNode):
         conditions: Conditional | Comparison | Parenthetical | None = None,
         preexisting_conditions: Conditional | Comparison | Parenthetical | None = None,
         hidden_concepts: List[Concept] | None = None,
+        render_condition: bool = True,
     ):
         super().__init__(
             input_concepts=input_concepts,
@@ -65,6 +66,7 @@ class SelectNode(StrategyNode):
             conditions=conditions,
             preexisting_conditions=preexisting_conditions,
             hidden_concepts=hidden_concepts,
+            render_condition=render_condition,
         )
         self.accept_partial = accept_partial
         self.datasource = datasource
@@ -120,7 +122,8 @@ class SelectNode(StrategyNode):
             ],
             nullable_concepts=[c.concept for c in datasource.columns if c.is_nullable],
             source_type=SourceType.DIRECT_SELECT,
-            condition=self.conditions,
+            # we can skip rendering conditions
+            condition=self.conditions if self.render_condition else None,
             # select nodes should never group
             force_group=self.force_group,
             hidden_concepts=self.hidden_concepts,
@@ -128,7 +131,7 @@ class SelectNode(StrategyNode):
 
     def resolve_from_constant_datasources(self) -> QueryDatasource:
         datasource = Datasource(
-            identifier=CONSTANT_DATASET, address=CONSTANT_DATASET, columns=[]
+            name=CONSTANT_DATASET, address=CONSTANT_DATASET, columns=[]
         )
         return QueryDatasource(
             input_concepts=[],
@@ -205,6 +208,7 @@ class SelectNode(StrategyNode):
             conditions=self.conditions,
             preexisting_conditions=self.preexisting_conditions,
             hidden_concepts=self.hidden_concepts,
+            render_condition=self.render_condition,
         )
 
 

trilogy/core/processing/utility.py

@@ -66,9 +66,6 @@ def resolve_join_order_v2(
 ) -> list[JoinOrderOutput]:
     datasources = [x for x in g.nodes if x.startswith("ds~")]
     concepts = [x for x in g.nodes if x.startswith("c~")]
-    # from trilogy.hooks.graph_hook import GraphHook
-
-    # GraphHook().query_graph_built(g)
 
     output: list[JoinOrderOutput] = []
     pivot_map = {
@@ -78,7 +75,7 @@ def resolve_join_order_v2(
     pivots = list(
         sorted(
             [x for x in pivot_map if len(pivot_map[x]) > 1],
-            key=lambda x: len(pivot_map[x]),
+            key=lambda x: (len(pivot_map[x]), len(x), x),
         )
     )
     solo = [x for x in pivot_map if len(pivot_map[x]) == 1]
@@ -95,7 +92,7 @@ def resolve_join_order_v2(
             root = pivots.pop()
 
         # sort so less partials is last and eligible lefts are
-        def score_key(x: str) -> int:
+        def score_key(x: str) -> tuple[int, int, str]:
             base = 1
             # if it's left, higher weight
             if x in eligible_left:
@@ -103,7 +100,7 @@ def resolve_join_order_v2(
             # if it has the concept as a partial, lower weight
             if root in partials.get(x, []):
                 base -= 1
-            return base
+            return (base, len(x), x)
 
         # get remainig un-joined datasets
         to_join = sorted(
@@ -296,7 +293,7 @@ def add_node_join_concept(
 
 
 def resolve_instantiated_concept(
-    concept: Concept, datasource: QueryDatasource
+    concept: Concept, datasource: QueryDatasource | Datasource
 ) -> Concept:
     if concept.address in datasource.output_concepts:
         return concept
@@ -309,14 +306,14 @@ def resolve_instantiated_concept(
 
 
 def get_node_joins(
-    datasources: List[QueryDatasource],
+    datasources: List[QueryDatasource | Datasource],
     environment: Environment,
     # concepts:List[Concept],
 ):
 
     graph = nx.Graph()
     partials: dict[str, list[str]] = {}
-    ds_node_map: dict[str, QueryDatasource] = {}
+    ds_node_map: dict[str, QueryDatasource | Datasource] = {}
     concept_map: dict[str, Concept] = {}
     for datasource in datasources:
         ds_node = f"ds~{datasource.identifier}"

trilogy/core/query_processor.py

@@ -5,7 +5,7 @@ from trilogy.core.graph_models import ReferenceGraph
 from trilogy.core.constants import CONSTANT_DATASET
 from trilogy.core.processing.concept_strategies_v3 import source_query_concepts
 from trilogy.core.enums import BooleanOperator
-from trilogy.constants import CONFIG, DEFAULT_NAMESPACE
+from trilogy.constants import CONFIG
 from trilogy.core.processing.nodes import SelectNode, StrategyNode, History
 from trilogy.core.models import (
     Concept,
@@ -55,12 +55,12 @@ def base_join_to_join(
 
     def get_datasource_cte(datasource: Datasource | QueryDatasource) -> CTE:
         for cte in ctes:
-            if cte.source.full_name == datasource.full_name:
+            if cte.source.identifier == datasource.identifier:
                 return cte
         for cte in ctes:
-            if cte.source.datasources[0].full_name == datasource.full_name:
+            if cte.source.datasources[0].identifier == datasource.identifier:
                 return cte
-        raise ValueError(f"Could not find CTE for datasource {datasource.full_name}")
+        raise ValueError(f"Could not find CTE for datasource {datasource.identifier}")
 
     if base_join.left_datasource is not None:
         left_cte = get_datasource_cte(base_join.left_datasource)
@@ -109,7 +109,7 @@ def generate_source_map(
     # now populate anything derived in this level
     for qdk, qdv in query_datasource.source_map.items():
         unnest = [x for x in qdv if isinstance(x, UnnestJoin)]
-        for x in unnest:
+        for _ in unnest:
             source_map[qdk] = []
         if (
             qdk not in source_map
@@ -119,16 +119,18 @@ def generate_source_map(
             source_map[qdk] = []
         basic = [x for x in qdv if isinstance(x, Datasource)]
         for base in basic:
-            source_map[qdk].append(base.name)
+            source_map[qdk].append(base.safe_identifier)
 
         ctes = [x for x in qdv if isinstance(x, QueryDatasource)]
         if ctes:
-            names = set([x.name for x in ctes])
-            matches = [cte for cte in all_new_ctes if cte.source.name in names]
+            names = set([x.safe_identifier for x in ctes])
+            matches = [
+                cte for cte in all_new_ctes if cte.source.safe_identifier in names
+            ]
 
             if not matches and names:
                 raise SyntaxError(
-                    f"Missing parent CTEs for source map; expecting {names}, have {[cte.source.name for cte in all_new_ctes]}"
+                    f"Missing parent CTEs for source map; expecting {names}, have {[cte.source.safe_identifier for cte in all_new_ctes]}"
                 )
             for cte in matches:
                 output_address = [
@@ -137,11 +139,11 @@ def generate_source_map(
                     if x.address not in [z.address for z in cte.partial_concepts]
                 ]
                 if qdk in output_address:
-                    source_map[qdk].append(cte.name)
+                    source_map[qdk].append(cte.safe_identifier)
             # now do a pass that accepts partials
             for cte in matches:
                 if qdk not in source_map:
-                    source_map[qdk] = [cte.name]
+                    source_map[qdk] = [cte.safe_identifier]
         if qdk not in source_map:
             if not qdv:
                 source_map[qdk] = []
@@ -154,8 +156,10 @@ def generate_source_map(
     # as they cannot be referenced in row resolution
     existence_source_map: Dict[str, list[str]] = defaultdict(list)
     for ek, ev in query_datasource.existence_source_map.items():
-        names = set([x.name for x in ev])
-        ematches = [cte.name for cte in all_new_ctes if cte.source.name in names]
+        ids = set([x.safe_identifier for x in ev])
+        ematches = [
+            cte.name for cte in all_new_ctes if cte.source.safe_identifier in ids
+        ]
         existence_source_map[ek] = ematches
     return {
         k: [] if not v else list(set(v)) for k, v in source_map.items()
@@ -209,7 +213,7 @@ def resolve_cte_base_name_and_alias_v2(
         and not source.datasources[0].name == CONSTANT_DATASET
     ):
         ds = source.datasources[0]
-        return ds.safe_location, ds.identifier
+        return ds.safe_location, ds.safe_identifier
 
     joins: List[Join] = [join for join in raw_joins if isinstance(join, Join)]
     if joins and len(joins) > 0:
@@ -268,17 +272,17 @@ def datasource_to_ctes(
         # this is required to ensure that constant datasets
         # render properly on initial access; since they have
         # no actual source
-        if source.full_name == DEFAULT_NAMESPACE + "_" + CONSTANT_DATASET:
+        if source.name == CONSTANT_DATASET:
             source_map = {k: [] for k in query_datasource.source_map}
             existence_map = source_map
         else:
             source_map = {
-                k: [] if not v else [source.identifier]
+                k: [] if not v else [source.safe_identifier]
                 for k, v in query_datasource.source_map.items()
             }
             existence_map = source_map
 
-    human_id = generate_cte_name(query_datasource.full_name, name_map)
+    human_id = generate_cte_name(query_datasource.identifier, name_map)
 
     final_joins = [base_join_to_join(join, parents) for join in query_datasource.joins]
 

trilogy/executor.py

@@ -276,6 +276,20 @@ class Executor(object):
             output.append(compiled_sql)
         return output
 
+    def parse_file(self, file: str | Path, persist: bool = False) -> Generator[
+        ProcessedQuery
+        | ProcessedQueryPersist
+        | ProcessedShowStatement
+        | ProcessedRawSQLStatement
+        | ProcessedCopyStatement,
+        None,
+        None,
+    ]:
+        file = Path(file)
+        with open(file, "r") as f:
+            command = f.read()
+            return self.parse_text_generator(command, persist=persist)
+
     def parse_text(
         self, command: str, persist: bool = False
     ) -> List[
@@ -319,9 +333,11 @@ class Executor(object):
             x = self.generator.generate_queries(
                 self.environment, [t], hooks=self.hooks
             )[0]
+
+            yield x
+
             if persist and isinstance(x, ProcessedQueryPersist):
                 self.environment.add_datasource(x.datasource)
-            yield x
 
     def execute_raw_sql(
         self, command: str, variables: dict | None = None

trilogy/hooks/query_debugger.py

@@ -77,7 +77,11 @@ def print_recursive_nodes(
             ]
         ]
     for child in input.parents:
-        display += print_recursive_nodes(child, mode=mode, depth=depth + 1)
+        display += print_recursive_nodes(
+            child,
+            mode=mode,
+            depth=depth + 1,
+        )
     return display
 
 

trilogy/parsing/parse_engine.py

@@ -123,6 +123,13 @@ from trilogy.parsing.common import (
     arbitrary_to_concept,
     process_function_args,
 )
+from dataclasses import dataclass
+
+
+@dataclass
+class WholeGrainWrapper:
+    where: WhereClause
+
 
 CONSTANT_TYPES = (int, float, str, bool, list, ListWrapper, MapWrapper)
 
@@ -566,9 +573,11 @@ class ParseToObjects(Transformer):
         return args
 
     def grain_clause(self, args) -> Grain:
-        #            namespace=self.environment.namespace,
         return Grain(components=[self.environment.concepts[a] for a in args[0]])
 
+    def whole_grain_clause(self, args) -> WholeGrainWrapper:
+        return WholeGrainWrapper(where=args[0])
+
     def MULTILINE_STRING(self, args) -> str:
         return args[3:-3]
 
@@ -582,11 +591,14 @@ class ParseToObjects(Transformer):
         grain: Optional[Grain] = None
         address: Optional[Address] = None
         where: Optional[WhereClause] = None
+        non_partial_for: Optional[WhereClause] = None
         for val in args[1:]:
             if isinstance(val, Address):
                 address = val
             elif isinstance(val, Grain):
                 grain = val
+            elif isinstance(val, WholeGrainWrapper):
+                non_partial_for = val.where
             elif isinstance(val, Query):
                 address = Address(location=f"({val.text})", is_query=True)
             elif isinstance(val, WhereClause):
@@ -596,7 +608,7 @@ class ParseToObjects(Transformer):
                 "Malformed datasource, missing address or query declaration"
             )
         datasource = Datasource(
-            identifier=name,
+            name=name,
             columns=columns,
             # grain will be set by default from args
             # TODO: move to factory
@@ -604,6 +616,7 @@ class ParseToObjects(Transformer):
             address=address,
             namespace=self.environment.namespace,
             where=where,
+            non_partial_for=non_partial_for,
         )
         for column in columns:
             column.concept = column.concept.with_grain(datasource.grain)
@@ -801,20 +814,10 @@ class ParseToObjects(Transformer):
             except Exception as e:
                 raise ImportError(f"Unable to import file {target}, parsing error: {e}")
 
-        for _, concept in nparser.environment.concepts.items():
-            self.environment.add_concept(
-                concept.with_namespace(alias), _ignore_cache=True
-            )
-
-        for _, datasource in nparser.environment.datasources.items():
-            self.environment.add_datasource(
-                datasource.with_namespace(alias), _ignore_cache=True
-            )
         imps = ImportStatement(
             alias=alias, path=Path(args[0]), environment=nparser.environment
         )
-        self.environment.imports[alias] = imps
-        self.environment.gen_concept_list_caches()
+        self.environment.add_import(alias, nparser.environment, imps)
         return imps
 
     @v_args(meta=True)
@@ -841,7 +844,7 @@ class ParseToObjects(Transformer):
                 if self.environment.namespace
                 else DEFAULT_NAMESPACE
             ),
-            identifier=identifier,
+            name=identifier,
             address=Address(location=address),
             grain=grain,
         )

trilogy/parsing/render.py

@@ -80,6 +80,9 @@ class Renderer:
         metrics = []
         # first, keys
         for concept in arg.concepts.values():
+            if "__preql_internal" in concept.address:
+                continue
+
             # don't render anything that came from an import
             if concept.namespace in arg.imports:
                 continue
@@ -122,10 +125,10 @@ class Renderer:
             for datasource in arg.datasources.values()
             if datasource.namespace == DEFAULT_NAMESPACE
         ]
-        rendered_imports = [
-            self.to_string(import_statement)
-            for import_statement in arg.imports.values()
-        ]
+        rendered_imports = []
+        for _, imports in arg.imports.items():
+            for import_statement in imports:
+                rendered_imports.append(self.to_string(import_statement))
         components = []
         if rendered_imports:
             components.append(rendered_imports)
@@ -133,19 +136,26 @@ class Renderer:
             components.append(rendered_concepts)
         if rendered_datasources:
             components.append(rendered_datasources)
+
         final = "\n\n".join("\n".join(x) for x in components)
         return final
 
     @to_string.register
     def _(self, arg: Datasource):
         assignments = ",\n    ".join([self.to_string(x) for x in arg.columns])
+        if arg.non_partial_for:
+            non_partial = f"\ncomplete where {self.to_string(arg.non_partial_for)}"
+        else:
+            non_partial = ""
         base = f"""datasource {arg.name} (
     {assignments}
     )
-{self.to_string(arg.grain)}
+{self.to_string(arg.grain)}{non_partial}
 {self.to_string(arg.address)}"""
+
         if arg.where:
             base += f"\nwhere {self.to_string(arg.where)}"
+
         base += ";"
         return base
 
@@ -214,9 +224,15 @@ class Renderer:
 
     @to_string.register
     def _(self, arg: "ColumnAssignment"):
+        if arg.modifiers:
+            modifiers = "".join(
+                [self.to_string(modifier) for modifier in arg.modifiers]
+            )
+        else:
+            modifiers = ""
         if isinstance(arg.alias, str):
-            return f"{arg.alias}: {self.to_string(arg.concept)}"
-        return f"{self.to_string(arg.alias)}: {self.to_string(arg.concept)}"
+            return f"{arg.alias}: {modifiers}{self.to_string(arg.concept)}"
+        return f"{self.to_string(arg.alias)}: {modifiers}{self.to_string(arg.concept)}"
 
     @to_string.register
     def _(self, arg: "RawColumnExpr"):
@@ -352,6 +368,8 @@ class Renderer:
 
     @to_string.register
     def _(self, arg: "ImportStatement"):
+        if arg.alias == DEFAULT_NAMESPACE:
+            return f"import {arg.path};"
         return f"import {arg.path} as {arg.alias};"
 
     @to_string.register

trilogy/parsing/trilogy.lark

@@ -35,8 +35,10 @@
     prop_ident: "<" IDENTIFIER ("," IDENTIFIER )* ","? ">" "." IDENTIFIER
 
     // datasource concepts
-    datasource: "datasource" IDENTIFIER  "("  column_assignment_list ")"  grain_clause? (address | query) where?
-    
+    datasource: "datasource" IDENTIFIER  "("  column_assignment_list ")"  grain_clause? whole_grain_clause? (address | query) where?
+   
+    whole_grain_clause: "complete" where
+
     grain_clause: "grain" "(" column_list ")"
     
     address: "address" (QUOTED_ADDRESS | ADDRESS)