pytrilogy 0.0.3.100__py3-none-any.whl → 0.0.3.102__py3-none-any.whl

{pytrilogy-0.0.3.100.dist-info → pytrilogy-0.0.3.102.dist-info}/METADATA

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

{pytrilogy-0.0.3.100.dist-info → pytrilogy-0.0.3.102.dist-info}/RECORD

@@ -1,5 +1,5 @@
-pytrilogy-0.0.3.100.dist-info/licenses/LICENSE.md,sha256=5ZRvtTyCCFwz1THxDTjAu3Lidds9WjPvvzgVwPSYNDo,1042
-trilogy/__init__.py,sha256=g9zY8214LmrIQyjxs_q4DVvbSXccQFQwFe0o0_PZcD8,304
+pytrilogy-0.0.3.102.dist-info/licenses/LICENSE.md,sha256=5ZRvtTyCCFwz1THxDTjAu3Lidds9WjPvvzgVwPSYNDo,1042
+trilogy/__init__.py,sha256=WZdbHlLqyuYo0xjcYkV5QDokunZLDlhGeibgoay48uc,304
 trilogy/constants.py,sha256=ohmro6so7PPNp2ruWQKVc0ijjXYPOyRrxB9LI8dr3TU,1746
 trilogy/engine.py,sha256=3MiADf5MKcmxqiHBuRqiYdsXiLj7oitDfVvXvHrfjkA,2178
 trilogy/executor.py,sha256=KgCAQhHPT-j0rPkBbALX0f84W9-Q-bkjHayGuavg99w,16490
@@ -14,18 +14,18 @@ trilogy/core/enums.py,sha256=H8I2Dz4POHZ4ixYCGzNs4c3KDqxLQklGLVfmje1DSMo,8877
 trilogy/core/env_processor.py,sha256=H-rr2ALj31l5oh3FqeI47Qju6OOfiXBacXNJGNZ92zQ,4521
 trilogy/core/environment_helpers.py,sha256=TRlqVctqIRBxzfjRBmpQsAVoiCcsEKBhG1B6PUE0l1M,12743
 trilogy/core/ergonomics.py,sha256=e-7gE29vPLFdg0_A1smQ7eOrUwKl5VYdxRSTddHweRA,1631
-trilogy/core/exceptions.py,sha256=fI16oTNCVMMAJFSn2AFzZVapzsF5M9WbdN5e5UixwXc,2807
-trilogy/core/functions.py,sha256=oY-F0hsA9vp1ZipGTyx4QVtz_x83Ekk-lkHv6mMkHVQ,33095
+trilogy/core/exceptions.py,sha256=axkVXYJYQXCCwMHwlyDA232g4tCOwdCZUt7eHeUMDMg,2829
+trilogy/core/functions.py,sha256=sdV6Z3NUVfwL1d18eNcaAXllVNqzLez23McsJ6xIp7M,33182
 trilogy/core/graph_models.py,sha256=4EWFTHGfYd72zvS2HYoV6hm7nMC_VEd7vWr6txY-ig0,3400
 trilogy/core/internal.py,sha256=r9QagDB2GvpqlyD_I7VrsfbVfIk5mnok2znEbv72Aa4,2681
 trilogy/core/optimization.py,sha256=ojpn-p79lr03SSVQbbw74iPCyoYpDYBmj1dbZ3oXCjI,8860
 trilogy/core/query_processor.py,sha256=uqygDJqkjIH4vLP-lbGRgTN7rRcYEkr3KGqNimNw_80,20345
 trilogy/core/utility.py,sha256=3VC13uSQWcZNghgt7Ot0ZTeEmNqs__cx122abVq9qhM,410
 trilogy/core/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-trilogy/core/models/author.py,sha256=ZSKEJ6Vg4otpI_m7_JuGyrFM8dZV1HaxBwprvDSwUzo,81149
-trilogy/core/models/build.py,sha256=ZwJJGyp4rVsISvL8Er_AxQdVJrafYc4fesSj4MNgoxU,70615
+trilogy/core/models/author.py,sha256=3I7PFpJgoQT9RPOT3DfiqAjEtkcQPJnScs60I2UoyWo,81461
+trilogy/core/models/build.py,sha256=iqk_-3plxX1BdxvUCTebqE9F3x62f40neKGf6Ld4VVU,70858
 trilogy/core/models/build_environment.py,sha256=mpx7MKGc60fnZLVdeLi2YSREy7eQbQYycCrP4zF-rHU,5258
