pytrilogy 0.0.3.7__py3-none-any.whl → 0.0.3.9__py3-none-any.whl

{pytrilogy-0.0.3.7.dist-info → pytrilogy-0.0.3.9.dist-info}/METADATA

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

{pytrilogy-0.0.3.7.dist-info → pytrilogy-0.0.3.9.dist-info}/RECORD

@@ -1,8 +1,8 @@
-trilogy/__init__.py,sha256=nCVrjnf_bl_zZ7GmePdSoaRQ40QxFDkSFlafhQp8Cn8,302
+trilogy/__init__.py,sha256=oZcEJCenpaskC-ViU-OpC-03zsr2chE8ggGCpg2Duws,302
 trilogy/compiler.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/constants.py,sha256=qZ1d0hoKPPV2HHCoFwPYTVB7b6bXjpWvXd3lE-zEhy8,1494
 trilogy/engine.py,sha256=3etkm2RSVKO0IkgPKkrcs33X5gN_fIMyqMNfChcsR1E,1318
-trilogy/executor.py,sha256=YgSCeeYVecI9526LGSLVe2apOo7Ddsttvs_nDC9yElQ,17194
+trilogy/executor.py,sha256=9HhdLQoou1Cy9KSDgpdYxK6uyg-UPkgx9jXJBuK5ITc,17271
 trilogy/parser.py,sha256=o4cfk3j3yhUFoiDKq9ZX_GjBF3dKhDjXEwb63rcBkBM,293
 trilogy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/utility.py,sha256=euQccZLKoYBz0LNg5tzLlvv2YHvXh9HArnYp1V3uXsM,763
@@ -20,12 +20,12 @@ trilogy/core/internal.py,sha256=iicDBlC6nM8d7e7jqzf_ZOmpUsW8yrr2AA8AqEiLx-s,1577
 trilogy/core/optimization.py,sha256=xGO8piVsLrpqrx-Aid_Y56_5slSv4eZmlP64hCHRiEc,7957
 trilogy/core/query_processor.py,sha256=Do8YpdPBdsbKtl9n37hobzk8SORMGqH-e_zNNxd-BE4,19456
 trilogy/core/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-trilogy/core/models/author.py,sha256=oRCKWhz-i1fO1LlHWiHE3l1awCHdQ3yx6FKH9n9RxRU,67188
-trilogy/core/models/build.py,sha256=kiq31T8LtUtgmT37m617Q2MlMvQTuAxJzwb6947EiWU,56127
+trilogy/core/models/author.py,sha256=eJOz-p20Am5IQPDeBntgIkncB1nUZGhuwcy7WBSbCmM,70240
+trilogy/core/models/build.py,sha256=bO1qYvuGl6LeNGgsfS6ZHAzZBR2lBPLg-QJymp9hgkU,57235
 trilogy/core/models/build_environment.py,sha256=8UggvlPU708GZWYPJMc_ou2r7M3TY2g69eqGvz03YX0,5528
 trilogy/core/models/core.py,sha256=yie1uuq62uOQ5fjob9NMJbdvQPrCErXUT7JTCuYRyjI,9697
 trilogy/core/models/datasource.py,sha256=6RjJUd2u4nYmEwFBpJlM9LbHVYDv8iHJxqiBMZqUrwI,9422
-trilogy/core/models/environment.py,sha256=h06y1Dv7naw2GuFFAAyoFZmicG7a7Lu-dRoYPVfrOGo,25967
+trilogy/core/models/environment.py,sha256=qFZ0_Op6zIhKc5oVS4EVYZ67f29wJhKP_xoEMV4kkuU,25991
 trilogy/core/models/execute.py,sha256=ABylFQgtavjjCfFkEsFdUwfMB4UBQLHjdzQ9E67QlAE,33521
 trilogy/core/optimizations/__init__.py,sha256=EBanqTXEzf1ZEYjAneIWoIcxtMDite5-n2dQ5xcfUtg,356
 trilogy/core/optimizations/base_optimization.py,sha256=gzDOKImoFn36k7XBD3ysEYDnbnb6vdVIztUfFQZsGnM,513
@@ -40,9 +40,9 @@ trilogy/core/processing/node_generators/__init__.py,sha256=o8rOFHPSo-s_59hREwXMW
 trilogy/core/processing/node_generators/basic_node.py,sha256=UVsXMn6jTjm_ofVFt218jAS11s4RV4zD781vP4im-GI,3371
 trilogy/core/processing/node_generators/common.py,sha256=ZsDzThjm_mAtdQpKAg8QIJiPVZ4KuUkKyilj4eOhSDs,9439
 trilogy/core/processing/node_generators/filter_node.py,sha256=rlY7TbgjJlGhahYgdCIJpJbaSREAGVJEsyUIGaA38O0,8271
-trilogy/core/processing/node_generators/group_node.py,sha256=94uoGZWvBKJ1eqjbDHCbZuRqMkux_lfpfkGZgAJTNCY,5876
+trilogy/core/processing/node_generators/group_node.py,sha256=3-TXVnRO9_jqE_e1kWLqbgtBShW8WFtKwQk8oOtOULs,5894
 trilogy/core/processing/node_generators/group_to_node.py,sha256=E5bEjovSx422d_MlAUCDFdY4P2WJVp61BmWwltkhzA8,3095
-trilogy/core/processing/node_generators/multiselect_node.py,sha256=z9FQOxxUvxW31a0TckFfAvnuvU8vP1GyN224RTbXUAk,7114
+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=8yeMWiyi9IFnza7qPn9YYC3WpA53weq3AY5WisIui8Y,6705
 trilogy/core/processing/node_generators/select_merge_node.py,sha256=VHCPMbnKfg7AOfoYa6PKxpNni-j5JEfliNUiltmZhds,19698
