pytrilogy 0.0.3.66__py3-none-any.whl → 0.0.3.67__py3-none-any.whl

{pytrilogy-0.0.3.66.dist-info → pytrilogy-0.0.3.67.dist-info}/METADATA

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

{pytrilogy-0.0.3.66.dist-info → pytrilogy-0.0.3.67.dist-info}/RECORD

@@ -1,5 +1,5 @@
-pytrilogy-0.0.3.66.dist-info/licenses/LICENSE.md,sha256=5ZRvtTyCCFwz1THxDTjAu3Lidds9WjPvvzgVwPSYNDo,1042
-trilogy/__init__.py,sha256=aRLUllOSoHKDIW__yBx1aitL_E96Qtj4AGz-mFHB16g,303
+pytrilogy-0.0.3.67.dist-info/licenses/LICENSE.md,sha256=5ZRvtTyCCFwz1THxDTjAu3Lidds9WjPvvzgVwPSYNDo,1042
+trilogy/__init__.py,sha256=kIt0gE_lZ8Zmqhi-fcE9krdwlETcz0sP0kiCjnsBQog,303
 trilogy/compiler.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/constants.py,sha256=lv_aJWP6dn6e2aF4BAE72jbnNtceFddfqtiDSsvzno0,1692
 trilogy/engine.py,sha256=OK2RuqCIUId6yZ5hfF8J1nxGP0AJqHRZiafcowmW0xc,1728
@@ -15,55 +15,55 @@ trilogy/core/enums.py,sha256=2sgoVzHQpscIx_WUqJMH0oGxtcg41gN0l1qkRjzK2iI,7803
 trilogy/core/env_processor.py,sha256=pFsxnluKIusGKx1z7tTnfsd_xZcPy9pZDungkjkyvI0,3170
 trilogy/core/environment_helpers.py,sha256=VvPIiFemqaLLpIpLIqprfu63K7muZ1YzNg7UZIUph8w,8267
 trilogy/core/ergonomics.py,sha256=e-7gE29vPLFdg0_A1smQ7eOrUwKl5VYdxRSTddHweRA,1631
-trilogy/core/exceptions.py,sha256=JPYyBcit3T_pRtlHdtKSeVJkIyWUTozW2aaut25A2xI,673
+trilogy/core/exceptions.py,sha256=jYEduuMehcMkmCpf-OC_taELPZm7qNfeSNzIWkDYScs,707
 trilogy/core/functions.py,sha256=poVfAwet1xdxTkC7WL38UmGRDpUVO9iSMNWSagl9_r4,29302
 trilogy/core/graph_models.py,sha256=wIT-oBchHWE46GLDkgN5K7EzhOBEo8LfaeWV5G5cYcE,3302
 trilogy/core/internal.py,sha256=iicDBlC6nM8d7e7jqzf_ZOmpUsW8yrr2AA8AqEiLx-s,1577
 trilogy/core/optimization.py,sha256=ojpn-p79lr03SSVQbbw74iPCyoYpDYBmj1dbZ3oXCjI,8860
-trilogy/core/query_processor.py,sha256=kBvQex0Xi2-u8DvAbAo_LXFTMKzMkFvwL-SCrIXU41k,20310
+trilogy/core/query_processor.py,sha256=jA1lek3Kbpi_-NamDPjJuJanUdY7KM3ODB7tS_qqxH4,20311
 trilogy/core/utility.py,sha256=3VC13uSQWcZNghgt7Ot0ZTeEmNqs__cx122abVq9qhM,410
 trilogy/core/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/core/models/author.py,sha256=44VyEInWied287lJp99T14Ahq8RSQK4q3Y-AzAByMTY,77818
-trilogy/core/models/build.py,sha256=yR3GtkIgLrT88B_wu9geqHWxnEI4joUWQSYW7_9Gjk0,63489
+trilogy/core/models/build.py,sha256=eNjbFwg_mEcwPeagQpkIybIluIrRCKJLAHdpZjm01e8,64857
 trilogy/core/models/build_environment.py,sha256=s_C9xAHuD3yZ26T15pWVBvoqvlp2LdZ8yjsv2_HdXLk,5363
 trilogy/core/models/core.py,sha256=EMAuWTngoNVGCdfNrAY7_k6g528iodNQLwPRVip-8DA,10980
 trilogy/core/models/datasource.py,sha256=6RjJUd2u4nYmEwFBpJlM9LbHVYDv8iHJxqiBMZqUrwI,9422
-trilogy/core/models/environment.py,sha256=7bkxUob5pNgvK7Om-qvlJgsDiCh5iSPlMHI7tN_OZhU,27717
+trilogy/core/models/environment.py,sha256=TBbPfsXHpJK49QKuqHwhgZD4PwHiSAYjXmTTTomRE7o,27861
 trilogy/core/models/execute.py,sha256=94CZVY_EdW675n8SihDnhaGTV0dq7BAAsl2Anf1mPmk,41815
 trilogy/core/optimizations/__init__.py,sha256=YH2-mGXZnVDnBcWVi8vTbrdw7Qs5TivG4h38rH3js_I,290
 trilogy/core/optimizations/base_optimization.py,sha256=gzDOKImoFn36k7XBD3ysEYDnbnb6vdVIztUfFQZsGnM,513
 trilogy/core/optimizations/inline_datasource.py,sha256=2sWNRpoRInnTgo9wExVT_r9RfLAQHI57reEV5cGHUcg,4329
 trilogy/core/optimizations/predicate_pushdown.py,sha256=g4AYE8Aw_iMlAh68TjNXGP754NTurrDduFECkUjoBnc,9399
 trilogy/core/processing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-trilogy/core/processing/concept_strategies_v3.py,sha256=uD_Bzy2l30TJ5-6v0tn9dO-vI6zFRgtHsIHUvge3Sps,22536
+trilogy/core/processing/concept_strategies_v3.py,sha256=zy5VZa9LITOws6aIILfv_bSR2-jR1Ndldy-nmwMyQ5w,23144
 trilogy/core/processing/discovery_loop.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-trilogy/core/processing/discovery_node_factory.py,sha256=X3-ywUvGbbcwwWtMqKXsPc6xyh3o41eiLRuByXGCvY4,14915
