pytrilogy 0.0.2.14__tar.gz → 0.0.2.17__tar.gz

{pytrilogy-0.0.2.14/pytrilogy.egg-info → pytrilogy-0.0.2.17}/PKG-INFO

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

{pytrilogy-0.0.2.14 → pytrilogy-0.0.2.17/pytrilogy.egg-info}/PKG-INFO

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

{pytrilogy-0.0.2.14 → pytrilogy-0.0.2.17}/trilogy/__init__.py

@@ -4,6 +4,6 @@ from trilogy.executor import Executor
 from trilogy.parser import parse
 from trilogy.constants import CONFIG
 
-__version__ = "0.0.2.14"
+__version__ = "0.0.2.17"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

{pytrilogy-0.0.2.14 → pytrilogy-0.0.2.17}/trilogy/core/models.py

@@ -2660,9 +2660,9 @@ class CTE(BaseModel):
             if isinstance(join, InstantiatedUnnestJoin):
                 continue
             if join.left_cte.name == parent.name:
-                join.left_cte = ds_being_inlined
+                join.inline_cte(parent)
             if join.right_cte.name == parent.name:
-                join.right_cte = ds_being_inlined
+                join.inline_cte(parent)
         for k, v in self.source_map.items():
             if isinstance(v, list):
                 self.source_map[k] = [
@@ -2885,34 +2885,38 @@ class JoinKey(BaseModel):
 
 
 class Join(BaseModel):
-    left_cte: CTE | Datasource
-    right_cte: CTE | Datasource
+    left_cte: CTE
+    right_cte: CTE
     jointype: JoinType
     joinkeys: List[JoinKey]
     joinkey_pairs: List[ConceptPair] | None = None
+    inlined_ctes: set[str] = Field(default_factory=set)
+
+    def inline_cte(self, cte: CTE):
+        self.inlined_ctes.add(cte.name)
 
     @property
     def left_name(self) -> str:
-        if isinstance(self.left_cte, Datasource):
-            return self.left_cte.identifier
+        if self.left_cte.name in self.inlined_ctes:
+            return self.left_cte.source.datasources[0].identifier
         return self.left_cte.name
 
     @property
     def right_name(self) -> str:
-        if isinstance(self.right_cte, Datasource):
-            return self.right_cte.identifier
+        if self.right_cte.name in self.inlined_ctes:
+            return self.right_cte.source.datasources[0].identifier
         return self.right_cte.name
 
     @property
     def left_ref(self) -> str:
-        if isinstance(self.left_cte, Datasource):
-            return f"{self.left_cte.safe_location} as {self.left_cte.identifier}"
+        if self.left_cte.name in self.inlined_ctes:
+            return f"{self.left_cte.source.datasources[0].safe_location} as {self.left_cte.source.datasources[0].identifier}"
         return self.left_cte.name
 
     @property
     def right_ref(self) -> str:
-        if isinstance(self.right_cte, Datasource):
-            return f"{self.right_cte.safe_location} as {self.right_cte.identifier}"
+        if self.right_cte.name in self.inlined_ctes:
+            return f"{self.right_cte.source.datasources[0].safe_location} as {self.right_cte.source.datasources[0].identifier}"
         return self.right_cte.name
 
     @property

{pytrilogy-0.0.2.14 → pytrilogy-0.0.2.17}/trilogy/core/processing/node_generators/filter_node.py

@@ -212,5 +212,5 @@ def gen_filter_node(
             # this node fetches only what we need to filter
             filter_node,
             enrich_node,
-        ]
+        ],
     )

{pytrilogy-0.0.2.14 → pytrilogy-0.0.2.17}/trilogy/core/processing/node_generators/rowset_node.py

@@ -71,12 +71,22 @@ def gen_rowset_node(
         and x.derivation != PurposeLineage.ROWSET
     ]
     node.hide_output_concepts(final_hidden)
-    # assume grain to be output of select
-    # but don't include anything aggregate at this point
-    assert node.resolution_cache
 
+    assert node.resolution_cache
+    # assume grain to be output of select
+    # but don't include anything hidden(the non-rowset concepts)
     node.grain = concept_list_to_grain(
-        node.output_concepts, parent_sources=node.resolution_cache.datasources
+        [
+            x
+            for x in node.output_concepts
+            if x.address
+            not in [
+                y.address
+                for y in node.hidden_concepts
+                if y.derivation != PurposeLineage.ROWSET
+            ]
+        ],
+        parent_sources=node.resolution_cache.datasources,
     )
 
     node.rebuild_cache()

{pytrilogy-0.0.2.14 → pytrilogy-0.0.2.17}/trilogy/dialect/base.py

@@ -608,6 +608,7 @@ class BaseDialect:
                             join,
                             self.QUOTE_CHARACTER,
                             self.render_concept_sql,
+                            self.render_expr,
                             cte,
                             self.UNNEST_MODE,
                         )

{pytrilogy-0.0.2.14 → pytrilogy-0.0.2.17}/trilogy/dialect/common.py

@@ -1,6 +1,13 @@
-from trilogy.core.models import Join, InstantiatedUnnestJoin, CTE, Concept, Datasource
+from trilogy.core.models import (
+    Join,
+    InstantiatedUnnestJoin,
+    CTE,
+    Concept,
+    Function,
+    RawColumnExpr,
+)
 from trilogy.core.enums import UnnestMode, Modifier
-from typing import Optional, Callable
+from typing import Callable
 
 
 def null_wrapper(lval: str, rval: str, modifiers: list[Modifier]) -> str:
