pytrilogy 0.0.3.48__py3-none-any.whl → 0.0.3.52__py3-none-any.whl

{pytrilogy-0.0.3.48.dist-info → pytrilogy-0.0.3.52.dist-info}/METADATA

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

{pytrilogy-0.0.3.48.dist-info → pytrilogy-0.0.3.52.dist-info}/RECORD

@@ -1,5 +1,5 @@
-pytrilogy-0.0.3.48.dist-info/licenses/LICENSE.md,sha256=5ZRvtTyCCFwz1THxDTjAu3Lidds9WjPvvzgVwPSYNDo,1042
-trilogy/__init__.py,sha256=X7jtGsMd3bHz73UVPQxZzoipqeTD3gI4UEQZtAq3OUs,303
+pytrilogy-0.0.3.52.dist-info/licenses/LICENSE.md,sha256=5ZRvtTyCCFwz1THxDTjAu3Lidds9WjPvvzgVwPSYNDo,1042
+trilogy/__init__.py,sha256=3lpAbpHzxQ6c0SUaZfiuOcDzIS6IZ5DyK1fl8FmZ3hE,303
 trilogy/compiler.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/constants.py,sha256=5eQxk1A0pv-TQk3CCvgZCFA9_K-6nxrOm7E5Lxd7KIY,1652
 trilogy/engine.py,sha256=OK2RuqCIUId6yZ5hfF8J1nxGP0AJqHRZiafcowmW0xc,1728
@@ -11,37 +11,37 @@ 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=JwbWyAHOC2xRTZe2SeEvlIGPvmC1KjcJ4uh1Po5USzQ,7380
+trilogy/core/enums.py,sha256=uZTi9K6PEpQ1oFV4OpHlC1NUSxrmAFdQBfRyy9Rba-8,7440
 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=4fEOGgXWDvgrJtCg_5m2Y9iWnHfLbvLQ82RkIMl_1K0,27722
+trilogy/core/functions.py,sha256=OIcaftda-afXrHMSvPksLbRTwPUwQHAIpy9l78EBZVU,28643
 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/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-trilogy/core/models/author.py,sha256=NhTKuk1eYAuYBbpvaFUxr-LntIoVarFQlNuNJwZmMmw,76990
-trilogy/core/models/build.py,sha256=MPiHgyfOumZ8zF3iB61pzrAeDAlGV2F9R0Dw7mTTyqQ,62708
+trilogy/core/models/author.py,sha256=KKW_3A1hdwq7D2dFwI6xZanukPuCQQ23R4GzE5VRJ6c,77206
+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=m_GodtQkhuPo5kyBNlfC9c_jgprV7M64kE6x_12_ExQ,34616
+trilogy/core/models/execute.py,sha256=ucxMwsu5OMoP0E4pVKtkCNU0nogElJKQAqfu3arE4Jo,34879
 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/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=tgLNXlwObWhcQmBGz8xpN4p-mFZ9Hl74VplQqDm86us,44105
+trilogy/core/processing/concept_strategies_v3.py,sha256=8Wos5d9_tzfnzSbejb36QL4uoGPQ3GiwP27u_a4JrcE,44097
 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/basic_node.py,sha256=UVsXMn6jTjm_ofVFt218jAS11s4RV4zD781vP4im-GI,3371
-trilogy/core/processing/node_generators/common.py,sha256=nVeH_AdO58ygtNSO0wNgMR7_h2D0dFSGM_rh1fJd4Yc,9468
-trilogy/core/processing/node_generators/filter_node.py,sha256=JymSKzA-9oQAZ3ZtJRK9c3w5FXs8MjJBGWU9TYUqx4E,9099
-trilogy/core/processing/node_generators/group_node.py,sha256=ISv2lLnr5m5nMpiXYJbgBqfUPQqeypjCAcaool9Kvnk,6109
+trilogy/core/processing/node_generators/common.py,sha256=PdysdroW9DUADP7f5Wv_GKPUyCTROZV1g3L45fawxi8,9443
+trilogy/core/processing/node_generators/filter_node.py,sha256=0hdfiS2I-Jvr6P-il3jnAJK-g-DMG7_cFbZGCnLnJAo,10032
+trilogy/core/processing/node_generators/group_node.py,sha256=nIfiMrJQEksUfqAeeA3X5PS1343y4lmPTipYuCa-rvs,6141
 trilogy/core/processing/node_generators/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
@@ -55,7 +55,7 @@ trilogy/core/processing/node_generators/window_node.py,sha256=RUHgpYovQObFod1xRI
 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=FHrY8GsTKPuMJklOjILbhGqCt5s1nmlj62Z-molARDA,16835
+trilogy/core/processing/nodes/base_node.py,sha256=z-aZEVjnLdFm6TpmneEm2bnRXj-tRFr7mN7DYG4zH9A,16967
 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
@@ -64,17 +64,17 @@ 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=JXJ0iVRlSEM2IBr1TANym2RaUf_p5E_l2sNykRzXWDo,1710
 trilogy/core/statements/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-trilogy/core/statements/author.py,sha256=2q0yvP_0AbExdXnASlLG7OaDcM7sBaRco6YALnrQwzg,15255
+trilogy/core/statements/author.py,sha256=jCwPXmnjj8u2ytBRAS_NU7ga0uB7k3_TZY6dZSIMl9Y,15253
 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
 trilogy/dialect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-trilogy/dialect/base.py,sha256=RkfNoNSo46p-WCafAWC5tXqJ_FMZEXANLyZSqX7_Pxw,42082
-trilogy/dialect/bigquery.py,sha256=7LcgPLDkeNBk6YTfaE-RBBi7SjWFV-jjuvZM1VMIXqk,3350
+trilogy/dialect/base.py,sha256=lZup3hq-DyYczpG260a0wBByHyOGkbw4-yrPJvXKOM4,42300
+trilogy/dialect/bigquery.py,sha256=mGnBl5A3rVi4f1gt74jnaxSOCheA07OcRi6ZD8KWOGg,3436
 trilogy/dialect/common.py,sha256=JQ8ONloalaWEXsTTWUhZcYyzMRaZ9HdUw7cN6QWtY5c,5295
 trilogy/dialect/config.py,sha256=olnyeVU5W5T6b9-dMeNAnvxuPlyc2uefb7FRME094Ec,3834
 trilogy/dialect/dataframe.py,sha256=RUbNgReEa9g3pL6H7fP9lPTrAij5pkqedpZ99D8_5AE,1522
-trilogy/dialect/duckdb.py,sha256=XTBK4RhE1_wF2_IA_7c2W5ih0uxZx0wZ1mfJ3YFIuso,3768
+trilogy/dialect/duckdb.py,sha256=IQzaRaCv5c6TUDERhbsLM4uTW0aGkO_DrAMR5k_j7TU,3861
 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
