pytrilogy 0.0.3.70__py3-none-any.whl → 0.0.3.72__py3-none-any.whl

{pytrilogy-0.0.3.70.dist-info → pytrilogy-0.0.3.72.dist-info}/METADATA

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

{pytrilogy-0.0.3.70.dist-info → pytrilogy-0.0.3.72.dist-info}/RECORD

@@ -1,5 +1,5 @@
-pytrilogy-0.0.3.70.dist-info/licenses/LICENSE.md,sha256=5ZRvtTyCCFwz1THxDTjAu3Lidds9WjPvvzgVwPSYNDo,1042
-trilogy/__init__.py,sha256=jOvyFSWu8pnqklbm3VK_FmD5VSPj1cqSUoyMFyDKVC8,303
+pytrilogy-0.0.3.72.dist-info/licenses/LICENSE.md,sha256=5ZRvtTyCCFwz1THxDTjAu3Lidds9WjPvvzgVwPSYNDo,1042
+trilogy/__init__.py,sha256=nTClKJQdHtjmdR7uHkenK_MjPmcfU2r_PQcI3PwQuNQ,303
 trilogy/compiler.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/constants.py,sha256=lv_aJWP6dn6e2aF4BAE72jbnNtceFddfqtiDSsvzno0,1692
 trilogy/engine.py,sha256=OK2RuqCIUId6yZ5hfF8J1nxGP0AJqHRZiafcowmW0xc,1728
@@ -11,31 +11,31 @@ trilogy/utility.py,sha256=euQccZLKoYBz0LNg5tzLlvv2YHvXh9HArnYp1V3uXsM,763
 trilogy/authoring/__init__.py,sha256=h-Ag7vT76tsjib9BfjOgI-yVpuJDgpn2TSps-ibRAj8,2593
 trilogy/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/core/constants.py,sha256=nizWYDCJQ1bigQMtkNIEMNTcN0NoEAXiIHLzpelxQ24,201
-trilogy/core/enums.py,sha256=2sgoVzHQpscIx_WUqJMH0oGxtcg41gN0l1qkRjzK2iI,7803
+trilogy/core/enums.py,sha256=fog9j6YU22LXuoArKsNJn-UFIEAVk06LI_-Zdg2UDv0,7841
 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=jYEduuMehcMkmCpf-OC_taELPZm7qNfeSNzIWkDYScs,707
-trilogy/core/functions.py,sha256=R8_aOe2mNRgOLmsnI9pG_GOU3I7kFPTnXQzplN2d7Dw,29343
-trilogy/core/graph_models.py,sha256=wIT-oBchHWE46GLDkgN5K7EzhOBEo8LfaeWV5G5cYcE,3302
+trilogy/core/functions.py,sha256=xT4DR6IRTt3N6TZ_LEcSV2nvLUWFGfajd5vQZd2Pw7k,29512
+trilogy/core/graph_models.py,sha256=BYhJzHKSgnZHVLJs1CfsgrxTPHqKqPNeA64RlozGY0A,3498
 trilogy/core/internal.py,sha256=iicDBlC6nM8d7e7jqzf_ZOmpUsW8yrr2AA8AqEiLx-s,1577
 trilogy/core/optimization.py,sha256=ojpn-p79lr03SSVQbbw74iPCyoYpDYBmj1dbZ3oXCjI,8860
-trilogy/core/query_processor.py,sha256=t91tYQS0o89r-acdxo8uDUpB1elNcqAhLWkbM8BFjho,20283
+trilogy/core/query_processor.py,sha256=5aFgv-2LVM1Uku9cR_tFuTRDwyLnxc95bCMAHeFy2AY,20332
 trilogy/core/utility.py,sha256=3VC13uSQWcZNghgt7Ot0ZTeEmNqs__cx122abVq9qhM,410
 trilogy/core/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/core/models/author.py,sha256=Wz_6yEZS5EyXJ5wHHl-C44ikFka5XftBYOjNRK98Hfw,77790
-trilogy/core/models/build.py,sha256=BNHzfqD5NWCKHntvnswvDrtCD1JFgvPedx23cPq942U,65405
+trilogy/core/models/build.py,sha256=59KmJDY1lzJMXuAZjxvT7K5IhIga9k2xwhzQBbx5zyo,65688
 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/datasource.py,sha256=wogTevZ-9CyUW2a8gjzqMCieircxi-J5lkI7EOAZnck,9596
 trilogy/core/models/environment.py,sha256=TBbPfsXHpJK49QKuqHwhgZD4PwHiSAYjXmTTTomRE7o,27861
-trilogy/core/models/execute.py,sha256=94CZVY_EdW675n8SihDnhaGTV0dq7BAAsl2Anf1mPmk,41815
+trilogy/core/models/execute.py,sha256=A4SkqmOW9XrbgPDhP7LnS9dUq-Tw4vgzVcQbkkB2ljA,41706
 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=zy5VZa9LITOws6aIILfv_bSR2-jR1Ndldy-nmwMyQ5w,23144
+trilogy/core/processing/concept_strategies_v3.py,sha256=3Hy8Lz5NOJt8B3cGv_B0LuOYrlcxM_WiPdsFaFWaMjE,23212
 trilogy/core/processing/discovery_loop.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/core/processing/discovery_node_factory.py,sha256=I3JJxoF-u8OVvqXXAOhvMg2h-KdpHQwg6EpCeQtxGCI,15123
 trilogy/core/processing/discovery_utility.py,sha256=3xdd1ypKappSDm0SJs7WtW5YegL80SlYhDQlkNePp4E,4549
@@ -49,25 +49,25 @@ trilogy/core/processing/node_generators/filter_node.py,sha256=oRRq2-T3ufgn4D23uQ
 trilogy/core/processing/node_generators/group_node.py,sha256=1QJhRxsTklJ5xq8wHlAURZaN9gL9FPpeCa1OJ7IwXnY,6769
 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=dSqfqWp2SolhDB16nkPaaTXgNQo4QquEufPdf7q0Tb4,17398
+trilogy/core/processing/node_generators/node_merge_node.py,sha256=KtTuvL9-xaTV_ZUO1DUyz2Rd595QfD9SvOv5filCDy0,17428
 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=2KIljy2TFLT9kjKUfhkFwSDkcu4hv4yRVTKOGzEe-NM,21763