-trilogy/core/processing/discovery_utility.py,sha256=hF3aUbRHHZFeFT5aBjE6TuSeU60I90gzmj512QXG_t8,4856
-trilogy/core/processing/discovery_validation.py,sha256=Ek9jviFgimLMUMYLXBChUQmOD94ihhwQ3NDVe6RTdWg,4930
+trilogy/core/processing/discovery_node_factory.py,sha256=73fViHQfKsrFbuk8zfx8YIiaT66pF5AFvw4suV7bXbM,14985
+trilogy/core/processing/discovery_utility.py,sha256=3xdd1ypKappSDm0SJs7WtW5YegL80SlYhDQlkNePp4E,4549
+trilogy/core/processing/discovery_validation.py,sha256=fGWJmKpgEd1f4RkK-fYOBUT1cwsJnahwXFAdRlou7MI,5365
 trilogy/core/processing/graph_utils.py,sha256=8QUVrkE9j-9C1AyrCb1nQEh8daCe0u1HuXl-Te85lag,1205
 trilogy/core/processing/utility.py,sha256=mrfR9pgek-xjxoDQSlvPqOW9dpmREjgzqn4AGoqpGeM,22774
 trilogy/core/processing/node_generators/__init__.py,sha256=w8TQQgNhyAra6JQHdg1_Ags4BGyxjXYruu6UeC5yOkI,873
 trilogy/core/processing/node_generators/basic_node.py,sha256=luN8LftafZepoFgDRv4gmvEGFlOI2j0icJ5fz4UT7uo,5165
 trilogy/core/processing/node_generators/common.py,sha256=PdysdroW9DUADP7f5Wv_GKPUyCTROZV1g3L45fawxi8,9443
-trilogy/core/processing/node_generators/filter_node.py,sha256=0hdfiS2I-Jvr6P-il3jnAJK-g-DMG7_cFbZGCnLnJAo,10032
-trilogy/core/processing/node_generators/group_node.py,sha256=nIfiMrJQEksUfqAeeA3X5PS1343y4lmPTipYuCa-rvs,6141
+trilogy/core/processing/node_generators/filter_node.py,sha256=oRRq2-T3ufgn4D23uQsc58f20eFk-djs4QI3WKA75K8,10908
+trilogy/core/processing/node_generators/group_node.py,sha256=S7mzEAVmjc7rnHrJ9PAp4Ld8njcBSrvAu3K1cxsLQdY,6140
 trilogy/core/processing/node_generators/group_to_node.py,sha256=jKcNCDOY6fNblrdZwaRU0sbUSr9H0moQbAxrGgX6iGA,3832
 trilogy/core/processing/node_generators/multiselect_node.py,sha256=GWV5yLmKTe1yyPhN60RG1Rnrn4ktfn9lYYXi_FVU4UI,7061
-trilogy/core/processing/node_generators/node_merge_node.py,sha256=-sVhRHB3NqNIOk_e7LLVhW17Rjcf82hxaHjEvpF5Q-w,16858
+trilogy/core/processing/node_generators/node_merge_node.py,sha256=dSqfqWp2SolhDB16nkPaaTXgNQo4QquEufPdf7q0Tb4,17398
 trilogy/core/processing/node_generators/recursive_node.py,sha256=l5zdh0dURKwmAy8kK4OpMtZfyUEQRk6N-PwSWIyBpSM,2468
 trilogy/core/processing/node_generators/rowset_node.py,sha256=2BiSsegbRF9csJ_Xl8P_CxIm4dAAb7dF29u6v_Odr-A,6709
-trilogy/core/processing/node_generators/select_merge_node.py,sha256=3GDGi1tNIfuKO_FMrNCfp-G1c3lxdRuuufcmomYLt4s,21446
-trilogy/core/processing/node_generators/select_node.py,sha256=3dvw0d53eUtCRCUPN6J48I3qBEX1Wha7saQ_ndPu6_I,1777
-trilogy/core/processing/node_generators/synonym_node.py,sha256=CN2swdGPEP_Irx4GykHp4gyLCK0dWd2vX7PYJUGxw7w,3548
+trilogy/core/processing/node_generators/select_merge_node.py,sha256=fisCkMyzNDEdDIi9BMuekpIJT5lBF4h0z_pEwR14x9s,21438
+trilogy/core/processing/node_generators/select_node.py,sha256=Ta1G39V94gjX_AgyZDz9OqnwLz4BjY3D6Drx9YpziMQ,3555
+trilogy/core/processing/node_generators/synonym_node.py,sha256=F9DWaKEmJDYnwAmQduTuQP2LCCHqAMDA3oDERRDN2pU,3773
 trilogy/core/processing/node_generators/union_node.py,sha256=VNo6Oey4p8etU9xrOh2oTT2lIOTvY6PULUPRvVa2uxU,2877
 trilogy/core/processing/node_generators/unnest_node.py,sha256=ueOQtoTf2iJHO09RzWHDFQ5iKZq2fVhGf2KAF2U2kU8,2677
 trilogy/core/processing/node_generators/window_node.py,sha256=GP3Hvkbb0TDA6ef7W7bmvQEHVH-NRIfBT_0W4fcH3g4,6529
 trilogy/core/processing/node_generators/select_helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/core/processing/node_generators/select_helpers/datasource_injection.py,sha256=Dw0pjdhuJX0p-18CjelLrIJoevAPKzZOTN9uSLNPOF4,6553
 trilogy/core/processing/nodes/__init__.py,sha256=zTge1EzwzEydlcMliIFO_TT7h7lS8l37lyZuQDir1h0,5487
-trilogy/core/processing/nodes/base_node.py,sha256=p6yljFNLQsXz277c5wTATMNqsKUbsdP_3e7--tezBMw,17691
+trilogy/core/processing/nodes/base_node.py,sha256=HcltmrYO5RUkmM7qryNQkcahgY0r8lfmIqDbN6Kx9zE,18043
 trilogy/core/processing/nodes/filter_node.py,sha256=5VtRfKbCORx0dV-vQfgy3gOEkmmscL9f31ExvlODwvY,2461