@@ -86,13 +86,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=u7V8uc2mdBtszVujk-hzllfDAqM3j5pKd8B9UEj-uNc,29223
+trilogy/parsing/common.py,sha256=g1RmQF4fS_OgkcC6j4hnKIcn_ap0fFa_kzNUlH5D0nA,29760
 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=K3TwjCiiZtG3UrICF9Alik56_KPusVNWfqE-oUaKfho,68664
+trilogy/parsing/parse_engine.py,sha256=p2YnE-YV-Dt0FlC6rP7Rq8phNxzk_O4ukNzVIDyHyu4,70054
 trilogy/parsing/render.py,sha256=hI4y-xjXrEXvHslY2l2TQ8ic0zAOpN41ADH37J2_FZY,19047
-trilogy/parsing/trilogy.lark,sha256=q15J3P71yA_4lsWjC1vb7eDTemkJGLPKYvf5Hn9IBIk,13584
+trilogy/parsing/trilogy.lark,sha256=ijY6220e2hV21F1XFsvpYRimSrpNGIdjP7b0TVz7caI,13814
 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
@@ -101,8 +101,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.48.dist-info/METADATA,sha256=xuGEKV1ZdJtS-uES50q5bj5x-_60E4Pb6VL5G_SKzNQ,9095
-pytrilogy-0.0.3.48.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
-pytrilogy-0.0.3.48.dist-info/entry_points.txt,sha256=ewBPU2vLnVexZVnB-NrVj-p3E-4vukg83Zk8A55Wp2w,56
-pytrilogy-0.0.3.48.dist-info/top_level.txt,sha256=cAy__NW_eMAa_yT9UnUNlZLFfxcg6eimUAZ184cdNiE,8
-pytrilogy-0.0.3.48.dist-info/RECORD,,
+pytrilogy-0.0.3.52.dist-info/METADATA,sha256=TIB3nLBjPqlhtsB-ZgL61mCM8MPkXdJkhB-nAIuhdcA,9095
+pytrilogy-0.0.3.52.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+pytrilogy-0.0.3.52.dist-info/entry_points.txt,sha256=ewBPU2vLnVexZVnB-NrVj-p3E-4vukg83Zk8A55Wp2w,56
+pytrilogy-0.0.3.52.dist-info/top_level.txt,sha256=cAy__NW_eMAa_yT9UnUNlZLFfxcg6eimUAZ184cdNiE,8
+pytrilogy-0.0.3.52.dist-info/RECORD,,

{pytrilogy-0.0.3.48.dist-info → pytrilogy-0.0.3.52.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.4.0)
+Generator: setuptools (80.7.1)
 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.48"
+__version__ = "0.0.3.52"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

trilogy/core/enums.py

@@ -131,6 +131,7 @@ class FunctionType(Enum):
     CONSTANT = "constant"
     COALESCE = "coalesce"
     IS_NULL = "isnull"
+    NULLIF = "nullif"
     BOOL = "bool"
 
     # COMPLEX
@@ -156,6 +157,8 @@ class FunctionType(Enum):
     ABS = "abs"
     SQRT = "sqrt"
     RANDOM = "random"
+    FLOOR = "floor"
+    CEIL = "ceil"
 
     # Aggregates
     ## group is not a real aggregate - it just means group by this + some other set of fields

trilogy/core/functions.py

@@ -279,6 +279,12 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
         output_purpose=Purpose.PROPERTY,
         arg_count=1,
     ),