-trilogy/core/models/core.py,sha256=EofJ8-kltNr_7oFhyCPqauVX1bSJzJI5xOp0eMP_vlA,12892
+trilogy/core/models/core.py,sha256=iT9WdZoiXeglmUHWn6bZyXCTBpkApTGPKtNm_Mhbu_g,12987
 trilogy/core/models/datasource.py,sha256=wogTevZ-9CyUW2a8gjzqMCieircxi-J5lkI7EOAZnck,9596
 trilogy/core/models/environment.py,sha256=hwTIRnJgaHUdCYof7U5A9NPitGZ2s9yxqiW5O2SaJ9Y,28759
 trilogy/core/models/execute.py,sha256=lsNzNjS3nZvoW5CHjYwxDTwBe502NZyytpK1eq8CwW4,42357
@@ -45,10 +45,10 @@ trilogy/core/processing/node_generators/basic_node.py,sha256=0Uhnf07056SBbRkt-wY
 trilogy/core/processing/node_generators/common.py,sha256=PdysdroW9DUADP7f5Wv_GKPUyCTROZV1g3L45fawxi8,9443
 trilogy/core/processing/node_generators/constant_node.py,sha256=LfpDq2WrBRZ3tGsLxw77LuigKfhbteWWh9L8BGdMGwk,1146
 trilogy/core/processing/node_generators/filter_node.py,sha256=ArBsQJl-4fWBJWCE28CRQ7UT7ErnFfbcseoQQZrBodY,11220
-trilogy/core/processing/node_generators/group_node.py,sha256=pq8aqKe4hCtkzFtpHvE15BJoYvpveoe50_2IM1pqjIQ,6732
+trilogy/core/processing/node_generators/group_node.py,sha256=yqOWl5TCV4PrdJua4OJkPUIHkljaLoSW2Y8eRAmVddQ,6733
 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=531ptEAZIczc7PR-kfuNe_KBaDToyIMUMKq4bkoZkgw,23561
+trilogy/core/processing/node_generators/node_merge_node.py,sha256=1joMV7XpQ9Gpe-d5y7JUMBHIqakV5wFJi3Mtvs4UcL4,23415
 trilogy/core/processing/node_generators/recursive_node.py,sha256=l5zdh0dURKwmAy8kK4OpMtZfyUEQRk6N-PwSWIyBpSM,2468
 trilogy/core/processing/node_generators/rowset_node.py,sha256=5L5u6xz1In8EaHQdcYgR2si-tz9WB9YLXURo4AkUT9A,6630
 trilogy/core/processing/node_generators/select_merge_node.py,sha256=KQvGoNT5ZBWQ_caEomRTtG1PKZC7OPT4PKfY0QmwMGE,22270
@@ -77,11 +77,11 @@ trilogy/core/statements/execute.py,sha256=kiwJcVeMa4wZR-xLfM2oYOJ9DeyJkP8An38WFy
 trilogy/core/validation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/core/validation/common.py,sha256=Sd-towAX1uSDe3dK51FcVtIwVrMhayEwdHqhzeJHro0,4776
 trilogy/core/validation/concept.py,sha256=PM2BxBxLvuBScSWZMPsDZVcOblDil5pNT0pHLcLhdPA,5242
-trilogy/core/validation/datasource.py,sha256=d9AQNcukIRgN2spItPsXFiNtlZva-lDnfei3i06yQCE,6489
+trilogy/core/validation/datasource.py,sha256=nJeEFyb6iMBwlEVdYVy1vLzAbdRZwOsUjGxgWKgY8oM,7636
 trilogy/core/validation/environment.py,sha256=ymvhQyt7jLK641JAAIQkqjQaAmr9C5022ILzYvDgPP0,2835
 trilogy/core/validation/fix.py,sha256=Z818UFNLxndMTLiyhB3doLxIfnOZ-16QGvVFWuD7UsA,3750
 trilogy/dialect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-trilogy/dialect/base.py,sha256=0QVHv4F0t3_gRQrZ0woFoUNKu7vaXGo-BG1l47CZUKc,49698
+trilogy/dialect/base.py,sha256=d2gXfa5Jh3uyN9H9MxG53JT-xQQgntq2X7EprobJYUc,49698
 trilogy/dialect/bigquery.py,sha256=XS3hpybeowgfrOrkycAigAF3NX2YUzTzfgE6f__2fT4,4316
 trilogy/dialect/common.py,sha256=_MarnMWRBn3VcNt3k5VUdFrwH6oHzGdNQquSpHNLq4o,5644
 trilogy/dialect/config.py,sha256=olnyeVU5W5T6b9-dMeNAnvxuPlyc2uefb7FRME094Ec,3834