@@ -63,7 +63,7 @@ trilogy/core/processing/nodes/union_node.py,sha256=fDFzLAUh5876X6_NM7nkhoMvHEdGJ
 trilogy/core/processing/nodes/unnest_node.py,sha256=oLKMMNMx6PLDPlt2V5neFMFrFWxET8r6XZElAhSNkO0,2181
 trilogy/core/processing/nodes/window_node.py,sha256=STvwheVttxSWVHB-yUQUSo-Pyz7Uk8G1txFDAbWMp-s,1380
 trilogy/core/statements/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-trilogy/core/statements/author.py,sha256=p3gLiPzXAHNNWVh8Xm9xECmywfG-LKDHB9U-Z6GdWCM,14246
+trilogy/core/statements/author.py,sha256=9wKZDwQ-BeaUCMjD9l0ffMMv8zivaYcAg12UhVFi-0Y,14248
 trilogy/core/statements/build.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/core/statements/common.py,sha256=KxEmz2ySySyZ6CTPzn0fJl5NX2KOk1RPyuUSwWhnK1g,759
 trilogy/core/statements/execute.py,sha256=cSlvpHFOqpiZ89pPZ5GDp9Hu6j6uj-5_h21FWm_L-KM,1248
@@ -71,8 +71,8 @@ trilogy/dialect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/dialect/base.py,sha256=u00kIIl98as1QzcduiiyyoBzxRGVeBxfeO5hWlRCAJU,40222
 trilogy/dialect/bigquery.py,sha256=mKC3zoEU232h9RtIXJjqiZ72lWH8a6S28p6wAZKrAfg,2952
 trilogy/dialect/common.py,sha256=cbTo_vamdp8pj9spSjGSH-bSZpy4FpNJ12k5vMvyT2Y,3942
-trilogy/dialect/config.py,sha256=e-ZDVh7Z648JYz85JwSobTyo2cTi4lYGFMglZzB7atM,3184
-trilogy/dialect/dataframe.py,sha256=ei5y91XyZHI3ydUbdQ2sInnw2qHGtgb21DNX6qff0xw,1419
+trilogy/dialect/config.py,sha256=EGYRQIbrkeMuud5Bkds7jSD5dCJR5hEYZUYcy-lYZl4,3308
+trilogy/dialect/dataframe.py,sha256=RUbNgReEa9g3pL6H7fP9lPTrAij5pkqedpZ99D8_5AE,1522
 trilogy/dialect/duckdb.py,sha256=2tH_OetgLJoKf_f4bdeeB0ozGC8f0h_xQ271I8qD-Oo,3690
 trilogy/dialect/enums.py,sha256=1KDgds_DC31hGxZzNI_TIggxXF7m9rIjn9KLgNf5WQU,4425
 trilogy/dialect/postgres.py,sha256=VH4EB4myjIeZTHeFU6vK00GxY9c53rCBjg2mLbdaCEE,3254
@@ -85,18 +85,18 @@ 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=yAE3x4SyO4PfAb7HhZ_l9sNPYaf_pcM1K8ioEy76SCU,20301
+trilogy/parsing/common.py,sha256=IgZ2K3LzJ0usLIwxRCRmS-4luP6uwmM-f1oqGNyGbm0,21306
 trilogy/parsing/config.py,sha256=Z-DaefdKhPDmSXLgg5V4pebhSB0h590vI0_VtHnlukI,111
 trilogy/parsing/exceptions.py,sha256=92E5i2frv5hj9wxObJZsZqj5T6bglvPzvdvco_vW1Zk,38
 trilogy/parsing/helpers.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-trilogy/parsing/parse_engine.py,sha256=32_yO_SreTjHxCkMziW2re15ilEZn01OUizVAvN9xHo,54656
+trilogy/parsing/parse_engine.py,sha256=uZ6MYjg6kkTm5HFfOKLGvVvzHiGgH-vY7lV-AIlIBgY,55701
 trilogy/parsing/render.py,sha256=o_XuQWhcwx1lD9eGVqkqZEwkmQK0HdmWWokGBtdeH4I,17837
-trilogy/parsing/trilogy.lark,sha256=EazfEvYPuvkPkNjUnVzFi0uD9baavugbSI8CyfawShk,12573
+trilogy/parsing/trilogy.lark,sha256=wZpqI1louDqm-t-TpmzW749dPA9w2EIAyowyEJIeXAM,12620
 trilogy/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/scripts/trilogy.py,sha256=1L0XrH4mVHRt1C9T1HnaDv2_kYEfbWTb5_-cBBke79w,3774