-trilogy/core/processing/nodes/group_node.py,sha256=4EbOur1wSsOpPvP6znHih126o6A-TWbBXyvhiw5B0rs,10505
+trilogy/core/processing/nodes/group_node.py,sha256=ZJ9LRF1sDOyel5v0MHXHORn6DYdn771nX0-KdHdt3-4,10517
 trilogy/core/processing/nodes/merge_node.py,sha256=02oWRca0ba41U6PSAB14jwnWWxoyrvxRPLwkli259SY,15865
 trilogy/core/processing/nodes/recursive_node.py,sha256=k0rizxR8KE64ievfHx_GPfQmU8QAP118Laeyq5BLUOk,1526
 trilogy/core/processing/nodes/select_node_v2.py,sha256=Xyfq8lU7rP7JTAd8VV0ATDNal64n4xIBgWQsOuMe_Ak,8824
@@ -76,7 +76,7 @@ trilogy/core/statements/build.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hS
 trilogy/core/statements/common.py,sha256=KxEmz2ySySyZ6CTPzn0fJl5NX2KOk1RPyuUSwWhnK1g,759
 trilogy/core/statements/execute.py,sha256=rqfuoMuXPcH7L7TmE1dSiZ_K_A1ohB8whVMfGimZBOk,1294
 trilogy/dialect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-trilogy/dialect/base.py,sha256=fM5tPJA5yi6tTHUTWpHldh4RApJUmrosDorbrRQibe4,43613
+trilogy/dialect/base.py,sha256=_EkBijBaJGF_d0SBNBCf_mbmDD7N9HrnO2XbRWM8ypg,43629
 trilogy/dialect/bigquery.py,sha256=6ghCqy-k7UioIJc1EEQ7gRo_PHaO8Vm7yYbiQ-kgpzs,3629
 trilogy/dialect/common.py,sha256=hhzuMTFW9QQIP7TKLT9BlJy6lw2R03a68jKQ-7t4-2c,6070
 trilogy/dialect/config.py,sha256=olnyeVU5W5T6b9-dMeNAnvxuPlyc2uefb7FRME094Ec,3834
@@ -110,8 +110,8 @@ trilogy/std/money.preql,sha256=XWwvAV3WxBsHX9zfptoYRnBigcfYwrYtBHXTME0xJuQ,2082
 trilogy/std/net.preql,sha256=-bMV6dyofskl4Kvows-iQ4JCxjVUwsZOeWCy8JO5Ftw,135
 trilogy/std/ranking.preql,sha256=LDoZrYyz4g3xsII9XwXfmstZD-_92i1Eox1UqkBIfi8,83
 trilogy/std/report.preql,sha256=LbV-XlHdfw0jgnQ8pV7acG95xrd1-p65fVpiIc-S7W4,202
-pytrilogy-0.0.3.66.dist-info/METADATA,sha256=cQJUWN4bTjEYsCxAcAOKmkzEkkmpxB7mBmMQPx0O4Cw,9095
-pytrilogy-0.0.3.66.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pytrilogy-0.0.3.66.dist-info/entry_points.txt,sha256=ewBPU2vLnVexZVnB-NrVj-p3E-4vukg83Zk8A55Wp2w,56
-pytrilogy-0.0.3.66.dist-info/top_level.txt,sha256=cAy__NW_eMAa_yT9UnUNlZLFfxcg6eimUAZ184cdNiE,8
-pytrilogy-0.0.3.66.dist-info/RECORD,,
+pytrilogy-0.0.3.67.dist-info/METADATA,sha256=q69gBB9Ympec6F7E9ASBDjTfuRs06HmUws7QvAxVBeA,9095
+pytrilogy-0.0.3.67.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pytrilogy-0.0.3.67.dist-info/entry_points.txt,sha256=ewBPU2vLnVexZVnB-NrVj-p3E-4vukg83Zk8A55Wp2w,56
+pytrilogy-0.0.3.67.dist-info/top_level.txt,sha256=cAy__NW_eMAa_yT9UnUNlZLFfxcg6eimUAZ184cdNiE,8
+pytrilogy-0.0.3.67.dist-info/RECORD,,

trilogy/__init__.py

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

trilogy/core/exceptions.py

@@ -8,7 +8,7 @@ class UndefinedConceptException(Exception):
         self.suggestions = suggestions
 
 
-class UnresolvableQueryException(Exception):
+class FrozenEnvironmentException(Exception):
     pass
 
 
@@ -16,15 +16,15 @@ class InvalidSyntaxException(Exception):
     pass
 
 
-class NoDatasourceException(Exception):
+class UnresolvableQueryException(Exception):
     pass
 
 
-class FrozenEnvironmentException(Exception):
+class NoDatasourceException(UnresolvableQueryException):
     pass
 
 
-class AmbiguousRelationshipResolutionException(Exception):
+class AmbiguousRelationshipResolutionException(UnresolvableQueryException):
     def __init__(self, message, parents: List[set[str]]):
         super().__init__(self, message)
         self.message = message

