pytrilogy 0.0.3.53__py3-none-any.whl → 0.0.3.55__py3-none-any.whl

{pytrilogy-0.0.3.53.dist-info → pytrilogy-0.0.3.55.dist-info}/METADATA

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

{pytrilogy-0.0.3.53.dist-info → pytrilogy-0.0.3.55.dist-info}/RECORD

@@ -1,7 +1,7 @@
-pytrilogy-0.0.3.53.dist-info/licenses/LICENSE.md,sha256=5ZRvtTyCCFwz1THxDTjAu3Lidds9WjPvvzgVwPSYNDo,1042
-trilogy/__init__.py,sha256=4T41znLlekPuyFkWm5zr0OjLiQwfA1YBEpTjY1Xl-6s,303
+pytrilogy-0.0.3.55.dist-info/licenses/LICENSE.md,sha256=5ZRvtTyCCFwz1THxDTjAu3Lidds9WjPvvzgVwPSYNDo,1042
+trilogy/__init__.py,sha256=8imvlrqcfkFMW4ZwYgNE-dGvIeWPqAyRgtnjVYICUyw,303
 trilogy/compiler.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-trilogy/constants.py,sha256=5eQxk1A0pv-TQk3CCvgZCFA9_K-6nxrOm7E5Lxd7KIY,1652
+trilogy/constants.py,sha256=lv_aJWP6dn6e2aF4BAE72jbnNtceFddfqtiDSsvzno0,1692
 trilogy/engine.py,sha256=OK2RuqCIUId6yZ5hfF8J1nxGP0AJqHRZiafcowmW0xc,1728
 trilogy/executor.py,sha256=GwNhP9UW4565dxnpHbw-VWNE2lX8uroQJQtSpC_j2pI,16298
 trilogy/parser.py,sha256=o4cfk3j3yhUFoiDKq9ZX_GjBF3dKhDjXEwb63rcBkBM,293
@@ -11,34 +11,34 @@ trilogy/utility.py,sha256=euQccZLKoYBz0LNg5tzLlvv2YHvXh9HArnYp1V3uXsM,763
 trilogy/authoring/__init__.py,sha256=v9PRuZs4fTnxhpXAnwTxCDwlLasUax6g2FONidcujR4,2369
 trilogy/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/core/constants.py,sha256=7XaCpZn5mQmjTobbeBn56SzPWq9eMNDfzfsRU-fP0VE,171
-trilogy/core/enums.py,sha256=QVylGAe6epdGGpOKkeJ4cbx0mIZb0aARAKhsoZaGhoA,7576
+trilogy/core/enums.py,sha256=XeA25YPIkVdgwrcHYyUGlcaNSrI8W3qfY7hHeZTzYKE,7711
 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/functions.py,sha256=IvqHyuO__o6Th8tkDWjb9cDxQDly6l3ZEfJ9y8YrTRU,29227
+trilogy/core/functions.py,sha256=poVfAwet1xdxTkC7WL38UmGRDpUVO9iSMNWSagl9_r4,29302
 trilogy/core/graph_models.py,sha256=z17EoO8oky2QOuO6E2aMWoVNKEVJFhLdsQZOhC4fNLU,2079
 trilogy/core/internal.py,sha256=iicDBlC6nM8d7e7jqzf_ZOmpUsW8yrr2AA8AqEiLx-s,1577
-trilogy/core/optimization.py,sha256=O7ag0IVQlJyWdAXBi_hHeU3Df5DRyd75Vlz6pks2J10,8197
-trilogy/core/query_processor.py,sha256=NNzYPKN5HzivQFXugSbJC_MaupkwOYii7A_vnXuBIK4,20063
+trilogy/core/optimization.py,sha256=ChIAv0kRmw9RKyDGDCdSdbIN5fJGMkIlE6eVfTFsxg4,8867
+trilogy/core/query_processor.py,sha256=jSS1xZFDqBuI0sZBbuYAAuuVGwas7W-mV_v5oFZJFpA,20275
 trilogy/core/utility.py,sha256=3VC13uSQWcZNghgt7Ot0ZTeEmNqs__cx122abVq9qhM,410
 trilogy/core/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-trilogy/core/models/author.py,sha256=KKW_3A1hdwq7D2dFwI6xZanukPuCQQ23R4GzE5VRJ6c,77206
+trilogy/core/models/author.py,sha256=N0bdexQaGWgdVg20Uc-5p37qnbTtAxfXo7fMLvX-0QA,77417
 trilogy/core/models/build.py,sha256=yBiOQ4Bhjz09pSD1jSGhhf9QFFQuplrvZ0JQB5-iXHk,63104
 trilogy/core/models/build_environment.py,sha256=s_C9xAHuD3yZ26T15pWVBvoqvlp2LdZ8yjsv2_HdXLk,5363
 trilogy/core/models/core.py,sha256=wx6hJcFECMG-Ij972ADNkr-3nFXkYESr82ObPiC46_U,10875
 trilogy/core/models/datasource.py,sha256=6RjJUd2u4nYmEwFBpJlM9LbHVYDv8iHJxqiBMZqUrwI,9422
 trilogy/core/models/environment.py,sha256=AVSrvjNcNX535GhCPtYhCRY2Lp_Hj0tdY3VVt_kZb9Q,27260
-trilogy/core/models/execute.py,sha256=F7-9VyUz5MC__VUSXd4U7gUb23Dc5PH5FdMUt6FqCPM,35214
+trilogy/core/models/execute.py,sha256=_JC93S5tpCQM9jpgmmbd6wkLMEfPvaMZwWZBVcgehlI,42931
 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=AHuTGh2x0GQ8usOe0NiFncfTFQ_KogdgDl4uucmhIbI,4241
+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=8Wos5d9_tzfnzSbejb36QL4uoGPQ3GiwP27u_a4JrcE,44097
+trilogy/core/processing/concept_strategies_v3.py,sha256=wOrcy-I_mSRvhUODmZqhRCCZo1wMyyqH6bm1tmMHdBI,44801
 trilogy/core/processing/graph_utils.py,sha256=8QUVrkE9j-9C1AyrCb1nQEh8daCe0u1HuXl-Te85lag,1205
 trilogy/core/processing/utility.py,sha256=rfzdgl-vWkCyhLzXNNuWgPLK59eiYypQb6TdZKymUqk,21469
-trilogy/core/processing/node_generators/__init__.py,sha256=o8rOFHPSo-s_59hREwXMW6gjUJCsiXumdbJNozHUf-Y,800
+trilogy/core/processing/node_generators/__init__.py,sha256=w8TQQgNhyAra6JQHdg1_Ags4BGyxjXYruu6UeC5yOkI,873
 trilogy/core/processing/node_generators/basic_node.py,sha256=UVsXMn6jTjm_ofVFt218jAS11s4RV4zD781vP4im-GI,3371
 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