-pytrilogy-0.0.3.7.dist-info/LICENSE.md,sha256=5ZRvtTyCCFwz1THxDTjAu3Lidds9WjPvvzgVwPSYNDo,1042
-pytrilogy-0.0.3.7.dist-info/METADATA,sha256=wvr0oUtX0As37OC9ljg5XnV7rblzMNvUppA4il2PtPI,8983
-pytrilogy-0.0.3.7.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-pytrilogy-0.0.3.7.dist-info/entry_points.txt,sha256=0petKryjvvtEfTlbZC1AuMFumH_WQ9v8A19LvoS6G6c,54
-pytrilogy-0.0.3.7.dist-info/top_level.txt,sha256=cAy__NW_eMAa_yT9UnUNlZLFfxcg6eimUAZ184cdNiE,8
-pytrilogy-0.0.3.7.dist-info/RECORD,,
+pytrilogy-0.0.3.9.dist-info/LICENSE.md,sha256=5ZRvtTyCCFwz1THxDTjAu3Lidds9WjPvvzgVwPSYNDo,1042
+pytrilogy-0.0.3.9.dist-info/METADATA,sha256=8Bv3VIgAPpBlaRGc1UlrWrMPLb0HYNpy-coiUXMzzK0,8983
+pytrilogy-0.0.3.9.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+pytrilogy-0.0.3.9.dist-info/entry_points.txt,sha256=0petKryjvvtEfTlbZC1AuMFumH_WQ9v8A19LvoS6G6c,54
+pytrilogy-0.0.3.9.dist-info/top_level.txt,sha256=cAy__NW_eMAa_yT9UnUNlZLFfxcg6eimUAZ184cdNiE,8
+pytrilogy-0.0.3.9.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.7"
+__version__ = "0.0.3.9"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

trilogy/core/models/author.py

@@ -75,6 +75,9 @@ class Mergeable(ABC):
     def with_merge(self, source: Concept, target: Concept, modifiers: List[Modifier]):
         raise NotImplementedError
 
+    def with_reference_replacement(self, source: str, target: Expr):
+        raise NotImplementedError(type(self))
+
 
 class ConceptArgs(ABC):
     @property
@@ -152,6 +155,11 @@ class ConceptRef(Addressable, Namespaced, DataTyped, Mergeable, BaseModel):
             metadata=self.metadata,
         )
 
+    def with_reference_replacement(self, source: str, target: Expr):
+        if self.address == source:
+            return target
+        return self
+
 
 class UndefinedConcept(ConceptRef):
     pass
@@ -409,7 +417,7 @@ class Grain(Namespaced, BaseModel):
     ) -> Grain:
         from trilogy.parsing.common import concepts_to_grain_concepts
 