+trilogy/core/processing/node_generators/rowset_node.py,sha256=5L5u6xz1In8EaHQdcYgR2si-tz9WB9YLXURo4AkUT9A,6630
+trilogy/core/processing/node_generators/select_merge_node.py,sha256=Cv2GwNiYSmwewjuK8T3JB3pbgrLZFPsB75DCP153BMA,22818
 trilogy/core/processing/node_generators/select_node.py,sha256=Ta1G39V94gjX_AgyZDz9OqnwLz4BjY3D6Drx9YpziMQ,3555
 trilogy/core/processing/node_generators/synonym_node.py,sha256=AnAsa_Wj50NJ_IK0HSgab_7klYmKVrv0WI1uUe-GvEY,3766
 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/window_node.py,sha256=8ZULQZW05nKlGQ1yRQF7XsiD5-AtRlqpkPYjZ1pq7Ak,6631
 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/node_generators/select_helpers/datasource_injection.py,sha256=mKCDHxr2eyrdozXEHq_HvuwtBgnb9JPlImJIx6JGX34,7834
 trilogy/core/processing/nodes/__init__.py,sha256=zTge1EzwzEydlcMliIFO_TT7h7lS8l37lyZuQDir1h0,5487
-trilogy/core/processing/nodes/base_node.py,sha256=HcltmrYO5RUkmM7qryNQkcahgY0r8lfmIqDbN6Kx9zE,18043
+trilogy/core/processing/nodes/base_node.py,sha256=C_CjlOzlGMXckyV0b_PJZerpopNesRCKfambMq7Asvc,18221
 trilogy/core/processing/nodes/filter_node.py,sha256=5VtRfKbCORx0dV-vQfgy3gOEkmmscL9f31ExvlODwvY,2461
 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
-trilogy/core/processing/nodes/union_node.py,sha256=fDFzLAUh5876X6_NM7nkhoMvHEdGJ_LpvPokpZKOhx4,1425
+trilogy/core/processing/nodes/union_node.py,sha256=hLAXXVWqEgMWi7dlgSHfCF59fon64av14-uPgJzoKzM,1870
 trilogy/core/processing/nodes/unnest_node.py,sha256=oLKMMNMx6PLDPlt2V5neFMFrFWxET8r6XZElAhSNkO0,2181
 trilogy/core/processing/nodes/window_node.py,sha256=JXJ0iVRlSEM2IBr1TANym2RaUf_p5E_l2sNykRzXWDo,1710
 trilogy/core/statements/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -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=SpNv1D9eig-XDOui2xoeMvdTfRpejAfJ_HaAMkuPW9w,45112
+trilogy/dialect/base.py,sha256=5FI4_XDdSavdHeC3VhSI8xrvQagFyRRq6Ttsh70ajo4,45241
 trilogy/dialect/bigquery.py,sha256=e19dGcarapgA0x5_Xmq2StyHzuDWPOOPaR4elkWXwug,4203
 trilogy/dialect/common.py,sha256=hhzuMTFW9QQIP7TKLT9BlJy6lw2R03a68jKQ-7t4-2c,6070
 trilogy/dialect/config.py,sha256=olnyeVU5W5T6b9-dMeNAnvxuPlyc2uefb7FRME094Ec,3834
@@ -93,11 +93,11 @@ trilogy/hooks/graph_hook.py,sha256=5BfR7Dt0bgEsCLgwjowgCsVkboGYfVJGOz8g9mqpnos,4
 trilogy/hooks/query_debugger.py,sha256=1npRjww94sPV5RRBBlLqMJRaFkH9vhEY6o828MeoEcw,5583
 trilogy/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/parsing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-trilogy/parsing/common.py,sha256=_5UEnLtu40VQ8gb6wg3GtSrxf6IONhEOntmdsm0X4lU,30961
+trilogy/parsing/common.py,sha256=yV1AckK0h8u1OFeGQBTMu-wuW5m63c5CcZuPicsTH_w,30660
 trilogy/parsing/config.py,sha256=Z-DaefdKhPDmSXLgg5V4pebhSB0h590vI0_VtHnlukI,111
 trilogy/parsing/exceptions.py,sha256=Xwwsv2C9kSNv2q-HrrKC1f60JNHShXcCMzstTSEbiCw,154
 trilogy/parsing/helpers.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-trilogy/parsing/parse_engine.py,sha256=vYhGmSJXi5TcLvt2mujISucQc35j4kHa78hj5ip9gGQ,72564
+trilogy/parsing/parse_engine.py,sha256=YFIWTkWrUJ8l-KoCVwPs1hodj3BhqX-DHbBXWQN5akc,72776
 trilogy/parsing/render.py,sha256=gGCFj2ue0UoaU2MR6qHGMAHXkYRMkTmHjnBowdcgFMY,19603
 trilogy/parsing/trilogy.lark,sha256=1RIqA7zrGuqDJYSv9yHGSw0vdIfGOLPOnc4hSBRSTVU,14346
 trilogy/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -107,11 +107,11 @@ trilogy/std/date.preql,sha256=HWZm4t4HWyxr5geWRsY05RnHBVDMci8z8YA2cu0-OOw,188
 trilogy/std/display.preql,sha256=nm7lox87Xf6lBvXCVCS6x2HskguMKzndEBucJ5pktzk,175
 trilogy/std/geography.preql,sha256=qLnHmDU5EnvjTbfqZF-NEclSYM5_e9rZra7QjV01rZ4,582
 trilogy/std/money.preql,sha256=XWwvAV3WxBsHX9zfptoYRnBigcfYwrYtBHXTME0xJuQ,2082
-trilogy/std/net.preql,sha256=-bMV6dyofskl4Kvows-iQ4JCxjVUwsZOeWCy8JO5Ftw,135
+trilogy/std/net.preql,sha256=7l7MqIjs6TDCpO6dBAoNJU81Ex255jZRK36kBgE1GDs,158
 trilogy/std/ranking.preql,sha256=LDoZrYyz4g3xsII9XwXfmstZD-_92i1Eox1UqkBIfi8,83
 trilogy/std/report.preql,sha256=LbV-XlHdfw0jgnQ8pV7acG95xrd1-p65fVpiIc-S7W4,202
-pytrilogy-0.0.3.70.dist-info/METADATA,sha256=dSEU2zgUrBXl88Yb-KV8y_hta24BeHt5VaPM19-YMFU,9734
-pytrilogy-0.0.3.70.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pytrilogy-0.0.3.70.dist-info/entry_points.txt,sha256=ewBPU2vLnVexZVnB-NrVj-p3E-4vukg83Zk8A55Wp2w,56
-pytrilogy-0.0.3.70.dist-info/top_level.txt,sha256=cAy__NW_eMAa_yT9UnUNlZLFfxcg6eimUAZ184cdNiE,8
-pytrilogy-0.0.3.70.dist-info/RECORD,,
+pytrilogy-0.0.3.72.dist-info/METADATA,sha256=FuNovLn_nPyODANKBbc681JtNz4gBoUVY9udJ7n7A3k,9734
+pytrilogy-0.0.3.72.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pytrilogy-0.0.3.72.dist-info/entry_points.txt,sha256=ewBPU2vLnVexZVnB-NrVj-p3E-4vukg83Zk8A55Wp2w,56
+pytrilogy-0.0.3.72.dist-info/top_level.txt,sha256=cAy__NW_eMAa_yT9UnUNlZLFfxcg6eimUAZ184cdNiE,8
+pytrilogy-0.0.3.72.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.70"
+__version__ = "0.0.3.72"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