@@ -99,26 +99,26 @@ trilogy/hooks/graph_hook.py,sha256=5BfR7Dt0bgEsCLgwjowgCsVkboGYfVJGOz8g9mqpnos,4
 trilogy/hooks/query_debugger.py,sha256=1npRjww94sPV5RRBBlLqMJRaFkH9vhEY6o828MeoEcw,5583
 trilogy/metadata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trilogy/parsing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-trilogy/parsing/common.py,sha256=550-L0444GUuBFdiDWkOg_DxnMXtcJFUMES2R5zlwik,31026
+trilogy/parsing/common.py,sha256=NJLm31J3W9BLWq1ClhNvYE43jrF950698KJ3o0UfSCo,31340
 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=2k1TvnBYE_CW5zCmNfVbf1aWBuMDm5Wz4QfKKgGnE5k,81824
-trilogy/parsing/render.py,sha256=tqB3GlGk3bX6AbkJjvADad2QH6n63nw1kgrpjzLX2tI,20520
-trilogy/parsing/trilogy.lark,sha256=rM4WleeyGhoRgU-FOGcaeHOzZcYVxN4f13e_3B4OeLQ,16389
+trilogy/parsing/parse_engine.py,sha256=T-3Q4UH256IB6cfX85crScZwZ6gAwslgv0fy3WKBdjc,81930
+trilogy/parsing/render.py,sha256=IklKMdXiqQEB6D28PrU1BewlDwD88Hnmqn1xjA9h720,23863
+trilogy/parsing/trilogy.lark,sha256=6eBDD6d4D9N1Nnn4CtmaoB-NpOpjHrEn5oi0JykAlbE,16509
 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
 trilogy/std/date.preql,sha256=HWZm4t4HWyxr5geWRsY05RnHBVDMci8z8YA2cu0-OOw,188
-trilogy/std/display.preql,sha256=nm7lox87Xf6lBvXCVCS6x2HskguMKzndEBucJ5pktzk,175
+trilogy/std/display.preql,sha256=S20HW8qbShBc4OZPcHYiRlLdcaBp9dwruozWBoXKscs,293
 trilogy/std/geography.preql,sha256=1A9Sq5PPMBnEPPf7f-rPVYxJfsnWpQ8oV_k4Fm3H2dU,675
 trilogy/std/metric.preql,sha256=DRECGhkMyqfit5Fl4Ut9zbWrJuSMI1iO9HikuyoBpE0,421
 trilogy/std/money.preql,sha256=XWwvAV3WxBsHX9zfptoYRnBigcfYwrYtBHXTME0xJuQ,2082
 trilogy/std/net.preql,sha256=WZCuvH87_rZntZiuGJMmBDMVKkdhTtxeHOkrXNwJ1EE,416
 trilogy/std/ranking.preql,sha256=LDoZrYyz4g3xsII9XwXfmstZD-_92i1Eox1UqkBIfi8,83
 trilogy/std/report.preql,sha256=LbV-XlHdfw0jgnQ8pV7acG95xrd1-p65fVpiIc-S7W4,202
-pytrilogy-0.0.3.100.dist-info/METADATA,sha256=T9p4b_yjL4_HtEwChltpxh5mlP8pCoRQPn28Ucu_1gI,11811
-pytrilogy-0.0.3.100.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pytrilogy-0.0.3.100.dist-info/entry_points.txt,sha256=ewBPU2vLnVexZVnB-NrVj-p3E-4vukg83Zk8A55Wp2w,56
-pytrilogy-0.0.3.100.dist-info/top_level.txt,sha256=cAy__NW_eMAa_yT9UnUNlZLFfxcg6eimUAZ184cdNiE,8
-pytrilogy-0.0.3.100.dist-info/RECORD,,
+pytrilogy-0.0.3.102.dist-info/METADATA,sha256=fQKKWHDkY9Nhofow6RO22oMSXp91H-vOD5d3kk3S-V8,11811
+pytrilogy-0.0.3.102.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pytrilogy-0.0.3.102.dist-info/entry_points.txt,sha256=ewBPU2vLnVexZVnB-NrVj-p3E-4vukg83Zk8A55Wp2w,56
+pytrilogy-0.0.3.102.dist-info/top_level.txt,sha256=cAy__NW_eMAa_yT9UnUNlZLFfxcg6eimUAZ184cdNiE,8
+pytrilogy-0.0.3.102.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.100"
+__version__ = "0.0.3.102"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

