pytrilogy 0.0.2.7__tar.gz → 0.0.2.8__tar.gz

{pytrilogy-0.0.2.7/pytrilogy.egg-info → pytrilogy-0.0.2.8}/PKG-INFO

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

{pytrilogy-0.0.2.7 → pytrilogy-0.0.2.8/pytrilogy.egg-info}/PKG-INFO

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

{pytrilogy-0.0.2.7 → pytrilogy-0.0.2.8}/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.7"
+__version__ = "0.0.2.8"
 
 __all__ = ["parse", "Executor", "Dialects", "Environment", "CONFIG"]

{pytrilogy-0.0.2.7 → pytrilogy-0.0.2.8}/trilogy/core/enums.py

@@ -123,6 +123,7 @@ class FunctionType(Enum):
     MAP_ACCESS = "map_access"
     ATTR_ACCESS = "attr_access"
     STRUCT = "struct"
+    ARRAY = "array"
 
     # TEXT AND MAYBE MORE
     SPLIT = "split"

{pytrilogy-0.0.2.7 → pytrilogy-0.0.2.8}/trilogy/core/models.py

@@ -2066,6 +2066,7 @@ class Datasource(Namespaced, BaseModel):
 class UnnestJoin(BaseModel):
     concept: Concept
     alias: str = "unnest"
+    rendering_required: bool = True
 
     def __hash__(self):
         return (self.alias + self.concept.address).__hash__()
@@ -2460,10 +2461,17 @@ class CTE(BaseModel):
                     for join in self.joins
                     if not isinstance(join, Join)
                     or (
-                        join.right_cte.name != removed_cte
-                        and join.left_cte.name != removed_cte
+                        isinstance(join, Join)
+                        and (
+                            join.right_cte.name != removed_cte
+                            and join.left_cte.name != removed_cte
+                        )
                     )
                 ]
+                for join in self.joins:
+                    if isinstance(join, UnnestJoin) and join.concept == concept:
+                        join.rendering_required = False
+
                 self.parent_ctes = [
                     x for x in self.parent_ctes if x.name != removed_cte
                 ]

{pytrilogy-0.0.2.7 → pytrilogy-0.0.2.8}/trilogy/dialect/base.py

@@ -51,7 +51,7 @@ from trilogy.core.models import (
     MergeStatementV2,
 )
 from trilogy.core.query_processor import process_query, process_persist
-from trilogy.dialect.common import render_join
+from trilogy.dialect.common import render_join, render_unnest
 from trilogy.hooks.base_hook import BaseHook
 from trilogy.core.enums import UnnestMode
 
@@ -128,6 +128,7 @@ FUNCTION_MAP = {
     FunctionType.UNNEST: lambda x: f"unnest({x[0]})",
     FunctionType.ATTR_ACCESS: lambda x: f"""{x[0]}.{x[1].replace("'", "")}""",
     FunctionType.STRUCT: lambda x: f"{{{', '.join(struct_arg(x))}}}",
+    FunctionType.ARRAY: lambda x: f"[{', '.join(x)}]",
     # math
     FunctionType.ADD: lambda x: f"{x[0]} + {x[1]}",
     FunctionType.SUBTRACT: lambda x: f"{x[0]} - {x[1]}",
@@ -466,7 +467,7 @@ class BaseDialect:
         elif isinstance(e, MapWrapper):
             return f"MAP {{{','.join([f'{self.render_expr(k, cte=cte, cte_map=cte_map)}:{self.render_expr(v, cte=cte, cte_map=cte_map)}' for k, v in e.items()])}}}"
         elif isinstance(e, list):
-            return f"[{','.join([self.render_expr(x, cte=cte, cte_map=cte_map) for x in e])}]"
+            return f"{self.FUNCTION_MAP[FunctionType.ARRAY]([self.render_expr(x, cte=cte, cte_map=cte_map) for x in e])}"
         elif isinstance(e, DataType):
             return str(e.value)
         elif isinstance(e, DatePart):
@@ -480,8 +481,12 @@ class BaseDialect:
             raise ValueError(f"Unable to render type {type(e)} {e}")
 
     def render_cte(self, cte: CTE):
-        if self.UNNEST_MODE in (UnnestMode.CROSS_APPLY, UnnestMode.CROSS_JOIN):
-            # for a cross apply, derviation happens in the join
+        if self.UNNEST_MODE in (
+            UnnestMode.CROSS_APPLY,
+            UnnestMode.CROSS_JOIN,
+            UnnestMode.CROSS_JOIN_ALIAS,
+        ):
+            # for a cross apply, derivation happens in the join
             # so we only use the alias to select
             select_columns = [
                 self.render_concept_sql(c, cte)
@@ -499,17 +504,38 @@ class BaseDialect:
                 for c in cte.output_columns
                 if c.address not in [y.address for y in cte.hidden_concepts]
             ]
-        if cte.quote_address:
-            source = f"{self.QUOTE_CHARACTER}{cte.base_name}{self.QUOTE_CHARACTER}"
+        source: str | None = cte.base_name
+        if not cte.render_from_clause:
+            if len(cte.joins) > 0:
+                if cte.join_derived_concepts and self.UNNEST_MODE in (
+                    UnnestMode.CROSS_JOIN_ALIAS,
+                    UnnestMode.CROSS_JOIN,
+                    UnnestMode.CROSS_APPLY,
+                ):
+                    source = f"{render_unnest(self.UNNEST_MODE, self.QUOTE_CHARACTER, cte.join_derived_concepts[0], self.render_concept_sql, cte)}"
+                # direct - eg DUCK DB - can be directly selected inline
+                elif cte.join_derived_concepts and self.UNNEST_MODE == UnnestMode.DIRECT:
+                    source = None
+                else:
+                    raise SyntaxError("CTE has joins but no from clause")
+            else:
+                source = None
+        else:
+            if cte.quote_address:
+                source = f"{self.QUOTE_CHARACTER}{cte.base_name}{self.QUOTE_CHARACTER}"
+            else:
+                source = cte.base_name
+            if cte.base_name != cte.base_alias:
+                source = f"{source} as {cte.base_alias}"
+        if not cte.render_from_clause:
+            final_joins = []
         else:
-            source = cte.base_name
-        if cte.base_name != cte.base_alias:
-            source = f"{source} as {cte.base_alias}"
+            final_joins = cte.joins or []
         return CompiledCTE(
             name=cte.name,
             statement=self.SQL_TEMPLATE.render(
                 select_columns=select_columns,
-                base=(f"{source}" if cte.render_from_clause else None),
+                base=f"{source}" if source else None,
                 grain=cte.grain,
                 limit=cte.limit,
                 # some joins may not need to be rendered
@@ -524,7 +550,7 @@ class BaseDialect:
                             cte,
                             self.UNNEST_MODE,
                         )
-                        for join in (cte.joins or [])
+                        for join in final_joins
                     ]
                     if j
                 ],