trilogy/core/enums.py

@@ -134,6 +134,7 @@ class FunctionType(Enum):
     CAST = "cast"
     CONCAT = "concat"
     CONSTANT = "constant"
+    TYPED_CONSTANT = "typed_constant"
     COALESCE = "coalesce"
     IS_NULL = "isnull"
     NULLIF = "nullif"

trilogy/core/functions.py

@@ -704,6 +704,11 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
         output_purpose=Purpose.CONSTANT,
         arg_count=1,
     ),
+    FunctionType.TYPED_CONSTANT: FunctionConfig(
+        output_purpose=Purpose.CONSTANT,
+        output_type_function=get_cast_output_type,
+        arg_count=2,
+    ),
     FunctionType.IS_NULL: FunctionConfig(
         output_purpose=Purpose.PROPERTY,
         output_type=DataType.BOOL,

trilogy/core/graph_models.py

@@ -4,7 +4,7 @@ from trilogy.core.models.build import BuildConcept, BuildDatasource, BuildWhereC
 
 
 def get_graph_exact_match(
-    g: nx.DiGraph, conditions: BuildWhereClause | None
+    g: nx.DiGraph, accept_partial: bool, conditions: BuildWhereClause | None
 ) -> set[str]:
     datasources: dict[str, BuildDatasource | list[BuildDatasource]] = (
         nx.get_node_attributes(g, "datasource")
@@ -20,6 +20,9 @@ def get_graph_exact_match(
             if not conditions and not ds.non_partial_for:
                 exact.add(node)
                 continue
+            elif not conditions and accept_partial and ds.non_partial_for:
+                exact.add(node)
+                continue
             elif conditions:
                 if not ds.non_partial_for:
                     continue
@@ -34,10 +37,11 @@ def get_graph_exact_match(
 
 def prune_sources_for_conditions(
     g: nx.DiGraph,
+    accept_partial: bool,
     conditions: BuildWhereClause | None,
 ):
 
-    complete = get_graph_exact_match(g, conditions)
+    complete = get_graph_exact_match(g, accept_partial, conditions)
     to_remove = []
     for node in g.nodes:
         if node.startswith("ds~") and node not in complete:

trilogy/core/models/build.py

@@ -1486,6 +1486,17 @@ def get_canonical_pseudonyms(environment: Environment) -> dict[str, set[str]]:
     return roots
 
 
+def requires_concept_nesting(
+    expr,
+) -> AggregateWrapper | WindowItem | FilterItem | Function | None:
+    if isinstance(expr, (AggregateWrapper, WindowItem, FilterItem)):
+        return expr
+    if isinstance(expr, Function) and expr.operator == FunctionType.GROUP:
+        # group by requires nesting
+        return expr
+    return None
+
+
 class Factory:
 
     def __init__(
@@ -1509,11 +1520,12 @@ class Factory:
             | WindowItem
             | FilterItem
             | Function
-            | ListWrapper[Any]
-            | MapWrapper[Any, Any]
+            | ListWrapper
+            | MapWrapper
             | int
             | float
             | str
+            | date
         ),
     ) -> tuple[Concept, BuildConcept]:
         from trilogy.parsing.common import arbitrary_to_concept
@@ -1572,7 +1584,8 @@ class Factory:
 
         raw_args: list[Concept | FuncArgs] = []
         for arg in base.arguments:
-            # to do proper discovery, we need to inject virtual intermediate ocncepts
+            # to do proper discovery, we need to inject virtual intermediate concepts
+            # we don't use requires_concept_nesting here by design
             if isinstance(arg, (AggregateWrapper, FilterItem, WindowItem)):
                 narg, _ = self.instantiate_concept(arg)
                 raw_args.append(narg)
@@ -1640,11 +1653,10 @@ class Factory:
     def _(self, base: CaseWhen) -> BuildCaseWhen:
 
         comparison = base.comparison
-        if isinstance(comparison, (AggregateWrapper, FilterItem, WindowItem)):
-            comparison, _ = self.instantiate_concept(comparison)
         expr: Concept | FuncArgs = base.expr
-        if isinstance(expr, (AggregateWrapper, FilterItem, WindowItem)):
-            expr, _ = self.instantiate_concept(expr)
+        validation = requires_concept_nesting(expr)
+        if validation:
+            expr, _ = self.instantiate_concept(validation)
         return BuildCaseWhen.model_construct(
             comparison=self.build(comparison),
             expr=self.build(expr),
@@ -1653,8 +1665,9 @@ class Factory:
     @build.register
     def _(self, base: CaseElse) -> BuildCaseElse:
         expr: Concept | FuncArgs = base.expr
-        if isinstance(expr, (AggregateWrapper, FilterItem, WindowItem)):
-            expr, _ = self.instantiate_concept(expr)
+        validation = requires_concept_nesting(expr)
+        if validation:
+            expr, _ = self.instantiate_concept(validation)
         return BuildCaseElse.model_construct(expr=self.build(expr))
 
     @build.register
@@ -1753,10 +1766,9 @@ class Factory:
     def _(self, base: OrderItem) -> BuildOrderItem:
 
         bexpr: Any
-        if isinstance(base.expr, (AggregateWrapper, WindowItem, FilterItem)) or (
-            isinstance(base.expr, Function) and base.expr.operator == FunctionType.GROUP
-        ):
-            bexpr, _ = self.instantiate_concept(base.expr)
+        validation = requires_concept_nesting(base.expr)
+        if validation:
+            bexpr, _ = self.instantiate_concept(validation)
         else:
             bexpr = base.expr
         return BuildOrderItem.model_construct(
@@ -1781,8 +1793,9 @@ class Factory:
     def _(self, base: WindowItem) -> BuildWindowItem:
 
         content: Concept | FuncArgs = base.content
-        if isinstance(content, (AggregateWrapper, FilterItem, WindowItem)):
-            content, _ = self.instantiate_concept(content)
+        validation = requires_concept_nesting(base.content)
+        if validation:
+            content, _ = self.instantiate_concept(validation)
         final_by = []
         for x in base.order_by:
             if (
@@ -1811,6 +1824,7 @@ class Factory:
     @build.register
     def _(self, base: SubselectComparison) -> BuildSubselectComparison:
         right: Any = base.right
+        # this has specialized logic - include all Functions
         if isinstance(base.right, (AggregateWrapper, WindowItem, FilterItem, Function)):
             right_c, _ = self.instantiate_concept(base.right)
             right = right_c
@@ -1824,12 +1838,14 @@ class Factory:
     def _(self, base: Comparison) -> BuildComparison:
 
         left = base.left
-        if isinstance(left, (AggregateWrapper, WindowItem, FilterItem)):
-            left_c, _ = self.instantiate_concept(left)
+        validation = requires_concept_nesting(base.left)
+        if validation:
+            left_c, _ = self.instantiate_concept(validation)
             left = left_c  # type: ignore
         right = base.right
-        if isinstance(right, (AggregateWrapper, WindowItem, FilterItem)):
-            right_c, _ = self.instantiate_concept(right)
+        validation = requires_concept_nesting(base.right)
+        if validation:
+            right_c, _ = self.instantiate_concept(validation)
             right = right_c  # type: ignore
         return BuildComparison.model_construct(
             left=self.handle_constant(self.build(left)),

trilogy/core/models/datasource.py

@@ -249,6 +249,11 @@ class Datasource(HasUUID, Namespaced, BaseModel):
             address=self.address,
             columns=[c.with_namespace(namespace) for c in self.columns],
             where=self.where.with_namespace(namespace) if self.where else None,
+            non_partial_for=(
+                self.non_partial_for.with_namespace(namespace)
+                if self.non_partial_for
+                else None
+            ),
         )
         return new
 

trilogy/core/models/execute.py

@@ -24,12 +24,12 @@ from trilogy.core.enums import (
     ComparisonOperator,
     Derivation,
     FunctionType,
-    Granularity,
     JoinType,
     Modifier,
     Purpose,
     SourceType,
 )
+from trilogy.core.exceptions import InvalidSyntaxException
 from trilogy.core.models.build import (
     BuildCaseElse,
     BuildCaseWhen,
@@ -438,7 +438,7 @@ class ConceptPair(BaseModel):
 
 
 class CTEConceptPair(ConceptPair):
-    cte: CTE
+    cte: CTE | UnionCTE
 
 
 class InstantiatedUnnestJoin(BaseModel):
@@ -460,6 +460,30 @@ class UnnestJoin(BaseModel):
         return self.alias + "".join([str(s.address) for s in self.concepts])
 
 
+def raise_helpful_join_validation_error(
+    concepts: List[BuildConcept],
+    left_datasource: BuildDatasource | QueryDatasource | None,
+    right_datasource: BuildDatasource | QueryDatasource | None,
+):
+
+    if not left_datasource or not right_datasource:
+        raise InvalidSyntaxException(
+            "No mutual keys found, and not two valid datasources"
+        )
+    left_keys = [c.address for c in left_datasource.output_concepts]
+    right_keys = [c.address for c in right_datasource.output_concepts]
+    match_concepts = [c.address for c in concepts]
+    assert left_datasource
+    assert right_datasource
+    raise InvalidSyntaxException(
+        "No mutual join keys found between"
+        f" {left_datasource.identifier} and"
+        f" {right_datasource.identifier}, left_keys {left_keys},"
+        f" right_keys {right_keys},"
+        f" provided join concepts {match_concepts}"
+    )
+
+
 class BaseJoin(BaseModel):
     right_datasource: Union[BuildDatasource, "QueryDatasource"]
     join_type: JoinType
@@ -479,27 +503,24 @@ class BaseJoin(BaseModel):
             )
 
         # Early returns maintained as in original code
-        if self.concept_pairs:
-            return self
-
-        if self.concepts == []:
+        if self.concept_pairs or self.concepts == []:
             return self
 
-        # Validation logic
+        # reduce concept list to just the mutual keys
         final_concepts = []
-        assert self.left_datasource and self.right_datasource
-
         for concept in self.concepts or []:
             include = True
             for ds in [self.left_datasource, self.right_datasource]:
                 synonyms = []
+                if not ds:
+                    continue
                 for c in ds.output_concepts:
                     synonyms += list(c.pseudonyms)
                 if (
-                    concept.address not in [c.address for c in ds.output_concepts]
+                    concept.address not in ds.output_concepts
                     and concept.address not in synonyms
                 ):
-                    raise SyntaxError(
+                    raise InvalidSyntaxException(
                         f"Invalid join, missing {concept} on {ds.name}, have"
                         f" {[c.address for c in ds.output_concepts]}"
                     )
@@ -507,32 +528,10 @@ class BaseJoin(BaseModel):
                 final_concepts.append(concept)
 
         if not final_concepts and self.concepts:
-            # if one datasource only has constants
-            # we can join on 1=1
-            for ds in [self.left_datasource, self.right_datasource]:
-                # single rows
-                if all(
-                    [
-                        c.granularity == Granularity.SINGLE_ROW
-                        for c in ds.output_concepts
-                    ]
-                ):
-                    self.concepts = []
-                    return self
-                # if everything is at abstract grain, we can skip joins
-                if all([c.grain.abstract for c in ds.output_concepts]):
-                    self.concepts = []
-                    return self
-
-            left_keys = [c.address for c in self.left_datasource.output_concepts]
-            right_keys = [c.address for c in self.right_datasource.output_concepts]
-            match_concepts = [c.address for c in self.concepts]
-            raise SyntaxError(
-                "No mutual join keys found between"
-                f" {self.left_datasource.identifier} and"
-                f" {self.right_datasource.identifier}, left_keys {left_keys},"
-                f" right_keys {right_keys},"
-                f" provided join concepts {match_concepts}"
+            raise_helpful_join_validation_error(
+                self.concepts,
+                self.left_datasource,
+                self.right_datasource,
             )
 
         self.concepts = final_concepts
@@ -1087,7 +1086,7 @@ class UnionCTE(BaseModel):
 class Join(BaseModel):
     right_cte: CTE | UnionCTE
     jointype: JoinType
-    left_cte: CTE | None = None
+    left_cte: CTE | UnionCTE | None = None
     joinkey_pairs: List[CTEConceptPair] | None = None
     inlined_ctes: set[str] = Field(default_factory=set)
     quote: str | None = None
@@ -1096,7 +1095,7 @@ class Join(BaseModel):
     def inline_cte(self, cte: CTE):
         self.inlined_ctes.add(cte.name)
 
-    def get_name(self, cte: CTE):
+    def get_name(self, cte: CTE | UnionCTE) -> str:
         if cte.identifier in self.inlined_ctes:
             return cte.source.datasources[0].safe_identifier
         return cte.safe_identifier

trilogy/core/processing/concept_strategies_v3.py

@@ -291,7 +291,7 @@ def evaluate_loop_conditions(
 
 
 def check_for_early_exit(
-    complete, partial, context: LoopContext, priority_concept: BuildConcept
+    complete, partial, missing, context: LoopContext, priority_concept: BuildConcept
 ) -> bool:
     if complete == ValidationResult.INCOMPLETE_CONDITION:
         cond_dict = {str(node): node.preexisting_conditions for node in context.stack}
@@ -321,7 +321,7 @@ def check_for_early_exit(
         )
     else:
         logger.info(
-            f"{depth_to_prefix(context.depth)}{LOGGER_PREFIX} Not complete, continuing search"
+            f"{depth_to_prefix(context.depth)}{LOGGER_PREFIX} Not complete (missing {missing}), continuing search"
         )
     # if we have attempted on root node, we've tried them all.
     # inject in another search with filter concepts
@@ -412,7 +412,7 @@ def generate_loop_completion(context: LoopContext, virtual: set[str]) -> Strateg
     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 output {[x.address for x in output.usable_outputs]} 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 or []]} with {context.conditions}"
     )
     if condition_required and context.conditions and non_virtual_different:
         logger.info(
@@ -532,7 +532,9 @@ def _search_concepts(
         )
         # assign
         context.found = found_c
-        early_exit = check_for_early_exit(complete, partial, context, priority_concept)
+        early_exit = check_for_early_exit(
+            complete, partial, missing_c, context, priority_concept
+        )
         if early_exit:
             break
 

trilogy/core/processing/node_generators/node_merge_node.py

@@ -253,7 +253,9 @@ def resolve_weak_components(
     break_flag = False
     found = []
     search_graph = environment_graph.copy()
-    prune_sources_for_conditions(search_graph, conditions=search_conditions)
+    prune_sources_for_conditions(
+        search_graph, accept_partial, conditions=search_conditions
+    )
     reduced_concept_sets: list[set[str]] = []
 
     # loop through, removing new nodes we find

trilogy/core/processing/node_generators/rowset_node.py

@@ -181,6 +181,5 @@ def gen_rowset_node(
             node,
             enrich_node,
         ],
-        partial_concepts=node.partial_concepts + enrich_node.partial_concepts,
         preexisting_conditions=conditions.conditional if conditions else None,
     )

trilogy/core/processing/node_generators/select_helpers/datasource_injection.py

@@ -1,3 +1,4 @@
+import sys
 from collections import defaultdict
 from datetime import date, datetime, timedelta
 from typing import List, Tuple, TypeVar
@@ -14,7 +15,7 @@ from trilogy.core.models.build import (
 from trilogy.core.models.core import DataType
 
 # Define a generic type that ensures start and end are the same type
-T = TypeVar("T", int, date, datetime)
+T = TypeVar("T", int, float, date, datetime)
 
 
 def reduce_expression(
@@ -37,21 +38,26 @@ def reduce_expression(
     elif var.datatype == DataType.DATETIME:
         lower_check = datetime.min  # type: ignore
         upper_check = datetime.max  # type: ignore
+    elif var.datatype == DataType.BOOL:
+        lower_check = False  # type: ignore
+        upper_check = True  # type: ignore
+    elif var.datatype == DataType.FLOAT:
+        lower_check = float("-inf")  # type: ignore
+        upper_check = float("inf")  # type: ignore
     else:
-        raise ValueError(f"Invalid datatype: {var.datatype}")
+        return False
 
     ranges: list[Tuple[T, T]] = []
     for op, value in group_tuple:
-        increment: int | timedelta
+        increment: int | timedelta | float
         if isinstance(value, date):
             increment = timedelta(days=1)
         elif isinstance(value, datetime):
             increment = timedelta(seconds=1)
         elif isinstance(value, int):
             increment = 1
-        # elif isinstance(value, float):
-        #     value = Decimal(value)
-        #     increment = Decimal(0.0000000001)
+        elif isinstance(value, float):
+            increment = sys.float_info.epsilon
 
         if op == ">":
             ranges.append(
@@ -88,24 +94,43 @@ def reduce_expression(
                     value,
                 )
             )
+        elif op == ComparisonOperator.IS:
+            ranges.append(
+                (
+                    value,
+                    value,
+                )
+            )
+        elif op == ComparisonOperator.NE:
+            pass
         else:
-            raise ValueError(f"Invalid operator: {op}")
+            return False
     return is_fully_covered(lower_check, upper_check, ranges, increment)
 
 
+TARGET_TYPES = (
+    int,
+    date,
+    float,
+    datetime,
+    bool,
+)
+REDUCABLE_TYPES = (int, float, date, bool, datetime, BuildFunction)
+
+
 def simplify_conditions(
     conditions: list[BuildComparison | BuildConditional | BuildParenthetical],
 ) -> bool:
     # Group conditions by variable
     grouped: dict[
-        BuildConcept, list[tuple[ComparisonOperator, datetime | int | date]]
+        BuildConcept, list[tuple[ComparisonOperator, datetime | int | date | float]]
     ] = defaultdict(list)
     for condition in conditions:
         if not isinstance(condition, BuildComparison):
             return False
-        if not isinstance(
-            condition.left, (int, date, datetime, BuildFunction)
-        ) and not isinstance(condition.right, (int, date, datetime, BuildFunction)):
+        if not isinstance(condition.left, REDUCABLE_TYPES) and not isinstance(
+            condition.right, REDUCABLE_TYPES
+        ):
             return False
         if not isinstance(condition.left, BuildConcept) and not isinstance(
             condition.right, BuildConcept
@@ -113,15 +138,20 @@ def simplify_conditions(
             return False
         vars = [condition.left, condition.right]
         concept = [x for x in vars if isinstance(x, BuildConcept)][0]
-        comparison = [x for x in vars if not isinstance(x, BuildConcept)][0]
-        if isinstance(comparison, BuildFunction):
-            if not comparison.operator == FunctionType.CONSTANT:
+        raw_comparison = [x for x in vars if not isinstance(x, BuildConcept)][0]
+        if isinstance(raw_comparison, BuildFunction):
+            if not raw_comparison.operator == FunctionType.CONSTANT:
                 return False
-            first_arg = comparison.arguments[0]
-            if not isinstance(first_arg, (int, date, datetime)):
+            first_arg = raw_comparison.arguments[0]
+            if not isinstance(first_arg, TARGET_TYPES):
                 return False
             comparison = first_arg
-        if not isinstance(comparison, (int, date, datetime)):
+        else:
+            if not isinstance(raw_comparison, TARGET_TYPES):
+                return False
+            comparison = raw_comparison
+
+        if not isinstance(comparison, REDUCABLE_TYPES):
             return False
 
         var = concept
@@ -136,11 +166,25 @@ def simplify_conditions(
     return True if all(isinstance(s, bool) and s for s in simplified) else False
 
 
+def boolean_fully_covered(
+    start: bool,
+    end: bool,
+    ranges: List[Tuple[bool, bool]],
+):
+    all = []
+    for r_start, r_end in ranges:
+        if r_start is True and r_end is True:
+            all.append(True)
+        elif r_start is False and r_end is False:
+            all.append(False)
+    return set(all) == {False, True}
+
+
 def is_fully_covered(
     start: T,
     end: T,
     ranges: List[Tuple[T, T]],
-    increment: int | timedelta,
+    increment: int | timedelta | float,
 ):
     """
     Check if the list of range pairs fully covers the set [start, end].
@@ -153,6 +197,11 @@ def is_fully_covered(
     Returns:
     - bool: True if the ranges fully cover [start, end], False otherwise.
     """
+    if isinstance(start, bool) and isinstance(end, bool):
+        # convert each element of each tuple to a boolean
+        bool_ranges = [(bool(r_start), bool(r_end)) for r_start, r_end in ranges]
+
+        return boolean_fully_covered(start, end, bool_ranges)
     # Sort ranges by their start values (and by end values for ties)
     ranges.sort()
 
@@ -173,14 +222,14 @@ def get_union_sources(
     datasources: list[BuildDatasource], concepts: list[BuildConcept]
 ) -> List[list[BuildDatasource]]:
     candidates: list[BuildDatasource] = []
+
     for x in datasources:
-        if all([c.address in x.output_concepts for c in concepts]):
+        if any([c.address in x.output_concepts for c in concepts]):
             if (
                 any([c.address in x.partial_concepts for c in concepts])
                 and x.non_partial_for
             ):
                 candidates.append(x)
-
     assocs: dict[str, list[BuildDatasource]] = defaultdict(list[BuildDatasource])
     for x in candidates:
         if not x.non_partial_for:

trilogy/core/processing/node_generators/select_merge_node.py

@@ -1,5 +1,5 @@
 from functools import reduce
-from typing import List, Optional
+from typing import TYPE_CHECKING, List, Optional
 
 import networkx as nx
 
@@ -30,6 +30,9 @@ from trilogy.core.processing.nodes import (
 )
 from trilogy.core.processing.utility import padding
 
+if TYPE_CHECKING:
+    from trilogy.core.processing.nodes.union_node import UnionNode
+
 LOGGER_PREFIX = "[GEN_ROOT_MERGE_NODE]"
 
 
@@ -119,8 +122,12 @@ def create_pruned_concept_graph(
 
     g = g.copy()
     union_options = get_union_sources(datasources, all_concepts)
+
     for ds_list in union_options:
         node_address = "ds~" + "-".join([x.name for x in ds_list])
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} injecting potentially relevant union datasource {node_address}"
+        )
         common: set[BuildConcept] = set.intersection(
             *[set(x.output_concepts) for x in ds_list]
         )
@@ -128,7 +135,7 @@ def create_pruned_concept_graph(
         for c in common:
             g.add_edge(node_address, concept_to_node(c))
             g.add_edge(concept_to_node(c), node_address)
-    prune_sources_for_conditions(g, conditions)
+    prune_sources_for_conditions(g, accept_partial, conditions)
     target_addresses = set([c.address for c in all_concepts])
     concepts: dict[str, BuildConcept] = nx.get_node_attributes(orig_g, "concept")
     datasource_map: dict[str, BuildDatasource | list[BuildDatasource]] = (
@@ -203,14 +210,14 @@ def create_pruned_concept_graph(
         for s in subgraphs
         if subgraph_is_complete(s, target_addresses, relevant_concepts_pre, g)
     ]
-
+    # from trilogy.hooks.graph_hook import GraphHook
+    # GraphHook().query_graph_built(g)
     if not subgraphs:
         logger.info(
             f"{padding(depth)}{LOGGER_PREFIX} cannot resolve root graph - no subgraphs after node prune"
         )
         return None
-    # from trilogy.hooks.graph_hook import GraphHook
-    # GraphHook().query_graph_built(g)
+
     if subgraphs and len(subgraphs) != 1:
         logger.info(
             f"{padding(depth)}{LOGGER_PREFIX} cannot resolve root graph - subgraphs are split - have {len(subgraphs)} from {subgraphs}"
@@ -233,6 +240,7 @@ def create_pruned_concept_graph(
 def resolve_subgraphs(
     g: nx.DiGraph,
     relevant: list[BuildConcept],
+    accept_partial: bool,
     conditions: BuildWhereClause | None,
     depth: int = 0,
 ) -> dict[str, list[str]]:
@@ -251,7 +259,7 @@ def resolve_subgraphs(
         ds: list(set(list(nx.all_neighbors(g, ds)))) for ds in datasources
     }
     partial_map = get_graph_partial_nodes(g, conditions)
-    exact_map = get_graph_exact_match(g, conditions)
+    exact_map = get_graph_exact_match(g, accept_partial, conditions)
     grain_length = get_graph_grains(g)
     concepts: dict[str, BuildConcept] = nx.get_node_attributes(g, "concept")
     non_partial_map = {
@@ -386,7 +394,7 @@ def create_datasource_node(
     datasource_conditions = datasource.where.conditional if datasource.where else None
     rval = SelectNode(
         input_concepts=[c.concept for c in datasource.columns],
-        output_concepts=all_concepts,
+        output_concepts=sorted(all_concepts, key=lambda x: x.address),
         environment=environment,
         parents=[],
         depth=depth,
@@ -408,6 +416,46 @@ def create_datasource_node(
     )
 
 
+def create_union_datasource(
+    datasource: list[BuildDatasource],
+    all_concepts: List[BuildConcept],
+    accept_partial: bool,
+    environment: BuildEnvironment,
+    depth: int,
+    conditions: BuildWhereClause | None = None,
+) -> tuple["UnionNode", bool]:
+    from trilogy.core.processing.nodes.union_node import UnionNode
+
+    logger.info(
+        f"{padding(depth)}{LOGGER_PREFIX} generating union node parents with condition {conditions}"
+    )
+    force_group = False
+    parents = []
+    for x in datasource:
+        subnode, fg = create_datasource_node(
+            x,
+            all_concepts,
+            accept_partial,
+            environment,
+            depth + 1,
+            conditions=conditions,
+        )
+        parents.append(subnode)
+        force_group = force_group or fg
+    logger.info(f"{padding(depth)}{LOGGER_PREFIX} returning union node")
+    return (
+        UnionNode(
+            output_concepts=all_concepts,
+            input_concepts=all_concepts,
+            environment=environment,
+            parents=parents,
+            depth=depth,
+            partial_concepts=[],
+        ),
+        force_group,
+    )
+
+
 def create_select_node(
     ds_name: str,
     subgraph: list[str],
@@ -452,31 +500,13 @@ def create_select_node(
         )
 
     elif isinstance(datasource, list):
-        logger.info(
-            f"{padding(depth)}{LOGGER_PREFIX} generating union node parents with condition {conditions}"
-        )
-        from trilogy.core.processing.nodes.union_node import UnionNode
-
-        force_group = False
-        parents = []
-        for x in datasource:
-            subnode, fg = create_datasource_node(
-                x,
-                all_concepts,
-                accept_partial,
-                environment,
-                depth,
-                conditions=conditions,
-            )
-            parents.append(subnode)
-            force_group = force_group or fg
-        logger.info(f"{padding(depth)}{LOGGER_PREFIX} generating union node")
-        bcandidate = UnionNode(
-            output_concepts=all_concepts,
-            input_concepts=all_concepts,
-            environment=environment,
-            parents=parents,
-            depth=depth,
+        bcandidate, force_group = create_union_datasource(
+            datasource,
+            all_concepts,
+            accept_partial,
+            environment,
+            depth,
+            conditions=conditions,
         )
     else:
         raise ValueError(f"Unknown datasource type {datasource}")
@@ -548,6 +578,9 @@ def gen_select_merge_node(
     ]
     if accept_partial:
         attempts.append(True)
+    logger.info(
+        f"{padding(depth)}{LOGGER_PREFIX} searching for root source graph for concepts {[c.address for c in all_concepts]} and conditions {conditions}"
+    )
     for attempt in attempts:
         pruned_concept_graph = create_pruned_concept_graph(
             g,
@@ -568,7 +601,11 @@ def gen_select_merge_node(
         return None
 
     sub_nodes = resolve_subgraphs(
-        pruned_concept_graph, relevant=non_constant, conditions=conditions, depth=depth
+        pruned_concept_graph,
+        relevant=non_constant,
+        accept_partial=accept_partial,
+        conditions=conditions,
+        depth=depth,
     )
 
     logger.info(f"{padding(depth)}{LOGGER_PREFIX} fetching subgraphs {sub_nodes}")

trilogy/core/processing/node_generators/window_node.py

@@ -39,6 +39,7 @@ def resolve_window_parent_concepts(
             base += item.concept_arguments
     if concept.grain:
         for gitem in concept.grain.components:
+            logger.info(f"{LOGGER_PREFIX} appending grain item {gitem} to base")
             base.append(environment.concepts[gitem])
     return concept.lineage.content, unique(base, "address")
 
@@ -55,7 +56,7 @@ def gen_window_node(
 ) -> StrategyNode | None:
     base, parent_concepts = resolve_window_parent_concepts(concept, environment)
     logger.info(
-        f"{padding(depth)}{LOGGER_PREFIX} generating window node for {concept} with parents {parent_concepts} and optional {local_optional}"
+        f"{padding(depth)}{LOGGER_PREFIX} generating window node for {concept} with parents {[x.address for x in parent_concepts]} and optional {local_optional}"
     )
     equivalent_optional = [
         x

trilogy/core/processing/nodes/base_node.py

@@ -160,9 +160,7 @@ class StrategyNode:
         self.whole_grain = whole_grain
         self.parents = parents or []
         self.resolution_cache: Optional[QueryDatasource] = None
-        self.partial_concepts = partial_concepts or get_all_parent_partial(
-            self.output_concepts, self.parents
-        )
+
         self.nullable_concepts = nullable_concepts or get_all_parent_nullable(
             self.output_concepts, self.parents
         )
@@ -188,7 +186,9 @@ class StrategyNode:
                 right=self.preexisting_conditions,
                 operator=BooleanOperator.AND,
             )
-        self.validate_parents()
+        self.partial_concepts: list[BuildConcept] = self.derive_partials(
+            partial_concepts
+        )
         self.validate_inputs()
         self.log = True
 
@@ -214,7 +214,7 @@ class StrategyNode:
 
     def add_parents(self, parents: list["StrategyNode"]):
         self.parents += parents
-        self.validate_parents()
+        self.partial_concepts = self.derive_partials(None)
         return self
 
     def set_preexisting_conditions(
@@ -238,7 +238,9 @@ class StrategyNode:
         self.rebuild_cache()
         return self
 
-    def validate_parents(self):
+    def derive_partials(
+        self, partial_concepts: List[BuildConcept] | None = None
+    ) -> List[BuildConcept]:
         # validate parents exist
         # assign partial values where needed
         for parent in self.parents:
@@ -246,12 +248,14 @@ class StrategyNode:
                 raise SyntaxError("Unresolvable parent")
 
         # TODO: make this accurate
-        if self.parents:
-            self.partial_concepts = get_all_parent_partial(
-                self.output_concepts, self.parents
-            )
-
-        self.partial_lcl = LooseBuildConceptList(concepts=self.partial_concepts)
+        if self.parents and partial_concepts is None:
+            partials = get_all_parent_partial(self.output_concepts, self.parents)
+        elif partial_concepts is None:
+            partials = []
+        else:
+            partials = partial_concepts
+        self.partial_lcl = LooseBuildConceptList(concepts=partials)
+        return partials
 
     def add_output_concepts(self, concepts: List[BuildConcept], rebuild: bool = True):
         for concept in concepts:

trilogy/core/processing/nodes/union_node.py

@@ -19,6 +19,7 @@ class UnionNode(StrategyNode):
         whole_grain: bool = False,
         parents: List["StrategyNode"] | None = None,
         depth: int = 0,
+        partial_concepts: List[BuildConcept] | None = None,
     ):
         super().__init__(
             input_concepts=input_concepts,
@@ -27,7 +28,13 @@ class UnionNode(StrategyNode):
             whole_grain=whole_grain,
             parents=parents,
             depth=depth,
+            partial_concepts=partial_concepts,
         )
+        if self.partial_concepts != []:
+            raise ValueError(
+                f"UnionNode should not have partial concepts, has {self.partial_concepts}, was given {partial_concepts}"
+            )
+        self.partial_concepts = []
 
     def _resolve(self) -> QueryDatasource:
         """We need to ensure that any filtered values are removed from the output to avoid inappropriate references"""
@@ -40,6 +47,7 @@ class UnionNode(StrategyNode):
             output_concepts=list(self.output_concepts),
             environment=self.environment,
             whole_grain=self.whole_grain,
-            parents=self.parents,
+            parents=[x.copy() for x in self.parents] if self.parents else None,
             depth=self.depth,
+            partial_concepts=self.partial_concepts,
         )

trilogy/core/query_processor.py

@@ -53,7 +53,7 @@ LOGGER_PREFIX = "[QUERY BUILD]"
 
 
 def base_join_to_join(
-    base_join: BaseJoin | UnnestJoin, ctes: List[CTE]
+    base_join: BaseJoin | UnnestJoin, ctes: List[CTE | UnionCTE]
 ) -> Join | InstantiatedUnnestJoin:
     """This function converts joins at the datasource level
     to joins at the CTE level"""
@@ -69,7 +69,9 @@ def base_join_to_join(
             alias=base_join.alias,
         )
 
-    def get_datasource_cte(datasource: BuildDatasource | QueryDatasource) -> CTE:
+    def get_datasource_cte(
+        datasource: BuildDatasource | QueryDatasource,
+    ) -> CTE | UnionCTE:
         eligible = set()
         for cte in ctes:
             if cte.source.identifier == datasource.identifier:
@@ -334,7 +336,7 @@ def datasource_to_cte(
     human_id = generate_cte_name(query_datasource.identifier, name_map)
 
     final_joins = [
-        base_join_to_join(join, [x for x in parents if isinstance(x, CTE)])
+        base_join_to_join(join, [x for x in parents if isinstance(x, (CTE, UnionCTE))])
         for join in query_datasource.joins
     ]
 

trilogy/dialect/base.py

@@ -163,6 +163,7 @@ FUNCTION_MAP = {
     FunctionType.ALIAS: lambda x: f"{x[0]}",
     FunctionType.GROUP: lambda x: f"{x[0]}",
     FunctionType.CONSTANT: lambda x: f"{x[0]}",
+    FunctionType.TYPED_CONSTANT: lambda x: f"{x[0]}",
     FunctionType.COALESCE: lambda x: f"coalesce({','.join(x)})",
     FunctionType.NULLIF: lambda x: f"nullif({x[0]},{x[1]})",
     FunctionType.CAST: lambda x: f"cast({x[0]} as {x[1]})",
@@ -764,7 +765,10 @@ class BaseDialect:
     def render_cte(self, cte: CTE | UnionCTE, auto_sort: bool = True) -> CompiledCTE:
         if isinstance(cte, UnionCTE):
             base_statement = f"\n{cte.operator}\n".join(
-                [self.render_cte(child).statement for child in cte.internal_ctes]
+                [
+                    self.render_cte(child, auto_sort=False).statement
+                    for child in cte.internal_ctes
+                ]
             )
             if cte.order_by:
 

trilogy/parsing/common.py

@@ -173,7 +173,9 @@ def concept_list_to_keys(
 
 
 def constant_to_concept(
-    parent: ListWrapper | TupleWrapper | MapWrapper | int | float | str,
+    parent: (
+        ListWrapper | TupleWrapper | MapWrapper | int | float | str | date | datetime
+    ),
     name: str,
     namespace: str,
     metadata: Metadata | None = None,
@@ -368,9 +370,9 @@ def _get_relevant_parent_concepts(arg) -> tuple[list[ConceptRef], bool]:
     return get_concept_arguments(arg), False
 
 
-def get_relevant_parent_concepts(arg):
-    results = _get_relevant_parent_concepts(arg)
-    return results
+def get_relevant_parent_concepts(arg) -> tuple[list[ConceptRef], bool]:
+    concepts, status = _get_relevant_parent_concepts(arg)
+    return unique(concepts, "address"), status
 
 
 def group_function_to_concept(
@@ -626,20 +628,11 @@ def window_item_to_concept(
 
     # when including the order by in discovery grain
     if parent.order_by:
+
         grain_components = parent.over + [bcontent.output]
         for item in parent.order_by:
-            # confirm that it's not just an aggregate at the grain of the stuff we're already keying of of
-            # in which case we can ignore contributions
-            if (
-                isinstance(item.expr, AggregateWrapper)
-                and set([x.address for x in item.expr.by]) == keys
-            ):
-                continue
-            elif isinstance(item.expr, AggregateWrapper):
-
-                grain_components += item.expr.by
-            else:
-                grain_components += item.concept_arguments
+            relevant, _ = get_relevant_parent_concepts(item.expr)
+            grain_components += relevant
     else:
         grain_components = parent.over + [bcontent.output]
 
@@ -842,6 +835,7 @@ def arbitrary_to_concept(
         | int
         | float
         | str
+        | date
     ),
     environment: Environment,
     namespace: str | None = None,

trilogy/parsing/parse_engine.py

@@ -640,6 +640,7 @@ class ParseToObjects(Transformer):
 
     @v_args(meta=True)
     def concept_derivation(self, meta: Meta, args) -> ConceptDerivationStatement:
+
         if len(args) > 3:
             metadata = args[3]
         else:
@@ -733,6 +734,7 @@ class ParseToObjects(Transformer):
 
     @v_args(meta=True)
     def constant_derivation(self, meta: Meta, args) -> Concept:
+
         if len(args) > 3:
             metadata = args[3]
         else:
@@ -1405,6 +1407,7 @@ class ParseToObjects(Transformer):
     def string_lit(self, args) -> str:
         if not args:
             return ""
+
         return args[0]
 
     @v_args(meta=True)
@@ -1890,7 +1893,9 @@ class ParseToObjects(Transformer):
 
     def internal_fcast(self, meta, args) -> Function:
         args = process_function_args(args, meta=meta, environment=self.environment)
+
         if isinstance(args[0], str):
+
             processed: date | datetime | int | float | bool | str
             if args[1] == DataType.DATE:
                 processed = date.fromisoformat(args[0])
@@ -1908,6 +1913,10 @@ class ParseToObjects(Transformer):
                 processed = args[0]
             else:
                 raise SyntaxError(f"Invalid cast type {args[1]}")
+            if isinstance(args[1], TraitDataType):
+                return self.function_factory.create_function(
+                    [processed, args[1]], FunctionType.TYPED_CONSTANT, meta
+                )
             return self.function_factory.create_function(
                 [processed], FunctionType.CONSTANT, meta
             )

trilogy/std/net.preql

@@ -5,4 +5,5 @@ type domain string;
 type ip_net_mask string;
 type ipv6_address string;
 type ipv4_address string;
-type suffix string;
+type suffix string;
+type url_image string;