trilogy/core/models/build.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from abc import ABC
+from collections import defaultdict
 from datetime import date, datetime
 from functools import cached_property, singledispatchmethod
 from typing import (
@@ -1466,6 +1467,20 @@ BuildExpr = (
 BuildConcept.model_rebuild()
 
 
+def get_canonical_pseudonyms(environment: Environment) -> dict[str, set[str]]:
+    roots: dict[str, set[str]] = defaultdict(set)
+    for k, v in environment.concepts.items():
+        roots[v.address].add(k)
+        for x in v.pseudonyms:
+            roots[v.address].add(x)
+    for k, v in environment.alias_origin_lookup.items():
+        lookup = environment.concepts[k].address
+        roots[lookup].add(v.address)
+        for x2 in v.pseudonyms:
+            roots[lookup].add(x2)
+    return roots
+
+
 class Factory:
 
     def __init__(
@@ -1479,6 +1494,7 @@ class Factory:
         self.local_concepts: dict[str, BuildConcept] = (
             {} if local_concepts is None else local_concepts
         )
+        self.pseudonym_map = get_canonical_pseudonyms(environment)
 
     def instantiate_concept(
         self,
@@ -1656,6 +1672,17 @@ class Factory:
         )
         is_aggregate = Concept.calculate_is_aggregate(build_lineage)
 
+        # if this is a pseudonym, we need to look up the base address
+        if base.address in self.environment.alias_origin_lookup:
+            lookup_address = self.environment.concepts[base.address].address
+            # map only to the canonical concept, not to other merged concepts
+            base_pseudonyms = {lookup_address}
+        else:
+            base_pseudonyms = {
+                x
+                for x in self.pseudonym_map.get(base.address, set())
+                if x != base.address
+            }
         rval = BuildConcept.model_construct(
             name=base.name,
             datatype=base.datatype,
@@ -1666,7 +1693,7 @@ class Factory:
             namespace=base.namespace,
             keys=base.keys,
             modifiers=base.modifiers,
-            pseudonyms=base.pseudonyms,
+            pseudonyms=base_pseudonyms,
             ## instantiated values
             derivation=derivation,
             granularity=granularity,
@@ -1688,14 +1715,22 @@ class Factory:
 
     @build.register
     def _(self, base: ColumnAssignment) -> BuildColumnAssignment:
-        fetched = self.environment.concepts[base.concept.address]
+        address = base.concept.address
+        fetched = (
+            self.build(
+                self.environment.alias_origin_lookup[address].with_grain(self.grain)
+            )
+            if address in self.environment.alias_origin_lookup
+            else self.build(self.environment.concepts[address].with_grain(self.grain))
+        )
+
         return BuildColumnAssignment.model_construct(
             alias=(
                 self.build(base.alias)
                 if isinstance(base.alias, Function)
                 else base.alias
             ),
-            concept=self.build(fetched.with_grain(self.grain)),
+            concept=fetched,
             modifiers=base.modifiers,
         )
 

trilogy/core/models/environment.py

@@ -362,9 +362,6 @@ class Environment(BaseModel):
                         and x.concept.address != deriv_lookup
                     ]
                     assert len(datasource.columns) < clen
-                    for x in datasource.columns:
-                        logger.info(x)
-
             return None
 
         if existing and self.config.allow_duplicate_declaration:
@@ -607,15 +604,15 @@ class Environment(BaseModel):
                 )
                 persisted = f"{PERSISTED_CONCEPT_PREFIX}_" + new_persisted_concept.name
                 # override the current concept source to reflect that it's now coming from a datasource
+                base_pseudonyms = new_persisted_concept.pseudonyms or set()
+                original_pseudonyms = {*base_pseudonyms, new_persisted_concept.address}
                 if (
                     new_persisted_concept.metadata.concept_source
                     != ConceptSource.PERSIST_STATEMENT
                 ):
                     original_concept = new_persisted_concept.model_copy(
                         deep=True,
-                        update={
-                            "name": persisted,
-                        },
+                        update={"name": persisted, "pseudonyms": original_pseudonyms},
                     )
                     self.add_concept(
                         original_concept,
@@ -629,6 +626,7 @@ class Environment(BaseModel):
                         ),
                         "derivation": Derivation.ROOT,
                         "purpose": new_persisted_concept.purpose,
+                        "pseudonyms": {*original_pseudonyms, original_concept.address},
                     }
                     # purpose is used in derivation calculation
                     # which should be fixed, but we'll do in a followup
@@ -650,6 +648,7 @@ class Environment(BaseModel):
                         new_persisted_concept,
                         meta=meta,
                     )