+    FunctionType.NULLIF: FunctionConfig(
+        valid_inputs={*DataType},
+        output_purpose=Purpose.PROPERTY,
+        output_type_function=lambda args: get_output_type_at_index(args, 0),
+        arg_count=2,
+    ),
     FunctionType.COALESCE: FunctionConfig(
         valid_inputs={*DataType},
         output_purpose=Purpose.PROPERTY,
@@ -637,6 +643,22 @@ FUNCTION_REGISTRY: dict[FunctionType, FunctionConfig] = {
         output_type_function=lambda args: get_output_type_at_index(args, 0),
         arg_count=2,
     ),
+    FunctionType.FLOOR: FunctionConfig(
+        valid_inputs=[
+            {DataType.INTEGER, DataType.FLOAT, DataType.NUMBER, DataType.NUMERIC},
+        ],
+        output_purpose=Purpose.PROPERTY,
+        output_type=DataType.INTEGER,
+        arg_count=1,
+    ),
+    FunctionType.CEIL: FunctionConfig(
+        valid_inputs=[
+            {DataType.INTEGER, DataType.FLOAT, DataType.NUMBER, DataType.NUMERIC},
+        ],
+        output_purpose=Purpose.PROPERTY,
+        output_type=DataType.INTEGER,
+        arg_count=1,
+    ),
     FunctionType.CUSTOM: FunctionConfig(
         output_purpose=Purpose.PROPERTY,
         arg_count=InfiniteFunctionArgs,
@@ -787,13 +809,14 @@ def create_function_derived_concept(
     namespace: str,
     operator: FunctionType,
     arguments: list[Concept],
+    environment: Environment,
     output_type: Optional[
         DataType | ListType | StructType | MapType | NumericType | TraitDataType
     ] = None,
     output_purpose: Optional[Purpose] = None,
 ) -> Concept:
     purpose = (
-        function_args_to_output_purpose(arguments)
+        function_args_to_output_purpose(arguments, environment=environment)
         if output_purpose is None
         else output_purpose
     )
@@ -846,13 +869,15 @@ def argument_to_purpose(arg) -> Purpose:
         raise ValueError(f"Cannot parse arg purpose for {arg} of type {type(arg)}")
 
 
-def function_args_to_output_purpose(args) -> Purpose:
+def function_args_to_output_purpose(args, environment: Environment) -> Purpose:
     has_metric = False
     has_non_constant = False
     has_non_single_row_constant = False
     if not args:
         return Purpose.CONSTANT
     for arg in args:
+        if isinstance(arg, ConceptRef):
+            arg = environment.concepts[arg.address]
         purpose = argument_to_purpose(arg)
         if purpose == Purpose.METRIC:
             has_metric = True

trilogy/core/models/author.py

@@ -25,6 +25,7 @@ from pydantic import (
     ValidationInfo,
     computed_field,
     field_validator,
+    model_validator,
 )
 
 from trilogy.constants import DEFAULT_NAMESPACE, MagicConstants
@@ -621,8 +622,8 @@ class Comparison(ConceptArgs, Mergeable, DataTyped, Namespaced, BaseModel):
             return v.reference
         return v
 
-    def __init__(self, *args, **kwargs) -> None:
-        super().__init__(*args, **kwargs)
+    @model_validator(mode="after")
+    def validate_comparison(self):
         if self.operator in (ComparisonOperator.IS, ComparisonOperator.IS_NOT):
             if self.right != MagicConstants.NULL and DataType.BOOL != arg_to_datatype(
                 self.right
@@ -632,7 +633,6 @@ class Comparison(ConceptArgs, Mergeable, DataTyped, Namespaced, BaseModel):
                 )
         elif self.operator in (ComparisonOperator.IN, ComparisonOperator.NOT_IN):
             right_type = arg_to_datatype(self.right)
-
             if isinstance(right_type, ListType) and not is_compatible_datatype(
                 arg_to_datatype(self.left), right_type.value_data_type
             ):
@@ -653,6 +653,8 @@ class Comparison(ConceptArgs, Mergeable, DataTyped, Namespaced, BaseModel):
                     f"Cannot compare {arg_to_datatype(self.left)} and {arg_to_datatype(self.right)} of different types with operator {self.operator} in {str(self)}"
                 )
 
+        return self
+
     def __add__(self, other):
         if other is None:
             return self
@@ -1022,7 +1024,7 @@ class Concept(Addressable, DataTyped, ConceptArgs, Mergeable, Namespaced, BaseMo
         keys = self.keys
 
         if self.is_aggregate and isinstance(new_lineage, Function) and grain.components:
-            grain_components = [
+            grain_components: list[ConceptRef | Concept] = [
                 environment.concepts[c].reference for c in grain.components
             ]
             new_lineage = AggregateWrapper(function=new_lineage, by=grain_components)
@@ -1847,9 +1849,6 @@ class AggregateWrapper(Mergeable, DataTyped, ConceptArgs, Namespaced, BaseModel)
     function: Function
     by: List[ConceptRef | Concept] = Field(default_factory=list)
 
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
     @field_validator("by", mode="before")
     @classmethod
     def enforce_concept_ref(cls, v):
@@ -1945,11 +1944,15 @@ class FilterItem(DataTyped, Namespaced, ConceptArgs, BaseModel):
 
     @property
     def output_datatype(self):
-        return self.content.datatype
+        return arg_to_datatype(self.content)
 
     @property
     def concept_arguments(self):
-        return [self.content] + self.where.concept_arguments
+        if isinstance(self.content, ConceptRef):
+            return [self.content] + self.where.concept_arguments
+        elif isinstance(self.content, ConceptArgs):
+            return self.content.concept_arguments + self.where.concept_arguments
+        return self.where.concept_arguments
 
 
 class RowsetLineage(Namespaced, Mergeable, BaseModel):

trilogy/core/models/build.py

@@ -262,11 +262,8 @@ class BuildGrain(BaseModel):
     components: set[str] = Field(default_factory=set)
     where_clause: Optional[BuildWhereClause] = None
 
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
     def without_condition(self):
-        return BuildGrain(components=self.components)
+        return BuildGrain.model_construct(components=self.components)
 
     @classmethod
     def from_concepts(
@@ -321,12 +318,12 @@ class BuildGrain(BaseModel):
                 # raise NotImplementedError(
                 #     f"Cannot merge grains with where clauses, self {self.where_clause} other {other.where_clause}"
                 # )
-        return BuildGrain(
+        return BuildGrain.model_construct(
             components=self.components.union(other.components), where_clause=where
         )
 
     def __sub__(self, other: "BuildGrain") -> "BuildGrain":
-        return BuildGrain(
+        return BuildGrain.model_construct(
             components=self.components.difference(other.components),
             where_clause=self.where_clause,
         )
@@ -637,9 +634,6 @@ class BuildComparison(BuildConceptArgs, ConstantInlineable, BaseModel):
     ]
     operator: ComparisonOperator
 
-    def __init__(self, *args, **kwargs) -> None:
-        super().__init__(*args, **kwargs)
-
     def __add__(self, other):
         if other is None:
             return self
@@ -1173,7 +1167,7 @@ class BuildAggregateWrapper(BuildConceptArgs, DataTyped, BaseModel):
 
 
 class BuildFilterItem(BuildConceptArgs, BaseModel):
-    content: BuildConcept
+    content: "BuildExpr"
     where: BuildWhereClause
 
     def __str__(self):
@@ -1181,15 +1175,27 @@ class BuildFilterItem(BuildConceptArgs, BaseModel):
 
     @property
     def output_datatype(self):
-        return self.content.datatype
+        return arg_to_datatype(self.content)
 
     @property
     def output_purpose(self):
         return self.content.purpose
 
+    @property
+    def content_concept_arguments(self):
+        if isinstance(self.content, BuildConcept):
+            return [self.content]
+        elif isinstance(self.content, BuildConceptArgs):
+            return self.content.concept_arguments
+        return []
+
     @property
     def concept_arguments(self):
-        return [self.content] + self.where.concept_arguments
+        if isinstance(self.content, BuildConcept):
+            return [self.content] + self.where.concept_arguments
+        elif isinstance(self.content, BuildConceptArgs):
+            return self.content.concept_arguments + self.where.concept_arguments
+        return self.where.concept_arguments
 
 
 class BuildRowsetLineage(BuildConceptArgs, BaseModel):

trilogy/core/models/execute.py

@@ -1,9 +1,16 @@
 from __future__ import annotations
 
 from collections import defaultdict
-from typing import Any, Dict, List, Optional, Set, Union
-
-from pydantic import BaseModel, Field, ValidationInfo, computed_field, field_validator
+from typing import Dict, List, Optional, Set, Union
+
+from pydantic import (
+    BaseModel,
+    Field,
+    ValidationInfo,
+    computed_field,
+    field_validator,
+    model_validator,
+)
 
 from trilogy.constants import CONFIG, logger
 from trilogy.core.constants import CONSTANT_DATASET
@@ -473,8 +480,8 @@ class BaseJoin(BaseModel):
     left_datasource: Optional[Union[BuildDatasource, "QueryDatasource"]] = None
     concept_pairs: list[ConceptPair] | None = None
 
-    def __init__(self, **data: Any):
-        super().__init__(**data)
+    @model_validator(mode="after")
+    def validate_join(self) -> "BaseJoin":
         if (
             self.left_datasource
             and self.left_datasource.identifier == self.right_datasource.identifier
@@ -483,14 +490,18 @@ class BaseJoin(BaseModel):
                 f"Cannot join a dataself to itself, joining {self.left_datasource} and"
                 f" {self.right_datasource}"
             )
-        final_concepts = []
 
-        # if we have a list of concept pairs
+        # Early returns maintained as in original code
         if self.concept_pairs:
-            return
+            return self
+
         if self.concepts == []:
-            return
+            return self
+
+        # Validation logic
+        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]:
@@ -507,6 +518,7 @@ class BaseJoin(BaseModel):
                     )
             if include:
                 final_concepts.append(concept)
+
         if not final_concepts and self.concepts:
             # if one datasource only has constants
             # we can join on 1=1
@@ -519,11 +531,11 @@ class BaseJoin(BaseModel):
                     ]
                 ):
                     self.concepts = []
-                    return
+                    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
+                    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]
@@ -535,7 +547,9 @@ class BaseJoin(BaseModel):
                 f" right_keys {right_keys},"
                 f" provided join concepts {match_concepts}"
             )