@@ -46,20 +46,22 @@ trilogy/core/processing/node_generators/group_node.py,sha256=nIfiMrJQEksUfqAeeA3
 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=sv55oynfqgpHEpo1OEtVDri-5fywzPhDlR85qaWikvY,16195
-trilogy/core/processing/node_generators/rowset_node.py,sha256=YmBs6ZQ7azLXRFEmeoecpGjK4pMHsUCovuBxfb3UKZI,6848
+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=lxXhMhDKGbu67QFNbbAT-BO8gbWppIvjn_hAXpLEPe0,19953
 trilogy/core/processing/node_generators/select_node.py,sha256=Y-zO0AFkTrpi2LyebjpyHU7WWANr7nKZSS9rY7DH4Wo,1888
 trilogy/core/processing/node_generators/synonym_node.py,sha256=9LHK2XHDjbyTLjmDQieskG8fqbiSpRnFOkfrutDnOTE,2258
 trilogy/core/processing/node_generators/union_node.py,sha256=VNo6Oey4p8etU9xrOh2oTT2lIOTvY6PULUPRvVa2uxU,2877
 trilogy/core/processing/node_generators/unnest_node.py,sha256=cOEKnMRzXUW3bwmiOlgn3E1-B38osng0dh2pDykwITY,2410
-trilogy/core/processing/node_generators/window_node.py,sha256=RUHgpYovQObFod1xRIMWtDzMcxwlm4-1Fdrf_Cuw5W4,6346
+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=GMW07bb6hXurhF0hZLYoMAKSIS65tat5hwBjvqqPeSA,6516
-trilogy/core/processing/nodes/__init__.py,sha256=xPFF7x3TFs1Z4IcfthCykZgrksb-UhN-pc_oIigfFSo,6014
-trilogy/core/processing/nodes/base_node.py,sha256=z-aZEVjnLdFm6TpmneEm2bnRXj-tRFr7mN7DYG4zH9A,16967
+trilogy/core/processing/nodes/__init__.py,sha256=9FaUt9_gtsC9Y0-I9BeHTnNlghKaA4iIaLwOM8QKwCE,6117
+trilogy/core/processing/nodes/base_node.py,sha256=IdKR2yaQGY1iRgKXgxF1UtlyuJEmPXWRh0rGFXv7Z_U,18111
 trilogy/core/processing/nodes/filter_node.py,sha256=5VtRfKbCORx0dV-vQfgy3gOEkmmscL9f31ExvlODwvY,2461
 trilogy/core/processing/nodes/group_node.py,sha256=MUvcOg9U5J6TnWBel8eht9PdI9BfAKjUxmfjP_ZXx9o,10484
 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/unnest_node.py,sha256=oLKMMNMx6PLDPlt2V5neFMFrFWxET8r6XZElAhSNkO0,2181
@@ -70,16 +72,16 @@ trilogy/core/statements/build.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hS
 trilogy/core/statements/common.py,sha256=KxEmz2ySySyZ6CTPzn0fJl5NX2KOk1RPyuUSwWhnK1g,759
 trilogy/core/statements/execute.py,sha256=cSlvpHFOqpiZ89pPZ5GDp9Hu6j6uj-5_h21FWm_L-KM,1248
 trilogy/dialect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-trilogy/dialect/base.py,sha256=Y4m4RQdYI3usjeTLJKUM_SIIyuxXZfe2hboG5JSxDLU,42412
-trilogy/dialect/bigquery.py,sha256=MyUumO8CeyPLh2JquoKPp6yQSZYEzUQ2mM07LCps-CA,3526
-trilogy/dialect/common.py,sha256=EFf2Ye7XcwTti7IsFRwMo_4AW2CF8eaxSk8XA0mA5qw,5400
+trilogy/dialect/base.py,sha256=SwYg3aCLmam70mlkJURYN42IggmbxviFnMUJ72WYE4g,42940
+trilogy/dialect/bigquery.py,sha256=4u4SuQ67_Zwyu0czyQnBMDUVlegqir0SA30iEbZEAwU,3575
+trilogy/dialect/common.py,sha256=IhW0v5zATvZ2K0vr4Ab4TWpYMKKkGangSpIyqaPYEkw,5762
 trilogy/dialect/config.py,sha256=olnyeVU5W5T6b9-dMeNAnvxuPlyc2uefb7FRME094Ec,3834
 trilogy/dialect/dataframe.py,sha256=RUbNgReEa9g3pL6H7fP9lPTrAij5pkqedpZ99D8_5AE,1522
-trilogy/dialect/duckdb.py,sha256=IQzaRaCv5c6TUDERhbsLM4uTW0aGkO_DrAMR5k_j7TU,3861
+trilogy/dialect/duckdb.py,sha256=C5TovwacDXo9YDpMTpPxkH7D0AxQERa7JL1RUkDGVng,3898
 trilogy/dialect/enums.py,sha256=FRNYQ5-w-B6-X0yXKNU5g9GowsMlERFogTC5u2nxL_s,4740
 trilogy/dialect/postgres.py,sha256=VH4EB4myjIeZTHeFU6vK00GxY9c53rCBjg2mLbdaCEE,3254
 trilogy/dialect/presto.py,sha256=Mw7_F8h19mWfuZHkHQJizQWbpu1lIHe6t2PA0r88gsY,3392
-trilogy/dialect/snowflake.py,sha256=vc0374Og0O5OIB7-Z7jbwoJJg0iomjvnUqHlxM8B0rg,3120
+trilogy/dialect/snowflake.py,sha256=-PQABpiyY5zrsXtS0MV4Pe0YFu06hhxuMVD0WA9yBsc,3185
 trilogy/dialect/sql_server.py,sha256=z2Vg7Qvw83rbGiEFIvHHLqVWJTWiz2xs76kpQj4HdTU,3131
 trilogy/hooks/__init__.py,sha256=T3SF3phuUDPLXKGRVE_Lf9mzuwoXWyaLolncR_1kY30,144
 trilogy/hooks/base_hook.py,sha256=I_l-NBMNC7hKTDx1JgHZPVOOCvLQ36m2oIGaR5EUMXY,1180
@@ -87,13 +89,13 @@ trilogy/hooks/graph_hook.py,sha256=c-vC-IXoJ_jDmKQjxQyIxyXPOuUcLIURB573gCsAfzQ,2
 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=g1RmQF4fS_OgkcC6j4hnKIcn_ap0fFa_kzNUlH5D0nA,29760
+trilogy/parsing/common.py,sha256=pvkmT67wYE6HwVecSTfW9RRaeiF6CD6iNHo-e-xiSrY,29901
 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=mQzUSWOX2QdUng2ozAkqLDfMLI_NoqPjAiauhe_mHz4,70606
+trilogy/parsing/parse_engine.py,sha256=jgmBqKi5JVR1MSOnEDUWOpGtdUih4TmP7l78yCEoS7o,70785
 trilogy/parsing/render.py,sha256=hI4y-xjXrEXvHslY2l2TQ8ic0zAOpN41ADH37J2_FZY,19047