@@ -21,19 +28,39 @@ def render_unnest(
     return f"{render_func(concept, cte, False)} as unnest_wrapper ({quote_character}{concept.safe_address}{quote_character})"
 
 
+def render_join_concept(
+    name: str,
+    quote_character: str,
+    cte: CTE,
+    concept: Concept,
+    render_expr,
+    inlined_ctes: set[str],
+):
+    if cte.name in inlined_ctes:
+        ds = cte.source.datasources[0]
+        raw_content = ds.get_alias(concept)
+        if isinstance(raw_content, RawColumnExpr):
+            rval = raw_content.text
+            return rval
+        elif isinstance(raw_content, Function):
+            rval = render_expr(raw_content, cte=cte)
+            return rval
+        return f"{name}.{quote_character}{raw_content}{quote_character}"
+    return f"{name}.{quote_character}{concept.safe_address}{quote_character}"
+
+
 def render_join(
     join: Join | InstantiatedUnnestJoin,
     quote_character: str,
-    render_func: Optional[Callable[[Concept, CTE, bool], str]] = None,
-    cte: Optional[CTE] = None,
+    render_func: Callable[[Concept, CTE, bool], str],
+    render_expr_func: Callable[[Concept, CTE], str],
+    cte: CTE,
     unnest_mode: UnnestMode = UnnestMode.CROSS_APPLY,
 ) -> str | None:
     # {% for key in join.joinkeys %}{{ key.inner }} = {{ key.outer}}{% endfor %}
     if isinstance(join, InstantiatedUnnestJoin):
         if unnest_mode == UnnestMode.DIRECT:
             return None
-        if not render_func:
-            raise ValueError("must provide a render function to build an unnest joins")
         if not cte:
             raise ValueError("must provide a cte to build an unnest joins")
         if unnest_mode == UnnestMode.CROSS_JOIN:
@@ -46,8 +73,22 @@ def render_join(
     right_base = join.right_ref
     base_joinkeys = [
         null_wrapper(
-            f"{left_name}.{quote_character}{join.left_cte.get_alias(key.concept) if isinstance(join.left_cte, Datasource) else key.concept.safe_address}{quote_character}",
-            f"{right_name}.{quote_character}{join.right_cte.get_alias(key.concept) if isinstance(join.right_cte, Datasource) else key.concept.safe_address}{quote_character}",
+            render_join_concept(
+                left_name,
+                quote_character,
+                join.left_cte,
+                key.concept,
+                render_expr_func,
+                join.inlined_ctes,
+            ),
+            render_join_concept(
+                right_name,
+                quote_character,
+                join.right_cte,
+                key.concept,
+                render_expr_func,
+                join.inlined_ctes,
+            ),
             modifiers=key.concept.modifiers or [],
         )
         for key in join.joinkeys
@@ -56,8 +97,22 @@ def render_join(
         base_joinkeys.extend(
             [
                 null_wrapper(
-                    f"{left_name}.{quote_character}{join.left_cte.get_alias(pair.left) if isinstance(join.left_cte, Datasource) else pair.left.safe_address}{quote_character}",
-                    f"{right_name}.{quote_character}{join.right_cte.get_alias(pair.right) if isinstance(join.right_cte, Datasource) else pair.right.safe_address}{quote_character}",
+                    render_join_concept(
+                        left_name,
+                        quote_character,
+                        join.left_cte,
+                        pair.left,
+                        render_expr_func,
+                        join.inlined_ctes,
+                    ),
+                    render_join_concept(
+                        right_name,
+                        quote_character,
+                        join.right_cte,
+                        pair.right,
+                        render_expr_func,
+                        join.inlined_ctes,
+                    ),
                     modifiers=pair.modifiers
                     + (pair.left.modifiers or [])
                     + (pair.right.modifiers or []),

{pytrilogy-0.0.2.14 → pytrilogy-0.0.2.17}/trilogy/executor.py

@@ -129,6 +129,11 @@ class Executor(object):
             ["name"],
         )
 
+    @execute_query.register
+    def _(self, query: str) -> CursorResult:
+
+        return self.execute_text(query)[-1]
+
     @execute_query.register
     def _(self, query: SelectStatement) -> CursorResult:
         sql = self.generator.generate_queries(

{pytrilogy-0.0.2.14 → pytrilogy-0.0.2.17}/trilogy/parsing/parse_engine.py

@@ -600,7 +600,7 @@ class ParseToObjects(Transformer):
         return args[3:-3]
 
     def raw_column_assignment(self, args):
-        return RawColumnExpr(text=args[0])
+        return RawColumnExpr(text=args[1])
 
     @v_args(meta=True)
     def datasource(self, meta: Meta, args):

{pytrilogy-0.0.2.14 → pytrilogy-0.0.2.17}/trilogy/parsing/render.py

@@ -328,6 +328,8 @@ class Renderer:
         inputs = ",".join(self.to_string(c) for c in arg.arguments)
         if arg.operator == FunctionType.CONSTANT:
             return f"{inputs}"
+        if arg.operator == FunctionType.INDEX_ACCESS:
+            return f"{self.to_string(arg.arguments[0])}[{self.to_string(arg.arguments[1])}]"
         return f"{arg.operator.value}({inputs})"
 
     @to_string.register

{pytrilogy-0.0.2.14 → pytrilogy-0.0.2.17}/trilogy/parsing/trilogy.lark

@@ -47,9 +47,11 @@
     
     //column_assignment
     //figure out if we want static
-    column_assignment: ((IDENTIFIER | _static_functions | raw_column_assignment ) ":" concept_assignment) 
+    column_assignment: (raw_column_assignment | IDENTIFIER |  _static_functions  ) ":" concept_assignment
+    
+    RAW_ENTRY.1: /raw\s*\(/s
 
-    raw_column_assignment: "raw" "(" MULTILINE_STRING ")"
+    raw_column_assignment: RAW_ENTRY  MULTILINE_STRING ")"
     
     column_assignment_list : column_assignment (","  column_assignment)* ","?