+
         self.concepts = final_concepts
+        return self
 
     @property
     def unique_id(self) -> str:
@@ -695,7 +709,7 @@ class QueryDatasource(BaseModel):
                 "can only merge two datasources if the force_group flag is the same"
             )
         logger.debug(
-            f"{LOGGER_PREFIX} merging {self.name} with"
+            f"[Query Datasource] merging {self.name} with"
             f" {[c.address for c in self.output_concepts]} concepts and"
             f" {other.name} with {[c.address for c in other.output_concepts]} concepts"
         )
@@ -759,7 +773,9 @@ class QueryDatasource(BaseModel):
             hidden_concepts=hidden,
             ordering=self.ordering,
         )
-
+        logger.debug(
+            f"[Query Datasource] merged with {[c.address for c in qds.output_concepts]} concepts"
+        )
         return qds
 
     @property

trilogy/core/processing/concept_strategies_v3.py

@@ -319,7 +319,7 @@ def generate_node(
         ]
 
         logger.info(
-            f"{depth_to_prefix(depth)}{LOGGER_PREFIX} for {concept.address}, generating aggregate node with {[x.address for x in agg_optional]}"
+            f"{depth_to_prefix(depth)}{LOGGER_PREFIX} for {concept.address}, generating aggregate node with {[x for x in agg_optional]}"
         )
         return gen_group_node(
             concept,

trilogy/core/processing/node_generators/common.py

@@ -67,14 +67,14 @@ def resolve_condition_parent_concepts(
 def resolve_filter_parent_concepts(
     concept: BuildConcept,
     environment: BuildEnvironment,
-) -> Tuple[BuildConcept, List[BuildConcept], List[Tuple[BuildConcept, ...]]]:
+) -> Tuple[List[BuildConcept], List[Tuple[BuildConcept, ...]]]:
     if not isinstance(concept.lineage, (BuildFilterItem,)):
         raise ValueError(
             f"Concept {concept} lineage is not filter item, is {type(concept.lineage)}"
         )
     direct_parent = concept.lineage.content
     base_existence = []
-    base_rows = [direct_parent]
+    base_rows = [direct_parent] if isinstance(direct_parent, BuildConcept) else []
     condition_rows, condition_existence = resolve_condition_parent_concepts(
         concept.lineage.where
     )
@@ -90,11 +90,10 @@ def resolve_filter_parent_concepts(
 
     if concept.lineage.where.existence_arguments:
         return (
-            concept.lineage.content,
             unique(base_rows, "address"),
             base_existence,
         )
-    return concept.lineage.content, unique(base_rows, "address"), []
+    return unique(base_rows, "address"), []
 
 
 def gen_property_enrichment_node(

trilogy/core/processing/node_generators/filter_node.py

@@ -25,71 +25,140 @@ LOGGER_PREFIX = "[GEN_FILTER_NODE]"
 FILTER_TYPES = (BuildFilterItem,)
 
 
-def gen_filter_node(
-    concept: BuildConcept,
+def pushdown_filter_to_parent(
     local_optional: List[BuildConcept],
-    environment: BuildEnvironment,
-    g,
+    conditions: BuildWhereClause | None,
+    filter_where: BuildWhereClause,
+    same_filter_optional: list[BuildConcept],
     depth: int,
-    source_concepts,
-    history: History | None = None,
+) -> bool:
+    optimized_pushdown = False
+    if not is_scalar_condition(filter_where.conditional):
+        optimized_pushdown = False
+    elif not local_optional:
+        optimized_pushdown = True
+    elif conditions and conditions == filter_where:
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} query conditions are the same as filter conditions, can optimize across all concepts"
+        )
+        optimized_pushdown = True
+    elif same_filter_optional == local_optional:
+        logger.info(
+            f"{padding(depth)}{LOGGER_PREFIX} all optional concepts are included in the filter, can optimize across all concepts"
+        )
+        optimized_pushdown = True
+
+    return optimized_pushdown
+
+
+def build_parent_concepts(
+    concept: BuildConcept,
+    environment: BuildEnvironment,
+    local_optional: List[BuildConcept],
     conditions: BuildWhereClause | None = None,
-) -> StrategyNode | None:
-    immediate_parent, parent_row_concepts, parent_existence_concepts = (
-        resolve_filter_parent_concepts(concept, environment)
+    depth: int = 0,
+):
+    parent_row_concepts, parent_existence_concepts = resolve_filter_parent_concepts(
+        concept, environment
     )
     if not isinstance(concept.lineage, FILTER_TYPES):
         raise SyntaxError('Filter node must have a filter type lineage"')
-    where = concept.lineage.where
+    filter_where = concept.lineage.where
 
-    optional_included: list[BuildConcept] = []
+    same_filter_optional: list[BuildConcept] = []
 
     for x in local_optional:
         if isinstance(x.lineage, FILTER_TYPES):
-            if concept.lineage.where == where:
+            if concept.lineage.where == filter_where:
                 logger.info(
-                    f"{padding(depth)}{LOGGER_PREFIX} fetching {x.lineage.content.address} as optional parent from optional {x} with same filter conditions "
+                    f"{padding(depth)}{LOGGER_PREFIX} fetching parents for peer {x} with same filter conditions"
                 )
-                if x.lineage.content.address not in parent_row_concepts:
-                    parent_row_concepts.append(x.lineage.content)
-                optional_included.append(x)
+
+                for arg in x.lineage.content_concept_arguments:
+                    if arg.address not in parent_row_concepts:
+                        parent_row_concepts.append(arg)
+                same_filter_optional.append(x)
                 continue
-        if conditions and conditions == where:
-            optional_included.append(x)
+        elif conditions and conditions == filter_where:
+            same_filter_optional.append(x)
 
     # sometimes, it's okay to include other local optional above the filter
     # in case it is, prep our list
     extra_row_level_optional: list[BuildConcept] = []
+
     for x in local_optional:
-        if x.address in optional_included:
+        if x.address in same_filter_optional:
             continue
         extra_row_level_optional.append(x)
+    is_optimized_pushdown = pushdown_filter_to_parent(
+        local_optional, conditions, filter_where, same_filter_optional, depth
+    )
+    if not is_optimized_pushdown:
+        parent_row_concepts += extra_row_level_optional
+    return (
+        parent_row_concepts,
+        parent_existence_concepts,
+        same_filter_optional,
+        is_optimized_pushdown,
+    )
 
-    # this flag controls whether we materialize the filter as a where on the prior CTE
-    # or do the filtering inline as a case statement
-    optimized_pushdown = False
-    if not is_scalar_condition(where.conditional):
-        optimized_pushdown = False
-    elif not local_optional:
-        optimized_pushdown = True
-    elif conditions and conditions == where:
+
+def add_existence_sources(
+    core_parent_nodes: list[StrategyNode],
+    parent_existence_concepts: list[tuple[BuildConcept, ...]],
+    source_concepts,
+    environment,
+    g,
+    depth,
+    history,
+):
+    for existence_tuple in parent_existence_concepts:
+        if not existence_tuple:
+            continue
         logger.info(
-            f"{padding(depth)}{LOGGER_PREFIX} query conditions are the same as filter conditions, can optimize across all concepts"
+            f"{padding(depth)}{LOGGER_PREFIX} fetching filter node existence parents {[x.address for x in existence_tuple]}"
         )
-        optimized_pushdown = True
-    elif optional_included == local_optional:
-        logger.info(
-            f"{padding(depth)}{LOGGER_PREFIX} all optional concepts are included in the filter, can optimize across all concepts"
+        parent_existence = source_concepts(
+            mandatory_list=list(existence_tuple),
+            environment=environment,
+            g=g,
+            depth=depth + 1,
+            history=history,
         )
-        optimized_pushdown = True
-    logger.info(
-        f"{padding(depth)}{LOGGER_PREFIX} filter `{concept}` condition `{concept.lineage.where}` derived from {immediate_parent.address} row parents {[x.address for x in parent_row_concepts]} and {[[y.address] for x  in parent_existence_concepts for y  in x]} existence parents"
+        if not parent_existence:
+            logger.info(
+                f"{padding(depth)}{LOGGER_PREFIX} filter existence node parents could not be found"
+            )
+            return None
+        core_parent_nodes.append(parent_existence)
+
+
+def gen_filter_node(
+    concept: BuildConcept,
+    local_optional: List[BuildConcept],
+    environment: BuildEnvironment,
+    g,
+    depth: int,
+    source_concepts,
+    history: History | None = None,
+    conditions: BuildWhereClause | None = None,
+) -> StrategyNode | None:
+    if not isinstance(concept.lineage, FILTER_TYPES):
+        raise SyntaxError('Filter node must have a filter type lineage"')
+    where = concept.lineage.where
+
+    (
+        parent_row_concepts,
+        parent_existence_concepts,
+        same_filter_optional,
+        optimized_pushdown,
+    ) = build_parent_concepts(
+        concept,
+        environment=environment,
+        local_optional=local_optional,
+        conditions=conditions,
+        depth=depth,
     )
-    # we'll populate this with the row parent
-    # and the existence parent(s)
-    core_parents = []
-    if not optimized_pushdown:
-        parent_row_concepts += extra_row_level_optional
 
     row_parent: StrategyNode = source_concepts(
         mandatory_list=parent_row_concepts,
@@ -100,27 +169,19 @@ def gen_filter_node(
         conditions=conditions,
     )
 
+    core_parent_nodes: list[StrategyNode] = []
     flattened_existence = [x for y in parent_existence_concepts for x in y]
     if parent_existence_concepts:
-        for existence_tuple in parent_existence_concepts:
-            if not existence_tuple:
-                continue
-            logger.info(
-                f"{padding(depth)}{LOGGER_PREFIX} fetching filter node existence parents {[x.address for x in existence_tuple]}"
-            )
-            parent_existence = source_concepts(
-                mandatory_list=list(existence_tuple),
-                environment=environment,
-                g=g,
-                depth=depth + 1,
-                history=history,
-            )
-            if not parent_existence:
-                logger.info(
-                    f"{padding(depth)}{LOGGER_PREFIX} filter existence node parents could not be found"
-                )
-                return None
-            core_parents.append(parent_existence)
+        add_existence_sources(
+            core_parent_nodes,
+            parent_existence_concepts,
+            source_concepts,
+            environment,
+            g,
+            depth,
+            history,
+        )
+
     if not row_parent:
         logger.info(
             f"{padding(depth)}{LOGGER_PREFIX} filter node row parents {[x.address for x in parent_row_concepts]} could not be found"
@@ -129,7 +190,7 @@ def gen_filter_node(
 
     if optimized_pushdown:
         logger.info(
-            f"{padding(depth)}{LOGGER_PREFIX} returning optimized filter node with pushdown to parent with condition {where.conditional}"
+            f"{padding(depth)}{LOGGER_PREFIX} returning optimized filter node with pushdown to parent with condition {where.conditional} across {[concept] + same_filter_optional + row_parent.output_concepts} "
         )
         if isinstance(row_parent, SelectNode):
             logger.info(
@@ -137,7 +198,9 @@ def gen_filter_node(
             )
             parent = StrategyNode(
                 input_concepts=row_parent.output_concepts,
-                output_concepts=[concept] + row_parent.output_concepts,
+                output_concepts=[concept]
+                + same_filter_optional
+                + row_parent.output_concepts,
                 environment=row_parent.environment,
                 parents=[row_parent],
                 depth=row_parent.depth,
@@ -146,46 +209,34 @@ def gen_filter_node(
             )
         else:
             parent = row_parent
-
-        expected_output = [concept] + [
-            x
-            for x in local_optional
-            if x.address in [y for y in parent.output_concepts]
-            or x.address in [y for y in optional_included]
-        ]
-        parent.add_parents(core_parents)
+            parent.add_output_concepts([concept] + same_filter_optional)
+        parent.add_parents(core_parent_nodes)
         parent.add_condition(where.conditional)
-        parent.add_existence_concepts(flattened_existence, False).set_output_concepts(
-            expected_output, False
-        )
+        parent.add_existence_concepts(flattened_existence, False)
         parent.grain = BuildGrain.from_concepts(
-            (
-                [environment.concepts[k] for k in immediate_parent.keys]
-                if immediate_parent.keys
-                else [immediate_parent]
-            )
-            + [
-                x
-                for x in local_optional
-                if x.address in [y.address for y in parent.output_concepts]
-            ],
+            parent.output_concepts,
             environment=environment,
         )
         parent.rebuild_cache()
         filter_node = parent
     else:
-        core_parents.append(row_parent)
-
+        core_parent_nodes.append(row_parent)
+        filters = [concept] + same_filter_optional
+        parents_for_grain = [
+            x.lineage.content
+            for x in filters
+            if isinstance(x.lineage.content, BuildConcept)
+        ]
         filter_node = FilterNode(
             input_concepts=unique(
-                [immediate_parent] + parent_row_concepts + flattened_existence,
+                parent_row_concepts + flattened_existence,
                 "address",
             ),
-            output_concepts=[concept, immediate_parent] + parent_row_concepts,
+            output_concepts=[concept] + same_filter_optional + parent_row_concepts,
             environment=environment,
-            parents=core_parents,
+            parents=core_parent_nodes,
             grain=BuildGrain.from_concepts(
-                [immediate_parent] + parent_row_concepts,
+                parents_for_grain + parent_row_concepts, environment=environment
             ),
             preexisting_conditions=conditions.conditional if conditions else None,
         )
@@ -211,7 +262,8 @@ def gen_filter_node(
     )
     enrich_node: StrategyNode = source_concepts(  # this fetches the parent + join keys
         # to then connect to the rest of the query
-        mandatory_list=[immediate_parent] + parent_row_concepts + local_optional,
+        mandatory_list=parent_row_concepts
+        + [x for x in local_optional if x.address not in filter_node.output_concepts],
         environment=environment,
         g=g,
         depth=depth + 1,
@@ -227,14 +279,13 @@ def gen_filter_node(
         f"{padding(depth)}{LOGGER_PREFIX} returning filter node and enrich node with {enrich_node.output_concepts} and {enrich_node.input_concepts}"
     )
     return MergeNode(
-        input_concepts=[concept, immediate_parent] + local_optional,
+        input_concepts=filter_node.output_concepts + enrich_node.output_concepts,
         output_concepts=[
             concept,
         ]
         + local_optional,
         environment=environment,
         parents=[
-            # this node fetches only what we need to filter
             filter_node,
             enrich_node,
         ],

trilogy/core/processing/node_generators/group_node.py

@@ -51,6 +51,7 @@ def gen_group_node(
     ):
         grain_components = [environment.concepts[c] for c in concept.grain.components]
         parent_concepts += grain_components
+        build_grain_parents = BuildGrain.from_concepts(parent_concepts)
         output_concepts += grain_components
         for possible_agg in local_optional:
 
@@ -76,9 +77,7 @@ def gen_group_node(
                     logger.info(
                         f"{padding(depth)}{LOGGER_PREFIX} found equivalent group by optional concept {possible_agg.address} for {concept.address}"
                     )
-                elif BuildGrain.from_concepts(agg_parents) == BuildGrain.from_concepts(
-                    parent_concepts
-                ):
+                elif BuildGrain.from_concepts(agg_parents) == build_grain_parents:
                     extra = [x for x in agg_parents if x.address not in parent_concepts]
                     parent_concepts += extra
                     output_concepts.append(possible_agg)
@@ -87,7 +86,7 @@ def gen_group_node(
                     )
                 else:
                     logger.info(
-                        f"{padding(depth)}{LOGGER_PREFIX} cannot include optional agg {possible_agg.address}; mismatched grain {BuildGrain.from_concepts(agg_parents)} vs {BuildGrain.from_concepts(parent_concepts)}"
+                        f"{padding(depth)}{LOGGER_PREFIX} cannot include optional agg {possible_agg.address}; mismatched parent grain {BuildGrain.from_concepts(agg_parents)} vs local parent {BuildGrain.from_concepts(parent_concepts)}"
                     )
     if parent_concepts:
         logger.info(

trilogy/core/processing/nodes/base_node.py

@@ -194,15 +194,18 @@ class StrategyNode:
         if not self.parents:
             return
         non_hidden = set()
+        hidden = set()
         for x in self.parents:
             for z in x.usable_outputs:
                 non_hidden.add(z.address)
                 for psd in z.pseudonyms:
                     non_hidden.add(psd)
+            for z in x.hidden_concepts:
+                hidden.add(z)
         if not all([x.address in non_hidden for x in self.input_concepts]):
             missing = [x for x in self.input_concepts if x.address not in non_hidden]
             raise ValueError(
-                f"Invalid input concepts; {missing} are missing non-hidden parent nodes"
+                f"Invalid input concepts; {missing} are missing non-hidden parent nodes; have {non_hidden} and hidden {hidden}"
             )
 
     def add_parents(self, parents: list["StrategyNode"]):

trilogy/core/statements/author.py

@@ -162,9 +162,7 @@ class SelectStatement(HasUUID, SelectTypeMixin, BaseModel):
                 output.local_concepts[x.content.address] = environment.concepts[
                     x.content.address
                 ]
-
         output.grain = output.calculate_grain(environment, output.local_concepts)
-
         output.validate_syntax(environment)
         return output
 

trilogy/dialect/base.py

@@ -161,6 +161,7 @@ FUNCTION_MAP = {
     FunctionType.GROUP: lambda x: f"{x[0]}",
     FunctionType.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]})",
     FunctionType.CASE: lambda x: render_case(x),
     FunctionType.SPLIT: lambda x: f"split({x[0]}, {x[1]})",
@@ -183,6 +184,8 @@ FUNCTION_MAP = {
     FunctionType.DIVIDE: lambda x: " / ".join(x),
     FunctionType.MULTIPLY: lambda x: " * ".join(x),
     FunctionType.ROUND: lambda x: f"round({x[0]},{x[1]})",
+    FunctionType.FLOOR: lambda x: f"floor({x[0]})",
+    FunctionType.CEIL: lambda x: f"ceil({x[0]})",
     FunctionType.MOD: lambda x: f"({x[0]} % {x[1]})",
     FunctionType.SQRT: lambda x: f"sqrt({x[0]})",
     FunctionType.RANDOM: lambda x: "random()",
@@ -400,9 +403,11 @@ class BaseDialect:
             elif isinstance(c.lineage, FILTER_ITEMS):
                 # for cases when we've optimized this
                 if cte.condition == c.lineage.where.conditional:
-                    rval = self.render_expr(c.lineage.content, cte=cte)
+                    rval = self.render_expr(
+                        c.lineage.content, cte=cte, raise_invalid=raise_invalid
+                    )
                 else:
-                    rval = f"CASE WHEN {self.render_expr(c.lineage.where.conditional, cte=cte)} THEN {self.render_concept_sql(c.lineage.content, cte=cte, alias=False, raise_invalid=raise_invalid)} ELSE NULL END"
+                    rval = f"CASE WHEN {self.render_expr(c.lineage.where.conditional, cte=cte)} THEN {self.render_expr(c.lineage.content, cte=cte, raise_invalid=raise_invalid)} ELSE NULL END"
             elif isinstance(c.lineage, BuildRowsetItem):
                 rval = f"{self.render_concept_sql(c.lineage.content, cte=cte, alias=False, raise_invalid=raise_invalid)}"
             elif isinstance(c.lineage, BuildMultiSelectLineage):

trilogy/dialect/bigquery.py

@@ -30,6 +30,8 @@ FUNCTION_MAP = {
     # math
     FunctionType.DIVIDE: lambda x: f"COALESCE(SAFE_DIVIDE({x[0]},{x[1]}),0)",
     FunctionType.DATE_ADD: lambda x: f"DATE_ADD({x[0]}, INTERVAL {x[2]} {x[1]})",
+    # string
+    FunctionType.CONTAINS: lambda x: f"CONTAINS_SUBSTR({x[0]}, {x[1]})",
 }
 
 FUNCTION_GRAIN_MATCH_MAP = {

trilogy/dialect/duckdb.py

@@ -35,6 +35,8 @@ FUNCTION_MAP = {
     FunctionType.CONCAT: lambda x: f"({' || '.join(x)})",
     FunctionType.DATE_LITERAL: lambda x: f"date '{x}'",
     FunctionType.DATETIME_LITERAL: lambda x: f"datetime '{x}'",
+    # string
+    FunctionType.CONTAINS: lambda x: f"CONTAINS(LOWER({x[0]}), LOWER({x[1]}))",
 }
 
 # if an aggregate function is called on a source that is at the same grain as the aggregate

trilogy/parsing/common.py

@@ -62,7 +62,7 @@ def process_function_arg(
             operator=FunctionType.PARENTHETICAL,
             arguments=processed,
             output_datatype=arg_to_datatype(processed[0]),
-            output_purpose=function_args_to_output_purpose(processed),
+            output_purpose=function_args_to_output_purpose(processed, environment),
         )
     elif isinstance(arg, Function):
         # if it's not an aggregate function, we can skip the virtual concepts
@@ -140,7 +140,7 @@ def get_purpose_and_keys(
     args: Tuple[ConceptRef | Concept, ...] | None,
     environment: Environment,
 ) -> Tuple[Purpose, set[str] | None]:
-    local_purpose = purpose or function_args_to_output_purpose(args)
+    local_purpose = purpose or function_args_to_output_purpose(args, environment)
     if local_purpose in (Purpose.PROPERTY, Purpose.METRIC) and args:
         keys = concept_list_to_keys(args, environment)
     else:
@@ -281,28 +281,38 @@ def concepts_to_grain_concepts(
     environment: Environment | None,
     local_concepts: dict[str, Concept] | None = None,
 ) -> list[Concept]:
-    pconcepts: list[Concept] = []
+    preconcepts: list[Concept] = []
     for c in concepts:
         if isinstance(c, Concept):
-            pconcepts.append(c)
+            preconcepts.append(c)
+
         elif isinstance(c, ConceptRef) and environment:
             if local_concepts and c.address in local_concepts:
-                pconcepts.append(local_concepts[c.address])
+                preconcepts.append(local_concepts[c.address])
             else:
-                pconcepts.append(environment.concepts[c.address])
+                preconcepts.append(environment.concepts[c.address])
         elif isinstance(c, str) and environment:
             if local_concepts and c in local_concepts:
-                pconcepts.append(local_concepts[c])
+                preconcepts.append(local_concepts[c])
             else:
-                pconcepts.append(environment.concepts[c])
+                preconcepts.append(environment.concepts[c])
         else:
             raise ValueError(
                 f"Unable to resolve input {c} without environment provided to concepts_to_grain call"
             )
-
+    pconcepts = []
+    for x in preconcepts:
+        if (
+            x.lineage
+            and isinstance(x.lineage, Function)
+            and x.lineage.operator == FunctionType.ALIAS
+        ):
+            # if the function is an alias, use the unaliased concept to calculate grain
+            pconcepts.append(environment.concepts[x.lineage.arguments[0].address])  # type: ignore
+        else:
+            pconcepts.append(x)
     final: List[Concept] = []
     for sub in pconcepts:
-
         if not concept_is_relevant(sub, pconcepts, environment):  # type: ignore
             continue
         final.append(sub)
@@ -515,8 +525,10 @@ def filter_item_to_concept(
     metadata: Metadata | None = None,
 ) -> Concept:
     fmetadata = metadata or Metadata()
+    fallback_keys = set()
     if isinstance(parent.content, ConceptRef):
         cparent = environment.concepts[parent.content.address]
+        fallback_keys = set([cparent.address])
     elif isinstance(
         parent.content,
         (
@@ -527,12 +539,16 @@ def filter_item_to_concept(
             Function,
             ListWrapper,
             MapWrapper,
+            int,
+            str,
+            float,
         ),
     ):
         cparent = arbitrary_to_concept(parent.content, environment, namespace=namespace)
+
     else:
         raise NotImplementedError(
-            f"Filter item with non ref content {parent.content} not yet supported"
+            f"Filter item with non ref content {parent.content} ({type(parent.content)}) not yet supported"
         )
     modifiers = get_upstream_modifiers(
         cparent.concept_arguments, environment=environment
@@ -547,13 +563,7 @@ def filter_item_to_concept(
         metadata=fmetadata,
         namespace=namespace,
         # filtered copies cannot inherit keys
-        keys=(
-            cparent.keys
-            if cparent.purpose == Purpose.PROPERTY
-            else {
-                cparent.address,
-            }
-        ),
+        keys=(cparent.keys if cparent.purpose == Purpose.PROPERTY else fallback_keys),
         grain=grain,
         modifiers=modifiers,
         derivation=Derivation.FILTER,

trilogy/parsing/parse_engine.py

@@ -190,16 +190,25 @@ def parse_concept_reference(
 
 def expr_to_boolean(
     root,
+    function_factory: FunctionFactory,
 ) -> Union[Comparison, SubselectComparison, Conditional]:
     if not isinstance(root, (Comparison, SubselectComparison, Conditional)):
         if arg_to_datatype(root) == DataType.BOOL:
             root = Comparison(left=root, right=True, operator=ComparisonOperator.EQ)
+        elif arg_to_datatype(root) == DataType.INTEGER:
+            root = Comparison(
+                left=function_factory.create_function(
+                    [root],
+                    FunctionType.BOOL,
+                ),
+                right=True,
+                operator=ComparisonOperator.EQ,
+            )
         else:
             root = Comparison(
-                left=root,
-                right=MagicConstants.NULL,
-                operator=ComparisonOperator.IS_NOT,
+                left=root, right=NULL_VALUE, operator=ComparisonOperator.IS_NOT
             )
+
     return root
 
 
@@ -1248,16 +1257,21 @@ class ParseToObjects(Transformer):
             intersection = base.locally_derived.intersection(pre_keys)
             if intersection:
                 for x in intersection:
-                    if (
-                        base.local_concepts[x].derivation
-                        == self.environment.concepts[x].derivation
+                    if str(base.local_concepts[x].lineage) == str(
+                        self.environment.concepts[x].lineage
                     ):
+                        local = base.local_concepts[x]
+                        friendly_name = (
+                            local.name
+                            if local.namespace == DEFAULT_NAMESPACE
+                            else local.namespace
+                        )
                         raise NameShadowError(
-                            f"Select statement {base} derives concept {x} with identical derivation as named concept. Use the named concept directly."
+                            f"Select statement {base} creates a new concept '{friendly_name}' with identical definition as the existing concept '{friendly_name}'. Replace {base.local_concepts[x].lineage} with a direct reference to {friendly_name}."
                         )
                 else:
                     raise NameShadowError(
-                        f"Select statement {base} creates new derived concepts {list(intersection)} with identical name(s) to existing concept(s). If these are identical, reference the concept directly. Otherwise alias your column as a new name."
+                        f"Select statement {base} creates new named concepts from calculations {list(intersection)} with identical name(s) to existing concept(s). Use new unique names for these."
                     )
         return base
 
@@ -1271,7 +1285,7 @@ class ParseToObjects(Transformer):
 
     def where(self, args):
         root = args[0]
-        root = expr_to_boolean(root)
+        root = expr_to_boolean(root, self.function_factory)
         return WhereClause(conditional=root)
 
     def having(self, args):
@@ -1490,7 +1504,14 @@ class ParseToObjects(Transformer):
     def parenthetical(self, args):
         return Parenthetical(content=args[0])
 
-    def condition_parenthetical(self, args):
+    @v_args(meta=True)
+    def condition_parenthetical(self, meta, args):
+        if len(args) == 2:
+            return Comparison(
+                left=Parenthetical(content=args[1]),
+                right=False,
+                operator=ComparisonOperator.EQ,
+            )
         return Parenthetical(content=args[0])
 
     def conditional(self, args):
@@ -1573,7 +1594,7 @@ class ParseToObjects(Transformer):
         if isinstance(raw, WhereClause):
             where = raw
         else:
-            where = WhereClause(conditional=raw)
+            where = WhereClause(conditional=expr_to_boolean(raw, self.function_factory))
         if isinstance(expr, str):
             expr = self.environment.concepts[expr].reference
         return FilterItem(content=expr, where=where)
@@ -1632,6 +1653,10 @@ class ParseToObjects(Transformer):
     def fcoalesce(self, meta, args):
         return self.function_factory.create_function(args, FunctionType.COALESCE, meta)
 
+    @v_args(meta=True)
+    def fnullif(self, meta, args):
+        return self.function_factory.create_function(args, FunctionType.NULLIF, meta)
+
     @v_args(meta=True)
     def unnest(self, meta, args):
         return self.function_factory.create_function(args, FunctionType.UNNEST, meta)
@@ -1861,6 +1886,14 @@ class ParseToObjects(Transformer):
             args.append(0)
         return self.function_factory.create_function(args, FunctionType.ROUND, meta)
 
+    @v_args(meta=True)
+    def ffloor(self, meta, args) -> Function:
+        return self.function_factory.create_function(args, FunctionType.FLOOR, meta)
+
+    @v_args(meta=True)
+    def fceil(self, meta, args) -> Function:
+        return self.function_factory.create_function(args, FunctionType.CEIL, meta)
+
     @v_args(meta=True)
     def fcase(self, meta, args: List[Union[CaseWhen, CaseElse]]) -> Function:
         return self.function_factory.create_function(args, FunctionType.CASE, meta)
@@ -1868,7 +1901,7 @@ class ParseToObjects(Transformer):
     @v_args(meta=True)
     def fcase_when(self, meta, args) -> CaseWhen:
         args = process_function_args(args, meta=meta, environment=self.environment)
-        root = expr_to_boolean(args[0])
+        root = expr_to_boolean(args[0], self.function_factory)
         return CaseWhen(comparison=root, expr=args[1])
 
     @v_args(meta=True)

trilogy/parsing/trilogy.lark

@@ -99,7 +99,7 @@
     type_declaration: "type" IDENTIFIER data_type 
 
     // user_id where state = Mexico
-    _filter_alt: (IDENTIFIER | "(" expr ")") "?" conditional
+    _filter_alt: (IDENTIFIER | literal | "(" expr ")") "?" conditional
     _filter_base: "filter"i IDENTIFIER where
     filter_item: _filter_base | _filter_alt
 
@@ -146,7 +146,8 @@
     _and_condition: _condition_unit
                | (_and_condition LOGICAL_AND _condition_unit)
 
-    condition_parenthetical: "(" conditional ")"
+    CONDITION_NOT: "NOT"i
+    condition_parenthetical: CONDITION_NOT? "(" conditional ")"
 
     _condition_unit: expr
                   | condition_parenthetical
@@ -221,13 +222,17 @@
     fmod: ( "mod"i "(" expr "," (int_lit | concept_lit ) ")")  
     _ROUND.1: "round"i "("
     fround: _ROUND expr ("," expr)? ")"
+    _FLOOR.1: "floor"i "("
+    ffloor: _FLOOR expr ")"
+    _CEIL.1: "ceil"i "("
+    fceil:  _CEIL expr ")"
     fabs: "abs"i "(" expr ")"
     _SQRT.1: "sqrt("
     fsqrt:  _SQRT expr ")"
     _RANDOM.1: "random("i
     frandom: _RANDOM expr ")"
         
-    _math_functions: fmul | fdiv | fadd | fsub | fround | fmod | fabs | fsqrt | frandom
+    _math_functions: fmul | fdiv | fadd | fsub | fround | ffloor | fceil | fmod | fabs | fsqrt | frandom
     
     //generic
     _fcast_primary: "cast"i "(" expr "as"i data_type ")"
@@ -241,8 +246,9 @@
     len: "len"i "(" expr ")"
     fnot: "NOT"i expr
     fbool: "bool"i "(" expr ")"
+    fnullif: "nullif"i "(" expr "," expr ")"
 
-    _generic_functions: fcast |  concat  | fcoalesce | fcase  | len | fnot | fbool
+    _generic_functions: fcast |  concat  | fcoalesce | fnullif | fcase  | len | fnot | fbool
 
     //constant
     CURRENT_DATE.1: /current_date\(\)/