+
         return datasource
 
     def delete_datasource(

trilogy/core/processing/concept_strategies_v3.py

@@ -224,6 +224,9 @@ def initialize_loop_context(
     else:
 
         completion_mandatory = mandatory_list
+    logger.info(
+        f"{depth_to_prefix(depth)}{LOGGER_PREFIX} Initialized loop context with mandatory list {[c.address for c in mandatory_list]} and completion mandatory {[c.address for c in completion_mandatory]}"
+    )
     return LoopContext(
         mandatory_list=mandatory_list,
         environment=environment,
@@ -330,7 +333,7 @@ def check_for_early_exit(
     return False
 
 
-def generate_loop_completion(context: LoopContext, virtual) -> StrategyNode:
+def generate_loop_completion(context: LoopContext, virtual: set[str]) -> StrategyNode:
     condition_required = True
     non_virtual = [c for c in context.completion_mandatory if c.address not in virtual]
     non_virtual_output = [
@@ -367,10 +370,15 @@ def generate_loop_completion(context: LoopContext, virtual) -> StrategyNode:
         output: StrategyNode = context.stack[0]
         if non_virtual_different:
             logger.info(
-                f"{depth_to_prefix(context.depth)}{LOGGER_PREFIX} Found different non-virtual output concepts ({non_virtual_difference_values}), removing condition injected values"
+                f"{depth_to_prefix(context.depth)}{LOGGER_PREFIX} Found different non-virtual output concepts ({non_virtual_difference_values}), removing condition injected values by setting outputs to {[x.address for x in output.output_concepts if x.address in non_virtual_output]}"
             )
             output.set_output_concepts(
-                [x for x in output.output_concepts if x.address in non_virtual_output],
+                [
+                    x
+                    for x in output.output_concepts
+                    if x.address in non_virtual_output
+                    or any(c in non_virtual_output for c in x.pseudonyms)
+                ],
                 rebuild=False,
             )
 
@@ -404,7 +412,7 @@ def generate_loop_completion(context: LoopContext, virtual) -> StrategyNode:
     elif context.conditions:
         output.preexisting_conditions = context.conditions.conditional
     logger.info(
-        f"{depth_to_prefix(context.depth)}{LOGGER_PREFIX} Graph is connected, returning {type(output)} node partial {[c.address for c in output.partial_concepts]} with {context.conditions}"
+        f"{depth_to_prefix(context.depth)}{LOGGER_PREFIX} Graph is connected, returning {type(output)} node output {[x.address for x in output.usable_outputs]} partial {[c.address for c in output.partial_concepts]} with {context.conditions}"
     )
     if condition_required and context.conditions and non_virtual_different:
         logger.info(
@@ -419,7 +427,7 @@ def generate_loop_completion(context: LoopContext, virtual) -> StrategyNode:
         )
         if result.required:
             logger.info(
-                f"{depth_to_prefix(context.depth)}{LOGGER_PREFIX} Adding group node"
+                f"{depth_to_prefix(context.depth)}{LOGGER_PREFIX} Adding group node with outputs {[x.address for x in context.original_mandatory]}"
             )
             return GroupNode(
                 output_concepts=context.original_mandatory,
@@ -466,6 +474,7 @@ def _search_concepts(
     )
 
     while context.incomplete:
+
         priority_concept = get_priority_concept(
             context.mandatory_list,
             context.attempted,
@@ -478,7 +487,7 @@ def _search_concepts(
         candidates = [
             c for c in context.mandatory_list if c.address != priority_concept.address
         ]
-        # the local conditions list may be override if we end up injecting conditions
+        # the local conditions list may be overriden if we end up injecting conditions
         candidate_list, local_conditions = generate_candidates_restrictive(
             priority_concept,
             candidates,

trilogy/core/processing/discovery_node_factory.py

@@ -351,7 +351,10 @@ class RootNodeHandler:
         extra = restrict_node_outputs_targets(expanded, root_targets, self.ctx.depth)
 
         pseudonyms = [
-            x for x in extra if any(x.address in y.pseudonyms for y in root_targets)
+            x
+            for x in extra
+            if any(x.address in y.pseudonyms for y in root_targets)
+            and x.address not in root_targets
         ]
 
         if pseudonyms:

trilogy/core/processing/discovery_utility.py

@@ -1,7 +1,7 @@
 from typing import List
 
 from trilogy.constants import logger
-from trilogy.core.enums import Derivation, Granularity
+from trilogy.core.enums import Derivation
 from trilogy.core.models.build import (
     BuildConcept,
     BuildRowsetItem,
@@ -52,14 +52,6 @@ def get_priority_concept(
     # pass_two = [c for c in all_concepts+filter_only if c.address not in attempted_addresses]
     for remaining_concept in (pass_one,):
         priority = (
-            # find anything that needs no joins first, so we can exit early
-            [
-                c
-                for c in remaining_concept
-                if c.derivation == Derivation.CONSTANT
-                and c.granularity == Granularity.SINGLE_ROW
-            ]
-            +
             # then multiselects to remove them from scope
             [c for c in remaining_concept if c.derivation == Derivation.MULTISELECT]
             +

trilogy/core/processing/discovery_validation.py

@@ -34,6 +34,9 @@ def validate_concept(
     seen: set[str],
     environment: BuildEnvironment,
 ):
+    # logger.debug(
+    #     f"Validating concept {concept.address} with accept_partial={accept_partial}"
+    # )
     found_map[str(node)].add(concept)
     seen.add(concept.address)
     if concept not in node.partial_concepts:
@@ -53,12 +56,21 @@ def validate_concept(
             found_map[str(node)].add(concept)
     for v_address in concept.pseudonyms:
         if v_address in seen:
-            return
-        v = environment.concepts[v_address]
+            continue
+        if v_address in environment.alias_origin_lookup:
+            # logger.debug(
+            #     f"Found alias origin for {v_address}: {environment.alias_origin_lookup[v_address]} mapped to {environment.concepts[v_address]}")
+            v = environment.alias_origin_lookup[v_address]
+        else:
+            v = environment.concepts[v_address]
+
         if v.address in seen:
-            return
+
+            continue
+
         if v.address == concept.address:
-            return
+
+            continue
         validate_concept(
             v,
             node,
@@ -93,6 +105,7 @@ def validate_stack(
 
         for concept in resolved.output_concepts:
             if concept.address in resolved.hidden_concepts:
+
                 continue
 
             validate_concept(

trilogy/core/processing/node_generators/filter_node.py

@@ -57,7 +57,13 @@ def build_parent_concepts(
     local_optional: List[BuildConcept],
     conditions: BuildWhereClause | None = None,
     depth: int = 0,
-):
+) -> tuple[
+    list[BuildConcept],
+    list[tuple[BuildConcept, ...]],
+    list[BuildConcept],
+    bool,
+    bool,
+]:
     parent_row_concepts, parent_existence_concepts = resolve_filter_parent_concepts(
         concept, environment
     )
@@ -66,6 +72,10 @@ def build_parent_concepts(
     filter_where = concept.lineage.where
 
     same_filter_optional: list[BuildConcept] = []
+    # mypy struggled here? we shouldn't need explicit bools
+    global_filter_is_local_filter: bool = (
+        True if (conditions and conditions == filter_where) else False
+    )
 
     for x in local_optional:
         if isinstance(x.lineage, FILTER_TYPES):
@@ -79,7 +89,7 @@ def build_parent_concepts(
                         parent_row_concepts.append(arg)
                 same_filter_optional.append(x)
                 continue
-        elif conditions and conditions == filter_where:
+        elif global_filter_is_local_filter:
             same_filter_optional.append(x)
 
     # sometimes, it's okay to include other local optional above the filter
@@ -100,6 +110,7 @@ def build_parent_concepts(
         parent_existence_concepts,
         same_filter_optional,
         is_optimized_pushdown,
+        global_filter_is_local_filter,
     )
 
 
@@ -152,6 +163,7 @@ def gen_filter_node(
         parent_existence_concepts,
         same_filter_optional,
         optimized_pushdown,
+        global_filter_is_local_filter,
     ) = build_parent_concepts(
         concept,
         environment=environment,
@@ -187,7 +199,13 @@ def gen_filter_node(
             f"{padding(depth)}{LOGGER_PREFIX} filter node row parents {[x.address for x in parent_row_concepts]} could not be found"
         )
         return None
-
+    if global_filter_is_local_filter:
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} filter node conditions match global conditions adding row parent {row_parent.output_concepts} with condition {where.conditional}"
+        )
+        row_parent.add_parents(core_parent_nodes)
+        row_parent.set_output_concepts([concept] + local_optional)
+        return row_parent
     if optimized_pushdown:
         logger.info(
             f"{padding(depth)}{LOGGER_PREFIX} returning optimized filter node with pushdown to parent with condition {where.conditional} across {[concept] + same_filter_optional + row_parent.output_concepts} "
@@ -211,7 +229,8 @@ def gen_filter_node(
             parent = row_parent
             parent.add_output_concepts([concept] + same_filter_optional)
         parent.add_parents(core_parent_nodes)
-        parent.add_condition(where.conditional)
+        if not parent.preexisting_conditions == where.conditional:
+            parent.add_condition(where.conditional)
         parent.add_existence_concepts(flattened_existence, False)
         parent.grain = BuildGrain.from_concepts(
             parent.output_concepts,
@@ -225,7 +244,8 @@ def gen_filter_node(
         parents_for_grain = [
             x.lineage.content
             for x in filters
-            if isinstance(x.lineage.content, BuildConcept)
+            if isinstance(x.lineage, BuildFilterItem)
+            and isinstance(x.lineage.content, BuildConcept)
         ]
         filter_node = FilterNode(
             input_concepts=unique(

trilogy/core/processing/node_generators/group_node.py

@@ -133,7 +133,7 @@ def gen_group_node(
         )
         return group_node
     missing_optional = [
-        x.address for x in local_optional if x.address not in group_node.output_concepts
+        x.address for x in local_optional if x.address not in group_node.usable_outputs
     ]
     if not missing_optional:
         logger.info(

trilogy/core/processing/node_generators/node_merge_node.py

@@ -42,6 +42,9 @@ def extract_concept(node: str, env: BuildEnvironment):
 
 def filter_unique_graphs(graphs: list[list[str]]) -> list[list[str]]:
     unique_graphs: list[set[str]] = []
+
+    # sort graphs from largest to smallest
+    graphs.sort(key=lambda x: len(x), reverse=True)
     for graph in graphs:
         if not any(set(graph).issubset(x) for x in unique_graphs):
             unique_graphs.append(set(graph))
@@ -110,12 +113,13 @@ def determine_induced_minimal_nodes(
 
     try:
         paths = nx.multi_source_dijkstra_path(H, nodelist)
-    except nx.exception.NodeNotFound as e:
-        logger.debug(f"Unable to find paths for {nodelist}- {str(e)}")
+        # logger.debug(f"Paths found for {nodelist}")
+    except nx.exception.NodeNotFound:
+        # logger.debug(f"Unable to find paths for {nodelist}- {str(e)}")
         return None
     H.remove_nodes_from(list(x for x in H.nodes if x not in paths))
     sG: nx.Graph = ax.steinertree.steiner_tree(H, nodelist).copy()
-    logger.debug("Steiner tree found for nodes %s", nodelist)
+    # logger.debug(f"Steiner tree found for nodes {nodelist} {sG.nodes}")
     final: nx.DiGraph = nx.subgraph(G, sG.nodes).copy()
 
     for edge in G.edges:
@@ -154,12 +158,31 @@ def determine_induced_minimal_nodes(
     return final
 
 
+def canonicalize_addresses(
+    reduced_concept_set: set[str], environment: BuildEnvironment
+) -> set[str]:
+    """
+    Convert a set of concept addresses to their canonical form.
+    This is necessary to ensure that we can compare concepts correctly,
+    especially when dealing with aliases or pseudonyms.
+    """
+    return set(
+        environment.concepts[x].address if x in environment.concepts else x
+        for x in reduced_concept_set
+    )
+
+
 def detect_ambiguity_and_raise(
-    all_concepts: list[BuildConcept], reduced_concept_sets: list[set[str]]
+    all_concepts: list[BuildConcept],
+    reduced_concept_sets_raw: list[set[str]],
+    environment: BuildEnvironment,
 ) -> None:
     final_candidates: list[set[str]] = []
     common: set[str] = set()
     # find all values that show up in every join_additions
+    reduced_concept_sets = [
+        canonicalize_addresses(x, environment) for x in reduced_concept_sets_raw
+    ]
     for ja in reduced_concept_sets:
         if not common:
             common = ja
@@ -198,18 +221,21 @@ def filter_relevant_subgraphs(
 
 
 def filter_duplicate_subgraphs(
-    subgraphs: list[list[BuildConcept]],
+    subgraphs: list[list[BuildConcept]], environment
 ) -> list[list[BuildConcept]]:
     seen: list[set[str]] = []
 
     for graph in subgraphs:
-        seen.append(set([x.address for x in graph]))
+        seen.append(
+            canonicalize_addresses(set([x.address for x in graph]), environment)
+        )
     final = []
     # sometimes w can get two subcomponents that are the same
     # due to alias resolution
     # if so, drop any that are strict subsets.
     for graph in subgraphs:
-        set_x = set([x.address for x in graph])
+        logger.info(f"Checking graph {graph} for duplicates in {seen}")
+        set_x = canonicalize_addresses(set([x.address for x in graph]), environment)
         if any([set_x.issubset(y) and set_x != y for y in seen]):
             continue
         final.append(graph)
@@ -295,7 +321,7 @@ def resolve_weak_components(
     if not found:
         return None
 
-    detect_ambiguity_and_raise(all_concepts, reduced_concept_sets)
+    detect_ambiguity_and_raise(all_concepts, reduced_concept_sets, environment)
 
     # take our first one as the actual graph
     g = found[0]
@@ -316,7 +342,7 @@ def resolve_weak_components(
         if not sub_component:
             continue
         subgraphs.append(sub_component)
-    final = filter_duplicate_subgraphs(subgraphs)
+    final = filter_duplicate_subgraphs(subgraphs, environment)
     return final
     # return filter_relevant_subgraphs(subgraphs)
 
@@ -361,17 +387,25 @@ def subgraphs_to_merge_node(
         )
         parents.append(parent)
     input_c = []
+    output_c = []
     for x in parents:
         for y in x.usable_outputs:
             input_c.append(y)
+            if y in output_concepts:
+                output_c.append(y)
+            elif any(y.address in c.pseudonyms for c in output_concepts) or any(
+                c.address in y.pseudonyms for c in output_concepts
+            ):
+                output_c.append(y)
+
     if len(parents) == 1 and enable_early_exit:
         logger.info(
             f"{padding(depth)}{LOGGER_PREFIX} only one parent node, exiting early w/ {[c.address for c in parents[0].output_concepts]}"
         )
         return parents[0]
-    return MergeNode(
+    rval = MergeNode(
         input_concepts=unique(input_c, "address"),
-        output_concepts=output_concepts,
+        output_concepts=output_c,
         environment=environment,
         parents=parents,
         depth=depth,
@@ -381,6 +415,7 @@ def subgraphs_to_merge_node(
         # preexisting_conditions=search_conditions.conditional,
         # node_joins=[]
     )
+    return rval
 
 
 def gen_merge_node(
@@ -437,24 +472,4 @@ def gen_merge_node(
                 search_conditions=search_conditions,
                 output_concepts=all_concepts,
             )
-
-    # one concept handling may need to be kicked to alias
-    if len(all_search_concepts) == 1:
-        concept = all_search_concepts[0]
-        for v in concept.pseudonyms:
-            test = subgraphs_to_merge_node(
-                [[concept, environment.alias_origin_lookup[v]]],
-                g=g,
-                all_concepts=[concept],
-                environment=environment,
-                depth=depth,
-                source_concepts=source_concepts,
-                history=history,
-                conditions=conditions,
-                enable_early_exit=False,
-                search_conditions=search_conditions,
-                output_concepts=[concept],
-            )
-            if test:
-                return test
     return None

trilogy/core/processing/node_generators/select_merge_node.py

@@ -85,9 +85,9 @@ def subgraph_is_complete(
     mapped = set([mapping.get(n, n) for n in nodes])
     passed = all([t in mapped for t in targets])
     if not passed:
-        logger.info(
-            f"Subgraph {nodes} is not complete, missing targets {targets} - mapped {mapped}"
-        )
+        # logger.info(
+        #     f"Subgraph {nodes} is not complete, missing targets {targets} - mapped {mapped}"
+        # )
         return False
     # check if all concepts have a datasource edge
     has_ds_edge = {
@@ -346,7 +346,7 @@ def create_datasource_node(
     depth: int,
     conditions: BuildWhereClause | None = None,
 ) -> tuple[StrategyNode, bool]:
-    logger.info(all_concepts)
+
     target_grain = BuildGrain.from_concepts(all_concepts, environment=environment)
     force_group = False
     if not datasource.grain.issubset(target_grain):
@@ -377,26 +377,26 @@ def create_datasource_node(
     partial_is_full = conditions and (conditions == datasource.non_partial_for)
 
     datasource_conditions = datasource.where.conditional if datasource.where else None
-
-    return (
-        SelectNode(
-            input_concepts=[c.concept for c in datasource.columns],
-            output_concepts=all_concepts,
-            environment=environment,
-            parents=[],
-            depth=depth,
-            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=datasource.grain,
-            conditions=datasource_conditions,
-            preexisting_conditions=(
-                conditions.conditional if partial_is_full and conditions else None
-            ),
+    rval = SelectNode(
+        input_concepts=[c.concept for c in datasource.columns],
+        output_concepts=all_concepts,
+        environment=environment,
+        parents=[],
+        depth=depth,
+        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=datasource.grain,
+        conditions=datasource_conditions,
+        preexisting_conditions=(
+            conditions.conditional if partial_is_full and conditions else None
         ),
+    )
+    return (
+        rval,
         force_group,
     )
 
@@ -484,7 +484,7 @@ def create_select_node(
             input_concepts=all_concepts,
             environment=environment,
             parents=[bcandidate],
-            depth=depth,
+            depth=depth + 1,
             partial_concepts=bcandidate.partial_concepts,
             nullable_concepts=bcandidate.nullable_concepts,
             preexisting_conditions=bcandidate.preexisting_conditions,
@@ -493,6 +493,7 @@ def create_select_node(
     else:
 
         candidate = bcandidate
+    assert candidate.resolve().output_concepts == all_concepts
     return candidate
 
 
@@ -604,6 +605,7 @@ def gen_select_merge_node(
         ]
     ):
         preexisting_conditions = conditions.conditional
+
     base = MergeNode(
         output_concepts=all_concepts,
         input_concepts=non_constant,

trilogy/core/processing/node_generators/select_node.py

@@ -18,6 +18,43 @@ from trilogy.core.processing.utility import padding
 LOGGER_PREFIX = "[GEN_SELECT_NODE]"
 
 
+def validate_query_is_resolvable(
+    missing: list[str],
+    environment: BuildEnvironment,
+    materialized_lcl: LooseBuildConceptList,
+) -> None:
+    # if a query cannot ever be resolved, exit early with an error
+    for x in missing:
+        if x not in environment.concepts:
+            # if it's locally derived, we can assume it can be resolved
+            continue
+        validation_concept = environment.concepts[x]
+        # if the concept we look up isn't what we searched for,
+        # we're in a pseudonym anyway, don't worry about validating
+        if validation_concept.address != x:
+            continue
+        if validation_concept.derivation == Derivation.ROOT:
+            has_source = False
+            for x in validation_concept.pseudonyms:
+                if x in environment.alias_origin_lookup:
+                    pseudonym_concept = environment.alias_origin_lookup[x]
+                else:
+                    pseudonym_concept = environment.concepts[x]
+                # if it's not a root concept pseudonym,
+                # assume we can derivve it
+                if pseudonym_concept.derivation != Derivation.ROOT:
+                    has_source = True
+                    break
+                if pseudonym_concept.address in materialized_lcl:
+                    has_source = True
+                    break
+            if not has_source:
+                raise NoDatasourceException(
+                    f"No datasource exists for root concept {validation_concept}, and no resolvable pseudonyms found from {validation_concept.pseudonyms}. This query is unresolvable from your environment. Check your datasource configuration?"
+                )
+    return None
+
+
 def gen_select_node(
     concepts: list[BuildConcept],
     environment: BuildEnvironment,
@@ -42,6 +79,7 @@ def gen_select_node(
             f"{padding(depth)}{LOGGER_PREFIX} Skipping select node generation for {concepts}"
             f" as it + optional includes non-materialized concepts (looking for all {all_lcl}, missing {missing}) "
         )
+        validate_query_is_resolvable(missing, environment, materialized_lcl)
         if fail_if_not_found:
             raise NoDatasourceException(f"No datasource exists for {concepts}")
         return None

trilogy/core/processing/node_generators/synonym_node.py

@@ -30,22 +30,27 @@ def gen_synonym_node(
     accept_partial: bool = False,
 ) -> StrategyNode | None:
     local_prefix = f"{padding(depth)}[GEN_SYNONYM_NODE]"
-    base_fingerprint = tuple([x.address for x in all_concepts])
+    base_fingerprint = tuple(sorted([x.address for x in all_concepts]))
     synonyms = defaultdict(list)
-    synonym_count = 0
+    has_synonyms = False
     for x in all_concepts:
         synonyms[x.address] = [x]
+        if x.address in environment.alias_origin_lookup:
+            parent = environment.concepts[x.address]
+            if parent.address != x.address:
+                synonyms[x.address].append(parent)
+                has_synonyms = True
         for y in x.pseudonyms:
 
             if y in environment.alias_origin_lookup:
                 synonyms[x.address].append(environment.alias_origin_lookup[y])
-                synonym_count += 1
+                has_synonyms = True
             elif y in environment.concepts:
                 synonyms[x.address].append(environment.concepts[y])
-                synonym_count += 1
+                has_synonyms = True
     for address in synonyms:
         synonyms[address].sort(key=lambda obj: obj.address)
-    if synonym_count == 0:
+    if not has_synonyms:
         return None
 
     logger.info(f"{local_prefix} Generating Synonym Node with {len(synonyms)} synonyms")
@@ -76,9 +81,8 @@ def gen_synonym_node(
         return (-similarity_score, addresses)
 
     combinations_list.sort(key=similarity_sort_key)
-    logger.info(combinations_list)
     for combo in combinations_list:
-        fingerprint = tuple([x.address for x in combo])
+        fingerprint = tuple(sorted([x.address for x in combo]))
         if fingerprint == base_fingerprint:
             continue
         logger.info(

trilogy/core/processing/nodes/base_node.py

@@ -29,6 +29,7 @@ def resolve_concept_map(
     inherited_inputs: List[BuildConcept],
     full_joins: List[BuildConcept] | None = None,
 ) -> dict[str, set[BuildDatasource | QueryDatasource | UnnestJoin]]:
+
     targets = targets or []
     concept_map: dict[str, set[BuildDatasource | QueryDatasource | UnnestJoin]] = (
         defaultdict(set)
@@ -56,7 +57,9 @@ def resolve_concept_map(
     # second loop, include partials
     for input in inputs:
         for concept in input.output_concepts:
-            if concept.address not in [t for t in inherited_inputs]:
+            if concept.address not in inherited and not (
+                concept.pseudonyms and any(s in inherited for s in concept.pseudonyms)
+            ):
                 continue
             if (
                 isinstance(input, QueryDatasource)
@@ -70,7 +73,6 @@ def resolve_concept_map(
         if target.address not in inherited:
             # an empty source means it is defined in this CTE
             concept_map[target.address] = set()
-
     return concept_map
 
 
@@ -195,8 +197,10 @@ class StrategyNode:
             return
         non_hidden = set()
         hidden = set()
+        usable_outputs = set()
         for x in self.parents:
             for z in x.usable_outputs:
+                usable_outputs.add(z.address)
                 non_hidden.add(z.address)
                 for psd in z.pseudonyms:
                     non_hidden.add(psd)
@@ -205,7 +209,7 @@ class StrategyNode:
         if not all([x.address in non_hidden for x in self.input_concepts]):
             missing = [x for x in self.input_concepts if x.address not in non_hidden]
             raise ValueError(
-                f"Invalid input concepts; {missing} are missing non-hidden parent nodes; have {non_hidden} and hidden {hidden}"
+                f"Invalid input concepts; {missing} are missing non-hidden parent nodes; have {non_hidden} and hidden {hidden} from root {usable_outputs}"
             )
 
     def add_parents(self, parents: list["StrategyNode"]):
@@ -282,6 +286,11 @@ class StrategyNode:
         if self.output_concepts == concepts:
             return self
         self.output_concepts = concepts
+        if self.hidden_concepts:
+            self.hidden_concepts = set(
+                x for x in self.hidden_concepts if x not in concepts
+            )
+
         self.output_lcl = LooseBuildConceptList(concepts=self.output_concepts)
 
         if rebuild:

trilogy/core/processing/nodes/group_node.py

@@ -165,7 +165,7 @@ class GroupNode(StrategyNode):
             p.resolve() for p in self.parents
         ]
         grains = self.check_if_required(
-            self.output_concepts, parent_sources, self.environment
+            self.output_concepts, parent_sources, self.environment, self.depth
         )
         target_grain = grains.target
         comp_grain = grains.upstream

trilogy/core/query_processor.py

@@ -407,6 +407,7 @@ def get_query_node(
         build_statement.local_concepts
     )
     graph = generate_graph(build_environment)
+
     logger.info(
         f"{LOGGER_PREFIX} getting source datasource for outputs {build_statement.output_components} grain {build_statement.grain}"
     )

trilogy/dialect/base.py

@@ -843,7 +843,7 @@ class BaseDialect:
                     else:
                         having = having + x if having else x
 
-        logger.info(f"{len(final_joins)} joins for cte {cte.name}")
+        logger.info(f"{LOGGER_PREFIX} {len(final_joins)} joins for cte {cte.name}")
         return CompiledCTE(
             name=cte.name,
             statement=self.SQL_TEMPLATE.render(