{pytrilogy-0.0.2.7 → pytrilogy-0.0.2.8}/trilogy/dialect/common.py

@@ -9,6 +9,18 @@ def null_wrapper(lval: str, rval: str, concept: Concept) -> str:
     return f"{lval} = {rval}"
 
 
+def render_unnest(
+    unnest_mode: UnnestMode,
+    quote_character: str,
+    concept: Concept,
+    render_func: Callable[[Concept, CTE, bool], str],
+    cte: CTE,
+):
+    if unnest_mode == UnnestMode.CROSS_JOIN:
+        return f"{render_func(concept, cte, False)} as {quote_character}{concept.safe_address}{quote_character}"
+    return f"{render_func(concept, cte, False)} as unnest_wrapper ({quote_character}{concept.safe_address}{quote_character})"
+
+
 def render_join(
     join: Join | InstantiatedUnnestJoin,
     quote_character: str,
@@ -25,10 +37,10 @@ def render_join(
         if not cte:
             raise ValueError("must provide a cte to build an unnest joins")
         if unnest_mode == UnnestMode.CROSS_JOIN:
-            return f"CROSS JOIN {render_func(join.concept, cte, False)} as {quote_character}{join.concept.safe_address}{quote_character}"
+            return f"CROSS JOIN {render_unnest(unnest_mode, quote_character, join.concept, render_func, cte)}"
         if unnest_mode == UnnestMode.CROSS_JOIN_ALIAS:
-            return f"CROSS JOIN {render_func(join.concept, cte, False)} as array_unnest ({quote_character}{join.concept.safe_address}{quote_character})"
-        return f"FULL JOIN {render_func(join.concept, cte, False)} as unnest_wrapper({quote_character}{join.concept.safe_address}{quote_character})"
+            return f"CROSS JOIN {render_unnest(unnest_mode, quote_character, join.concept, render_func, cte)}"
+        return f"FULL JOIN {render_unnest(unnest_mode, quote_character, join.concept, render_func, cte)}"
     left_name = join.left_name
     right_name = join.right_name
     right_base = join.right_ref

{pytrilogy-0.0.2.7 → pytrilogy-0.0.2.8}/trilogy/dialect/presto.py

@@ -33,6 +33,7 @@ FUNCTION_MAP = {
     FunctionType.DATE_ADD: lambda x: f"DATE_ADD('{x[1]}', {x[2]}, {x[0]})",
     FunctionType.CURRENT_DATE: lambda x: "CURRENT_DATE",
     FunctionType.CURRENT_DATETIME: lambda x: "CURRENT_TIMESTAMP",
+    FunctionType.ARRAY: lambda x: f"ARRAY[{', '.join(x)}]",
 }
 
 FUNCTION_GRAIN_MATCH_MAP = {
@@ -86,7 +87,7 @@ class PrestoDialect(BaseDialect):
     QUOTE_CHARACTER = '"'
     SQL_TEMPLATE = SQL_TEMPLATE
     DATATYPE_MAP = {**BaseDialect.DATATYPE_MAP, DataType.NUMERIC: "DECIMAL"}
-    UNNEST_MODE = UnnestMode.CROSS_JOIN
+    UNNEST_MODE = UnnestMode.CROSS_JOIN_ALIAS
 
 
 class TrinoDialect(PrestoDialect):