pytrilogy 0.0.2.25__py3-none-any.whl → 0.0.2.26__py3-none-any.whl

trilogy/dialect/base.py

@@ -607,6 +607,7 @@ class BaseDialect:
                     else:
                         having = having + x if having else x
 
+        logger.info(f"{len(final_joins)} joins for cte {cte.name}")
         return CompiledCTE(
             name=cte.name,
             statement=self.SQL_TEMPLATE.render(

trilogy/dialect/common.py

@@ -68,39 +68,18 @@ def render_join(
         if unnest_mode == UnnestMode.CROSS_JOIN_ALIAS:
             return f"CROSS JOIN {render_unnest(unnest_mode, quote_character, join.concept_to_unnest, render_func, cte)}"
         return f"FULL JOIN {render_unnest(unnest_mode, quote_character, join.concept_to_unnest, render_func, cte)}"
-    left_name = join.left_name
+    # left_name = join.left_name
     right_name = join.right_name
     right_base = join.right_ref
-    base_joinkeys = [
-        null_wrapper(
-            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
-    ]
+    base_joinkeys = []
     if join.joinkey_pairs:
         base_joinkeys.extend(
             [
                 null_wrapper(
                     render_join_concept(
-                        left_name,
+                        join.get_name(pair.cte),
                         quote_character,
-                        join.left_cte,
+                        pair.cte,
                         pair.left,
                         render_expr_func,
                         join.inlined_ctes,

trilogy/executor.py

@@ -334,7 +334,9 @@ class Executor(object):
             text(command),
         )
 
-    def execute_text(self, command: str) -> List[CursorResult]:
+    def execute_text(
+        self, command: str, non_interactive: bool = False
+    ) -> List[CursorResult]:
         """Run a preql text command"""
         output = []
         # connection = self.engine.connect()
@@ -351,11 +353,18 @@ class Executor(object):
                     )
                 )
                 continue
+            if non_interactive:
+                if not isinstance(
+                    statement, (ProcessedCopyStatement, ProcessedQueryPersist)
+                ):
+                    continue
             output.append(self.execute_query(statement))
         return output
 
-    def execute_file(self, file: str | Path) -> List[CursorResult]:
+    def execute_file(
+        self, file: str | Path, non_interactive: bool = False
+    ) -> List[CursorResult]:
         file = Path(file)
         with open(file, "r") as f:
             command = f.read()
-        return self.execute_text(command)
+        return self.execute_text(command, non_interactive=non_interactive)

trilogy/parsing/common.py

@@ -292,21 +292,19 @@ def arbitrary_to_concept(
 
     if isinstance(parent, AggregateWrapper):
         if not name:
-            name = (
-                f"_agg_{parent.function.operator.value}_{string_to_hash(str(parent))}"
-            )
+            name = f"{VIRTUAL_CONCEPT_PREFIX}_agg_{parent.function.operator.value}_{string_to_hash(str(parent))}"
         return agg_wrapper_to_concept(parent, namespace, name, metadata, purpose)
     elif isinstance(parent, WindowItem):
         if not name:
-            name = f"_window_{parent.type.value}_{string_to_hash(str(parent))}"
+            name = f"{VIRTUAL_CONCEPT_PREFIX}_window_{parent.type.value}_{string_to_hash(str(parent))}"
         return window_item_to_concept(parent, name, namespace, purpose, metadata)
     elif isinstance(parent, FilterItem):
         if not name:
-            name = f"_filter_{parent.content.name}_{string_to_hash(str(parent))}"
+            name = f"{VIRTUAL_CONCEPT_PREFIX}_filter_{parent.content.name}_{string_to_hash(str(parent))}"
         return filter_item_to_concept(parent, name, namespace, purpose, metadata)
     elif isinstance(parent, Function):
         if not name:
-            name = f"_func_{parent.operator.value}_{string_to_hash(str(parent))}"
+            name = f"{VIRTUAL_CONCEPT_PREFIX}_func_{parent.operator.value}_{string_to_hash(str(parent))}"
         return function_to_concept(parent, name, namespace)
     elif isinstance(parent, ListWrapper):
         if not name:

trilogy/parsing/parse_engine.py

@@ -254,8 +254,9 @@ class ParseToObjects(Transformer):
     def IDENTIFIER(self, args) -> str:
         return args.value
 
-    def concept_lit(self, args) -> Concept:
-        return self.environment.concepts.__getitem__(args[0])
+    @v_args(meta=True)
+    def concept_lit(self, meta: Meta, args) -> Concept:
+        return self.environment.concepts.__getitem__(args[0], meta.line)
 
     def ADDRESS(self, args) -> Address:
         return Address(location=args.value, quoted=False)

trilogy/parsing/render.py

@@ -17,6 +17,7 @@ from trilogy.core.models import (
     SelectItem,
     WhereClause,
     Conditional,
+    SubselectComparison,
     Comparison,
     Environment,
     ConceptDeclarationStatement,
@@ -25,6 +26,7 @@ from trilogy.core.models import (
     WindowItem,
     FilterItem,
     ColumnAssignment,
+    RawColumnExpr,
     CaseElse,
     CaseWhen,
     ImportStatement,
@@ -50,13 +52,16 @@ from collections import defaultdict
 
 
 QUERY_TEMPLATE = Template(
-    """SELECT{%- for select in select_columns %}
-    {{ select }},{% endfor %}{% if where %}
-WHERE
-    {{ where }}{% endif %}{%- if order_by %}
+    """{% if where %}WHERE
+    {{ where }}
+{% endif %}SELECT{%- for select in select_columns %}
+    {{ select }},{% endfor %}{% if 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 %};"""
 )
 
@@ -133,14 +138,14 @@ class Renderer:
 
     @to_string.register
     def _(self, arg: Datasource):
-        assignments = ",\n\t".join([self.to_string(x) for x in arg.columns])
+        assignments = ",\n    ".join([self.to_string(x) for x in arg.columns])
         base = f"""datasource {arg.name} (
     {assignments}
-    ) 
-{self.to_string(arg.grain)} 
+    )
+{self.to_string(arg.grain)}
 {self.to_string(arg.address)}"""
         if arg.where:
-            base += f"\n{self.to_string(arg.where)}"
+            base += f"\nwhere {self.to_string(arg.where)}"
         base += ";"
         return base
 
@@ -209,7 +214,13 @@ class Renderer:
 
     @to_string.register
     def _(self, arg: "ColumnAssignment"):
-        return f"{arg.alias}: {self.to_string(arg.concept)}"
+        if isinstance(arg.alias, str):
+            return f"{arg.alias}: {self.to_string(arg.concept)}"
+        return f"{self.to_string(arg.alias)}: {self.to_string(arg.concept)}"
+
+    @to_string.register
+    def _(self, arg: "RawColumnExpr"):
+        return f"raw('''{arg.text}''')"
 
     @to_string.register
     def _(self, arg: "ConceptDeclarationStatement"):
@@ -266,6 +277,7 @@ class Renderer:
         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
@@ -301,16 +313,23 @@ class Renderer:
 
     @to_string.register
     def _(self, arg: OrderBy):
-        return ",\t".join([self.to_string(c) for c in arg.items])
+        return ",\n".join([self.to_string(c) for c in arg.items])
 
     @to_string.register
     def _(self, arg: "WhereClause"):
-        return f"{self.to_string(arg.conditional)}"
+        base = f"{self.to_string(arg.conditional)}"
+        if base[0] == "(" and base[-1] == ")":
+            return base[1:-1]
+        return base
 
     @to_string.register
     def _(self, arg: "Conditional"):
         return f"({self.to_string(arg.left)} {arg.operator.value} {self.to_string(arg.right)})"
 
+    @to_string.register
+    def _(self, arg: "SubselectComparison"):
+        return f"{self.to_string(arg.left)} {arg.operator.value} {self.to_string(arg.right)}"
+
     @to_string.register
     def _(self, arg: "Comparison"):
         return f"{self.to_string(arg.left)} {arg.operator.value} {self.to_string(arg.right)}"
@@ -319,10 +338,12 @@ class Renderer:
     def _(self, arg: "WindowItem"):
         over = ",".join(self.to_string(c) for c in arg.over)
         order = ",".join(self.to_string(c) for c in arg.order_by)
-        if over:
+        if over and order:
             return (
-                f"{arg.type.value} {self.to_string(arg.content)} by {order} OVER {over}"
+                f"{arg.type.value} {self.to_string(arg.content)} by {order} over {over}"
             )
+        elif over:
+            return f"{arg.type.value} {self.to_string(arg.content)} over {over}"
         return f"{arg.type.value} {self.to_string(arg.content)} by {order}"
 
     @to_string.register
@@ -343,13 +364,15 @@ class Renderer:
 
     @to_string.register
     def _(self, arg: "ConceptTransform"):
-        return f"{self.to_string(arg.function)}->{arg.output.name}"
+        return f"{self.to_string(arg.function)} -> {arg.output.name}"
 
     @to_string.register
     def _(self, arg: "Function"):
         inputs = ",".join(self.to_string(c) for c in arg.arguments)
         if arg.operator == FunctionType.CONSTANT:
             return f"{inputs}"
+        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])}]"
         return f"{arg.operator.value}({inputs})"
@@ -361,7 +384,8 @@ class Renderer:
     @to_string.register
     def _(self, arg: AggregateWrapper):
         if arg.by:
-            return f"{self.to_string(arg.function)} by {self.to_string(arg.by)}"
+            by = ", ".join([self.to_string(x) for x in arg.by])
+            return f"{self.to_string(arg.function)} by {by}"
         return f"{self.to_string(arg.function)}"
 
     @to_string.register

trilogy/parsing/trilogy.lark

@@ -289,8 +289,8 @@
 
     // base language constructs
     concept_lit: IDENTIFIER
-    IDENTIFIER: /[a-zA-Z\_][a-zA-Z0-9\_\-\.\-]*/
-    QUOTED_ADDRESS:  /`[a-zA-Z\_][a-zA-Z0-9\_\-\.\-\*\:]*`/
+    IDENTIFIER: /[a-zA-Z\_][a-zA-Z0-9\_\-\.]*/
+    QUOTED_ADDRESS:  /`[a-zA-Z\_][a-zA-Z0-9\_\.\-\*\:]*`/
     ADDRESS: IDENTIFIER
 
     MULTILINE_STRING: /\'{3}(.*?)\'{3}/s