-        return Grain.model_construct(
+        x = Grain.model_construct(
             components={
                 c.address
                 for c in concepts_to_grain_concepts(concepts, environment=environment)
@@ -417,6 +425,8 @@ class Grain(Namespaced, BaseModel):
             where_clause=where_clause,
         )
 
+        return x
+
     def with_namespace(self, namespace: str) -> "Grain":
         return Grain.model_construct(
             components={address_with_namespace(c, namespace) for c in self.components},
@@ -537,6 +547,7 @@ class Comparison(ConceptArgs, Mergeable, Namespaced, BaseModel):
         MagicConstants,
         WindowItem,
         AggregateWrapper,
+        FilterItem,
     ]
     right: Union[
         int,
@@ -556,6 +567,7 @@ class Comparison(ConceptArgs, Mergeable, Namespaced, BaseModel):
         WindowItem,
         AggregateWrapper,
         TupleWrapper,
+        FilterItem,
     ]
     operator: ComparisonOperator
 
@@ -662,6 +674,21 @@ class Comparison(ConceptArgs, Mergeable, Namespaced, BaseModel):
             operator=self.operator,
         )
 
+    def with_reference_replacement(self, source, target):
+        return self.__class__.model_construct(
+            left=(
+                self.left.with_reference_replacement(source, target)
+                if isinstance(self.left, Mergeable)
+                else self.left
+            ),
+            right=(
+                self.right.with_reference_replacement(source, target)
+                if isinstance(self.right, Mergeable)
+                else self.right
+            ),
+            operator=self.operator,
+        )
+
     def with_namespace(self, namespace: str):
         return self.__class__.model_construct(
             left=(
@@ -1224,7 +1251,7 @@ class OrderItem(Mergeable, ConceptArgs, Namespaced, BaseModel):
     def with_merge(
         self, source: Concept, target: Concept, modifiers: List[Modifier]
     ) -> "OrderItem":
-        return OrderItem(
+        return OrderItem.model_construct(
             expr=(
                 self.expr.with_merge(source, target, modifiers)
                 if isinstance(self.expr, Mergeable)
@@ -1233,19 +1260,19 @@ class OrderItem(Mergeable, ConceptArgs, Namespaced, BaseModel):
             order=self.order,
         )
 
-    @property
-    def output(self):
-        return self.expr.output
+    def with_reference_replacement(self, source, target):
+        return OrderItem.model_construct(
+            expr=(
+                self.expr.with_reference_replacement(source, target)
+                if isinstance(self.expr, Mergeable)
+                else self.expr
+            ),
+            order=self.order,
+        )
 
     @property
     def concept_arguments(self) -> Sequence[ConceptRef]:
-        base: List[ConceptRef] = []
-        x = self.expr
-        if isinstance(x, ConceptRef):
-            base += [x]
-        elif isinstance(x, ConceptArgs):
-            base += x.concept_arguments
-        return base
+        return get_concept_arguments(self.expr)
 
     @property
     def row_arguments(self) -> Sequence[ConceptRef]:
@@ -1305,6 +1332,17 @@ class WindowItem(DataTyped, ConceptArgs, Mergeable, Namespaced, BaseModel):
         )
         return output
 
+    def with_reference_replacement(self, source, target):
+        return WindowItem.model_construct(
+            type=self.type,
+            content=self.content.with_reference_replacement(source, target),
+            over=[x.with_reference_replacement(source, target) for x in self.over],
+            order_by=[
+                x.with_reference_replacement(source, target) for x in self.order_by
+            ],
+            index=self.index,
+        )
+
     def with_namespace(self, namespace: str) -> "WindowItem":
         return WindowItem.model_construct(
             type=self.type,
@@ -1316,31 +1354,19 @@ class WindowItem(DataTyped, ConceptArgs, Mergeable, Namespaced, BaseModel):
 
     @property
     def concept_arguments(self) -> List[ConceptRef]:
-        return self.arguments
-
-    @property
-    def arguments(self) -> List[ConceptRef]:
         output = [self.content]
         for order in self.order_by:
-            output += [order.output]
+            output += get_concept_arguments(order)
         for item in self.over:
-            output += [item]
+            output += get_concept_arguments(item)
         return output
 
-    @property
-    def output(self) -> ConceptRef:
-        return self.content
-
     @property
     def output_datatype(self):
         if self.type in (WindowType.RANK, WindowType.ROW_NUMBER):
             return DataType.INTEGER
         return self.content.output_datatype
 
-    @property
-    def output_purpose(self):
-        return Purpose.PROPERTY
-
 
 def get_basic_type(
     type: DataType | ListType | StructType | MapType | NumericType,
@@ -1407,12 +1433,28 @@ class CaseWhen(Namespaced, ConceptArgs, Mergeable, BaseModel):
             ),
         )
 
+    def with_reference_replacement(self, source, target):
+        return CaseWhen.model_construct(
+            comparison=self.comparison.with_reference_replacement(source, target),
+            expr=(
+                self.expr.with_reference_replacement(source, target)
+                if isinstance(self.expr, Mergeable)
+                else self.expr
+            ),
+        )
+
 
 class CaseElse(Namespaced, ConceptArgs, Mergeable, BaseModel):
     expr: "Expr"
     # this ensures that it's easily differentiable from CaseWhen
     discriminant: ComparisonOperator = ComparisonOperator.ELSE
 
+    def __str__(self):
+        return self.__repr__()
+
+    def __repr__(self):
+        return f"ELSE {str(self.expr)}"
+
     @field_validator("expr", mode="before")
     def enforce_expr(cls, v):
         if isinstance(v, Concept):
@@ -1435,6 +1477,19 @@ class CaseElse(Namespaced, ConceptArgs, Mergeable, BaseModel):
             ),
         )
 
+    def with_reference_replacement(self, source, target):
+        return CaseElse.model_construct(
+            discriminant=self.discriminant,
+            expr=(
+                self.expr.with_reference_replacement(
+                    source,
+                    target,
+                )
+                if isinstance(self.expr, Mergeable)
+                else self.expr
+            ),
+        )
+
     def with_namespace(self, namespace: str) -> CaseElse:
         return CaseElse.model_construct(
             discriminant=self.discriminant,
@@ -1483,35 +1538,10 @@ class Function(DataTyped, ConceptArgs, Mergeable, Namespaced, BaseModel):
             List[Set[DataType]],
         ]
     ] = None
-    arguments: Sequence[
-        Union[
-            ConceptRef,
-            AggregateWrapper,
-            Function,
-            Parenthetical,
-            CaseWhen,
-            CaseElse,
-            WindowItem,
-            int,
-            float,
-            str,
-            date,
-            datetime,
-            MapWrapper[Any, Any],
-            DataType,
-            ListType,
-            MapType,
-            NumericType,
-            DatePart,
-            list,
-            ListWrapper[Any],
-        ]
-    ]
+    arguments: Sequence[FuncArgs]
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
-        if "datatype" in str(self):
-            raise SyntaxError(str(self))
 
     def __repr__(self):
         return f'{self.operator.value}({",".join([str(a) for a in self.arguments])})'
@@ -1597,6 +1627,29 @@ class Function(DataTyped, ConceptArgs, Mergeable, Namespaced, BaseModel):
                     )
         return v
 
+    def with_reference_replacement(self, source: str, target: Expr):
+        return Function.model_construct(
+            operator=self.operator,
+            arguments=[
+                (
+                    c.with_reference_replacement(
+                        source,
+                        target,
+                    )
+                    if isinstance(
+                        c,
+                        Mergeable,
+                    )
+                    else c
+                )
+                for c in self.arguments
+            ],
+            output_datatype=self.output_datatype,
+            output_purpose=self.output_purpose,
+            valid_inputs=self.valid_inputs,
+            arg_count=self.arg_count,
+        )
+
     def with_namespace(self, namespace: str) -> "Function":
         return Function.model_construct(
             operator=self.operator,
@@ -1658,10 +1711,13 @@ class Function(DataTyped, ConceptArgs, Mergeable, Namespaced, BaseModel):
         return base_grain
 
 
-class AggregateWrapper(Mergeable, ConceptArgs, Namespaced, BaseModel):
+class AggregateWrapper(Mergeable, DataTyped, ConceptArgs, Namespaced, BaseModel):
     function: Function
     by: List[ConceptRef] = Field(default_factory=list)
 
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
     @field_validator("by", mode="before")
     @classmethod
     def enforce_concept_ref(cls, v):
@@ -1693,10 +1749,6 @@ class AggregateWrapper(Mergeable, ConceptArgs, Namespaced, BaseModel):
     def output_purpose(self):
         return self.function.output_purpose
 
-    @property
-    def arguments(self):
-        return self.function.arguments
-
     def with_merge(self, source: Concept, target: Concept, modifiers: List[Modifier]):
         return AggregateWrapper.model_construct(
             function=self.function.with_merge(source, target, modifiers=modifiers),
@@ -1707,6 +1759,16 @@ class AggregateWrapper(Mergeable, ConceptArgs, Namespaced, BaseModel):
             ),
         )
 