trilogy/core/exceptions.py

@@ -69,7 +69,7 @@ class DatasourceColumnBindingData:
     actual_modifiers: List[Modifier]
 
     def format_failure(self):
-        return f"Concept {self.address} value '{self.value}' with type {self.value_modifiers} does not conform to expected type {str(self.actual_type)} with modifiers {self.actual_modifiers}"
+        return f"Concept {self.address} value '{self.value}' with type {self.value_type} and {self.value_modifiers} does not conform to expected type {str(self.actual_type)} with modifiers {self.actual_modifiers}"
 
     def is_modifier_issue(self) -> bool:
         return len(self.value_modifiers) > 0 and any(

trilogy/core/functions.py

@@ -18,6 +18,7 @@ from trilogy.core.models.author import (
     AggregateWrapper,
     Concept,
     ConceptRef,
+    Conditional,
     Function,
     Parenthetical,
     UndefinedConcept,
@@ -129,8 +130,8 @@ def validate_case_output(
 def create_struct_output(
     args: list[Any],
 ) -> StructType:
-    zipped = dict(zip(args[::2], args[1::2]))
-    types = [arg_to_datatype(x) for x in args[1::2]]
+    zipped = dict(zip(args[1::2], args[::2]))
+    types = [arg_to_datatype(x) for x in args[::2]]
     return StructType(fields=types, fields_map=zipped)
 
 
@@ -997,6 +998,8 @@ def argument_to_purpose(arg) -> Purpose:
         return argument_to_purpose(arg.content)
     elif isinstance(arg, WindowItem):
         return Purpose.PROPERTY
+    elif isinstance(arg, Conditional):
+        return Purpose.PROPERTY
     elif isinstance(arg, Concept):
         base = arg.purpose
         if (

trilogy/core/models/author.py

@@ -259,6 +259,15 @@ class Parenthetical(
             )
         )
 
+    def with_reference_replacement(self, source, target):
+        return Parenthetical.model_construct(
+            content=(
+                self.content.with_reference_replacement(source, target)
+                if isinstance(self.content, Mergeable)
+                else self.content
+            )
+        )
+
     @property
     def concept_arguments(self) -> Sequence[ConceptRef]:
         base: List[ConceptRef] = []

trilogy/core/models/build.py

@@ -1511,7 +1511,10 @@ def requires_concept_nesting(
 ) -> AggregateWrapper | WindowItem | FilterItem | Function | None:
     if isinstance(expr, (AggregateWrapper, WindowItem, FilterItem)):
         return expr
-    if isinstance(expr, Function) and expr.operator == FunctionType.GROUP:
+    if isinstance(expr, Function) and expr.operator in (
+        FunctionType.GROUP,
+        FunctionType.PARENTHETICAL,
+    ):
         # group by requires nesting
         return expr
     return None
@@ -1696,13 +1699,12 @@ class Factory:
         return self._build_case_when(base)
 
     def _build_case_when(self, base: CaseWhen) -> BuildCaseWhen:
-        comparison = base.comparison
         expr: Concept | FuncArgs = base.expr
         validation = requires_concept_nesting(expr)
         if validation:
             expr, _ = self.instantiate_concept(validation)
         return BuildCaseWhen(
-            comparison=self.build(comparison),
+            comparison=self.build(base.comparison),
             expr=self.build(expr),
         )
 
@@ -2019,7 +2021,12 @@ class Factory:
         return self._build_parenthetical(base)
 
     def _build_parenthetical(self, base: Parenthetical) -> BuildParenthetical:
-        return BuildParenthetical(content=(self.build(base.content)))
+        validate = requires_concept_nesting(base.content)
+        if validate:
+            content, _ = self.instantiate_concept(validate)
+            return BuildParenthetical(content=self.build(content))
+        else:
+            return BuildParenthetical(content=self.build(base.content))
 
     @build.register
     def _(self, base: SelectLineage) -> BuildSelectLineage:

trilogy/core/models/core.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from abc import ABC
 from collections import UserDict, UserList
 from datetime import date, datetime
+from decimal import Decimal
 from enum import Enum
 from typing import (
     Any,
@@ -448,6 +449,8 @@ def arg_to_datatype(arg) -> CONCRETE_TYPES:
         return DataType.STRING
     elif isinstance(arg, float):
         return DataType.FLOAT
+    elif isinstance(arg, Decimal):
+        return DataType.NUMERIC
     elif isinstance(arg, DataType):
         return arg
     elif isinstance(arg, NumericType):

trilogy/core/processing/node_generators/group_node.py

@@ -28,6 +28,7 @@ def get_aggregate_grain(
     parent_concepts: List[BuildConcept] = unique(
         resolve_function_parent_concepts(concept, environment=environment), "address"
     )
+
     if (
         concept.grain
         and len(concept.grain.components) > 0

trilogy/core/processing/node_generators/node_merge_node.py

@@ -164,9 +164,6 @@ def reinject_common_join_keys_v2(
             reduced = BuildGrain.from_concepts(concrete_concepts).components
             existing_addresses = set()
             for concrete in concrete_concepts:
-                logger.debug(
-                    f"looking at column {concrete.address} with pseudonyms {concrete.pseudonyms}"
-                )
                 cnode = concept_to_node(concrete.with_default_grain())
                 if cnode in final.nodes:
                     existing_addresses.add(concrete.address)

trilogy/core/validation/datasource.py

@@ -36,31 +36,51 @@ def type_check(
 ) -> bool:
     if input is None and nullable:
         return True
+
     target_type = expected_type
     while isinstance(target_type, TraitDataType):
         return type_check(input, target_type.data_type, nullable)
+
     if target_type == DataType.STRING:
         return isinstance(input, str)
     if target_type == DataType.INTEGER:
         return isinstance(input, int)
+    if target_type == DataType.BIGINT:
+        return isinstance(input, int)  # or check for larger int if needed
     if target_type == DataType.FLOAT or isinstance(target_type, NumericType):
         return (
             isinstance(input, float)
             or isinstance(input, int)
             or isinstance(input, Decimal)
         )
+    if target_type == DataType.NUMBER:
+        return isinstance(input, (int, float, Decimal))
+    if target_type == DataType.NUMERIC:
+        return isinstance(input, (int, float, Decimal))
     if target_type == DataType.BOOL:
         return isinstance(input, bool)
     if target_type == DataType.DATE:
-        return isinstance(input, date)
+        return isinstance(input, date) and not isinstance(input, datetime)
     if target_type == DataType.DATETIME:
         return isinstance(input, datetime)
+    if target_type == DataType.TIMESTAMP:
+        return isinstance(input, datetime)  # or timestamp type if you have one
+    if target_type == DataType.UNIX_SECONDS:
+        return isinstance(input, (int, float))  # Unix timestamps are numeric
+    if target_type == DataType.DATE_PART:
+        return isinstance(
+            input, str
+        )  # assuming date parts are strings like "year", "month"
     if target_type == DataType.ARRAY or isinstance(target_type, ArrayType):
         return isinstance(input, list)
     if target_type == DataType.MAP or isinstance(target_type, MapType):
         return isinstance(input, dict)
     if target_type == DataType.STRUCT or isinstance(target_type, StructType):
         return isinstance(input, dict)
+    if target_type == DataType.NULL:
+        return input is None
+    if target_type == DataType.UNKNOWN:
+        return True
     return False
 
 
@@ -125,15 +145,19 @@ def validate_datasource(
             rval = row[actual_address]
             passed = type_check(rval, col.concept.datatype, col.is_nullable)
             if not passed:
+                value_type = (
+                    arg_to_datatype(rval) if rval is not None else col.concept.datatype
+                )
+                traits = None
+                if isinstance(col.concept.datatype, TraitDataType):
+                    traits = col.concept.datatype.traits
+                if traits and not isinstance(value_type, TraitDataType):
+                    value_type = TraitDataType(type=value_type, traits=traits)
                 failures.append(
                     DatasourceColumnBindingData(
                         address=col.concept.address,
                         value=rval,
-                        value_type=(
-                            arg_to_datatype(rval)
-                            if rval is not None
-                            else col.concept.datatype
-                        ),
+                        value_type=value_type,
                         value_modifiers=[Modifier.NULLABLE] if rval is None else [],
                         actual_type=col.concept.datatype,
                         actual_modifiers=col.concept.modifiers,

trilogy/dialect/base.py

@@ -163,7 +163,7 @@ def render_case(args):
 
 
 def struct_arg(args):
-    return [f"{x[0]}: {x[1]}" for x in zip(args[::2], args[1::2])]
+    return [f"{x[1]}: {x[0]}" for x in zip(args[::2], args[1::2])]
 
 
 FUNCTION_MAP = {

trilogy/parsing/common.py

@@ -249,11 +249,14 @@ def atom_is_relevant(
         return atom_is_relevant(atom.left, others, environment) or atom_is_relevant(
             atom.right, others, environment
         )
+    elif isinstance(atom, Parenthetical):
+        return atom_is_relevant(atom.content, others, environment)
     elif isinstance(atom, ConceptArgs):
         # use atom is relevant here to trigger the early exit behavior for concepts in set
         return any(
             [atom_is_relevant(x, others, environment) for x in atom.concept_arguments]
         )
+
     return False
 
 
@@ -294,12 +297,18 @@ def concept_is_relevant(
         if all([c in others for c in concept.grain.components]):
             return False
     if concept.derivation in (Derivation.BASIC,) and isinstance(
-        concept.lineage, Function
+        concept.lineage, (Function, CaseWhen)
     ):
         relevant = False
         for arg in concept.lineage.arguments:
             relevant = atom_is_relevant(arg, others, environment) or relevant
+
         return relevant
+    if concept.derivation in (Derivation.BASIC,) and isinstance(
+        concept.lineage, Parenthetical
+    ):
+        return atom_is_relevant(concept.lineage.content, others, environment)
+
     if concept.granularity == Granularity.SINGLE_ROW:
         return False
     return True
@@ -346,6 +355,7 @@ def concepts_to_grain_concepts(
         if sub.address in seen:
             continue
         if not concept_is_relevant(sub, pconcepts, environment):  # type: ignore
+
             continue
         seen.add(sub.address)
 

trilogy/parsing/parse_engine.py

@@ -992,6 +992,9 @@ class ParseToObjects(Transformer):
     def order_by(self, args):
         return OrderBy(items=args[0])
 
+    def over_component(self, args):
+        return ConceptRef(address=args[0].value.lstrip(",").strip())
+
     def over_list(self, args):
         return [x for x in args]
 

trilogy/parsing/render.py

@@ -1,4 +1,6 @@
 from collections import defaultdict
+from contextlib import contextmanager
+from dataclasses import dataclass
 from datetime import date, datetime
 from functools import singledispatchmethod
 from typing import Any
@@ -23,6 +25,7 @@ from trilogy.core.models.author import (
     FunctionCallWrapper,
     Grain,
     OrderBy,
+    Ordering,
     OrderItem,
     Parenthetical,
     SubselectComparison,
@@ -67,23 +70,72 @@ from trilogy.core.statements.author import (
 
 QUERY_TEMPLATE = Template(
     """{% if where %}WHERE
-    {{ where }}
+{{ where }}
 {% endif %}SELECT{%- for select in select_columns %}
-    {{ select }},{% endfor %}{% if having %}
+{{ select }},{% endfor %}{% if having %}
 HAVING
-    {{ having }}
+{{ having }}
 {% endif %}{%- if order_by %}
 ORDER BY{% for order in order_by %}
-    {{ order }}{% if not loop.last %},{% endif %}{% endfor %}{% endif %}{%- if limit is not none %}
+{{ order }}{% if not loop.last %},{% endif %}{% endfor %}{% endif %}{%- if limit is not none %}
 LIMIT {{ limit }}{% endif %}
 ;"""
 )
 
 
+@dataclass
+class IndentationContext:
+    """Tracks indentation state during rendering"""
+
+    depth: int = 0
+    indent_string: str = "    "  # 4 spaces by default
+
+    @property
+    def current_indent(self) -> str:
+        return self.indent_string * self.depth
+
+    def increase_depth(self, extra_levels: int = 1) -> "IndentationContext":
+        return IndentationContext(
+            depth=self.depth + extra_levels, indent_string=self.indent_string
+        )
+
+
 class Renderer:
 
-    def __init__(self, environment: Environment | None = None):
+    def __init__(
+        self, environment: Environment | None = None, indent_string: str = "    "
+    ):
         self.environment = environment
+        self.indent_context = IndentationContext(indent_string=indent_string)
+
+    @contextmanager
+    def indented(self, levels: int = 1):
+        """Context manager for temporarily increasing indentation"""
+        old_context = self.indent_context
+        self.indent_context = self.indent_context.increase_depth(levels)
+        try:
+            yield
+        finally:
+            self.indent_context = old_context
+
+    def indent_lines(self, text: str, extra_levels: int = 0) -> str:
+        """Apply current indentation to all lines in text"""
+        if not text:
+            return text
+
+        indent = self.indent_context.indent_string * (
+            self.indent_context.depth + extra_levels
+        )
+        lines = text.split("\n")
+        indented_lines = []
+
+        for line in lines:
+            if line.strip():  # Only indent non-empty lines
+                indented_lines.append(indent + line)
+            else:
+                indented_lines.append(line)  # Keep empty lines as-is
+
+        return "\n".join(indented_lines)
 
     def render_statement_string(self, list_of_statements: list[Any]) -> str:
         new = []
@@ -98,7 +150,7 @@ class Renderer:
                 new.append("\n\n")
             else:
                 new.append("\n")
-            new.append(Renderer().to_string(stmt))
+            new.append(self.to_string(stmt))
             last_statement_type = stmt_type
         return "".join(new)
 
@@ -192,14 +244,19 @@ class Renderer:
 
     @to_string.register
     def _(self, arg: Datasource):
-        assignments = ",\n    ".join([self.to_string(x) for x in arg.columns])
+        with self.indented():
+            assignments = ",\n".join(
+                [self.indent_lines(self.to_string(x)) for x in arg.columns]
+            )
+
         if arg.non_partial_for:
             non_partial = f"\ncomplete where {self.to_string(arg.non_partial_for)}"
         else:
             non_partial = ""
+
         base = f"""datasource {arg.name} (
-    {assignments}
-    )
+{assignments}
+)
 {self.to_string(arg.grain) if arg.grain.components else ''}{non_partial}
 {self.to_string(arg.address)}"""
 
@@ -349,7 +406,8 @@ class Renderer:
         else:
             output = f"{concept.purpose.value} {namespace}{concept.name} <- {self.to_string(concept.lineage)};"
         if base_description:
-            output += f" #{base_description}"
+            lines = "\n#".join(base_description.split("\n"))
+            output += f" #{lines}"
         return output
 
     @to_string.register
@@ -389,26 +447,45 @@ class Renderer:
 
     @to_string.register
     def _(self, arg: SelectStatement):
+        with self.indented():
+            select_columns = [
+                self.indent_lines(self.to_string(c)) for c in arg.selection
+            ]
+            where_clause = None
+            if arg.where_clause:
+                where_clause = self.indent_lines(self.to_string(arg.where_clause))
+            having_clause = None
+            if arg.having_clause:
+                having_clause = self.indent_lines(self.to_string(arg.having_clause))
+            order_by = None
+            if arg.order_by:
+                order_by = [
+                    self.indent_lines(self.to_string(c)) for c in arg.order_by.items
+                ]
+
         return QUERY_TEMPLATE.render(
-            select_columns=[self.to_string(c) for c in arg.selection],
-            where=self.to_string(arg.where_clause) if arg.where_clause else None,
-            having=self.to_string(arg.having_clause) if arg.having_clause else None,
-            order_by=(
-                [self.to_string(c) for c in arg.order_by.items]
-                if arg.order_by
-                else None
-            ),
+            select_columns=select_columns,
+            where=where_clause,
+            having=having_clause,
+            order_by=order_by,
             limit=arg.limit,
         )
 
     @to_string.register
     def _(self, arg: MultiSelectStatement):
-        base = "\nMERGE\n".join([self.to_string(select)[:-2] for select in arg.selects])
+        # Each select gets its own indentation
+        select_parts = []
+        for select in arg.selects:
+            select_parts.append(
+                self.to_string(select)[:-2]
+            )  # Remove the trailing ";\n"
+
+        base = "\nMERGE\n".join(select_parts)
         base += self.to_string(arg.align)
         if arg.where_clause:
             base += f"\nWHERE\n{self.to_string(arg.where_clause)}"
         if arg.order_by:
-            base += f"\nORDER BY\n\t{self.to_string(arg.order_by)}"
+            base += f"\nORDER BY\n{self.to_string(arg.order_by)}"
         if arg.limit:
             base += f"\nLIMIT {arg.limit}"
         base += "\n;"
@@ -420,7 +497,9 @@ class Renderer:
 
     @to_string.register
     def _(self, arg: AlignClause):
-        return "\nALIGN\n\t" + ",\n\t".join([self.to_string(c) for c in arg.items])
+        with self.indented():
+            align_items = [self.indent_lines(self.to_string(c)) for c in arg.items]
+        return "\nALIGN\n" + ",\n".join(align_items)
 
     @to_string.register
     def _(self, arg: AlignItem):
@@ -428,7 +507,13 @@ class Renderer:
 
     @to_string.register
     def _(self, arg: OrderBy):
-        return ",\n".join([self.to_string(c) for c in arg.items])
+        with self.indented():
+            order_items = [self.indent_lines(self.to_string(c)) for c in arg.items]
+        return ",\n".join(order_items)
+
+    @to_string.register
+    def _(self, arg: Ordering):
+        return arg.value
 
     @to_string.register
     def _(self, arg: "WhereClause"):
@@ -439,7 +524,7 @@ class Renderer:
 
     @to_string.register
     def _(self, arg: "Conditional"):
-        return f"({self.to_string(arg.left)} {arg.operator.value} {self.to_string(arg.right)})"
+        return f"{self.to_string(arg.left)} {arg.operator.value} {self.to_string(arg.right)}"
 
     @to_string.register
     def _(self, arg: "SubselectComparison"):
@@ -451,7 +536,8 @@ class Renderer:
 
     @to_string.register
     def _(self, arg: "Comment"):
-        return f"{arg.text}"
+        lines = "\n#".join(arg.text.split("\n"))
+        return f"{lines}"
 
     @to_string.register
     def _(self, arg: "WindowItem"):
@@ -467,7 +553,6 @@ class Renderer:
 
     @to_string.register
     def _(self, arg: "FilterItem"):
-
         return f"filter {self.to_string(arg.content)} where {self.to_string(arg.where)}"
 
     @to_string.register
@@ -536,18 +621,34 @@ class Renderer:
             if len(args) == 1:
                 return f"group({args[0]})"
             return f"group({args[0]}) by {arg_string}"
-        inputs = ",".join(args)
 
         if arg.operator == FunctionType.CONSTANT:
-            return f"{inputs}"
+            return f"{', '.join(args)}"
         if arg.operator == FunctionType.CAST:
             return f"CAST({self.to_string(arg.arguments[0])} AS {self.to_string(arg.arguments[1])})"
         if arg.operator == FunctionType.INDEX_ACCESS:
             return f"{self.to_string(arg.arguments[0])}[{self.to_string(arg.arguments[1])}]"
 
         if arg.operator == FunctionType.CASE:
-            inputs = "\n\t".join(args)
-            return f"CASE\n\t{inputs}\nEND"
+            with self.indented():
+                indented_args = [
+                    self.indent_lines(self.to_string(a)) for a in arg.arguments
+                ]
+            inputs = "\n".join(indented_args)
+            return f"CASE\n{inputs}\n{self.indent_context.current_indent}END"
+
+        if arg.operator == FunctionType.STRUCT:
+            # zip arguments to pairs
+            input_pairs = zip(arg.arguments[0::2], arg.arguments[1::2])
+            with self.indented():
+                pair_strings = []
+                for k, v in input_pairs:
+                    pair_line = f"{self.to_string(k)}-> {v}"
+                    pair_strings.append(self.indent_lines(pair_line))
+            inputs = ",\n".join(pair_strings)
+            return f"struct(\n{inputs}\n{self.indent_context.current_indent})"
+
+        inputs = ",".join(args)
         return f"{arg.operator.value}({inputs})"
 
     @to_string.register

trilogy/parsing/trilogy.lark

@@ -134,10 +134,14 @@
     metadata: "metadata" "(" IDENTIFIER "=" string_lit ")"
     
     limit: "LIMIT"i /[0-9]+/
+
+    _order_atom: expr ordering
+    
+    order_list: _order_atom (","  _order_atom)* ","?
     
-    order_list: expr ordering (","  expr ordering)* ","?
+    over_component: /,\s*[a-zA-Z\_][a-zA-Z0-9\_\.]*/ "END"?
     
-    over_list: concept_lit (","  concept_lit )* ","?
+    over_list: concept_lit  over_component* 
     
     ORDERING_DIRECTION: /ASC|DESC/i
 
@@ -433,7 +437,8 @@
     map_lit: "{" (literal ":" literal ",")* literal ":" literal ","? "}"
 
     _STRUCT.1: "struct("i
-    struct_lit: _STRUCT (IDENTIFIER "->" expr ",")* IDENTIFIER "->" expr ","? ")"
+    _BINDING.1: "->"
+    struct_lit: _STRUCT expr _BINDING IDENTIFIER   ( "," expr _BINDING  IDENTIFIER  )* ","? ")"
     
     !bool_lit: "True"i | "False"i
 

trilogy/std/display.preql

@@ -2,5 +2,8 @@
 
 type percent float; # Percentage value
 
-def calc_percent(a, b, digits=-1) -> case when digits =-1 then (a/b):: float::percent
-else round((a/b):: float::percent, digits) end;
+def calc_percent(a, b, digits=-1) -> case when digits =-1 then 
+case when b = 0 then 0.0::float::percent else
+(a/b)::float::percent end
+else round((case when b = 0 then 0.0::float::percent else
+(a/b)::float::percent end):: float::percent, digits) end;