-trilogy/parsing/trilogy.lark,sha256=ybs65Ckb89PCitK4hcwy6znqElcWvIeMDQzsI2p_3YI,14197
+trilogy/parsing/trilogy.lark,sha256=se-gnL3UfrdznVvhNbzzcE5VZxZ18iNMbNMFvRjr30I,14304
 trilogy/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/scripts/trilogy.py,sha256=1L0XrH4mVHRt1C9T1HnaDv2_kYEfbWTb5_-cBBke79w,3774
 trilogy/std/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -102,8 +104,8 @@ trilogy/std/display.preql,sha256=2BbhvqR4rcltyAbOXAUo7SZ_yGFYZgFnurglHMbjW2g,40
 trilogy/std/geography.preql,sha256=-fqAGnBL6tR-UtT8DbSek3iMFg66ECR_B_41pODxv-k,504
 trilogy/std/money.preql,sha256=ZHW-csTX-kYbOLmKSO-TcGGgQ-_DMrUXy0BjfuJSFxM,80
 trilogy/std/report.preql,sha256=LbV-XlHdfw0jgnQ8pV7acG95xrd1-p65fVpiIc-S7W4,202
-pytrilogy-0.0.3.53.dist-info/METADATA,sha256=AXRI2M3hD9xHGN8YuQ_nxnylPcy6zSWmKS3cBjZjtek,9095
-pytrilogy-0.0.3.53.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-pytrilogy-0.0.3.53.dist-info/entry_points.txt,sha256=ewBPU2vLnVexZVnB-NrVj-p3E-4vukg83Zk8A55Wp2w,56
-pytrilogy-0.0.3.53.dist-info/top_level.txt,sha256=cAy__NW_eMAa_yT9UnUNlZLFfxcg6eimUAZ184cdNiE,8
-pytrilogy-0.0.3.53.dist-info/RECORD,,
+pytrilogy-0.0.3.55.dist-info/METADATA,sha256=cLSfLU5-e2rmY39yQSBiG0H52-3RB_RjF7w8nmu9-Pw,9095
+pytrilogy-0.0.3.55.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+pytrilogy-0.0.3.55.dist-info/entry_points.txt,sha256=ewBPU2vLnVexZVnB-NrVj-p3E-4vukg83Zk8A55Wp2w,56
+pytrilogy-0.0.3.55.dist-info/top_level.txt,sha256=cAy__NW_eMAa_yT9UnUNlZLFfxcg6eimUAZ184cdNiE,8
+pytrilogy-0.0.3.55.dist-info/RECORD,,

{pytrilogy-0.0.3.53.dist-info → pytrilogy-0.0.3.55.dist-info}/WHEEL

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

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.53"
+__version__ = "0.0.3.55"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

trilogy/constants.py

@@ -7,6 +7,8 @@ logger = getLogger("trilogy")
 
 DEFAULT_NAMESPACE = "local"
 
+RECURSIVE_GATING_CONCEPT = "_terminal"
+
 VIRTUAL_CONCEPT_PREFIX = "_virt"
 
 ENV_CACHE_NAME = ".preql_cache.json"

trilogy/core/enums.py

@@ -51,6 +51,7 @@ class Derivation(Enum):
     ROOT = "root"
     ROWSET = "rowset"
     MULTISELECT = "multiselect"
+    RECURSIVE = "recursive"
 
 
 class Granularity(Enum):
@@ -117,6 +118,7 @@ class FunctionType(Enum):
 
     # structural
     UNNEST = "unnest"
+    RECURSE_EDGE = "recurse_edge"
 
     UNION = "union"
 
@@ -233,6 +235,8 @@ class FunctionClass(Enum):
 
     ONE_TO_MANY = [FunctionType.UNNEST]
 
+    RECURSIVE = [FunctionType.RECURSE_EDGE]
+
 
 class Boolean(Enum):
     TRUE = "true"
@@ -333,6 +337,7 @@ class SourceType(Enum):
     MERGE = "merge"
     BASIC = "basic"
     UNION = "union"
+    RECURSIVE = "recursive"
 
 
 class ShowCategory(Enum):

trilogy/core/functions.py

@@ -190,6 +190,9 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
         output_type_function=get_unnest_output_type,
         arg_count=1,
     ),