+    def with_reference_replacement(self, source, target):
+        return AggregateWrapper.model_construct(
+            function=self.function.with_reference_replacement(source, target),
+            by=(
+                [c.with_reference_replacement(source, target) for c in self.by]
+                if self.by
+                else []
+            ),
+        )
+
     def with_namespace(self, namespace: str) -> "AggregateWrapper":
         return AggregateWrapper.model_construct(
             function=self.function.with_namespace(namespace),
@@ -1796,11 +1858,6 @@ class RowsetItem(Mergeable, ConceptArgs, Namespaced, BaseModel):
             rowset=self.rowset.with_namespace(namespace),
         )
 
-    @property
-    def arguments(self) -> List[ConceptRef]:
-        output = [self.content]
-        return output
-
     @property
     def output(self) -> ConceptRef:
         return self.content
@@ -1831,7 +1888,10 @@ class OrderBy(Mergeable, Namespaced, BaseModel):
 
     @property
     def concept_arguments(self):
-        return [x.expr for x in self.items]
+        base = []
+        for x in self.items:
+            base += x.concept_arguments
+        return base
 
 
 class AlignClause(Namespaced, BaseModel):
@@ -2088,6 +2148,11 @@ class Comment(BaseModel):
     text: str
 
 
+class ArgBinding(BaseModel):
+    name: str
+    default: Expr | None = None
+
+
 Expr = (
     MagicConstants
     | bool
@@ -2099,6 +2164,7 @@ Expr = (
     | datetime
     | TupleWrapper
     | ListWrapper
+    | MapWrapper
     | WindowItem
     | FilterItem
     | ConceptRef
@@ -2107,4 +2173,30 @@ Expr = (
     | Parenthetical
     | Function
     | AggregateWrapper
+    | CaseWhen
+    | CaseElse
+)
+
+FuncArgs = (
+    ConceptRef
+    | AggregateWrapper
+    | Function
+    | Parenthetical
+    | CaseWhen
+    | CaseElse
+    | WindowItem
+    | FilterItem
+    | int
+    | float
+    | str
+    | date
+    | datetime
+    | MapWrapper[Any, Any]
+    | DataType
+    | ListType
+    | MapType
+    | NumericType
+    | DatePart
+    | list
+    | ListWrapper[Any]
 )

trilogy/core/models/build.py

@@ -51,6 +51,7 @@ from trilogy.core.models.author import (
     ConceptRef,
     Conditional,
     FilterItem,
+    FuncArgs,
     Function,
     Grain,
     HavingClause,
@@ -1498,10 +1499,22 @@ class Factory:
 
     @build.register
     def _(self, base: Function) -> BuildFunction:
-
+        from trilogy.parsing.common import arbitrary_to_concept
+
+        raw_args: list[Concept | FuncArgs] = []
+        for arg in base.arguments:
+            # to do proper discovery, we need to inject virtual intermediate ocncepts
+            if isinstance(arg, (AggregateWrapper, FilterItem, WindowItem)):
+                narg = arbitrary_to_concept(
+                    arg,
+                    environment=self.environment,
+                )
+                raw_args.append(narg)
+            else:
+                raw_args.append(arg)
         new = BuildFunction.model_construct(
             operator=base.operator,
-            arguments=[self.build(c) for c in base.arguments],
+            arguments=[self.build(c) for c in raw_args],
             output_datatype=base.output_datatype,
             output_purpose=base.output_purpose,
             valid_inputs=base.valid_inputs,
@@ -1639,9 +1652,26 @@ class Factory:
 
     @build.register
     def _(self, base: Comparison) -> BuildComparison:
+        from trilogy.parsing.common import arbitrary_to_concept
+
+        left = base.left
+        if isinstance(left, AggregateWrapper):
+            left_c = arbitrary_to_concept(
+                left,
+                environment=self.environment,
+            )
+            left = left_c  # type: ignore
+        right = base.right
+        if isinstance(right, AggregateWrapper):
+            right_c = arbitrary_to_concept(
+                right,
+                environment=self.environment,
+            )
+
+            right = right_c  # type: ignore
         return BuildComparison.model_construct(
-            left=(self.build(base.left)),
-            right=(self.build(base.right)),
+            left=(self.build(left)),
+            right=(self.build(right)),
             operator=base.operator,
         )
 
@@ -1660,7 +1690,7 @@ class Factory:
         )
 
     @build.register
-    def _(self, base: RowsetItem):
+    def _(self, base: RowsetItem) -> BuildRowsetItem:
 
         factory = Factory(
             environment=self.environment,

trilogy/core/models/environment.py

@@ -9,6 +9,7 @@ from typing import (
     TYPE_CHECKING,
     Annotated,
     Any,
+    Callable,
     Dict,
     ItemsView,
     List,
@@ -189,7 +190,7 @@ class Environment(BaseModel):
     datasources: Annotated[
         EnvironmentDatasourceDict, PlainValidator(validate_datasources)
     ] = Field(default_factory=EnvironmentDatasourceDict)
-    functions: Dict[str, Function] = Field(default_factory=dict)
+    functions: Dict[str, Callable[..., Any]] = Field(default_factory=dict)
     data_types: Dict[str, DataType] = Field(default_factory=dict)
     named_statements: Dict[str, SelectLineage] = Field(default_factory=dict)
     imports: Dict[str, list[Import]] = Field(

trilogy/core/processing/node_generators/group_node.py

@@ -37,7 +37,7 @@ def gen_group_node(
         resolve_function_parent_concepts(concept, environment=environment), "address"
     )
     logger.info(
-        f"{padding(depth)}{LOGGER_PREFIX} parent concepts for {concept} are {[x.address for x in parent_concepts]} from group grain {concept.grain}"
+        f"{padding(depth)}{LOGGER_PREFIX} parent concepts for {concept} {concept.lineage} are {[x.address for x in parent_concepts]} from group grain {concept.grain}"
     )
 
     # if the aggregation has a grain, we need to ensure these are the ONLY optional in the output of the select

trilogy/core/processing/node_generators/multiselect_node.py

@@ -76,7 +76,7 @@ def gen_multiselect_node(
     for select in lineage.selects:
 
         snode: StrategyNode = get_query_node(history.base_environment, select)
-        # raise SyntaxError(select.output_components)
+
         logger.info(
             f"{padding(depth)}{LOGGER_PREFIX} Fetched parent node with outputs {select.output_components}"
         )

trilogy/core/statements/author.py

@@ -127,7 +127,9 @@ class SelectStatement(HasUUID, SelectTypeMixin, BaseModel):
             order_by=order_by,
             meta=meta or Metadata(),
         )
+
         output.grain = output.calculate_grain(environment)
+
         for x in selection:
 
             if x.is_undefined and environment.concepts.fail_on_missing:

trilogy/dialect/config.py

@@ -1,4 +1,10 @@
-from pandas import DataFrame
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    try:
+        from pandas import DataFrame
+    except ImportError:
+        DataFrame = Any
 
 
 class DialectConfig:
@@ -110,6 +116,6 @@ class TrinoConfig(PrestoConfig):
 
 
 class DataFrameConfig(DuckDBConfig):
-    def __init__(self, dataframes: dict[str, DataFrame]):
+    def __init__(self, dataframes: dict[str, "DataFrame"]):
         super().__init__()
         self.dataframes = dataframes

trilogy/dialect/dataframe.py

@@ -1,19 +1,24 @@
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
-from pandas import DataFrame
 from sqlalchemy import text
 
 from trilogy.core.models.environment import Environment
 from trilogy.dialect.duckdb import DuckDBDialect
 from trilogy.engine import ExecutionEngine
 
+if TYPE_CHECKING:
+    try:
+        from pandas import DataFrame
+    except ImportError:
+        DataFrame = Any
+
 
 class DataframeDialect(DuckDBDialect):
     pass
 
 
 class DataframeConnectionWrapper(ExecutionEngine):
-    def __init__(self, engine: ExecutionEngine, dataframes: dict[str, DataFrame]):
+    def __init__(self, engine: ExecutionEngine, dataframes: dict[str, "DataFrame"]):
         self.engine = engine
         self.dataframes = dataframes
         self.connection = None
@@ -34,7 +39,7 @@ class DataframeConnectionWrapper(ExecutionEngine):
                 )
         pass
 
-    def add_dataframe(self, name: str, df: DataFrame, connection, env: Environment):
+    def add_dataframe(self, name: str, df: "DataFrame", connection, env: Environment):
         self.dataframes[name] = df
         self._register_dataframes(env, connection)
 

trilogy/executor.py

@@ -166,8 +166,11 @@ class Executor(object):
         )
 
     @execute_query.register
-    def _(self, query: str) -> CursorResult:
-        return self.execute_text(query)[-1]
+    def _(self, query: str) -> CursorResult | None:
+        results = self.execute_text(query)
+        if results:
+            return results[-1]
+        return None
 
     @execute_query.register
     def _(self, query: SelectStatement) -> CursorResult:

trilogy/parsing/common.py

@@ -46,6 +46,63 @@ from trilogy.core.statements.author import RowsetDerivationStatement, SelectStat
 from trilogy.utility import string_to_hash, unique
 
 
+def process_function_arg(
+    arg,
+    meta: Meta | None,
+    environment: Environment,
+):
+    # if a function has an anonymous function argument
+    # create an implicit concept
+    if isinstance(arg, Parenthetical):
+        processed = process_function_args([arg.content], meta, environment)
+        return Function(
+            operator=FunctionType.PARENTHETICAL,
+            arguments=processed,
+            output_datatype=arg_to_datatype(processed[0]),
+            output_purpose=function_args_to_output_purpose(processed),
+        )
+    elif isinstance(arg, Function):
+        # if it's not an aggregate function, we can skip the virtual concepts
+        # to simplify anonymous function handling
+        if (
+            arg.operator not in FunctionClass.AGGREGATE_FUNCTIONS.value
+            and arg.operator != FunctionType.UNNEST
+        ):
+            return arg
+        id_hash = string_to_hash(str(arg))
+        name = f"{VIRTUAL_CONCEPT_PREFIX}_{arg.operator.value}_{id_hash}"
+        if f"{environment.namespace}.{name}" in environment.concepts:
+            return environment.concepts[f"{environment.namespace}.{name}"]
+        concept = function_to_concept(
+            arg,
+            name=name,
+            environment=environment,
+        )
+        # to satisfy mypy, concept will always have metadata
+        if concept.metadata and meta:
+            concept.metadata.line_number = meta.line
+        environment.add_concept(concept, meta=meta)
+        return concept
+    elif isinstance(
+        arg,
+        (ListWrapper, MapWrapper),
+    ):
+        id_hash = string_to_hash(str(arg))
+        name = f"{VIRTUAL_CONCEPT_PREFIX}_{id_hash}"
+        if f"{environment.namespace}.{name}" in environment.concepts:
+            return environment.concepts[f"{environment.namespace}.{name}"]
+        concept = arbitrary_to_concept(
+            arg,
+            name=name,
+            environment=environment,
+        )
+        if concept.metadata and meta:
+            concept.metadata.line_number = meta.line
+        environment.add_concept(concept, meta=meta)
+        return concept
+    return arg
+
+
 def process_function_args(
     args,
     meta: Meta | None,
@@ -53,54 +110,7 @@ def process_function_args(
 ) -> List[Concept | Function | str | int | float | date | datetime]:
     final: List[Concept | Function | str | int | float | date | datetime] = []
     for arg in args:
-        # if a function has an anonymous function argument
-        # create an implicit concept
-        if isinstance(arg, Parenthetical):
-            processed = process_function_args([arg.content], meta, environment)
-            final.append(
-                Function(
-                    operator=FunctionType.PARENTHETICAL,
-                    arguments=processed,
-                    output_datatype=arg_to_datatype(processed[0]),
-                    output_purpose=function_args_to_output_purpose(processed),
-                )
-            )
-        elif isinstance(arg, Function):
-            # if it's not an aggregate function, we can skip the virtual concepts
-            # to simplify anonymous function handling
-            if (
-                arg.operator not in FunctionClass.AGGREGATE_FUNCTIONS.value
-                and arg.operator != FunctionType.UNNEST
-            ):
-                final.append(arg)
-                continue
-            id_hash = string_to_hash(str(arg))
-            concept = function_to_concept(
-                arg,
-                name=f"{VIRTUAL_CONCEPT_PREFIX}_{arg.operator.value}_{id_hash}",
-                environment=environment,
-            )
-            # to satisfy mypy, concept will always have metadata
-            if concept.metadata and meta:
-                concept.metadata.line_number = meta.line
-            environment.add_concept(concept, meta=meta)
-            final.append(concept)
-        elif isinstance(
-            arg, (FilterItem, WindowItem, AggregateWrapper, ListWrapper, MapWrapper)
-        ):
-            id_hash = string_to_hash(str(arg))
-            concept = arbitrary_to_concept(
-                arg,
-                name=f"{VIRTUAL_CONCEPT_PREFIX}_{id_hash}",
-                environment=environment,
-            )
-            if concept.metadata and meta:
-                concept.metadata.line_number = meta.line
-            environment.add_concept(concept, meta=meta)
-            final.append(concept)
-
-        else:
-            final.append(arg)
+        final.append(process_function_arg(arg, meta, environment))
     return final
 
 
@@ -240,6 +250,24 @@ def concepts_to_grain_concepts(
     return v2
 
 
+def get_relevant_parent_concepts(arg) -> tuple[list[ConceptRef], bool]:
+    from trilogy.core.models.author import get_concept_arguments
+
+    is_metric = False
+    if isinstance(arg, Function):
+        all = []
+        for y in arg.arguments:
+            refs, local_flag = get_relevant_parent_concepts(y)
+            all += refs
+            is_metric = is_metric or local_flag
+        return all, is_metric
+    elif isinstance(arg, AggregateWrapper) and not arg.by:
+        return [], True
+    elif isinstance(arg, AggregateWrapper) and arg.by:
+        return arg.by, True
+    return get_concept_arguments(arg), False
+
+
 def function_to_concept(
     parent: Function,
     name: str,
@@ -247,14 +275,12 @@ def function_to_concept(
     namespace: str | None = None,
     metadata: Metadata | None = None,
 ) -> Concept:
+
     pkeys: List[Concept] = []
     namespace = namespace or environment.namespace
-    concrete_args = [
-        x
-        for x in [environment.concepts[c.address] for c in parent.concept_arguments]
-        if not isinstance(x, UndefinedConcept)
-    ]
-
+    is_metric = False
+    ref_args, is_metric = get_relevant_parent_concepts(parent)
+    concrete_args = [environment.concepts[c.address] for c in ref_args]
     pkeys += [x for x in concrete_args if not x.derivation == Derivation.CONSTANT]
     grain: Grain | None = Grain()
     for x in pkeys:
@@ -265,12 +291,18 @@ def function_to_concept(
     modifiers = get_upstream_modifiers(pkeys, environment)
     key_grain: list[str] = []
     for x in pkeys:
-        if x.keys:
+        # metrics will group to keys, so do no do key traversal
+        if is_metric:
+            key_grain.append(x.address)
+        # otherwse, for row ops, assume keys are transitive
+        elif x.keys:
             key_grain += [*x.keys]
         else:
             key_grain.append(x.address)
     keys = set(key_grain)
-    if not pkeys:
+    if is_metric:
+        purpose = Purpose.METRIC
+    elif not pkeys:
         purpose = Purpose.CONSTANT
     else:
         purpose = parent.output_purpose

trilogy/parsing/parse_engine.py

@@ -4,7 +4,7 @@ from enum import Enum
 from os.path import dirname, join
 from pathlib import Path
 from re import IGNORECASE
-from typing import List, Optional, Tuple, Union
+from typing import Callable, List, Optional, Tuple, Union
 
 from lark import Lark, ParseTree, Transformer, Tree, v_args
 from lark.exceptions import (
@@ -49,6 +49,7 @@ from trilogy.core.models.author import (
     AggregateWrapper,
     AlignClause,
     AlignItem,
+    ArgBinding,
     CaseElse,
     CaseWhen,
     Comment,
@@ -61,6 +62,7 @@ from trilogy.core.models.author import (
     Function,
     Grain,
     HavingClause,
+    Mergeable,
     Metadata,
     OrderBy,
     OrderItem,
@@ -1075,27 +1077,45 @@ class ParseToObjects(Transformer):
         return HavingClause(conditional=root)
 
     @v_args(meta=True)
-    def function_binding_list(self, meta: Meta, args) -> Concept:
+    def function_binding_list(self, meta: Meta, args) -> list[ArgBinding]:
         return args
 
     @v_args(meta=True)
-    def function_binding_item(self, meta: Meta, args) -> Concept:
-        return args
+    def function_binding_item(self, meta: Meta, args) -> ArgBinding:
+        if len(args) == 2:
+            return ArgBinding(name=args[0], default=args[1])
+        return ArgBinding(name=args[0], default=None)
 
     @v_args(meta=True)
-    def raw_function(self, meta: Meta, args) -> Function:
+    def raw_function(self, meta: Meta, args) -> Callable[[list[Expr]], Expr]:
         identity = args[0]
-        fargs = args[1]
+        function_arguments: list[ArgBinding] = args[1]
         output = args[2]
-        item = Function(
-            operator=FunctionType.SUM,
-            arguments=[x[1] for x in fargs],
-            output_datatype=output,
-            output_purpose=Purpose.PROPERTY,
-            arg_count=len(fargs) + 1,
-        )
-        self.environment.functions[identity] = item
-        return item
+
+        def function_factory(*creation_args: list[Expr]):
+            nout = output.copy(deep=True)
+            creation_arg_list: list[Expr] = list(creation_args)
+            if len(creation_args) < len(function_arguments):
+                for binding in function_arguments[len(creation_arg_list) :]:
+                    if binding.default is None:
+                        raise ValueError(f"Missing argument {binding.name}")
+                    creation_arg_list.append(binding.default)
+            if isinstance(nout, Mergeable):
+                for idx, x in enumerate(creation_arg_list):
+                    # these will always be local namespace
+                    nout = nout.with_reference_replacement(
+                        f"{DEFAULT_NAMESPACE}.{function_arguments[idx].name}", x
+                    )
+            return nout
+
+        self.environment.functions[identity] = function_factory
+        return function_factory
+
+    def custom_function(self, args):
+        name = args[0]
+        args = args[1:]
+        remapped = self.environment.functions[name](*args)
+        return remapped
 
     @v_args(meta=True)
     def function(self, meta: Meta, args) -> Function:
@@ -1141,24 +1161,24 @@ class ParseToObjects(Transformer):
     def comparison(self, args) -> Comparison:
         if args[1] == ComparisonOperator.IN:
             raise SyntaxError
-        if isinstance(args[0], AggregateWrapper):
-            left_c = arbitrary_to_concept(
-                args[0],
-                environment=self.environment,
-            )
-            self.environment.add_concept(left_c)
-            left = left_c.reference
-        else:
-            left = args[0]
-        if isinstance(args[2], AggregateWrapper):
-            right_c = arbitrary_to_concept(
-                args[2],
-                environment=self.environment,
-            )
-            self.environment.add_concept(right_c)
-            right = right_c.reference
-        else:
-            right = args[2]
+        # if isinstance(args[0], AggregateWrapper):
+        #     left_c = arbitrary_to_concept(
+        #         args[0],
+        #         environment=self.environment,
+        #     )
+        #     self.environment.add_concept(left_c)
+        #     left = left_c.reference
+        # else:
+        left = args[0]
+        # if isinstance(args[2], AggregateWrapper):
+        #     right_c = arbitrary_to_concept(
+        #         args[2],
+        #         environment=self.environment,
+        #     )
+        #     self.environment.add_concept(right_c)
+        #     right = right_c.reference
+        # else:
+        right = args[2]
         return Comparison(left=left, right=right, operator=args[1])
 
     def between_comparison(self, args) -> Conditional:

trilogy/parsing/trilogy.lark

@@ -89,9 +89,9 @@
 
     // FUNCTION blocks
     function: raw_function
-    function_binding_item: IDENTIFIER ":" data_type
-    function_binding_list: function_binding_item ("," function_binding_item )* ","?
-    raw_function: "bind" "sql"  IDENTIFIER  "("  function_binding_list ")" "->" data_type "as"i MULTILINE_STRING
+    function_binding_item: IDENTIFIER ("=" literal)?
+    function_binding_list: (function_binding_item ",")* function_binding_item ","?
+    raw_function: "def"  IDENTIFIER  "("  function_binding_list ")" "->" expr
     
     // user_id where state = Mexico
     _filter_alt: IDENTIFIER "?" conditional
@@ -178,7 +178,7 @@
     map_key_access: expr "[" string_lit "]"
     attr_access: expr  "." string_lit 
 
-    expr:  _constant_functions | window_item | filter_item | subselect_comparison | between_comparison |  fgroup |  aggregate_functions | unnest | union | _static_functions |  literal |  concept_lit  | index_access |  map_key_access | attr_access | parenthetical | expr_tuple | comparison |  alt_like 
+    expr:  _constant_functions | window_item | filter_item | subselect_comparison | between_comparison |  fgroup |  aggregate_functions | unnest | union | _static_functions |  literal |  concept_lit  | index_access |  map_key_access | attr_access | parenthetical | expr_tuple | comparison |  alt_like | custom_function 
     
     // functions
     
@@ -297,6 +297,8 @@
     
     _static_functions:  _string_functions | _math_functions | _generic_functions |  _date_functions
 
+    custom_function:  "@" IDENTIFIER  "(" (expr ",")* expr ")"
+
     // base language constructs
     concept_lit: IDENTIFIER
     IDENTIFIER: /[a-zA-Z\_][a-zA-Z0-9\_\.]*/