+    FunctionType.RECURSE_EDGE: FunctionConfig(
+        arg_count=2,
+    ),
     FunctionType.GROUP: FunctionConfig(
         arg_count=-1,
         output_type_function=lambda args: get_output_type_at_index(args, 0),

trilogy/core/models/author.py

@@ -1164,6 +1164,12 @@ class Concept(Addressable, DataTyped, ConceptArgs, Mergeable, Namespaced, BaseMo
             and lineage.operator == FunctionType.UNNEST
         ):
             return Derivation.UNNEST
+        elif (
+            lineage
+            and isinstance(lineage, (BuildFunction, Function))
+            and lineage.operator == FunctionType.RECURSE_EDGE
+        ):
+            return Derivation.RECURSIVE
         elif (
             lineage
             and isinstance(lineage, (BuildFunction, Function))

trilogy/core/models/execute.py

@@ -12,9 +12,16 @@ from pydantic import (
     model_validator,
 )
 
-from trilogy.constants import CONFIG, logger
+from trilogy.constants import (
+    CONFIG,
+    DEFAULT_NAMESPACE,
+    RECURSIVE_GATING_CONCEPT,
+    MagicConstants,
+    logger,
+)
 from trilogy.core.constants import CONSTANT_DATASET
 from trilogy.core.enums import (
+    ComparisonOperator,
     Derivation,
     FunctionType,
     Granularity,
@@ -24,16 +31,20 @@ from trilogy.core.enums import (
     SourceType,
 )
 from trilogy.core.models.build import (
+    BuildCaseElse,
+    BuildCaseWhen,
     BuildComparison,
     BuildConcept,
     BuildConditional,
     BuildDatasource,
+    BuildExpr,
     BuildFunction,
     BuildGrain,
     BuildOrderBy,
     BuildParamaterizedConceptReference,
     BuildParenthetical,
     BuildRowsetItem,
+    DataType,
     LooseBuildConceptList,
 )
 from trilogy.core.models.datasource import Address
@@ -841,6 +852,195 @@ class QueryDatasource(BaseModel):
         return self.identifier
 
 
+class AliasedExpression(BaseModel):
+    expr: BuildExpr
+    alias: str
+
+
+class RecursiveCTE(CTE):
+
+    def generate_loop_functions(
+        self,
+        recursive_derived: BuildConcept,
+        left_recurse_concept: BuildConcept,
+        right_recurse_concept: BuildConcept,
+    ) -> tuple[BuildConcept, BuildConcept, BuildConcept]:
+
+        join_gate = BuildConcept(
+            name=RECURSIVE_GATING_CONCEPT,
+            namespace=DEFAULT_NAMESPACE,
+            grain=recursive_derived.grain,
+            build_is_aggregate=False,
+            datatype=DataType.BOOL,
+            purpose=Purpose.KEY,
+            derivation=Derivation.BASIC,
+            lineage=BuildFunction(
+                operator=FunctionType.CASE,
+                arguments=[
+                    BuildCaseWhen(
+                        comparison=BuildComparison(
+                            left=right_recurse_concept,
+                            right=MagicConstants.NULL,
+                            operator=ComparisonOperator.IS,
+                        ),
+                        expr=True,
+                    ),
+                    BuildCaseElse(expr=False),
+                ],
+                output_datatype=DataType.BOOL,
+                output_purpose=Purpose.KEY,
+            ),
+        )
+        bottom_join_gate = BuildConcept(
+            name=f"{RECURSIVE_GATING_CONCEPT}_two",
+            namespace=DEFAULT_NAMESPACE,
+            grain=recursive_derived.grain,
+            build_is_aggregate=False,
+            datatype=DataType.BOOL,
+            purpose=Purpose.KEY,
+            derivation=Derivation.BASIC,
+            lineage=BuildFunction(
+                operator=FunctionType.CASE,
+                arguments=[
+                    BuildCaseWhen(
+                        comparison=BuildComparison(
+                            left=right_recurse_concept,
+                            right=MagicConstants.NULL,
+                            operator=ComparisonOperator.IS,
+                        ),
+                        expr=True,
+                    ),
+                    BuildCaseElse(expr=False),
+                ],
+                output_datatype=DataType.BOOL,
+                output_purpose=Purpose.KEY,
+            ),
+        )
+        bottom_derivation = BuildConcept(
+            name=recursive_derived.name + "_bottom",
+            namespace=recursive_derived.namespace,
+            grain=recursive_derived.grain,
+            build_is_aggregate=False,
+            datatype=recursive_derived.datatype,
+            purpose=recursive_derived.purpose,
+            derivation=Derivation.RECURSIVE,
+            lineage=BuildFunction(
+                operator=FunctionType.CASE,
+                arguments=[
+                    BuildCaseWhen(
+                        comparison=BuildComparison(
+                            left=right_recurse_concept,
+                            right=MagicConstants.NULL,
+                            operator=ComparisonOperator.IS,
+                        ),
+                        expr=recursive_derived,
+                    ),
+                    BuildCaseElse(expr=right_recurse_concept),
+                ],
+                output_datatype=recursive_derived.datatype,
+                output_purpose=recursive_derived.purpose,
+            ),
+        )
+        return bottom_derivation, join_gate, bottom_join_gate
+
+    @property
+    def internal_ctes(self) -> List[CTE]:
+        filtered_output = [
+            x for x in self.output_columns if x.name != RECURSIVE_GATING_CONCEPT
+        ]
+        recursive_derived = [
+            x for x in self.output_columns if x.derivation == Derivation.RECURSIVE
+        ][0]
+        if not isinstance(recursive_derived.lineage, BuildFunction):
+            raise SyntaxError(
+                "Recursive CTEs must have a function lineage, found"
+                f" {recursive_derived.lineage}"
+            )
+        left_recurse_concept = recursive_derived.lineage.concept_arguments[0]
+        right_recurse_concept = recursive_derived.lineage.concept_arguments[1]
+        parent_ctes: List[CTE | UnionCTE]
+        if self.parent_ctes:
+            base = self.parent_ctes[0]
+            loop_input_cte = base
+            parent_ctes = [base]
+            parent_identifier = base.identifier
+        else:
+            raise SyntaxError("Recursive CTEs must have a parent CTE currently")
+        bottom_derivation, join_gate, bottom_join_gate = self.generate_loop_functions(
+            recursive_derived, left_recurse_concept, right_recurse_concept
+        )
+        base_output = [*filtered_output, join_gate]
+        bottom_output = []
+        for x in filtered_output:
+            if x.address == recursive_derived.address:
+                bottom_output.append(bottom_derivation)
+            else:
+                bottom_output.append(x)
+
+        bottom_output = [*bottom_output, bottom_join_gate]
+        top = CTE(
+            name=self.name,
+            source=self.source,
+            output_columns=base_output,
+            source_map=self.source_map,
+            grain=self.grain,
+            existence_source_map=self.existence_source_map,
+            parent_ctes=self.parent_ctes,
+            joins=self.joins,
+            condition=self.condition,
+            partial_concepts=self.partial_concepts,
+            hidden_concepts=self.hidden_concepts,
+            nullable_concepts=self.nullable_concepts,
+            join_derived_concepts=self.join_derived_concepts,
+            group_to_grain=self.group_to_grain,
+            order_by=self.order_by,
+            limit=self.limit,
+        )
+        top_cte_array: list[CTE | UnionCTE] = [top]
+        bottom_source_map = {
+            left_recurse_concept.address: [top.identifier],
+            right_recurse_concept.address: [parent_identifier],
+            # recursive_derived.address: self.source_map[recursive_derived.address],
+            join_gate.address: [top.identifier],
+            recursive_derived.address: [top.identifier],
+        }
+        bottom = CTE(
+            name=self.name,
+            source=self.source,
+            output_columns=bottom_output,
+            source_map=bottom_source_map,
+            grain=self.grain,
+            existence_source_map=self.existence_source_map,
+            parent_ctes=top_cte_array + parent_ctes,
+            joins=[
+                Join(
+                    right_cte=loop_input_cte,
+                    jointype=JoinType.INNER,
+                    joinkey_pairs=[
+                        CTEConceptPair(
+                            left=recursive_derived,
+                            right=left_recurse_concept,
+                            existing_datasource=loop_input_cte.source,
+                            modifiers=[],
+                            cte=top,
+                        )
+                    ],
+                    condition=BuildComparison(
+                        left=join_gate, right=True, operator=ComparisonOperator.IS_NOT
+                    ),
+                )
+            ],
+            partial_concepts=self.partial_concepts,
+            hidden_concepts=self.hidden_concepts,
+            nullable_concepts=self.nullable_concepts,
+            join_derived_concepts=self.join_derived_concepts,
+            group_to_grain=self.group_to_grain,
+            order_by=self.order_by,
+            limit=self.limit,
+        )
+        return [top, bottom]
+
+
 class UnionCTE(BaseModel):
     name: str
     source: QueryDatasource
@@ -891,6 +1091,10 @@ class UnionCTE(BaseModel):
     def condition(self, value):
         raise NotImplementedError
 
+    @property
+    def identifier(self) -> str:
+        return self.name
+
     @property
     def safe_identifier(self):
         return self.name
@@ -906,12 +1110,13 @@ class UnionCTE(BaseModel):
 
 
 class Join(BaseModel):
-    right_cte: CTE
+    right_cte: CTE | UnionCTE
     jointype: JoinType
     left_cte: CTE | None = None
     joinkey_pairs: List[CTEConceptPair] | None = None
     inlined_ctes: set[str] = Field(default_factory=set)
     quote: str | None = None
+    condition: BuildConditional | BuildComparison | BuildParenthetical | None = None
 
     def inline_cte(self, cte: CTE):
         self.inlined_ctes.add(cte.name)

trilogy/core/optimization.py

@@ -3,7 +3,7 @@ from trilogy.core.enums import BooleanOperator, Derivation
 from trilogy.core.models.build import (
     BuildConditional,
 )
-from trilogy.core.models.execute import CTE, UnionCTE
+from trilogy.core.models.execute import CTE, RecursiveCTE, UnionCTE
 from trilogy.core.optimizations import (
     InlineDatasource,
     OptimizationRule,
@@ -120,13 +120,20 @@ def gen_inverse_map(input: list[CTE | UnionCTE]) -> dict[str, list[CTE | UnionCT
     return inverse_map
 
 
+SENSITIVE_DERIVATIONS = [
+    Derivation.UNNEST,
+    Derivation.WINDOW,
+    Derivation.RECURSIVE,
+]
+
+
 def is_direct_return_eligible(cte: CTE | UnionCTE) -> CTE | UnionCTE | None:
     # if isinstance(select, (PersistStatement, MultiSelectStatement)):
     #     return False
     if len(cte.parent_ctes) != 1:
         return None
     direct_parent = cte.parent_ctes[0]
-    if isinstance(direct_parent, UnionCTE):
+    if isinstance(direct_parent, (UnionCTE, RecursiveCTE)):
         return None
 
     output_addresses = set([x.address for x in cte.output_columns])
@@ -151,21 +158,31 @@ def is_direct_return_eligible(cte: CTE | UnionCTE) -> CTE | UnionCTE | None:
     ]
     condition_arguments = cte.condition.row_arguments if cte.condition else []
     for x in derived_concepts:
-        if x.derivation == Derivation.WINDOW:
-            return None
-        if x.derivation == Derivation.UNNEST:
-            return None
-        if x.derivation == Derivation.AGGREGATE:
+        if x.derivation in SENSITIVE_DERIVATIONS:
             return None
     for x in parent_derived_concepts:
         if x.address not in condition_arguments:
             continue
-        if x.derivation == Derivation.UNNEST:
-            return None
-        if x.derivation == Derivation.WINDOW:
+        if x.derivation in SENSITIVE_DERIVATIONS:
             return None
+    for x in condition_arguments:
+        # if it's derived in the parent
+        if x.address in parent_derived_concepts:
+            if x.derivation in SENSITIVE_DERIVATIONS:
+                return None
+            # this maybe needs to be recursive if we flatten a ton of derivation
+            # into one CTE
+            if not x.lineage:
+                continue
+            for z in x.lineage.concept_arguments:
+                # if it was preexisting in the parent, it's safe
+                if z.address in direct_parent.source.input_concepts:
+                    continue
+                # otherwise if it's dangerous, play it safe.
+                if z.derivation in SENSITIVE_DERIVATIONS:
+                    return None
     logger.info(
-        f"[Optimization][EarlyReturn] Removing redundant output CTE with derived_concepts {[x.address for x in derived_concepts]}"
+        f"[Optimization][EarlyReturn] Removing redundant output CTE {cte.name} with derived_concepts {[x.address for x in derived_concepts]}"
     )
     return direct_parent
 

trilogy/core/optimizations/inline_datasource.py

@@ -1,13 +1,8 @@
 from collections import defaultdict
 
 from trilogy.constants import CONFIG
-
-# from trilogy.core.models.datasource import Datasource
 from trilogy.core.models.build import BuildDatasource
-from trilogy.core.models.execute import (
-    CTE,
-    UnionCTE,
-)
+from trilogy.core.models.execute import CTE, RecursiveCTE, UnionCTE
 from trilogy.core.optimizations.base_optimization import OptimizationRule
 
 
@@ -24,7 +19,8 @@ class InlineDatasource(OptimizationRule):
             return any(
                 self.optimize(x, inverse_map=inverse_map) for x in cte.internal_ctes
             )
-
+        if isinstance(cte, RecursiveCTE):
+            return False
         if not cte.parent_ctes:
             return False
 
@@ -36,6 +32,8 @@ class InlineDatasource(OptimizationRule):
         for parent_cte in cte.parent_ctes:
             if isinstance(parent_cte, UnionCTE):
                 continue
+            if isinstance(parent_cte, RecursiveCTE):
+                continue
             if not parent_cte.is_root_datasource:
                 self.debug(f"Cannot inline: parent {parent_cte.name} is not root")
                 continue

trilogy/core/processing/concept_strategies_v3.py

@@ -24,6 +24,7 @@ from trilogy.core.processing.node_generators import (
     gen_group_to_node,
     gen_merge_node,
     gen_multiselect_node,
+    gen_recursive_node,
     gen_rowset_node,
     gen_synonym_node,
     gen_union_node,
@@ -150,6 +151,7 @@ def get_priority_concept(
             + [c for c in remaining_concept if c.derivation == Derivation.FILTER]
             # unnests are weird?
             + [c for c in remaining_concept if c.derivation == Derivation.UNNEST]
+            + [c for c in remaining_concept if c.derivation == Derivation.RECURSIVE]
             + [c for c in remaining_concept if c.derivation == Derivation.BASIC]
             # finally our plain selects
             + [
@@ -294,6 +296,20 @@ def generate_node(
             source_concepts=source_concepts,
             conditions=conditions,
         )
+    elif concept.derivation == Derivation.RECURSIVE:
+        logger.info(
+            f"{depth_to_prefix(depth)}{LOGGER_PREFIX} for {concept.address}, generating recursive node with optional {[x.address for x in local_optional]} and condition {conditions}"
+        )
+        return gen_recursive_node(
+            concept,
+            local_optional,
+            history=history,
+            environment=environment,
+            g=g,
+            depth=depth + 1,
+            source_concepts=source_concepts,
+            conditions=conditions,
+        )
     elif concept.derivation == Derivation.UNION:
         logger.info(
             f"{depth_to_prefix(depth)}{LOGGER_PREFIX} for {concept.address}, generating union node with optional {[x.address for x in local_optional]} and condition {conditions}"
@@ -920,6 +936,7 @@ def _search_concepts(
                     Derivation.FILTER,
                     Derivation.WINDOW,
                     Derivation.UNNEST,
+                    Derivation.RECURSIVE,
                     Derivation.ROWSET,
                     Derivation.BASIC,
                     Derivation.MULTISELECT,

trilogy/core/processing/node_generators/__init__.py

@@ -4,6 +4,7 @@ from .group_node import gen_group_node
 from .group_to_node import gen_group_to_node
 from .multiselect_node import gen_multiselect_node
 from .node_merge_node import gen_merge_node
+from .recursive_node import gen_recursive_node
 from .rowset_node import gen_rowset_node
 from .select_node import gen_select_node
 from .synonym_node import gen_synonym_node
@@ -24,4 +25,5 @@ __all__ = [
     "gen_rowset_node",
     "gen_multiselect_node",
     "gen_synonym_node",
+    "gen_recursive_node",
 ]

trilogy/core/processing/node_generators/recursive_node.py

@@ -0,0 +1,87 @@
+from typing import List
+
+from trilogy.constants import DEFAULT_NAMESPACE, RECURSIVE_GATING_CONCEPT, logger
+from trilogy.core.models.build import (
+    BuildComparison,
+    BuildConcept,
+    BuildFunction,
+    BuildGrain,
+    BuildWhereClause,
+    ComparisonOperator,
+    DataType,
+    Derivation,
+    Purpose,
+)
+from trilogy.core.models.build_environment import BuildEnvironment
+from trilogy.core.processing.nodes import History, RecursiveNode, StrategyNode
+from trilogy.core.processing.utility import padding
+
+LOGGER_PREFIX = "[GEN_RECURSIVE_NODE]"
+
+GATING_CONCEPT = BuildConcept(
+    name=RECURSIVE_GATING_CONCEPT,
+    namespace=DEFAULT_NAMESPACE,
+    grain=BuildGrain(),
+    build_is_aggregate=False,
+    datatype=DataType.BOOL,
+    purpose=Purpose.KEY,
+    derivation=Derivation.BASIC,
+)
+
+
+def gen_recursive_node(
+    concept: BuildConcept,
+    local_optional: List[BuildConcept],
+    history: History,
+    environment: BuildEnvironment,
+    g,
+    depth: int,
+    source_concepts,
+    conditions: BuildWhereClause | None = None,
+) -> StrategyNode | None:
+    arguments = []
+    if isinstance(concept.lineage, BuildFunction):
+        arguments = concept.lineage.concept_arguments
+    logger.info(
+        f"{padding(depth)}{LOGGER_PREFIX} Fetching recursive node for {concept.name} with arguments {arguments} and conditions {conditions}"
+    )
+    parent = source_concepts(
+        mandatory_list=arguments,
+        environment=environment,
+        g=g,
+        depth=depth + 1,
+        history=history,
+        # conditions=conditions,
+    )
+    if not parent:
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} could not find recursive node parents"
+        )
+        return None
+    outputs = (
+        [concept]
+        + arguments
+        + [
+            GATING_CONCEPT,
+        ]
+    )
+    base = RecursiveNode(
+        input_concepts=arguments,
+        output_concepts=outputs,
+        environment=environment,
+        parents=([parent] if (arguments or local_optional) else []),
+        # preexisting_conditions=conditions
+    )
+    # TODO:
+    # recursion will result in a union; group up to our final targets
+    wrapped_base = StrategyNode(
+        input_concepts=outputs,
+        output_concepts=outputs,
+        environment=environment,
+        parents=[base],
+        depth=depth,
+        conditions=BuildComparison(
+            left=GATING_CONCEPT, right=True, operator=ComparisonOperator.IS
+        ),
+    )
+    return wrapped_base

trilogy/core/processing/node_generators/rowset_node.py

@@ -95,9 +95,7 @@ def gen_rowset_node(
         f"{padding(depth)}{LOGGER_PREFIX} hiding {final_hidden} local optional {local_optional}"
     )
     node.hide_output_concepts(final_hidden)
-    assert node.resolution_cache
-    # assume grain to be output of select
-    # but don't include anything hidden(the non-rowset concepts)
+
     node.grain = BuildGrain.from_concepts(
         [
             x

trilogy/core/processing/node_generators/window_node.py

@@ -11,7 +11,12 @@ from trilogy.core.models.build_environment import BuildEnvironment
 from trilogy.core.processing.node_generators.common import (
     gen_enrichment_node,
 )
-from trilogy.core.processing.nodes import History, StrategyNode, WindowNode
+from trilogy.core.processing.nodes import (
+    History,
+    StrategyNode,
+    WhereSafetyNode,
+    WindowNode,
+)
 from trilogy.core.processing.utility import create_log_lambda, padding
 from trilogy.utility import unique
 
@@ -71,10 +76,13 @@ def gen_window_node(
     if equivalent_optional:
         for x in equivalent_optional:
             assert isinstance(x.lineage, WINDOW_TYPES)
+            base, parents = resolve_window_parent_concepts(x, environment)
             logger.info(
-                f"{padding(depth)}{LOGGER_PREFIX} found equivalent optional {x} with parents {resolve_window_parent_concepts(x, environment)[1]}"
+                f"{padding(depth)}{LOGGER_PREFIX} found equivalent optional {x} with parents {parents}"
             )
             additional_outputs.append(x)
+            # also append the base concept it's being grouped over
+            targets.append(base)
 
     grain_equivalents = [
         x
@@ -85,7 +93,8 @@ def gen_window_node(
     ]
 
     for x in grain_equivalents:
-        logger.info("Appending grain equivalent %s", x)
+        if x.address in additional_outputs:
+            continue
         targets.append(x)
 
     # finally, the ones we'll need to enrich
@@ -134,7 +143,7 @@ def gen_window_node(
     _window_node.rebuild_cache()
     _window_node.resolve()
 
-    window_node = StrategyNode(
+    window_node = WhereSafetyNode(
         input_concepts=[concept] + additional_outputs + parent_concepts + targets,
         output_concepts=[concept] + additional_outputs + parent_concepts + targets,
         environment=environment,

trilogy/core/processing/nodes/__init__.py

@@ -6,10 +6,11 @@ from trilogy.core.models.build import BuildConcept, BuildWhereClause
 from trilogy.core.models.build_environment import BuildEnvironment
 from trilogy.core.models.environment import Environment
 
-from .base_node import NodeJoin, StrategyNode
+from .base_node import NodeJoin, StrategyNode, WhereSafetyNode
 from .filter_node import FilterNode
 from .group_node import GroupNode
 from .merge_node import MergeNode
+from .recursive_node import RecursiveNode
 from .select_node_v2 import ConstantNode, SelectNode
 from .union_node import UnionNode
 from .unnest_node import UnnestNode
@@ -193,4 +194,6 @@ __all__ = [
     "UnnestNode",
     "UnionNode",
     "History",
+    "WhereSafetyNode",
+    "RecursiveNode",
 ]

trilogy/core/processing/nodes/base_node.py

@@ -291,9 +291,14 @@ class StrategyNode:
     def add_output_concept(self, concept: BuildConcept, rebuild: bool = True):
         return self.add_output_concepts([concept], rebuild)
 
-    def hide_output_concepts(self, concepts: List[BuildConcept], rebuild: bool = True):
+    def hide_output_concepts(
+        self, concepts: List[BuildConcept] | list[str] | set[str], rebuild: bool = True
+    ):
         for x in concepts:
-            self.hidden_concepts.add(x.address)
+            if isinstance(x, BuildConcept):
+                self.hidden_concepts.add(x.address)
+            else:
+                self.hidden_concepts.add(x)
         if rebuild:
             self.rebuild_cache()
         return self
@@ -471,3 +476,28 @@ class NodeJoin:
             f" {self.right_node} on"
             f" {','.join([str(k) for k in self.concepts])}"
         )
+
+
+class WhereSafetyNode(StrategyNode):
+    """Specialized node to be used to pad certain
+    select outputs that can't be immediately used in a where
+    clause; eg window functions. Will remove itself if not required."""
+
+    def resolve(self) -> QueryDatasource:
+        if not self.conditions and len(self.parents) == 1:
+            parent = self.parents[0]
+            parent = parent.copy()
+            # avoid performance hit by not rebuilding until end
+            parent.set_output_concepts(self.output_concepts, rebuild=False)
+            parent.hide_output_concepts(self.hidden_concepts, rebuild=False)
+
+            # these conditions
+            if self.preexisting_conditions:
+                parent.set_preexisting_conditions(self.preexisting_conditions)
+            # TODO: add a helper for this
+            parent.ordering = self.ordering
+
+            # actually build the node
+            parent.rebuild_cache()
+            return parent.resolve()
+        return super().resolve()

trilogy/core/processing/nodes/recursive_node.py

@@ -0,0 +1,46 @@
+from typing import List
+
+from trilogy.core.enums import SourceType
+from trilogy.core.models.build import BuildConcept
+from trilogy.core.models.build_environment import BuildEnvironment
+from trilogy.core.models.execute import QueryDatasource
+from trilogy.core.processing.nodes.base_node import StrategyNode
+
+
+class RecursiveNode(StrategyNode):
+    """Union nodes represent combining two keyspaces"""
+
+    source_type = SourceType.RECURSIVE
+
+    def __init__(
+        self,
+        input_concepts: List[BuildConcept],
+        output_concepts: List[BuildConcept],
+        environment: BuildEnvironment,
+        whole_grain: bool = False,
+        parents: List["StrategyNode"] | None = None,
+        depth: int = 0,
+    ):
+        super().__init__(
+            input_concepts=input_concepts,
+            output_concepts=output_concepts,
+            environment=environment,
+            whole_grain=whole_grain,
+            parents=parents,
+            depth=depth,
+        )
+
+    def _resolve(self) -> QueryDatasource:
+        """We need to ensure that any filtered values are removed from the output to avoid inappropriate references"""
+        base = super()._resolve()
+        return base
+
+    def copy(self) -> "RecursiveNode":
+        return RecursiveNode(
+            input_concepts=list(self.input_concepts),
+            output_concepts=list(self.output_concepts),
+            environment=self.environment,
+            whole_grain=self.whole_grain,
+            parents=self.parents,
+            depth=self.depth,
+        )

trilogy/core/query_processor.py

@@ -26,6 +26,7 @@ from trilogy.core.models.execute import (
     InstantiatedUnnestJoin,
     Join,
     QueryDatasource,
+    RecursiveCTE,
     UnionCTE,
     UnnestJoin,
 )
@@ -340,7 +341,12 @@ def datasource_to_cte(
     base_name, base_alias = resolve_cte_base_name_and_alias_v2(
         human_id, query_datasource, source_map, final_joins
     )
-    cte = CTE(
+    cte_class = CTE
+
+    if query_datasource.source_type == SourceType.RECURSIVE:
+        cte_class = RecursiveCTE
+        # extra_kwargs['left_recursive_concept'] = query_datasource.left
+    cte = cte_class(
         name=human_id,
         source=query_datasource,
         # output columns are what are selected/grouped by

trilogy/dialect/base.py

@@ -48,7 +48,7 @@ from trilogy.core.models.core import (
 )
 from trilogy.core.models.datasource import Datasource, RawColumnExpr
 from trilogy.core.models.environment import Environment
-from trilogy.core.models.execute import CTE, CompiledCTE, UnionCTE
+from trilogy.core.models.execute import CTE, CompiledCTE, RecursiveCTE, UnionCTE
 from trilogy.core.processing.utility import (
     decompose_condition,
     is_scalar_condition,
@@ -173,6 +173,7 @@ FUNCTION_MAP = {
     FunctionType.INDEX_ACCESS: lambda x: f"{x[0]}[{x[1]}]",
     FunctionType.MAP_ACCESS: lambda x: f"{x[0]}[{x[1]}]",
     FunctionType.UNNEST: lambda x: f"unnest({x[0]})",
+    FunctionType.RECURSE_EDGE: lambda x: f"CASE WHEN {x[1]} IS NULL THEN {x[0]} ELSE {x[1]} END",
     FunctionType.ATTR_ACCESS: lambda x: f"""{x[0]}.{x[1].replace("'", "")}""",
     FunctionType.STRUCT: lambda x: f"{{{', '.join(struct_arg(x))}}}",
     FunctionType.ARRAY: lambda x: f"[{', '.join(x)}]",
@@ -247,7 +248,7 @@ FUNCTION_GRAIN_MATCH_MAP = {
 
 GENERIC_SQL_TEMPLATE = Template(
     """{%- if ctes %}
-WITH {% for cte in ctes %}
+WITH {% if recursive%} RECURSIVE {% endif %}{% for cte in ctes %}
 {{cte.name}} as (
 {{cte.statement}}){% if not loop.last %},{% endif %}{% endfor %}{% endif %}
 {%- if full_select -%}
@@ -734,6 +735,11 @@ class BaseDialect:
                 ]
                 base_statement += "\nORDER BY " + ",".join(ordering)
             return CompiledCTE(name=cte.name, statement=base_statement)
+        elif isinstance(cte, RecursiveCTE):
+            base_statement = "\nUNION ALL\n".join(
+                [self.render_cte(child, False).statement for child in cte.internal_ctes]
+            )
+            return CompiledCTE(name=cte.name, statement=base_statement)
         if self.UNNEST_MODE in (
             UnnestMode.CROSS_APPLY,
             UnnestMode.CROSS_JOIN,
@@ -1002,9 +1008,12 @@ class BaseDialect:
                 f" {selected}"
             )
 
+        recursive = any(isinstance(x, RecursiveCTE) for x in query.ctes)
+
         compiled_ctes = self.generate_ctes(query)
 
         final = self.SQL_TEMPLATE.render(
+            recursive=recursive,
             output=(
                 query.output_to if isinstance(query, ProcessedQueryPersist) else None
             ),

trilogy/dialect/bigquery.py

@@ -59,8 +59,9 @@ BQ_SQL_TEMPLATE = Template(
     """{%- if output %}
 CREATE OR REPLACE TABLE {{ output.address.location }} AS
 {% endif %}{%- if ctes %}
-WITH {% for cte in ctes %}
-{{cte.name}} as ({{cte.statement}}){% if not loop.last %},{% endif %}{% endfor %}{% endif %}
+WITH {% if recursive%}RECURSIVE{% endif %}{% for cte in ctes %}
+{{cte.name}} as ({{cte.statement}}){% if not loop.last %},{% else%}
+{% endif %}{% endfor %}{% endif %}
 {%- if full_select -%}
 {{full_select}}
 {%- else -%}
@@ -68,10 +69,8 @@ SELECT
 {%- for select in select_columns %}
     {{ select }}{% if not loop.last %},{% endif %}{% endfor %}
 {% if base %}FROM
-    {{ base }}{% endif %}{% if joins %}
-{% for join in joins %}
-{{ join }}
-{% endfor %}{% endif %}
+    {{ base }}{% endif %}{% if joins %}{% for join in joins %}
+    {{ join }}{% endfor %}{% endif %}
 {% if where %}WHERE
     {{ where }}
 {% endif %}

trilogy/dialect/common.py

@@ -2,15 +2,19 @@ from typing import Callable
 
 from trilogy.core.enums import Modifier, UnnestMode
 from trilogy.core.models.build import (
+    BuildComparison,
     BuildConcept,
+    BuildConditional,
     BuildFunction,
     BuildParamaterizedConceptReference,
+    BuildParenthetical,
 )
 from trilogy.core.models.datasource import RawColumnExpr
 from trilogy.core.models.execute import (
     CTE,
     InstantiatedUnnestJoin,
     Join,
+    UnionCTE,
 )
 
 
@@ -49,7 +53,7 @@ def render_unnest(
 def render_join_concept(
     name: str,
     quote_character: str,
-    cte: CTE,
+    cte: CTE | UnionCTE,
     concept: BuildConcept,
     render_expr,
     inlined_ctes: set[str],
@@ -71,7 +75,16 @@ def render_join(
     join: Join | InstantiatedUnnestJoin,
     quote_character: str,
     render_expr_func: Callable[
-        [BuildConcept | BuildParamaterizedConceptReference | BuildFunction, CTE], str
+        [
+            BuildConcept
+            | BuildParamaterizedConceptReference
+            | BuildFunction
+            | BuildConditional
+            | BuildComparison
+            | BuildParenthetical,
+            CTE,
+        ],
+        str,
     ],
     cte: CTE,
     unnest_mode: UnnestMode = UnnestMode.CROSS_APPLY,
@@ -127,4 +140,7 @@ def render_join(
         base_joinkeys = ["1=1"]
 
     joinkeys = " AND ".join(sorted(base_joinkeys))
-    return f"{join.jointype.value.upper()} JOIN {right_base} on {joinkeys}"
+    base = f"{join.jointype.value.upper()} JOIN {right_base} on {joinkeys}"
+    if join.condition:
+        base = f"{base} and {render_expr_func(join.condition, cte)}"
+    return base

trilogy/dialect/duckdb.py

@@ -58,7 +58,7 @@ DUCKDB_TEMPLATE = Template(
     """{%- if output %}
 CREATE OR REPLACE TABLE {{ output.address.location }} AS
 {% endif %}{%- if ctes %}
-WITH {% for cte in ctes %}
+WITH {% if recursive%}RECURSIVE{% endif %}{% for cte in ctes %}
 {{cte.name}} as (
 {{cte.statement}}){% if not loop.last %},{% else %}
 {% endif %}{% endfor %}{% endif %}

trilogy/dialect/snowflake.py

@@ -41,12 +41,14 @@ FUNCTION_GRAIN_MATCH_MAP = {
     FunctionType.AVG: lambda args: f"{args[0]}",
 }
 
-BQ_SQL_TEMPLATE = Template(
+
+SNOWFLAKE_SQL_TEMPLATE = Template(
     """{%- if output %}
 CREATE OR REPLACE TABLE {{ output.address.location }} AS
 {% endif %}{%- if ctes %}
-WITH {% for cte in ctes %}
-{{cte.name}} as ({{cte.statement}}){% if not loop.last %},{% endif %}{% endfor %}{% endif %}
+WITH {% if recursive%}RECURSIVE{% endif %}{% for cte in ctes %}
+{{cte.name}} as ({{cte.statement}}){% if not loop.last %},{% endif %}{% else %}
+{% endfor %}{% endif %}
 {%- if full_select -%}
 {{full_select}}
 {%- else -%}
@@ -55,10 +57,8 @@ SELECT
 {%- for select in select_columns %}
     {{ select }}{% if not loop.last %},{% endif %}{% endfor %}
 {% if base %}FROM
-    {{ base }}{% endif %}{% if joins %}
-{% for join in joins %}
-{{ join }}
-{% endfor %}{% endif %}
+    {{ base }}{% endif %}{% if joins %}{% for join in joins %}
+    {{ join }}{% endfor %}{% endif %}
 {% if where %}WHERE
     {{ where }}
 {% endif %}
@@ -84,5 +84,5 @@ class SnowflakeDialect(BaseDialect):
         **FUNCTION_GRAIN_MATCH_MAP,
     }
     QUOTE_CHARACTER = '"'
-    SQL_TEMPLATE = BQ_SQL_TEMPLATE
+    SQL_TEMPLATE = SNOWFLAKE_SQL_TEMPLATE
     UNNEST_MODE = UnnestMode.SNOWFLAKE

trilogy/parsing/common.py

@@ -476,6 +476,9 @@ def function_to_concept(
     elif parent.operator == FunctionType.UNNEST:
         derivation = Derivation.UNNEST
         granularity = Granularity.MULTI_ROW
+    elif parent.operator == FunctionType.RECURSE_EDGE:
+        derivation = Derivation.RECURSIVE
+        granularity = Granularity.MULTI_ROW
     elif parent.operator in FunctionClass.SINGLE_ROW.value:
         derivation = Derivation.CONSTANT
         granularity = Granularity.SINGLE_ROW

trilogy/parsing/parse_engine.py

@@ -1657,6 +1657,12 @@ class ParseToObjects(Transformer):
     def fnullif(self, meta, args):
         return self.function_factory.create_function(args, FunctionType.NULLIF, meta)
 
+    @v_args(meta=True)
+    def frecurse_edge(self, meta, args):
+        return self.function_factory.create_function(
+            args, FunctionType.RECURSE_EDGE, meta
+        )
+
     @v_args(meta=True)
     def unnest(self, meta, args):
         return self.function_factory.create_function(args, FunctionType.UNNEST, meta)

trilogy/parsing/trilogy.lark

@@ -247,8 +247,10 @@
     fnot: "NOT"i expr
     fbool: "bool"i "(" expr ")"
     fnullif: "nullif"i "(" expr "," expr ")"
+    _FRECURSE_EDGE.1: "recurse_edge("i
+    frecurse_edge: _FRECURSE_EDGE expr "," expr ")"
 
-    _generic_functions: fcast |  concat  | fcoalesce | fnullif | fcase  | len | fnot | fbool
+    _generic_functions: fcast |  concat  | fcoalesce | fnullif | fcase  | len | fnot | fbool | frecurse_edge
 
     //constant
     CURRENT_DATE.1: /current_date\(\)/